SPointCategoryΒΆ

scene.spad line 828

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.
hash: % -> SingleInteger
from SetCategory
hashUpdate!: (HashState, %) -> HashState
from SetCategory
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

CoercibleTo OutputForm

SetCategory