vsr_multivector.h File Reference

generic multivector class, templated on a geometric algebra and a field More...

#include "vsr_algebra.h"
#include <math.h>
#include <iostream>

Go to the source code of this file.

Classes
struct	vsr::Multivector< algebra_type, basis_type >
	Generic Geometric Number Types (templated on an algebra and a basis ) More...
struct	vsr::GAE< algebra >
struct	vsr::NE< T >

Namespaces
	vsr
	the versor library namespace

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

Detailed Description

generic multivector class, templated on a geometric algebra and a field

using Vec = vsr::algebra< metric<3>, float>::types::Vec; Vec v(1,0,0);

---

  Filename:  vsr_multivector.h

Description: generic multivector class, templated on a geometric algebra and a field

Version:  1.0
Created:  04/07/2015 15:54:28

Revision: none Compiler: gcc4.7 or above or clang 3.2 or above

Author: Pablo Colapinto (), gmail->wolftype Organization: wolftype

---