vsr Namespace Reference

---

the versor library namespace More...

Namespaces
	cga
	3D Conformal Geometric Algebra Namespace
	ega
	3D Euclidean Geometric Algebra NamespaceNote that ega assumes 3D case for other dimensions we'll use ega2D (
	nga
	ND Generic Operations.

Classes
struct	algebra
	An algebra instance is templated on: More...
struct	algebra_impl
struct	algebra_impl< Algebra, false, false >
struct	algebra_impl< Algebra, false, true >
struct	algebra_impl< Algebra, true, false >
struct	all_blades
	all blades within a spatial dim upto and including maxgrade More...
struct	all_blades< dim, 0 >
	limiting case of grade 0 (scalar) More...
struct	blade
	metafunction to construct a basis blade type from spatial dimension and subspace grade More...
struct	blade< dim, 0 >
	limiting case of grade 0 (scalar) More...
class	Conic
	conic transforms More...
struct	Constraint
struct	ConvexHull
	convex (and other assorted) hulls assembled into a half edge graph More...
struct	CubeEdge
class	CubicLattice
	Discretized Volume Indexing (Isometric Cubic Lattice w/o data) More...
class	Data
class	Distance
class	DoubleData
struct	Eval
class	Field
	A Basic 3D Field (slowly porting this over from the now defunct vsr_lattice class) Use to Evaluate Neighbors, Tensors, etc. More...
struct	GAE
struct	Group
	A Group of Operations called with group( sometype t ) or group( vector<sometype> t) V are versors any dimension, etc DualLines in cga2D or DualPlanes in cga3D or Circles . More...
struct	HEGraph
	Templated half edge structure (pointers to any type) Navigates references to surface topology of data only (DOES NOT STORE DATA) More...
class	Interp
struct	Lattice
	ND lattice, on a metric specified by V's type. Not a group, but a group can be made from it. More...
struct	Math
struct	Multivector
	Generic Geometric Number Types (templated on an algebra and a basis ) More...
struct	named_types
struct	named_types< algebra_impl< alg, false, true > >
struct	named_types< algebra_impl< alg, true, false > >
class	Nbr
	Data Structure of Neighbors in a cartesian volume (left, right, bottom, top, front, back) More...
struct	NCube
	ND Cube. More...
struct	NCube< 1 >
	1D Cube More...
class	NData
class	NData< 1, T >
struct	NE
struct	Patch
	Info Container for Euler integration of a 2d Field. More...
struct	PointGroup2D
struct	PointGroup3D
struct	Rand
	Probability Density Functions. More...
struct	Root
	goal is to use generators to collect all the unique transformations of the group, so we can apply them easily later. More...
class	Set
struct	SimpleGroup
	Simple Reflection Group (no translating or gliding spinors) More...
struct	Simplex
struct	SpaceGroup2D
struct	SpaceGroup3D
class	Stat
class	Verlet
struct	VPatch
	Volume Patch Info Container for Euler integration of a 3d Field. More...
class	Vxl

