geom Namespace Reference

Namespace of all geomc functions and classes. More...

Classes
class	AffineTransform
	Affine transformation class. More...
class	AnyConvex
	Helper class which virtualizes the static polymorphism of Convex shapes. More...
class	AnyConvexImpl
	Implementation of AnyConvex for a specific Shape. More...
class	BezierPath
	An extendable path defined by a sequence of knots and tangent points. More...
class	BezierSpline
	A cubic spline with two knots and two tangent points. More...
class	BinLatticePartition
class	Bounded
	Base class describing shapes with finite extents in N dimensions. More...
class	BSpline
	A cubic spline with four guide points and continuous curvature. More...
class	BSplinePath
	An extendable path defined by a sequence of guide knots. More...
class	Capsule
	An N-dimensional capsule shape. More...
class	CatromSpline
	A cubic spline which passes smoothly through four knots. More...
class	CatromSplinePath
	An extendable path which passes through a sequence of knots. More...
class	ConstSubtree
	An const iterator to a subtree. More...
struct	ConstType
struct	ConstType< T, false >
struct	ConstType< T, true >
class	Convex
	Base class describing convex shapes in N-dimensional space. More...
class	CubicSpline
	Base class for cubic splines. More...
class	Cylinder
	An N-dimensional cylinder, given by its radius and endpoints. More...
struct	DenseUniformDistribution
	A random number generator that produces uniformly-distributed values. More...
struct	DenseUniformDistribution< double >
	Dense uniform distribution specialization for double. More...
struct	DenseUniformDistribution< Dual< T, P > >
	Dense uniform distribution specialization for Duals. More...
struct	DenseUniformDistribution< float >
	Dense uniform distribution specialization for float. More...
class	Deque
	A lightweight double ended queue backed by a flat array. More...
class	DiagMatrix
	A matrix with nonzero elements only along the main diagonal. More...
struct	Digest
	Partially-specializable hash function object for arbitrary object and hash types. More...
struct	Digest< AffineTransform< T, N >, H >
struct	Digest< Capsule< T, N >, H >
struct	Digest< CharT[N], H >
struct	Digest< const char *, H >
struct	Digest< Cylinder< T, N >, H >
struct	Digest< Dilated< Shape >, H >
struct	Digest< Dual< T, Dp >, H >
struct	Digest< Extruded< Shape >, H >
struct	Digest< Frustum< Shape >, H >
struct	Digest< H, H >
struct	Digest< Hollow< Shape >, H >
struct	Digest< Isometry< T, N >, H >
struct	Digest< Plane< T, N >, H >
struct	Digest< Quat< T >, H >
struct	Digest< Ray< T, N >, H >
struct	Digest< Rect< T, N >, H >
struct	Digest< Rotation< T, 2 >, H >
struct	Digest< Rotation< T, 3 >, H >
struct	Digest< Similar< Shape >, H >
struct	Digest< Similarity< T, N >, H >
struct	Digest< SimpleMatrix< T, M, N, Lyt, P >, H >
struct	Digest< Simplex< T, N >, H >
struct	Digest< Sphere< T, N >, H >
struct	Digest< SphericalCap< T, N >, H >
struct	Digest< std::array< T, N >, H >
struct	Digest< std::initializer_list< T >, H >
struct	Digest< std::optional< T >, H >
struct	Digest< std::pair< T1, T2 >, H >
struct	Digest< std::span< T >, H >
struct	Digest< std::string, H >
struct	Digest< std::string_view, H >
struct	Digest< std::tuple< Ts... >, H >
struct	Digest< std::type_index, H >
struct	Digest< std::variant< Ts... >, H >
struct	Digest< std::vector< T >, H >
struct	Digest< T, H >
struct	Digest< Transformed< Shape >, H >
struct	Digest< Vec< T, N >, H >
class	Dilated
	A wrapper shape which dilates the extents of another Shape. More...
struct	Dimension
	Defines a type for storing a length or element count. More...
struct	Dimension< DYNAMIC_DIM >
struct	Dimensional
	Represents an object or operation that exists in a certain dimension with a certain coordinate type. More...
class	DimensionMismatchException
struct	disable_std_hash_fallback
	Specialize for T to disable the use of std::hash for Digest<T>. More...
struct	disable_std_hash_fallback< const char * >
struct	Dual
	Class implementing the dual numbers, whose arithmetic operations perform a simultaneous calculation of the first derivative. More...
class	Extruded
	An axis-aligned extrusion of an arbitrary N-1 dimensional Convex shape. More...
class	FlatMatrixLayout
class	FlatMatrixLayout< T, COL_MAJOR >
class	Frustum
	An N-dimensional frustum (truncated pyramid) with an arbitrary Convex shape as its base, and its (possibly excluded) point at the origin. More...
struct	GenericStorage
	Array storage with templated static or dynamic size, and template-selectable ownership policy. More...
struct	GenericStorage< T, N, STORAGE_UNIQUE >
struct	GenericStorage< T, N, STORAGE_WRAPPED >
class	GeomException
class	GridIterator
	Iterator over the integer points in an N-dimensional grid. More...
class	GridIterator< T, 1, Order >
class	HermitePath
	An extendable path defined by a sequence of knots and tangent velocities. More...
class	HermiteSpline
	A cubic spline defined by two points and two velocities. More...
class	Hollow
	Selects the boundary of a shape. More...
struct	Intersector
class	Isometry
	A rigid rotation and translation. More...
class	KDTree
	A hierarchical spatial index. More...
class	MatrixHandle
	A generic matrix class which can hold references to all other matrix types. More...
class	MatrixWrapper
class	NonsquareMatrixException
class	Path
class	PerlinNoise
	Real-valued smooth noise over N dimensions. More...
class	PermutationMatrix
	A matrix which, by multiplication, permutes the rows or columns of another matrix. More...
class	Plane
	A geometric plane or hyperplane. More...
class	PLUDecomposition
struct	PointType
struct	PointType< T, 1 >
class	PolynomialSpline
	A cubic polynomial spline. More...
class	Projectable
	Base class describing N-dimensional shapes which implement the ability to project an arbitrary point to the nearest point on their surface. More...
class	Quat
	Quaternion class. More...
class	Raster
	An M-dimensional grid of interpolated data which can be continuously sampled. More...
class	Ray
	Ray class. More...
class	RayIntersectable
	Base class describing N-dimensional shapes which can be intersection-tested with a Ray. More...
class	Rect
	An N-dimensional axis-aligned interval. More...
class	Rotation
	A rotation in N-dimensional space. More...
class	Rotation< T, 2 >
	2D rotation. More...
class	Rotation< T, 3 >
	3D rotation. More...
struct	SampleShape
	Sample a point from a shape. More...
struct	SampleShape< Cylinder< T, N > >
	Sample a point from the interior of a cylinder. More...
struct	SampleShape< Extruded< Hollow< Shape > > >
	Sample a point from the an extruded shape with no endcaps. More...
struct	SampleShape< Extruded< Shape > >
	Sample a point from the interior of an extruded shape. More...
struct	SampleShape< Hollow< Extruded< Shape > > >
	Sample a point from the boundary of an Extruded shape. More...
struct	SampleShape< Hollow< Rect< T, N > > >
	Sample a point from the boundary of a Rect. More...
struct	SampleShape< Hollow< Sphere< T, N > > >
	Sample a point from the surface of a sphere. More...
struct	SampleShape< Rect< T, N > >
	Sample a point from the interior of a rect. More...
struct	SampleShape< Similar< Shape > >
	Sample a point from the interior of a shape transformed by a Similarity. More...
struct	SampleShape< Simplex< T, N > >
	Sample a point from the interior of a simplex. More...
struct	SampleShape< Sphere< T, N > >
	Sample a point from the interior of a sphere. More...
struct	SampleShape< SphericalCap< T, N > >
	Sample a point from the surface of a spherical cap. More...
struct	SampleShape< SphericalShell< T, N > >
	Sample a point from within a spherical shell. More...
struct	SampleShape< Transformed< Shape > >
	Sample a point from the interior of a transformed shape. More...
class	SdfEvaluable
	Base class describing N-dimensional shapes which implement a signed distance function. More...
class	Similar
	A shape transformed by a similarity transform (translation, rotation, and scale). More...
class	Similarity
	A similarity transform, which is a rotation, scaling, and translation. More...
class	SimpleMatrix
	A basic matrix with M x N elements. More...
