# SPointCategoryΒΆ

PointCategory is the category of points and vectors in space. Points may be used to represent shapes in a scenegraph such as: the vertices of a cube or points along a line. Shapes such as these may be defined explicitly or may be plotted. We implement SetCategory to allow us to curry transforms from one point to another.

*: (DoubleFloat, %) -> %

*(`s`, `x`) gives scalar multiplication Although, scalar multiplication is strictly only a valid operation for vectors and not points, we allow it here because there are some useful short cuts, for instance, to find the central point between two points we can add them together and scalar multiply by 0.5.

+: (%, %) -> %

+(`x`, `y`) gives addition add the corresponding elements of the vector or point. The type (vector or point) depends on the following table: vector + vector = vector point + vector = point point + point = invalid (but interpret as vector) Although, adding two points is not strictly a valid operation, we allow it here by interpreting the point as a vector relative to the origin. We do that because there are some useful short cuts, for instance, to find the central point between two points we can add them together and scalar multiply by 0.5.

-: (%, %) -> %

`-(x, y)` gives subtraction subtract the corresponding elements of the vector or point. The type (vector or point) depends on the following table: vector - vector = vector point - vector = point vector - point = invalid (but interpret as point) point - point = invalid (but interpret as vector) Although, subtracting two points is not strictly a valid operation, we allow it here by interpreting the result as the vector distance between the two points.

=: (%, %) -> Boolean

from BasicType

~=: (%, %) -> Boolean

from BasicType

coerce: % -> OutputForm

output

colinearity: (%, %) -> DoubleFloat

`colinearity(x, y)` returns a measure of how parallel two vectors are independent of the length of the vectors: 1.0 is completely parallel 0.0 is completely perpendicular returned value will be between these

dimension: % -> PositiveInteger

`dimension(p)` returns the number of dimensions that make up the point category `p`.

distance: (%, %) -> DoubleFloat

`distance(p1, p2)` returns the distance between the points `p1` is the first point. `p2` is the second point. There are 2 metrics associated with any SPointCategory the underlying space and the space that it is embedded in this is the distance in the underlying space.

distanceSquared: (%, %) -> DoubleFloat

`distanceSquared(p1, p2)` returns the distance between the points `p1` and `p2`. There are 2 metrics associated with any SPointCategory the underlying space and the space that it is embedded in this is the distance in the underlying space.

extendedCoords: % -> List DoubleFloat

`extendedCoords(pt)` returns extended coordinates as a list.

inBounds?: (%, %, %) -> Boolean

`inBounds?(pt, mns, mxs)` returns `true` if `pt` is inside bounding box where bounding box is specified by min and max.

isPoint?: % -> Boolean

`isPoint?(p)` returns `true` if this represents a point as opposed to a vector.

isVector?: % -> Boolean

`isVector? returns` `true` if this represents a vector as opposed to a point.

latex: % -> String

from SetCategory

max: (%, %) -> %

`max(a, b)` returns a point whose value in each dimension is the maximum. So if a has the largest `x` value and `b` has the largest `y` value then the result will combine these. This is useful for constructing boundary boxes around sets of points.

min: (%, %) -> %

`min(a, b)` returns a point whose value in each dimension is the minimum. So if a has the smallest `x` value and `b` has the smallest `y` value then the result will combine these. This is useful for constructing boundary boxes around sets of points.

parallel: (%, %) -> DoubleFloat

`parallel(x, y)` returns the length of the parallel component of two vectors. In the case of Euclidean space this is the dot product of two vectors. We use this function to test the colinearity

perpendicular: (%, %) -> %

`perpendicular(x, y)` returns a vector perpendicular to the two vectors in the case of 3D Euclidean space this is the cross the product of two vectors. We use this function to compute orthogonal

Pnan?: % -> Boolean

`Pnan?(p)` returns `true` if any of its elements are not valid DoubleFloat values. Examples of invalid floating point numbers are when we have divided a given element by zero or taken sqrt of negative number at some stage? Note: we can still represent a point at infinity and we can represent points using complex numbers, but we do this using projective or conformal space or by using the appropriate instance of SPointCategory, not by using invalid floating point numbers.

screenCoords: % -> List DoubleFloat

`screenCoords(pt)` returns screen coordinates as a list.

screenCoordX: % -> DoubleFloat

`screenCoordX(pt)` returns the `'x'`(left to right) screen coordinate.

screenCoordY: % -> DoubleFloat

`screenCoordY(pt)` returns the `'y'`(bottom to top) screen coordinate.

screenCoordZ: % -> DoubleFloat

`screenCoordZ(pt)` returns the `'z'`(out from screen) screen coordinate.

sipnt: (Integer, Integer) -> %

`sipnt(a, b)` constructs a 2D point defined by a and `b` of type Integer

sipnt: (Integer, Integer, Integer) -> %

`sipnt(a, b, c)` constructs a 3D point defined by a, `b` and `c` of type Integer

sivec: (Integer, Integer) -> %

`sivec(a, b)` constructs a 2D vector defined by a and `b` of type Integer

sivec: (Integer, Integer, Integer) -> %

`sivec(a, b, c)` constructs a 3D vector defined by a, `b` and `c` of type Integer

spnt: (DoubleFloat, DoubleFloat) -> %

`spnt(a, b)` constructs a 2D point defined by a and `b` of type `R`

spnt: (DoubleFloat, DoubleFloat, DoubleFloat) -> %

`spnt(a, b, c)` constructs a 3D point defined by a, `b` and `c` of type `R`

svec: (DoubleFloat, DoubleFloat) -> %

`svec(a, b)` constructs a 2D vector defined by a and `b` of type `R`

svec: (DoubleFloat, DoubleFloat, DoubleFloat) -> %

`svec(a, b, c)` constructs a 3D vector defined by a, `b` and `c` of type `R`

toPoint: % -> %

`toPoint(p)` returns a Point with the same coordinates as `p` If `p` was originally a vector then that will be treated as the distance from the origin.

toVector: % -> %

`toVector returns` a Vector with the same coordinates as `p` If `p` was originally a point then the vector will be the distance from the origin.

unitVector: % -> %

`unitVector(p)` returns a vector with the same direction as `p` but with unit length. We scale until length is 1

BasicType

SetCategory