geomc 1.0
A c++ linear algebra template library
Loading...
Searching...
No Matches
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...
 
struct  CoordType
 
struct  CoordType< Vec< T, N > >
 
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< 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::string, H >
 
struct  Digest< std::string_view, H >
 
struct  Digest< std::tuple< Ts... >, 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  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< Shape > >
 Sample a point from the interior of an extruded shape. More...
 
struct  SampleShape< Hollow< Extruded< Hollow< Shape > > > >
 Sample a point from the surface of an extruded shape with no endcaps. 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.
 
struct  TransposeIterator
 
class  Tree
 A dynamic tree of arbitrary arity. 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  Transform
 Represents a means of transforming a point or vector.
 
concept  Transformable
 
concept  DimensionalObject
 Concept for an object or operation that exists in a certain dimension with a certain coordinate type.
 
concept  CubicSplineObject
 Concept for a cubic spline.
 
concept  BoundedObject
 A shape which can efficiently report its bounding box.
 
concept  ConvexObject
 A convex shape which implements its convex support function.
 
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  InteriorMeasurableObject
 A shape which can measure its interior region.
 
concept  BoundaryMeasurableObject
 A shape which can measure its boundary.
 
concept  MeasurableObject
 A shape which can measure both its surface area and volume.
 
concept  ProjectableObject
 A shape which can perform an orthogonal projection to its boundary.
 

Typedefs

typedef AffineTransform< double, 2 > AffineTransform2d
 
typedef AffineTransform< float, 2 > AffineTransform2f
 
typedef AffineTransform< double, 3 > AffineTransform3d
 
typedef AffineTransform< float, 3 > AffineTransform3f
 
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>
chebyshev (index_t kind, index_t n, T x)
 
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>
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>
det (const SimpleMatrix< T, 2, 2, Lyt, P > &m)
 
template<typename T, MatrixLayout Lyt, StoragePolicy P>
det (const SimpleMatrix< T, 3, 3, Lyt, P > &m)
 
template<typename T, MatrixLayout Lyt, StoragePolicy P>
det (const SimpleMatrix< T, 4, 4, Lyt, P > &m)
 
template<typename T, index_t M, index_t N, MatrixLayout Lyt, StoragePolicy P>
det (const SimpleMatrix< T, M, N, Lyt, P > &m)
 Compute the determinant of a square matrix.
 
template<typename T>
det2x2 (const T m[4])
 
template<typename T>
det2x2 (T a, T b, T c, T d)
 Compute the 2x2 matrix determinant from individual parameters.
 
template<typename T>
det3x3 (const T m[9])
 Compute the 3x3 matrix determinant.
 
template<typename 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>
det4x4 (const T m[16])
 Compute the 4x4 matrix determinant.
 
template<typename T>
det_destructive (T *m, index_t n)
 Destructively compute the determinant of a square matrix.
 
template<typename 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>
hash (const T &obj)
 Produce a hash of an object.
 
template<typename T, typename H>
hash_array (H nonce, const T *objs, size_t count)
 
template<typename 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>
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>
legendre (index_t l, index_t m, T x)
 
template<typename 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>
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_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 (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 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 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>
requires requires(T t, U u) { {t * u} -> std::convertible_to<T>; }
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>
requires requires (T t, U u) { {u * t} -> std::convertible_to<T>; }
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>
requires requires(T t, U u) { {t * u} -> std::convertible_to<T>; }
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>
requires requires(T t, U u) { {t + u} -> std::convertible_to<T>; }
constexpr Dual< T, Dp > operator+ (const Dual< T, Dp > &d, U s)
 Dual + scalar.
 
template<typename T, DiscontinuityPolicy Dp>
requires requires (T t, T u) {t + u;}
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>
requires requires(T t, U u) { {u + t} -> std::convertible_to<T>; }
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>
requires requires(T t, U u) { {t += u} -> std::convertible_to<T&>; }
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>
requires requires(T t, U u) { {t - u} -> std::convertible_to<T>; }
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>
requires requires(T t, U u) { {u - t} -> std::convertible_to<T>; }
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>
requires requires(T t, U u) { {t -= u} -> std::convertible_to<T&>; }
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>
requires requires (T t, U u) { {t / u} -> std::convertible_to<T>; }
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>
requires requires (T t, U u) { {u / t} -> std::convertible_to<T>; }
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>
requires requires (T t, U u) { {t / u} -> std::convertible_to<T>; }
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>
requires requires (T t, U u) { {t / u} -> std::convertible_to<T>; }
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 >::valanddetail::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 >::valandnotdetail::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>
Vec< 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>
Vec< 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>
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>
multiply_add (T a, T b, T c)
 Fused multiply-add.
 
template<typename T>
diff_of_products (T a, T b, T c, T d)
 
template<typename T>
sum_of_products (T a, T b, T c, T d)
 
template<typename T>
positive_mod (T a, T b)
 
template<typename 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>
interp_linear (const S s[], const T p[], int dim)
 
template<typename S, typename T>
interp_cubic (S s, const T p[4])
 
template<typename S, typename 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>
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>
requires (not std::integral<T>)
constexpr T radians (T degrees)
 Convert degrees to radians.
 
template<typename T>
requires (not std::integral<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
aRGBA 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
pAn 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.
nThe 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
pAn array of n indecies representing the permutation mapping. p will contain the identity permutation after the function returns.
nThe 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
sRainbow 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:
=
{
std::min(2 << N, 16 ),
std::min(2 << N, 16 )
}
@ INSERT_SMALLEST_VOLUME_INCREASE
Insert objects into the node that will experience the smallest volume increase as a result of the add...
Definition KDTree.h:69
@ AXIS_LONGEST
Divide a node along its longest axis.
Definition KDTree.h:49
@ PIVOT_MEAN
Split a node at the population average.
Definition KDTree.h:60

◆ Rect< T, N >::empty

template<typename T, index_t N>
Rect<T,N> Rect< T, N >::empty
constexpr
Initial value:
detail::max<T>(),
detail::lowest<T>()
)
An N-dimensional axis-aligned interval.
Definition Rect.h:68

◆ 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:
detail::lowest<T>(),
detail::max<T>()
)