class	Simplex
	A simplex in N dimensions (e.g. a tetrahedron, triangle, line, point). More...
struct	SizedStorage
	Array storage with templated static or dynamic size. If the array is dynamic, its length is stored internally and can be queried. More...
struct	SizedStorage< T, DYNAMIC_DIM >
struct	SmallStorage
	Array storage which does not allocate from the heap unless the requested size is larger than a threshold, N. More...
class	Sphere
	An N-dimensional circle, sphere, or hypersphere with a filled interior. More...
class	SphericalCap
	The surface of a sphere within a certain angle from its pole. More...
class	SphericalHarmonics
	Class and methods for representing band-limited functions on the surface of a 3D sphere. More...
class	SplinePath
	Base class for a path defined by a sequence of concatenated splines. More...
struct	Storage
	Array storage with templated static or dynamic size. More...
struct	Storage< T, DYNAMIC_DIM >
struct	storage_token_t
class	Subtree
	A non-const iterator to a subtree. More...
class	SubtreeBase
	Base class for all iterators into Trees. More...
class	Transformed
	A wrapper shape which transforms another arbitrary shape with an AffineTransform. More...
class	Transformed< Rect< T, N > >
	Partial specialization of Transformed for Rects. More...
struct	TransposeIterator
class	Tree
	A dynamic tree of arbitrary arity. More...
struct	Truned
	A shape swept along an arc. More...
struct	UniqueStorage
	Array storage with templated static or dynamic size, and without reference counting. More...
struct	UniqueStorage< T, DYNAMIC_DIM >
struct	UnmanagedStorage
class	Vec
	A tuple of N elements of type T. More...
class	Vec< T, 2 >
	2D specialization of vector class. More...
class	Vec< T, 3 >
	3D specialization of vector class. More...
class	Vec< T, 4 >
	4D specialization of vector class. More...
struct	VectorDimension
struct	VectorDimension< Vec< T, M > >
struct	WrappedStorage
	Array storage with templated static or dynamic size, acting as a thin, templated wrapper around a bare array which is memory managed by the caller. More...
class	ZonalHarmonics
	Represents a function on the N-sphere with axial symmetry. More...

Concepts
concept	BoundaryMeasurableObject
	A shape which can measure its boundary.
concept	BoundedObject
	A shape which can efficiently report its bounding box.
concept	ConvexObject
	A convex shape which implements its convex support function.
concept	CubicSplineObject
	Concept for a cubic spline.
concept	DimensionalObject
	Concept for an object or operation that exists in a certain dimension with a certain coordinate type.
concept	InteriorMeasurableObject
	A shape which can measure its interior region.
concept	MeasurableObject
	A shape which can measure both its surface area and volume.
concept	natively_std_hashable
concept	NDimensional
concept	ProjectableObject
	A shape which can perform an orthogonal projection to its boundary.
concept	RayIntersectableObject
	A shape which can be intersected by a ray.
concept	RegionObject
	A shape which can test for point containment.
concept	SdfObject
	A shape which can report its exact signed distance field.
concept	Transform
	Represents a means of transforming a point or vector.
concept	Transformable

Typedefs
typedef AffineTransform< double, 2 >	AffineTransform2d
typedef AffineTransform< float, 2 >	AffineTransform2f
typedef AffineTransform< double, 3 >	AffineTransform3d
typedef AffineTransform< float, 3 >	AffineTransform3f
template<typename T>
using	Coordinate = typename detail::CoordType<T>::elem_t
using	DefaultLCG
	A default random number generator type.
typedef Rect< index_t, 2 >	MatrixRegion
typedef Quat< double >	Quatd
typedef Quat< float >	Quatf
typedef Ray< double, 2 >	Ray2d
typedef Ray< float, 2 >	Ray2f
typedef Ray< index_t, 2 >	Ray2i
typedef Ray< double, 3 >	Ray3d
typedef Ray< float, 3 >	Ray3f
typedef Ray< index_t, 3 >	Ray3i
typedef Ray< double, 4 >	Ray4d
typedef Ray< float, 4 >	Ray4f
typedef Ray< index_t, 4 >	Ray4i
typedef SimpleMatrix< double, 2, 2 >	SimpleMatrix2d
typedef SimpleMatrix< float, 2, 2 >	SimpleMatrix2f
typedef SimpleMatrix< double, 3, 3 >	SimpleMatrix3d
typedef SimpleMatrix< float, 3, 3 >	SimpleMatrix3f
typedef SimpleMatrix< double, 4, 4 >	SimpleMatrix4d
typedef SimpleMatrix< float, 4, 4 >	SimpleMatrix4f
typedef SimpleMatrix< double, 0, 0 >	SimpleMatrixNd
typedef SimpleMatrix< float, 0, 0 >	SimpleMatrixNf
template<typename T, index_t N>
using	SphericalShell = Dilated<Hollow<Sphere<T,N>>>
	Convenience typedef for a spherical shell.
template<typename T>
using	Tetrahedron = Simplex<T,3>
template<typename T>
using	Triangle = Simplex<T,2>
typedef Vec< double, 2 >	Vec2d
typedef Vec< float, 2 >	Vec2f
typedef Vec< index_t, 2 >	Vec2i
typedef Vec< double, 3 >	Vec3d
typedef Vec< float, 3 >	Vec3f
typedef Vec< index_t, 3 >	Vec3i
typedef Vec< double, 4 >	Vec4d
typedef Vec< float, 4 >	Vec4f
typedef Vec< index_t, 4 >	Vec4i
template<typename T, index_t N>
using	VecType = typename PointType<T,N>::point_t
	The type of a vector in N dimensions with elements of type T.
template<typename T, index_t M, index_t N, MatrixLayout Lyt = ROW_MAJOR>
using	WrapperMatrix = SimpleMatrix<T,M,N,Lyt,STORAGE_WRAPPED>

Enumerations
enum	ArrayOrder { ARRAYORDER_FIRST_DIM_CONSECUTIVE , ARRAYORDER_LAST_DIM_CONSECUTIVE }
	Array traversal order, specified in terms of which axes to increment first. More...
enum class	DiscontinuityPolicy {   NaN , Average , Left , Right ,   Inf }
	Policy for handling discontinuous derivatives. More...
enum	EdgeBehavior { EDGE_CLAMP , EDGE_PERIODIC , EDGE_MIRROR , EDGE_CONSTANT }
	Raster edge-sampling behavior. More...
enum	Interpolation { INTERP_NEAREST , INTERP_LINEAR , INTERP_CUBIC }
	Behavior for sampling between data points. More...
enum class	KDAxisChoice { AXIS_LONGEST , AXIS_HIGHEST_VARIANCE , AXIS_CYCLICAL }
	Strategy for choosing an axis along which to split a group of objects in a spatial index. More...
enum class	KDInsertionChoice { INSERT_SMALLEST_VOLUME_INCREASE , INSERT_SHORTEST_DISTANCE }
	Strategy for insertion of an object into an existing tree. More...
enum class	KDPivotChoice { PIVOT_MEAN , PIVOT_MEDIAN }
	Strategy for choosing the pivot value when splitting a group of objects in a spatial index. More...
enum	MatrixLayout { ROW_MAJOR , COL_MAJOR }
enum	StoragePolicy { STORAGE_SHARED , STORAGE_UNIQUE , STORAGE_WRAPPED }

Functions
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	abs (const geom::Dual< T, P > &d)
	Absolute value.
template<typename T, index_t N>
geom::Vec< T, N >	abs (const geom::Vec< T, N > &v)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	acos (const geom::Dual< T, P > &d)
	Arccos (inverse cosine) function.