Typedefs
template<typename algebra >
using	GASca = Multivector< algebra, typename algebra::types::sca >
template<typename algebra >
using	GAVec = Multivector< algebra, typename algebra::types::vec >
template<typename algebra >
using	GABiv = Multivector< algebra, typename algebra::types::biv >
template<typename algebra >
using	GATri = Multivector< algebra, typename algebra::types::tri >
template<typename algebra >
using	GAPnt = Multivector< algebra, typename algebra::types::pnt >
template<typename algebra >
using	GADls = Multivector< algebra, typename algebra::types::dls >
template<typename algebra >
using	GAPar = Multivector< algebra, typename algebra::types::par >
template<typename algebra >
using	GACir = Multivector< algebra, typename algebra::types::cir >
template<typename algebra >
using	GASph = Multivector< algebra, typename algebra::types::sph >
template<typename algebra >
using	GAFlp = Multivector< algebra, typename algebra::types::flp >
template<typename algebra >
using	GADll = Multivector< algebra, typename algebra::types::dll >
template<typename algebra >
using	GALin = Multivector< algebra, typename algebra::types::lin >
template<typename algebra >
using	GADlp = Multivector< algebra, typename algebra::types::dlp >
template<typename algebra >
using	GAPln = Multivector< algebra, typename algebra::types::pln >
template<typename algebra >
using	GAMnk = Multivector< algebra, typename algebra::types::mnk >
template<typename algebra >
using	GAInf = Multivector< algebra, typename algebra::types::inf >
template<typename algebra >
using	GAOri = Multivector< algebra, typename algebra::types::ori >
template<typename algebra >
using	GAPss = Multivector< algebra, typename algebra::types::pss >
template<typename algebra >
using	GATnv = Multivector< algebra, typename algebra::types::tnv >
template<typename algebra >
using	GADrv = Multivector< algebra, typename algebra::types::drv >
template<typename algebra >
using	GATnb = Multivector< algebra, typename algebra::types::tnb >
template<typename algebra >
using	GADrb = Multivector< algebra, typename algebra::types::drb >
template<typename algebra >
using	GATnt = Multivector< algebra, typename algebra::types::tnt >
template<typename algebra >
using	GADrt = Multivector< algebra, typename algebra::types::drt >
template<typename algebra >
using	GARot = Multivector< algebra, typename algebra::types::rot >
template<typename algebra >
using	GATrs = Multivector< algebra, typename algebra::types::trs >
template<typename algebra >
using	GADil = Multivector< algebra, typename algebra::types::dil >
template<typename algebra >
using	GAMot = Multivector< algebra, typename algebra::types::mot >
template<typename algebra >
using	GABst = Multivector< algebra, typename algebra::types::bst >
template<typename algebra >
using	GATrv = Multivector< algebra, typename algebra::types::trv >
template<typename algebra >
using	GACon = Multivector< algebra, typename algebra::types::con >
template<typename algebra >
using	GATsd = Multivector< algebra, typename algebra::types::tsd >
template<typename algebra >
using	GAEucPss = Multivector< algebra, typename algebra::types::eucpss >
template<bits::type N, typename T = VSR_PRECISION>
using	euclidean = algebra< metric< N >, T >
template<bits::type N, typename T = VSR_PRECISION>
using	conformal = algebra< metric< N-1, 1, true >, T >
template<bits::type N, typename T = VSR_PRECISION>
using	NESca = GASca< euclidean< N, T > >
template<bits::type N, typename T = VSR_PRECISION>
using	NEVec = GAVec< euclidean< N, T > >
template<bits::type N, typename T = VSR_PRECISION>
using	NEBiv = GABiv< euclidean< N, T > >
template<bits::type N, typename T = VSR_PRECISION>
using	NETri = GATri< euclidean< N, T > >
template<bits::type N, typename T = VSR_PRECISION>
using	NERot = GARot< euclidean< N, T > >
template<bits::type dim, typename T = VSR_PRECISION>
using	euclidean_vector = GAVec< euclidean< dim, T > >
template<bits::type dim, typename T = VSR_PRECISION>
using	euclidean_bivector = GABiv< euclidean< dim, T > >
template<bits::type dim, typename T = VSR_PRECISION>
using	euclidean_trivector = GATri< euclidean< dim, T > >
template<bits::type dim, typename T = VSR_PRECISION>
using	euclidean_rotor = GARot< euclidean< dim, T > >
template<bits::type N, typename T = VSR_PRECISION>
using	NSca = GASca< conformal< N, T >>
	*--------------------------------------------------------------------------—