template<typename Ma, typename Mb>
std::enable_if< detail::MatrixDimensionMatch< Ma, Mb >::isStaticMatch, typenamedetail::_ImplMatrixAdd< Ma, Mb >::return_t >::type	add (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
Matrix	add (const Matrix1 &a, const Matrix2 &b)
template<typename Matrix, typename Matrix1, typename Matrix2>
void	add (Matrix *d, const Matrix1 &a, const Matrix2 &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixDimensionMatch< Ma, Mb >::isStaticMatchanddetail::MatrixDimensionMatch< Ma, Md >::isStaticMatch, void >::type	add (Md *d, const Ma &a, const Mb &b)
template<typename Shape>
AnyConvexImpl< Shape >	as_any_convex (const Shape &s)
	Wrap s in a virtual class which implements the Convex concept.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	asin (const geom::Dual< T, P > &d)
	Arcsin (inverse sine) function.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	atan (const geom::Dual< T, P > &d)
	Arctan (inverse tangent) function.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	atan2 (const geom::Dual< T, P > &y, const geom::Dual< T, P > &x)
	Arctangent of y/x in the range [-pi, pi].
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	ceil (const geom::Dual< T, P > &d)
	Ceiling function.
template<typename T, index_t N>
geom::Vec< T, N >	ceil (const geom::Vec< T, N > &v)
template<typename T>
T	chebyshev (index_t kind, index_t n, T x)
template<typename T>
const Vec< T, 4 >	composite_over (Vec< T, 4 > fg, Vec< T, 4 > bg)
	Composite two non-premultiplied colors over each other.
template<typename T>
constexpr T	coord (const T &v, index_t n)
	Access the nth coordinate of a const 1-D vector (scalar).
template<typename T, index_t N>
constexpr T	coord (const Vec< T, N > &v, index_t n)
	Access the nth coordinate of a const vector or scalar.
template<typename T>
constexpr T &	coord (T &v, index_t n)
	Access the nth coordinate of a 1-D vector (scalar).
template<typename T, index_t N>
constexpr T &	coord (Vec< T, N > &v, index_t n)
	Access the nth coordinate of a vector or scalar.
template<typename Ms, typename Md>
void	copyMatrixRegion (const Ms &src, Md &dst, const MatrixRegion &src_region, const Vec< index_t, 2 > &dst_begin)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	cos (const geom::Dual< T, P > &d)
	Cosine function.
template<typename T, index_t N>
geom::Vec< T, N >	cos (const geom::Vec< T, N > &v)
DefaultLCG	create_rng ()
	Create a new random number generator with a nondeterministic seed.
template<typename T, index_t N, index_t M>
T	det (const DiagMatrix< T, N, M > &m)
	Compute the determinant of a diagonal matrix.
template<index_t N>
index_t	det (const PermutationMatrix< N > &m)
	Compute the determinant of a permutation matrix.
template<typename T, MatrixLayout Lyt, StoragePolicy P>
T	det (const SimpleMatrix< T, 2, 2, Lyt, P > &m)
template<typename T, MatrixLayout Lyt, StoragePolicy P>
T	det (const SimpleMatrix< T, 3, 3, Lyt, P > &m)
template<typename T, MatrixLayout Lyt, StoragePolicy P>
T	det (const SimpleMatrix< T, 4, 4, Lyt, P > &m)
template<typename T, index_t M, index_t N, MatrixLayout Lyt, StoragePolicy P>
T	det (const SimpleMatrix< T, M, N, Lyt, P > &m)
	Compute the determinant of a square matrix.
template<typename T>
T	det2x2 (const T m[4])
template<typename T>
T	det2x2 (T a, T b, T c, T d)
	Compute the 2x2 matrix determinant from individual parameters.
template<typename T>
T	det3x3 (const T m[9])
	Compute the 3x3 matrix determinant.
template<typename T>
T	det3x3 (T a, T b, T c, T d, T e, T f, T g, T h, T i)
	Compute the 3x3 matrix determinant from individual parameters.
template<typename T>
T	det4x4 (const T m[16])
	Compute the 4x4 matrix determinant.
template<typename T>
T	det_destructive (T *m, index_t n)
	Destructively compute the determinant of a square matrix.
template<typename T>
T	detNxN (const T *m, index_t n)
	Compute the determinant of a square matrix.
template<typename Shape>
Dilated< Shape >	dilate (const Dilated< Shape > &s, typename Shape::elem_t dilation)
	Dilate the shape s by the amount dilation.
template<typename Shape>
Dilated< Shape >	dilate (const Shape &s, typename Shape::elem_t dilation)
	Dilate the shape s by the amount dilation.
template<typename T, index_t N>
Sphere< T, N >	dilate (const Sphere< T, N > &s, T dilation)
	Dilate the Sphere s by the amount dilation.
template<typename T, index_t N>
Plane< T, N >	dilate (Plane< T, N > p, T dilation)
	Dilate the Plane p by the amount dilation.
template<typename T>
AffineTransform< T, 3 >	direction_align (const Vec< T, 3 > &dir, const Vec< T, 3 > &align_with)
template<typename T, index_t N>
void	emit_hull (FILE *f, const Vec< T, N > *pts, index_t n)
template<typename T, index_t N>
void	emit_simplex (FILE *f, const Simplex< T, N > &s)
template<typename T, index_t N>
void	emit_splex_stage (FILE *f, const Simplex< T, N > &cur, const Simplex< T, N > &next, const Vec< T, N > &a, const Vec< T, N > &d)
template<typename T, index_t N>
void	emit_vec (FILE *f, const char *label, const Vec< T, N > &v)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	exp (const geom::Dual< T, P > &d)
	Exponential (ex) function.
template<typename T, index_t N>
geom::Vec< T, N >	exp (const geom::Vec< T, N > &v)
template<typename Shape>
Extruded< Shape >	extrude (const Shape &s, typename Shape::elem_t h0, typename Shape::elem_t h1)
	Convenience function to extrude the shape s between heights h0 and h1 by wrapping s in the Extruded template.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	floor (const geom::Dual< T, P > &d)
	Floor function.
template<typename T, index_t N>
geom::Vec< T, N >	floor (const geom::Vec< T, N > &v)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	fma (geom::Dual< T, P > a, geom::Dual< T, P > b, geom::Dual< T, P > c)
	Fused multiply-add.
template<typename T>
const Vec< T, 4 >	from_argb (int aRGB)
template<typename T>
Vec< T, 3 >	from_rgb (int aRGB)
template<typename T>
const Vec< T, 4 >	from_rgba (int rgba)
template<typename Shape>
Frustum< Shape >	frustum (const Shape &s, typename Shape::elem_t h0, typename Shape::elem_t h1)
	Convenience function to raise the shape s into a frustum between heights h0 and h1, by wrapping s in the Frustum template.
template<typename T, typename H>
H	hash (const T &obj)
	Produce a hash of an object.
template<typename T, typename H>
H	hash_array (H nonce, const T *objs, size_t count)
template<typename H>
H	hash_bytes (H nonce, const void *obj, size_t size)
template<std::unsigned_integral H>
constexpr H	hash_combine (H h0, H h1)
	Combine two hashes into one.
template<typename H>
constexpr H	hash_combine_many (H h)
template<typename H, typename... Hs>
constexpr H	hash_combine_many (H h, Hs... hashes)
template<typename H, typename... Ts>
H	hash_many (H nonce, const Ts &... objs)
template<typename T, index_t N>
bool	intersects (const AnyConvex< T, N > &shape_a, const AnyConvex< T, N > &shape_b)
template<typename Matrix1>
Matrix	inv (const Matrix1 &m, bool *success)
template<typename Mx>
detail::_ImplMtxInv< Mx >::return_t	inv (const Mx &m, bool *success, M_ENABLE_IF(Mx::ROWDIM==Mx::COLDIM or Mx::ROWDIM *Mx::COLDIM==DYNAMIC_DIM))
template<typename Matrix1, typename Matrix2>
bool	inv (Matrix1 *into, const Matrix2 &src)
template<typename Md, typename Mx>
bool	inv (Md *into, const Mx &src, M_ENABLE_IF((detail::MatrixDimensionMatch< Md, Mx >::isStaticMatch and(Mx::ROWDIM==Mx::COLDIM or Mx::ROWDIM *Mx::COLDIM==DYNAMIC_DIM))))
template<typename T>
bool	inv2x2 (T *out, const T m[4])
	2 × 2 matrix inversion on a flat array.
template<typename T>
bool	inv3x3 (T *out, const T m[9])
	3 × 3 matrix inversion on a flat array.
template<typename T>
bool	inv4x4 (T *out, const T m[16])
	4 × 4 matrix inversion on a flat array.
template<typename T, index_t N>
bool	invNxN (T *out, T *m)
	N × N matrix inversion.
template<typename T>
bool	invNxN (T *out, T *m, index_t n)
	N × N matrix inversion on a flat array.
template<typename T>
T	legendre (index_t l, index_t m, T x)
template<typename T>
T	legendre (index_t n, T x)
template<typename T, index_t N>
void	legendre (SphericalHarmonics< T, N > *sh, index_t m, T x)
template<typename T>
T	legendre_integral (index_t n, T x)
template<typename T, geom::DiscontinuityPolicy Dp>
geom::Dual< T, Dp >	log (const geom::Dual< T, Dp > &d)
	Returns the natural logarithm of d.
template<typename T, index_t N>
geom::Vec< T, N >	log (const geom::Vec< T, N > &v)
template<typename T, index_t N>
constexpr T	mag (const Vec< T, N > &v)
	Compute the magnitude of a vector or scalar.
template<typename T>
constexpr T	mag (T x)
	Compute the absolute value of a scalar.
template<typename T, index_t N>
constexpr T	mag2 (const Vec< T, N > &v)
	Compute the squared magnitude of a vector or scalar.
template<typename T>
constexpr T	mag2 (T x)
	Compute the square of a scalar.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	max (const geom::Dual< T, P > &d1, const geom::Dual< T, P > &d2)
	Maximum.
template<typename T, index_t N>
geom::Vec< T, N >	max (const geom::Vec< T, N > &a, const geom::Vec< T, N > &b)
template<typename T>
constexpr T	measure_ball_interior (index_t d, T r)
	Formula for the volume of a d dimensional ball with radius r.
template<typename T>
constexpr T	measure_sphere_boundary (index_t d, T r)
	Formula for the surface area of a d dimensional ball with radius r.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	min (const geom::Dual< T, P > &d1, const geom::Dual< T, P > &d2)
	Minimum.
template<typename T, index_t N>
geom::Vec< T, N >	min (const geom::Vec< T, N > &a, const geom::Vec< T, N > &b)
template<typename T, index_t N>
Isometry< T, N >	mix (T s, const Isometry< T, N > &a, const Isometry< T, N > &b)
	Continuously interpolate two isometries.
template<typename T, index_t N>
Similarity< T, N >	mix (T s, const Similarity< T, N > &a, const Similarity< T, N > &b)
	Interpolate between two similarity transforms. It is invalid to interpolate between two similarity transforms with different signs.
template<typename T>
Rotation< T, 2 >	mix (T s, const Rotation< T, 2 > &a, const Rotation< T, 2 > &b)
	Minimally interpolate two rotations.
template<typename T>
Rotation< T, 3 >	mix (T s, const Rotation< T, 3 > &a, const Rotation< T, 3 > &b)
	Minimally interpolate two rotations.
template<typename Ma, typename Mb>
bool	mtx_aliases_storage (const Ma &a, const Mb &b)
template<typename T, index_t N>
bool	mtx_aliases_storage (const Vec< T, N > &a, const Vec< T, N > &b)
template<typename Matrix, typename Matrix1>
void	mtxcopy (Matrix *into, const Matrix1 &src)
template<typename Md, typename Ms>
void	mtxcopy (Md *into, const Ms &src, typename std::enable_if< detail::_ImplVecOrient< Md, Ms >::orient==detail::ORIENT_VEC_UNKNOWN, int >::type dummy=0)
template<typename Md, typename Ms>
void	mtxcopy (Md *into, const Ms &src, typename std::enable_if< detail::LinalgDimensionMatch< Md, Ms >::val and(detail::_ImplVecOrient< Md, Ms >::orient !=detail::ORIENT_VEC_UNKNOWN), int >::type dummy=0)
template<typename Ma, typename Mb>
std::enable_if< detail::MatrixMultipliable< Ma, Mb >::val, typenamedetail::_ImplMtxMul< Ma, Mb >::return_t >::type	mul (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
Matrix	mul (const Matrix1 &a, const Matrix2 &b)
template<typename Matrix, typename Matrix1, typename Matrix2>
Matrix &	mul (Matrix *into, const Matrix1 &a, const Matrix2 &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixMultipliable< Ma, Mb >::valanddetail::_ImplMtxResult< Ma, Mb, Md >::agreement==detail::MTX_RESULT_UNKNOWN, Md & >::type	mul (Md *into, const Ma &a, const Mb &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixMultipliable< Ma, Mb >::valanddetail::_ImplMtxResult< Ma, Mb, Md >::agreement==detail::MTX_RESULT_MATCH, Md & >::type	mul (Md *into, const Ma &a, const Mb &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixMultipliable< Ma, Mb >::valanddetail::_ImplMtxResult< Ma, Mb, Md >::agreement==detail::MTX_RESULT_UNKNOWN, Md & >::type	mul_acc (Md *into, const Ma &a, const Mb &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixMultipliable< Ma, Mb >::valanddetail::_ImplMtxResult< Ma, Mb, Md >::agreement==detail::MTX_RESULT_MATCH, Md & >::type	mul_acc (Md *into, const Ma &a, const Mb &b)
template<typename T, index_t N>
bool	nullspace (const Vec< T, N > bases[], index_t n, Vec< T, N > null_basis[])
	Compute the null space of a vector basis.
template<typename Ma, typename Mb>
std::enable_if< detail::IsMatrix< Ma >::valanddetail::IsMatrix< Mb >::val, bool >::type	operator!= (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
bool	operator!= (const Matrix1 &a, const Matrix2 &b)
template<typename T, index_t N, Transform< T, N > Xf>
BezierSpline< T, N >	operator* (const Xf &xf, const BezierSpline< T, N > &spline)
template<typename T, index_t N, Transform< T, N > Xf>
BSpline< T, N >	operator* (const Xf &xf, const BSpline< T, N > &spline)
template<typename T, index_t N, Transform< T, N > Xf>
CatromSpline< T, N >	operator* (const Xf &xf, const CatromSpline< T, N > &spline)
template<typename T, index_t N, Transform< T, N > Xf>
HermiteSpline< T, N >	operator* (const Xf &xf, const HermiteSpline< T, N > &spline)
template<typename T, index_t N>
Capsule< T, N >	operator* (const Isometry< T, N > &xf, const Capsule< T, N > &c)
	Transform a capsule by an isometry.
template<typename T, index_t N>
Cylinder< T, N >	operator* (const Isometry< T, N > &xf, const Cylinder< T, N > &c)
	Transform a cylinder by an isometry.
template<typename T, index_t N, typename Shape>
Dilated< Shape >	operator* (const Isometry< T, N > &xf, const Dilated< Shape > &s)
	Transform a dilated shape by an isometry.
template<typename T, index_t N>
Simplex< T, N >	operator* (const Isometry< T, N > &xf, const Simplex< T, N > &s)
	Transform a simplex by an isometry.
template<typename T, index_t N>
Sphere< T, N >	operator* (const Isometry< T, N > &xf, const Sphere< T, N > &s)
	Transform a sphere by an isometry.
template<typename T, index_t N>
Isometry< T, N >	operator* (const Isometry< T, N > &xf, T s)
	Scale the magnitude of an isometry.
template<typename T, index_t N>
Isometry< T, N >	operator* (T s, const Isometry< T, N > &xf)
	Scale the magnitude of an isometry. A scale of 0 produces an identity transform. Applying a scale of 1 to an isometry results in no change.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator* (const Dual< T, Dp > &d, U s)
	Dual-scalar multiplication.
template<typename T, DiscontinuityPolicy Dp>
constexpr auto	operator* (const Dual< T, Dp > &d1, const Dual< T, Dp > &d2)
	Dual-dual multiplication.
template<typename Ma, typename Mb>
detail::MatrixMultReturnType< Ma, Mb >::return_t	operator* (const Ma &a, const Mb &b)
template<typename U, typename Matrix>
Matrix	operator* (const Matrix &m, U k)
template<typename Matrix1, typename Matrix2>
Matrix	operator* (const Matrix1 &a, const Matrix2 &b)
template<typename U, typename Mx>
std::enable_if< detail::IsMatrix< Mx >::valandstd::is_scalar< U >::value, typenamedetail::_ImplMatrixScale< Mx >::return_t >::type	operator* (const Mx &m, U k)
template<typename V, typename U>
std::enable_if< std::is_scalar< U >::valueanddetail::IsVector< V >::value, V >::type	operator* (const V &v, U d)
template<typename V, typename U>
std::enable_if< std::is_scalar< U >::valueanddetail::IsVector< V >::value, V >::type	operator* (U d, const V &v)
template<typename U, typename Matrix>
Matrix	operator* (U k, const Matrix &m)
template<typename U, typename Mx>
std::enable_if< detail::IsMatrix< Mx >::valandstd::is_scalar< U >::value, typenamedetail::_ImplMatrixScale< Mx >::return_t >::type	operator* (U k, const Mx &m)
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator* (U s, const Dual< T, Dp > &d)
	Scalar-dual multiplication.
template<typename T, index_t N>
Ray< T, N >	operator* (const Isometry< T, N > &xf, const Ray< T, N > &ray)
	Transform a ray.
template<typename T, index_t N>
PointType< T, N >::point_t	operator* (const Ray< T, N > r, T s)
template<typename T, index_t N>
Ray< T, N >	operator* (const Rotation< T, N > &rot, Ray< T, N > ray)
	Apply a rotation to a ray.
template<typename T, index_t N>
Ray< T, N >	operator* (const Similarity< T, N > &i, const Ray< T, N > &ray)
	Transform a ray.
template<typename T, index_t N>
PointType< T, N >::point_t	operator* (T s, const Ray< T, N > r)
template<typename T, index_t N>
Isometry< T, N >	operator* (const Isometry< T, N > &i, const Rotation< T, N > &r)
	Apply an isometry to a rotation.
template<typename T>
Rotation< T, 2 >	operator* (const Rotation< T, 2 > &o, T s)
	Extend a rotation.
template<typename T>
Rotation< T, 3 >	operator* (const Rotation< T, 3 > &o, T s)
	Extend a rotation.
template<typename T, index_t N>
Isometry< T, N >	operator* (const Rotation< T, N > &r, const Isometry< T, N > &i)
	Apply a rotation to an isometry.
template<typename T, index_t N>
Similarity< T, N >	operator* (const Rotation< T, N > &r, const Similarity< T, N > &i)
	Apply a rotation to a similarity.
template<typename T, index_t N>
Similarity< T, N >	operator* (const Similarity< T, N > &i, const Rotation< T, N > &r)
	Apply a similarity to a rotation.
template<typename T>
Rotation< T, 2 >	operator* (T s, const Rotation< T, 2 > &o)
	Extend a rotation.
template<typename T>
Rotation< T, 3 >	operator* (T s, const Rotation< T, 3 > &o)
	Extend a rotation.
template<typename Shape>
Similar< Shape >	operator* (const Similarity< typename Shape::elem_t, Shape::N > &xf, const Shape &shape)
	Transform the shape shape by wrapping it with a Similarity transform.
template<typename Shape>
Similar< Shape >	operator* (const Similarity< typename Shape::elem_t, Shape::N > &xf, const Similar< Shape > &s)
	Transform the shape s by xf.
template<typename T, index_t N>
Capsule< T, N >	operator* (const Similarity< T, N > &xf, const Capsule< T, N > &c)
	Transform a capsule by a similarity transform.
template<typename T, index_t N>
Cylinder< T, N >	operator* (const Similarity< T, N > &xf, const Cylinder< T, N > &c)
	Transform a cylinder by a similarity transform.
template<typename T, index_t N, typename Shape>
Dilated< Shape >	operator* (const Similarity< T, N > &xf, const Dilated< Shape > &s)
	Transform a dilated shape by a similarity transform.
template<typename T, index_t N>
Simplex< T, N >	operator* (const Similarity< T, N > &xf, const Simplex< T, N > &s)
	Transform a simplex by a similarity transform.
template<typename T, index_t N>
Sphere< T, N >	operator* (const Similarity< T, N > &xf, const Sphere< T, N > &s)
	Transform a sphere by a similarity transform.
template<typename Shape>
Transformed< Shape >	operator* (const AffineTransform< typename Shape::elem_t, Shape::N > &xf, const Shape &s)
	Transform the shape s by wrapping it in an Transformed class.
template<typename Shape>
Transformed< Shape >	operator* (const AffineTransform< typename Shape::elem_t, Shape::N > &xf, const Transformed< Shape > &s)
	Transform the transformed shape s by xf.
template<typename Shape, typename T, index_t N>
Transformed< Shape >	operator* (const Isometry< T, N > &xf, const Transformed< Shape > &s)
	Transform the shape s by an isometry xf.
template<typename Shape, typename T, index_t N>
Transformed< Shape >	operator* (const Similarity< T, N > &xf, const Transformed< Shape > &s)
	Transform the shape s by a similarity transform xf.
template<typename T, index_t N>
const Vec< T, N >	operator* (const Vec< T, N > &a, const Vec< T, N > &b)
template<typename T, index_t N, typename U>
Vec< T, N >	operator* (const Vec< T, N > &v, U d)
template<typename T, index_t N, typename U>
Vec< T, N >	operator* (U d, const Vec< T, N > &v)
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator*= (Dual< T, Dp > &x, const Dual< T, Dp > &y)
	Multiply and assign to dual.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator*= (Dual< T, Dp > &x, T s)
	Multiply and assign to dual.
template<typename Matix, T, M, N>
Matrix &	operator*= (Matrix &m, const DiagMatrix< T, M, N > &d)
template<typename Mx, typename T, index_t M, index_t N>
std::enable_if< detail::MatrixMultipliable< Mx, DiagMatrix< T, M, N > >::val, Mx & >::type	operator*= (Mx &m, const DiagMatrix< T, M, N > &d)
template<typename Shape>
Similar< Shape > &	operator*= (Similar< Shape > &s, const Similarity< typename Shape::elem_t, Shape::N > &xf)
	In-place transform the shape s by xf.
template<typename Shape>
Transformed< Shape > &	operator*= (Transformed< Shape > &s, const AffineTransform< typename Shape::elem_t, Shape::N > &xf)
	In-place transform the transformed shape s by xf.
template<typename T, index_t N>
Isometry< T, N >	operator+ (const Isometry< T, N > &i, const Vec< T, N > &v)
	Apply a translation to an isometry.
template<typename T, index_t N>
Isometry< T, N >	operator+ (const Vec< T, N > &v, const Isometry< T, N > &i)
	Apply a translation to an isometry.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator+ (const Dual< T, Dp > &d, U s)
	Dual + scalar.
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator+ (const Dual< T, Dp > &d1, const Dual< T, Dp > &d2)
	Addition.
template<typename Ma, typename Mb>
detail::_ImplMatrixAddReturnType< Ma, Mb >::return_t	operator+ (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
Matrix	operator+ (const Matrix1 &a, const Matrix2 &b)
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator+ (U s, const Dual< T, Dp > &d)
	Scalar + dual.
template<typename T, index_t N>
Rect< T, N >	operator+ (VecType< T, N > p, const Rect< T, N > &r)
template<typename T, index_t N>
Similarity< T, N >	operator+ (const Similarity< T, N > &i, const Vec< T, N > &v)
	Apply a translation to a similarity.
template<typename T, index_t N>
Similarity< T, N >	operator+ (const Vec< T, N > &v, const Similarity< T, N > &i)
	Apply a translation to a similarity.
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator+= (Dual< T, Dp > &x, const Dual< T, Dp > &y)
	Add and assign.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator+= (Dual< T, Dp > &x, U s)
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator- (const Dual< T, Dp > &d)
	Unary negation.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator- (const Dual< T, Dp > &d, U s)
	Dual - scalar.
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator- (const Dual< T, Dp > &d1, const Dual< T, Dp > &d2)
	Subtraction.
template<typename Ma, typename Mb>
detail::_ImplMatrixAddReturnType< Ma, Mb >::return_t	operator- (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
Matrix	operator- (const Matrix1 &a, const Matrix2 &b)
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator- (U s, const Dual< T, Dp > &d)
	Scalar - dual.
template<typename T, index_t N>
Rect< T, N >	operator- (VecType< T, N > p, const Rect< T, N > &r)
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator-= (Dual< T, Dp > &x, const Dual< T, Dp > &y)
	Subtract and assign.
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator-= (Dual< T, Dp > &x, U s)
template<typename T, index_t N, Transform< T, N > Xf>
BezierSpline< T, N >	operator/ (const BezierSpline< T, N > &spline, const Xf &xf)
template<typename T, index_t N, Transform< T, N > Xf>
BSpline< T, N >	operator/ (const BSpline< T, N > &spline, const Xf &xf)
template<typename T, index_t N, Transform< T, N > Xf>
CatromSpline< T, N >	operator/ (const CatromSpline< T, N > &spline, const Xf &xf)
template<typename T, index_t N, Transform< T, N > Xf>
HermiteSpline< T, N >	operator/ (const HermiteSpline< T, N > &spline, const Xf &xf)
template<typename T, index_t N>
Capsule< T, N >	operator/ (const Capsule< T, N > &c, const Isometry< T, N > &xf)
	Inverse-transform a capsule by an isometry.
template<typename T, index_t N>
Cylinder< T, N >	operator/ (const Cylinder< T, N > &c, const Isometry< T, N > &xf)
	Inverse-transform a cylinder by an isometry.
template<typename T, index_t N, typename Shape>
Dilated< Shape >	operator/ (const Dilated< Shape > &s, const Isometry< T, N > &xf)
	Inverse-transform a dilated shape by an isometry.
template<typename T, index_t N>
Simplex< T, N >	operator/ (const Simplex< T, N > &s, const Isometry< T, N > &xf)
	Inverse-transform a simplex by an isometry.
template<typename T, index_t N>
Sphere< T, N >	operator/ (const Sphere< T, N > &s, const Isometry< T, N > &xf)
	Inverse-transform a sphere by an isometry.
template<typename T, index_t N>
Vec< T, N >	operator/ (const Vec< T, N > &v, const Isometry< T, N > &i)
	Transform a point.
template<typename T, std::common_with< T > U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator/ (const Dual< T, Dp > &d, U s)
	Dual / scalar division.
template<typename T, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator/ (const Dual< T, Dp > &d1, const Dual< T, Dp > &d2)
	Dual-dual division.
template<typename T, std::common_with< T > U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp >	operator/ (U s, const Dual< T, Dp > &d)
	Scalar / dual division.
template<typename T, index_t N>
Ray< T, N >	operator/ (const Ray< T, N > &ray, const Isometry< T, N > &xf)
	Inverse-transform a ray.
template<typename T, index_t N>
Ray< T, N >	operator/ (const Ray< T, N > &ray, const Similarity< T, N > &i)
	Inverse-transform a ray.
template<typename T, index_t N>
Ray< T, N >	operator/ (Ray< T, N > ray, const Rotation< T, N > &rot)
	Apply the inverse of a rotation to a ray.
template<typename T>
Vec< T, 2 >	operator/ (const Vec< T, 2 > &v, const Rotation< T, 2 > &r)
	Apply the inverse of a rotation to a vector.
template<typename T>
Vec< T, 3 >	operator/ (const Vec< T, 3 > &v, const Rotation< T, 3 > &r)
	Apply the inverse of a rotation to a vector.
template<typename Shape>
Similar< Shape >	operator/ (const Shape &s, const Similarity< typename Shape::elem_t, Shape::N > &xf)
	Transform the shape s by the inverse of xf.
template<typename Shape>
Similar< Shape >	operator/ (const Similar< Shape > &s, const Similarity< typename Shape::elem_t, Shape::N > &xf)
	Transform the shape s by the inverse of xf.
template<typename T, index_t N>
Capsule< T, N >	operator/ (const Capsule< T, N > &c, const Similarity< T, N > &xf)
	Inverse-transform a capsule by a similarity transform.
template<typename T, index_t N>
Cylinder< T, N >	operator/ (const Cylinder< T, N > &c, const Similarity< T, N > &xf)
	Inverse-transform a cylinder by a similarity transform.
template<typename T, index_t N, typename Shape>
Dilated< Shape >	operator/ (const Dilated< Shape > &s, const Similarity< T, N > &xf)
	Inverse-transform a dilated shape by a similarity transform.
template<typename T, index_t N>
Simplex< T, N >	operator/ (const Simplex< T, N > &s, const Similarity< T, N > &xf)
	Inverse-transform a simplex by a similarity transform.
template<typename T, index_t N>
Sphere< T, N >	operator/ (const Sphere< T, N > &s, const Similarity< T, N > &xf)
	Inverse-transform a sphere by a similarity transform.
template<typename T, index_t N>
Vec< T, N >	operator/ (const Vec< T, N > &v, const Similarity< T, N > &i)
	Transform a point.
template<typename Shape>
Transformed< Shape >	operator/ (const Shape &s, const AffineTransform< typename Shape::elem_t, Shape::N > &xf)
	Transform the shape s by the inverse of xf.
template<typename Shape>
Transformed< Shape >	operator/ (const Transformed< Shape > &s, const AffineTransform< typename Shape::elem_t, Shape::N > &xf)
	Transform the transformed shape s by the inverse of xf.
template<typename Shape, typename T, index_t N>
Transformed< Shape >	operator/ (const Transformed< Shape > &s, const Isometry< T, N > &xf)
	Inverse transform the shape s by an isometry xf.
template<typename Shape, typename T, index_t N>
Transformed< Shape >	operator/ (const Transformed< Shape > &s, const Similarity< T, N > &xf)
	Inverse transform the shape s by a similarity transform xf.
template<typename T, index_t N>
const Vec< T, N >	operator/ (const Vec< T, N > &a, const Vec< T, N > &b)
template<typename T, index_t N, typename U>
Vec< T, N >	operator/ (const Vec< T, N > &v, U d)
template<typename T, index_t N, typename U>
Vec< T, N >	operator/ (const Vec< T, N > &v, U d)
template<typename T, typename U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator/= (Dual< T, Dp > &x, const Dual< U, Dp > &y)
	Divide and assign to dual.
template<typename T, std::common_with< T > U, DiscontinuityPolicy Dp>
constexpr Dual< T, Dp > &	operator/= (Dual< T, Dp > &x, U s)
	Divide and assign to dual.
template<typename Shape>
Similar< Shape > &	operator/= (Similar< Shape > &s, const Similarity< typename Shape::elem_t, Shape::N > &xf)
	In-place transform the shape s by the inverse of xf.
template<typename Shape>
Transformed< Shape > &	operator/= (Transformed< Shape > &s, const AffineTransform< typename Shape::elem_t, Shape::N > &xf)
	In-place transform the transformed shape s by the inverse of xf.
template<typename Ma, typename Mb>
std::enable_if< detail::IsMatrix< Ma >::valanddetail::IsMatrix< Mb >::valandnotdetail::MatrixDimensionMatch< Ma, Mb >::isStaticMatch, bool >::type	operator== (const Ma &a, const Mb &b)
template<typename Ma, typename Mb>
std::enable_if< detail::IsMatrix< Ma >::valanddetail::IsMatrix< Mb >::valanddetail::MatrixDimensionMatch< Ma, Mb >::isStaticMatch, bool >::type	operator== (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
bool	operator== (const Matrix1 &a, const Matrix2 &b)
template<typename T>
Vec< T, 2 >	orthogonal (const Vec< T, 2 > v[1])
template<typename T>
Vec< T, 3 >	orthogonal (const Vec< T, 3 > v[2])
template<typename T, index_t N>
Vec< T, N >	orthogonal (const Vec< T, N > v[N-1])
	Return a vector orthogonal to the given N-1 vectors.
template<typename T>
void	orthogonalize (Vec< T, 2 > basis[2], index_t _n=2)
template<typename T, index_t N>
void	orthogonalize (Vec< T, N > basis[], index_t n)
	Use the Gram-Schmidt process to orthogonalize a set of basis vectors.
template<typename T, index_t N>
void	orthonormalize (Vec< T, N > basis[], index_t n)
	Use the Gram-Schmidt process to orthonormalize a set of basis vectors.
template<typename RandomAccessIterator>
void	permutation_apply (index_t *p, index_t n, RandomAccessIterator v)
	Apply a permutation in-place, resetting the permutation to identity in the process.
index_t	permutation_sign (index_t *p, index_t n)
	Compute the sign of a permutation, resetting the permutation to identity in the process.
template<typename T, typename U>
geom::Dual< T >	pow (const geom::Dual< T > &base, U xp)
	Returns base raised to exponent xp.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	pow (const geom::Dual< T, P > &base, const geom::Dual< T, P > &xp)
	Returns base raised to exponent xp.
template<typename T, typename U, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	pow (U base, const geom::Dual< T, P > &xp)
	Returns base raised to exponent xp.
template<typename T, index_t N>
Vec< T, N >	project_to_orthogonal_subspace (const Vec< T, N > bases[], Vec< T, N > x, index_t n)
	Project a vector onto an orthogonal subspace.
template<typename T, index_t N>
Vec< T, N >	project_to_subspace (Vec< T, N > bases[], Vec< T, N > x, index_t n)
	Project a vector onto a non-orthogonal subspace.
template<typename T>
Vec< T, 3 >	rainbow (double s)
template<typename T, index_t N, typename Generator>
VecType< T, N >	random_gaussian (Generator &rng)
	Generate a random vector drawn from a multivariate gaussian distribution with mean 0 and variance 1.
template<typename T, index_t N, typename Generator>
VecType< T, N >	random_unit (Generator &rng)
	Generate a random vector with unit length.
template<typename T, index_t N>
AffineTransform< T, N >	remap_transform (const Rect< T, N > &region)
	Return a transformation which maps the unit interval to the region.
template<typename T>
AffineTransform< T, 3 >	rotation (Quat< T > q)
template<typename T>
AffineTransform< T, 2 >	rotation (T radians)
template<typename T>
AffineTransform< T, 3 >	rotation (Vec< T, 3 > axis, const Vec< T, 3 > &center, T radians)
template<typename T>
AffineTransform< T, 3 >	rotation (Vec< T, 3 > axis, T radians)
template<typename T>
AffineTransform< T, 3 >	rotation_x (T theta)
template<typename T>
AffineTransform< T, 3 >	rotation_y (T theta)
template<typename T>
AffineTransform< T, 3 >	rotation_z (T theta)
template<typename T>
SimpleMatrix< T, 3, 3 >	rotmat (const Quat< T > &q)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *into, const Quat< T > &q)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *into, const Vec< T, 3 > &axis, T theta)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *into, T x, T y, T z, T px, T py, T pz, T theta)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *into, T x, T y, T z, T theta)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *into, Vec< T, 3 > axis, Vec< T, 3 > ctr, T theta)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *out_mat, SimpleMatrix< T, 4, 4 > *out_inv, const Vec< T, 3 > &axis, const Vec< T, 3 > &ctr, T theta)
template<typename T>
void	rotmat (SimpleMatrix< T, 4, 4 > *out_mat, SimpleMatrix< T, 4, 4 > *out_inv, T x, T y, T z, T px, T py, T pz, T theta)
template<typename T>
SimpleMatrix< T, 3, 3 >	rotmat_direction_align (const Vec< T, 3 > &dir, const Vec< T, 3 > &alignWith)
template<typename T>
void	rotmat_direction_align (SimpleMatrix< T, 3, 3 > *into, const Vec< T, 3 > &dir, const Vec< T, 3 > &alignWith)
template<typename T>
void	rotmat_direction_align (SimpleMatrix< T, 4, 4 > *into, const Vec< T, 3 > &dir, const Vec< T, 3 > &alignWith)
template<typename T>
void	rotmat_x (SimpleMatrix< T, 4, 4 > *into, T theta)
template<typename T>
SimpleMatrix< T, 3, 3 >	rotmat_x (T theta)
template<typename T>
void	rotmat_y (SimpleMatrix< T, 4, 4 > *into, T theta)
template<typename T>
SimpleMatrix< T, 3, 3 >	rotmat_y (T theta)
template<typename T>
void	rotmat_z (SimpleMatrix< T, 4, 4 > *into, T theta)
template<typename T>
SimpleMatrix< T, 3, 3 >	rotmat_z (T theta)
template<typename T, index_t N>
Dilated< Rect< T, N > >	roundrect (const Rect< T, N > &rect, T radius)
	Produce a rounded rectangle with corner radius radius.
template<typename T, index_t N>
AffineTransform< T, N >	scale (const Vec< T, N > &sx)
template<typename T>
AffineTransform< T, 2 >	scale (T sx, T sy)
template<typename T>
AffineTransform< T, 3 >	scale (T sx, T sy, T sz)
template<typename U typename Matrix, typename Matrix>
void	scale (Matrix1 *d, U k, const Matrix &m)
template<typename U, typename Mx, typename Md>
std::enable_if< detail::IsMatrix< Mx >::valandstd::is_scalar< U >::valueanddetail::MatrixDimensionMatch< Mx, Md >::isStaticMatch, void >::type	scale (Md *d, U k, const Mx &m)
template<typename T>
AffineTransform< T, 1 >	scale (T sx)
template<typename U, typename Matrix>
Matrix	scale (U k, const Matrix &m)
template<typename U, typename Mx>
std::enable_if< detail::IsMatrix< Mx >::valandstd::is_scalar< U >::value, typenamedetail::_ImplMatrixScale< Mx >::return_t >::type	scale (U k, const Mx &m)
template<typename T, index_t N>
Dilated< Hollow< Sphere< T, N > > >	shell (const Sphere< T, N > &s, T thickness)
	Create a spherical shell with wall thickness thickness around the Sphere s.
template<typename T, index_t N>
Dilated< Hollow< Sphere< T, N > > >	shell (Vec< T, N > center, T r0, T r1)
	Create a spherical shell around center, with inner and outer radii r0 and r1.
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	sin (const geom::Dual< T, P > &d)
	Sine function.
template<typename T, index_t N>
geom::Vec< T, N >	sin (const geom::Vec< T, N > &v)
template<typename T>
T	spherical_harmonic_coeff (index_t l, index_t m, T cos_alt, T azi)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	sqrt (const geom::Dual< T, P > &d)
	Square root.
template<typename T, index_t N>
geom::Vec< T, N >	sqrt (const geom::Vec< T, N > &v)
template<typename Ma, typename Mb>
std::enable_if< detail::MatrixDimensionMatch< Ma, Mb >::isStaticMatch, typenamedetail::_ImplMatrixAdd< Ma, Mb >::return_t >::type	sub (const Ma &a, const Mb &b)
template<typename Matrix1, typename Matrix2>
Matrix	sub (const Matrix1 &a, const Matrix2 &b)
template<typename Matrix, typename Matrix1, typename Matrix2>
void	sub (Matrix *d, const Matrix1 &a, const Matrix2 &b)
template<typename Md, typename Ma, typename Mb>
std::enable_if< detail::MatrixDimensionMatch< Ma, Mb >::isStaticMatchanddetail::MatrixDimensionMatch< Ma, Md >::isStaticMatch, void >::type	sub (Md *d, const Ma &a, const Mb &b)
template<typename T, geom::DiscontinuityPolicy P>
geom::Dual< T, P >	tan (const geom::Dual< T, P > &d)
	Tangent function.
template<typename T, index_t N>
geom::Vec< T, N >	tan (const geom::Vec< T, N > &v)
template<typename T, index_t N>
bool	trace_simplex (const Vec< T, N > verts[N], const Ray< T, N > &ray, Vec< T, N-1 > *uv, T *s)
template<typename T, index_t N, MatrixLayout Lyt, StoragePolicy P>
AffineTransform< T, N >	transformation (const SimpleMatrix< T, N, N, Lyt, P > &mat)
template<typename T, index_t N>
AffineTransform< T, N >	translation (const Vec< T, N > &tx)
template<typename T>
AffineTransform< T, 2 >	translation (T tx, T ty)
template<typename T>
AffineTransform< T, 3 >	translation (T tx, T ty, T tz)
template<typename T>
AffineTransform< T, 1 >	translation (T tx)
template<typename Matrix1>
Matrix	transpose (const Matrix1 &m)
template<typename Mx>
std::enable_if< detail::IsMatrix< Mx >::val, typenamedetail::_ImplMtxTxpose< Mx >::return_t >::type	transpose (const Mx &m)
template<typename Matrix1, typename Matrix2>
void	transpose (Matrix1 *into, const Matrix2 &m)
template<typename Md, typename Mx>
std::enable_if< detail::IsMatrix< Md >::valanddetail::IsMatrix< Mx >::valand(Md::ROWDIM==Mx::COLDIMorMd::ROWDIM *Mx::COLDIM==0) and(Md::COLDIM==Mx::ROWDIMorMd::COLDIM *Mx::ROWDIM==0), void >::type	transpose (Md *into, const Mx &m)
template<typename T, index_t M, index_t N, MatrixLayout Lyt, StoragePolicy P>
std::enable_if< M *N==0orM==N, void >::type	transpose (SimpleMatrix< T, M, N, Lyt, P > *into, const SimpleMatrix< T, M, N, Lyt, P > &m)
template<typename T, index_t N>
void	transpose_square_matrix (T *m)
	Transpose a square matrix with static dimensions.
template<typename T>
void	transpose_square_matrix (T *m, index_t n)
	Transpose a square matrix.
template<typename T>
Vec< T, 3 >	triangle_normal (const Vec< T, 3 > p1, const Vec< T, 3 > p2, const Vec< T, 3 > p3)
template<std::integral H>
constexpr H	truncated_constant (uint64_t k0, uint64_t k1)
template<typename T, typename H>
constexpr H	type_constant ()
template<typename T, index_t N>
AffineTransform< T, N >	unmap_transform (const Rect< T, N > &region)
	Return a transformation which maps the region to the unit interval.
template<typename T>
T	multiply_add (T m, T x, T b)
	Fused multiply-add.
template<typename T>
T	diff_of_products (T a, T b, T c, T d)
template<typename T>
T	sum_of_products (T a, T b, T c, T d)
template<typename T>
T	positive_mod (T a, T b)
template<typename T>
T	clamp (const T &v, const T &lo, const T &hi)
template<typename S, typename T>
std::common_type< S, T >::type	mix (S t, T a, T b)
template<typename S, typename T>
T	interp_linear (const S s[], const T p[], int dim)
template<typename S, typename T>
T	interp_cubic (S s, const T p[4])
template<typename S, typename T>
T	interp_cubic (const S s[], const T p[], int dim)
template<typename T>
bool	quadratic_solve (T results[2], T a, T b, T c)
template<typename T>
T	angle_to (T radians_0, T radians_1)
template<typename T>
constexpr auto	ceil_div (T a, T b)
	Compute ceil(a/b).
template<typename T>
constexpr auto	snap (T a, T b)
	Snap a to the nearest multiple of b larger than or equal to a.
template<typename T>
constexpr auto	floor_div (T a, T b)
	Compute floor(a/b).
template<typename T> requires std::integral<T>
constexpr bool	is_power_of_two (T x)
template<typename T>
constexpr T	radians (T degrees)
	Convert degrees to radians.
template<typename T>
constexpr T	degrees (T radians)
	Convert radians to degrees.
template<typename T, bool RowMajor>
bool	cholesky (T *m, index_t n)
	Perform a Cholesky decomposition on a bare array.
template<typename T, index_t M, index_t N>
bool	cholesky (SimpleMatrix< T, M, N > *m)
	Perform a Cholesky decomposition on a Matrix.
template<typename T, bool RowMajor = true>
index_t	decomp_lup (T *m, index_t rows, index_t cols, index_t *reorder, bool *parity)
	LU decomposition, pivoting columns.
template<typename T, bool RowMajor = true>
index_t	decomp_plu (T *m, index_t rows, index_t cols, index_t *reorder, bool *parity)
	LU decomposition, pivoting rows.
template<typename T, bool RowMajor = true>
void	backsolve_plu (const T *plu, const index_t *p, index_t n, index_t m, T *x, const T *b, index_t skip=0)
	Solve the decomposed matrix equation LUX = PB for X, given LU and B.
template<typename T, bool RowMajor = true>
void	backsolve_lu (const T *lu, index_t n, index_t m, T *x, index_t skip=0)
	Solve a decomposed system of linear equations LUX = B, without a permutation map.
template<typename T, bool RowMajor = true>
bool	linear_solve (T *a, index_t n, index_t m, T *x, index_t skip=0)
	Solve the matrix equation AX = B for the matrix X, given matrices A and B.
template<typename T, index_t N>
bool	linear_solve (Vec< T, N > bases[N], index_t m, Vec< T, N > *x, index_t skip=0)
	Write each vector in b in terms of the basis vectors in bases.

Variables
template<typename T, index_t N, typename Object, typename NodeData>
const KDTree< T, N, Object, NodeData >::KDStructureParams	KDTree< T, N, Object, NodeData >::DefaultParameters
template<typename T, index_t N>
constexpr Rect< T, N >	Rect< T, N >::empty
template<typename T, index_t N>
constexpr Rect< T, N >::point_t	Rect< T, N >::endpoint_measure
template<typename T, index_t N>
constexpr Rect< T, N >	Rect< T, N >::full
template<typename T, index_t N>
constexpr Rect< T, N >	Rect< T, N >::signed_unit_interval = Rect<T,N>((T)-1, (T)1)
template<typename T, index_t N>
constexpr Rect< T, N >	Rect< T, N >::unit_interval = Rect<T,N>((T)0, (T)1)
template<typename T>
const Vec< T, 2 >	Vec< T, 2 >::X_AXIS = Vec<T,2>(1,0)
template<typename T>
const Vec< T, 2 >	Vec< T, 2 >::Y_AXIS = Vec<T,2>(0,1)
template<typename T>
const Vec< T, 3 >	Vec< T, 3 >::X_AXIS = Vec<T,3>(1,0,0)
template<typename T>
const Vec< T, 3 >	Vec< T, 3 >::Y_AXIS = Vec<T,3>(0,1,0)
template<typename T>
const Vec< T, 3 >	Vec< T, 3 >::Z_AXIS = Vec<T,3>(0,0,1)
template<typename T>
const Vec< T, 4 >	Vec< T, 4 >::W_AXIS = Vec<T,4>(0,0,0,1)
template<typename T>
const Vec< T, 4 >	Vec< T, 4 >::X_AXIS = Vec<T,4>(1,0,0,0)
template<typename T>
const Vec< T, 4 >	Vec< T, 4 >::Y_AXIS = Vec<T,4>(0,1,0,0)
template<typename T>
const Vec< T, 4 >	Vec< T, 4 >::Z_AXIS = Vec<T,4>(0,0,1,0)

Detailed Description

Namespace of all geomc functions and classes.

Typedef Documentation

VecType

template<typename T, index_t N>

using VecType = typename PointType<T,N>::point_t

The type of a vector in N dimensions with elements of type T.

VecType<T,N> is a Vec<T,N> in dimension > 1, otherwise a T.

Function Documentation

from_rgb()

template<typename T>

Vec< T, 3 > from_rgb

(

int

aRGB

)

Parameters

aRGB	A packed 8-bit per channel RGB color value (with alpha or irrelevant data in the eight high order bits).

Returns

An (r,g,b) tuple extracted from aRGB.

permutation_apply()

template<typename RandomAccessIterator>

void permutation_apply	(	index_t *	p,
		index_t	n,
		RandomAccessIterator	v )

Apply a permutation in-place, resetting the permutation to identity in the process.

Parameters

p	An array of n indecies representing the sources of elements in the permuted sequence; i.e. output[i] = input[p[i]]. p will contain the identity permutation after the function returns.
n	The number of elements in the permutation. @v A random access iterator containing the sequence to be permuted.

permutation_sign()

index_t permutation_sign ( index_t * p, index_t n )

inline

Compute the sign of a permutation, resetting the permutation to identity in the process.

Parameters

p	An array of n indecies representing the permutation mapping. p will contain the identity permutation after the function returns.
n	The number of elements in the permutation.

rainbow()

template<typename T>

Vec< T, 3 > rainbow

(

double

s

)

An (r,g,b) color tuple representing a hue selected by s, with 0 being red, progressing in rainbow order through the colors before returning to red at 1. The cycle is extended similarly outside of (0, 1).

Parameters

s	Rainbow parameter between 0 and 1.

Returns

An (r,g,b) color tuple.

triangle_normal()

template<typename T>

Vec< T, 3 > triangle_normal	(	const Vec< T, 3 >	p1,
		const Vec< T, 3 >	p2,
		const Vec< T, 3 >	p3 )

Returns

The normal of the triangle formed by p1, p2, and p3.

Variable Documentation

KDTree< T, N, Object, NodeData >::DefaultParameters

template<typename T, index_t N, typename Object, typename NodeData>

const KDTree<T,N,Object,NodeData>::KDStructureParams KDTree< T, N, Object, NodeData >::DefaultParameters

Initial value:

                                                                     = 
{
    KDAxisChoice::AXIS_LONGEST,
    KDPivotChoice::PIVOT_MEAN,
    KDInsertionChoice::INSERT_SMALLEST_VOLUME_INCREASE,
    std::min(2 << N, 16 ),        
    std::min(2 << N, 16 )         
}

Rect< T, N >::empty

template<typename T, index_t N>

Rect<T,N> Rect< T, N >::empty

constexpr

Initial value:

                            = Rect<T,N>(
    detail::max<T>(),
    detail::lowest<T>()
)

Rect< T, N >::endpoint_measure

template<typename T, index_t N>

Rect<T,N>::point_t Rect< T, N >::endpoint_measure

constexpr

Initial value:

                                                      =
std::is_integral<T>::value ? 1 : 0

Rect< T, N >::full

template<typename T, index_t N>

Rect<T,N> Rect< T, N >::full

constexpr

Initial value:

                           = Rect<T,N>(
    detail::lowest<T>(),
    detail::max<T>()
)