template<bits::type N, typename T = VSR_PRECISION>
using	NVec = GAVec< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NBiv = GABiv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NPnt = GAPnt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NBst = GABst< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NPar = GAPar< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NCir = GACir< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NRot = GARot< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTnv = GATnv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTrv = GATrv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTrs = GATrs< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDrv = GADrv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDil = GADil< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTsd = GATsd< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NOri = GAOri< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NInf = GAInf< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDls = GADls< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDll = GADll< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NLin = GALin< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NMnk = GAMnk< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NPss = GAPss< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NSph = GASph< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTri = GATri< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NFlp = GAFlp< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NPln = GAPln< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDlp = GADlp< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDrb = GADrb< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTnb = GATnb< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NTnt = GATnt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NDrt = GADrt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NMot = GAMot< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	NCon = GACon< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_scalar = GASca< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_vector = GAVec< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Biv = GABiv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Pnt = GAPnt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Bst = GABst< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Par = GAPar< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Cir = GACir< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Rot = GARot< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Tnv = GATnv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Trv = GATrv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Trs = GATrs< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Drv = GADrv< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Dil = GADil< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Tsd = GATsd< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Ori = GAOri< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Inf = GAInf< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Dls = GADls< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Dll = GADll< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Lin = GALin< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Mnk = GAMnk< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Pss = GAPss< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Sph = GASph< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Tri = GATri< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Flp = GAFlp< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Pln = GAPln< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Dlp = GADlp< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Drb = GADrb< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Tnb = GATnb< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Tnt = GATnt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Drt = GADrt< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Mot = GAMot< conformal< N, T >>
template<bits::type N, typename T = VSR_PRECISION>
using	conformal_Con = GACon< conformal< N, T >>
typedef MGAMV< STA::Metric, STA::Vec >	Vec
typedef MGAMV< STA::Metric, STA::Sca >	Sca
typedef MGAMV< STA::Metric, STA::Y0 >	Y0
typedef MGAMV< STA::Metric, STA::Y1 >	Y1
typedef MGAMV< STA::Metric, STA::Y2 >	Y2
typedef MGAMV< STA::Metric, STA::Y3 >	Y3
typedef MGAMV< STA::Metric, STA::O1 >	O1
typedef MGAMV< STA::Metric, STA::O2 >	O2
typedef MGAMV< STA::Metric, STA::O3 >	O3
typedef MGAMV< STA::Metric, STA::I >	I
typedef MGAMV< STA::Metric, STA::P3 >	P3
typedef MGAMV< STA::Metric, STA::Event >	Event
typedef MGAMV< STA::Metric, STA::Split >	Split
using	vec4 = NEVec< 4, int >
typedef std::map< const char *, int >	NameMap

Enumerations
enum	Interpolation {   LINEAR, QUADRIC, CUBIC, BSPLINE,   NURB }
enum	Cube {   LEFT = 1, RIGHT = 1 << 1, BOTTOM = 1 << 2, TOP = 1 << 3,   FRONT = 1 << 4, BACK = 1 << 5, ALLSIDES = LEFT | RIGHT | BOTTOM | TOP | FRONT | BACK }
enum	StandardTypes {   BOOLEAN, UCHAR, CHAR, UINT,   INT, ULONG, LONG, FLOAT,   DOUBLE }

Functions
template<class A >
void	Draw (const A &s, float r=1, float g=1, float b=1, float a=1)
Rot	AA (const Vec &s)
void	Immediate (const Vec &s)
ega::Rot	AA (const ega::Vec &s)
void	Immediate (const ega::Vec &s)
template<int N>
void	Draw (const Simplex< N > &s, float r=1.0, float g=1.0, float b=1.0, float a=1.0)
template<typename T >
T	Diff (const T &a, const T &b)
template<typename T >
VT	Dist (const T &a, const T &b)
	Squared Distances.
template<TT DIM>
VT	Dist (const NPnt< DIM > &a, const NPnt< DIM > &b)
ostream &	operator<< (ostream &os, const Nbr &m)
ostream &	operator<< (ostream &os, const Vxl &m)
NameMap	create_types ()

Detailed Description

---

the versor library namespace

---