// Generated on 2007-08-08 10:15:48 by G2 0.1 from 'E:\gasandbox\ga_sandbox\libgasandbox\c2ga.gs2'
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License
// as published by the Free Software Foundation; either version 2
// of the License, or (at your option) any later version.
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <string>
#include "mvtypebase.h"
// pre_h_include
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#ifndef _GA_c2ga_h_H_
#define _GA_c2ga_h_H_
namespace c2ga {
// multivector types:
enum g2Type {
MVT_NONE = -1,
MVT_NO_T = 10,
MVT_E1_T = 11,
MVT_E2_T = 12,
MVT_NI_T = 13,
MVT_SCALAR = 14,
MVT_POINT = 15,
MVT_NORMALIZEDPOINT = 16,
MVT_FLATPOINT = 17,
MVT_NORMALIZEDFLATPOINT = 18,
MVT_POINTPAIR = 19,
MVT_TRVERSORLOG = 20,
MVT_LINE = 21,
MVT_DUALLINE = 22,
MVT_CIRCLE = 23,
MVT_FREEVECTOR = 24,
MVT_FREEBIVECTOR = 25,
MVT_TANGENTVECTOR = 26,
MVT_TANGENTBIVECTOR = 27,
MVT_VECTORE2GA = 28,
MVT_BIVECTORE2GA = 29,
MVT_TRVERSOR = 30,
MVT_TRSVERSOR = 31,
MVT_EVENVERSOR = 32,
MVT_TRANSLATOR = 33,
MVT_NORMALIZEDTRANSLATOR = 34,
MVT_ROTOR = 35,
MVT_SCALOR = 36,
MVT___NO_CT__ = 37,
MVT___E1_CT__ = 38,
MVT___E2_CT__ = 39,
MVT___NI_CT__ = 40,
MVT___I4I_CT__ = 41,
MVT___I4_CT__ = 42,
MVT___I2_CT__ = 43,
MVT___NONI_CT__ = 44,
MVT___E2NI_CT__ = 45,
MVT___E1NI_CT__ = 46,
MVT___SYN_SMV___E1_E2_NOF1_0 = 47,
MVT___SYN_SMV___E1E2NIF1_0 = 48,
MVT___SYN_SMV___E1_E2_NI_NOF_1_0 = 49,
MVT___SYN_SMV___SCALAR_NOE1_NOE2_E1E2_NONI_E1NI_E2NI = 50,
MVT___SYN_SMV___SCALAR_NOE1_NOE2_NONI = 51,
MVT___SYN_SMV___NO_E1_E2_NOE1E2_NI_NOE1NI_NOE2NI = 52,
MVT___SYN_SMV___SCALAR_NOE1_E1E2_E1NI = 53,
MVT___SYN_SMV___NO_E1_E2_NOE1E2_NI_NOE1NI_E1E2NI = 54,
MVT___SYN_SMV___SCALAR_NOE2_E1E2_E2NI = 55,
MVT___SYN_SMV___NO_E1_E2_NOE1E2_NI_NOE2NI_E1E2NI = 56,
MVT___SYN_SMV___SCALAR_NONI_E1NI_E2NI = 57,
MVT___SYN_SMV___NO_E1_E2_NI_NOE1NI_NOE2NI_E1E2NI = 58,
MVT___SYN_SMV___E1NI_E2NI_NONIF_1_0 = 59,
MVT___SYN_SMV___SCALARF_1_0 = 60,
MVT___SYN_SMV___NIF_1_0 = 61,
MVT___SYN_SMV___NIF1_0 = 62,
MVT___SYN_SMV___E1_E2_NI_NOE1NI_NOE2NI_E1E2NI_NOF1_0 = 63,
MVT___SYN_SMV___E1_E2_NI_NOF2_0 = 64,
MVT___SYN_SMV___E1_E2_NI = 65,
MVT___SYN_SMV___NOE1_NOE2_NONI = 66,
MVT___SYN_SMV___NO_NOE1E2_NOE1NI_NOE2NI = 67,
MVT___SYN_SMV___SCALAR_E1E2_E1NI = 68,
MVT___SYN_SMV___E1_E2_NI_E1E2NI = 69,
MVT___SYN_SMV___SCALAR_E1E2_E2NI = 70,
MVT___SYN_SMV___SCALARF0_0 = 71,
MVT___SYN_SMV___NI_E1E2NI = 72,
MVT_MV = 8,
MVT_LAST = 73
};
// outermorphism types:
enum omType {
OMT_NONE = -2,
OMT_OM = 9,
OMT_LAST = 73
};
// grade definitions that can be joined using the '|' operator:
const int GRADE_0 = 1;
const int GRADE_1 = 2;
const int GRADE_2 = 4;
const int GRADE_3 = 8;
const int GRADE_4 = 16;
// The dimension of the space:
extern const int mv_spaceDim;
// Is the metric of the space Euclidean?
extern const bool mv_metricEuclidean;
// This array can be used to lookup the number of coordinates for a grade part of a general multivector
extern const int mv_gradeSize[5];
// This array can be used to lookup the number of coordinates based on a grade usage bitmap
extern const int mv_size[32];
// This array of ASCIIZ strings contains the names of the basis vectors
extern const char *mv_basisVectorNames[4];
// This array of integers contains the order of basis elements in the general multivector
// Use it to answer: 'what basis vectors are in the basis element at position [x]?
extern const int mv_basisElements[16][5];
// This array of integers contains the 'sign' (even/odd permutation of canonical order) of basis elements in the general multivector
// Use it to answer 'what is the permutation of the coordinate at index [x]'?
extern const double mv_basisElementSignByIndex[16];
// This array of integers contains the 'sign' (even/odd permutation of canonical order) of basis elements in the general multivector
// Use it to answer 'what is the permutation of the coordinate of bitmap [x]'?
extern const double mv_basisElementSignByBitmap[16];
// This array of integers contains the order of basis elements in the general multivector
// Use it to answer: 'at what index do I find basis element [x] (x = basis vector bitmap)?'
extern const int mv_basisElementIndexByBitmap[16];
// This array of integers contains the indices of basis elements in the general multivector
// Use it to answer: 'what basis element do I find at index [x]'?
extern const int mv_basisElementBitmapByIndex[16];
// This array of grade of each basis elements in the general multivector
// Use it to answer: 'what is the grade of basis element bitmap [x]'?
extern const int mv_basisElementGradeByBitmap[16];
/* *************************************************************************** */
/* *************************** define all classes upfront *************************** */
/* *************************************************************************** */
class no_t;
class e1_t;
class e2_t;
class ni_t;
class scalar;
class point;
class normalizedPoint;
class flatPoint;
class normalizedFlatPoint;
class pointPair;
class TRversorLog;
class line;
class dualLine;
class circle;
class freeVector;
class freeBivector;
class tangentVector;
class tangentBivector;
class vectorE2GA;
class bivectorE2GA;
class TRversor;
class TRSversor;
class evenVersor;
class translator;
class normalizedTranslator;
class rotor;
class scalor;
class __no_ct__;
class __e1_ct__;
class __e2_ct__;
class __ni_ct__;
class __I4i_ct__;
class __I4_ct__;
class __I2_ct__;
class __noni_ct__;
class __e2ni_ct__;
class __e1ni_ct__;
class __syn_smv___e1_e2_nof1_0;
class __syn_smv___e1e2nif1_0;
class __syn_smv___e1_e2_ni_nof_1_0;
class __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni;
class __syn_smv___scalar_noe1_noe2_noni;
class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni;
class __syn_smv___scalar_noe1_e1e2_e1ni;
class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni;
class __syn_smv___scalar_noe2_e1e2_e2ni;
class __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni;
class __syn_smv___scalar_noni_e1ni_e2ni;
class __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni;
class __syn_smv___e1ni_e2ni_nonif_1_0;
class __syn_smv___scalarf_1_0;
class __syn_smv___nif_1_0;
class __syn_smv___nif1_0;
class __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0;
class __syn_smv___e1_e2_ni_nof2_0;
class __syn_smv___e1_e2_ni;
class __syn_smv___noe1_noe2_noni;
class __syn_smv___no_noe1e2_noe1ni_noe2ni;
class __syn_smv___scalar_e1e2_e1ni;
class __syn_smv___e1_e2_ni_e1e2ni;
class __syn_smv___scalar_e1e2_e2ni;
class __syn_smv___scalarf0_0;
class __syn_smv___ni_e1e2ni;
class mv;
class om;
// exception handling:
const int MV_EXCEPTION_WARNING = 1;
const int MV_EXCEPTION_ERROR = 2;
// Exception mechanism: ignore & pray
inline void mv_throw_exception(const char *msg, int level) {}
// You can alter the formatting of 'string()' through this function.
// 'format' = NULL will give you back the default.
void mv_setStringFormat(const char *what, const char *format = NULL);
extern const char *mv_string_fp; /* = \"%2.2f\" */
extern const char *mv_string_start; /* = \"\" */
extern const char *mv_string_end; /* = \"\" */
extern const char *mv_string_mul; /* = \"*\" */
extern const char *mv_string_wedge; /* = \"^\" */
extern const char *mv_string_plus; /* = \" + \" */
extern const char *mv_string_minus; /* = \" - \" */
// declaration of profiling functions
namespace g2Profiling {
void profile(unsigned int funcIdx, unsigned short storageTypeIdx, unsigned short nbArg,
unsigned short argType[], int nbReturnType, unsigned short returnType[]);
void reset();
void save(const char *filename = "E:\\gasandbox\\ga_sandbox\\libgasandbox\\c2ga.gp2", bool append = true);
void init(const char *filename = "E:\\gasandbox\\ga_sandbox\\libgasandbox\\c2ga.gp2",
const char *hostName = "localhost", int port = 7693);
} // end of namespace g2Profiling
inline void mv_memcpy(float *to, const float *from, const int nb) {
memcpy(to, from, sizeof(float) * nb);
}
inline void mv_zero(float *ptr, const int nb) {
memset(ptr, 0, sizeof(float) * nb);
}
// a is any number, b is positive number
inline bool mv_absLessThan(const float a, const float b) {
return ((a > b) || (a < -b));
}
inline float mv_stringToNumber(const char *asciiz) {
return (float)atof(asciiz);
}
void updateCoordinateString(const mv &x, char **cs, size_t &csl);
char *c_str(const mv & obj, const char *fp = NULL);
std::string toString(const mv & obj, const char *fp = NULL);
inline char *c_str_f(const mv & obj) {return c_str(obj, "%f");}
inline char *c_str_e(const mv & obj) {return c_str(obj, "%e");}
inline char *c_str_e20(const mv & obj) {return c_str(obj, "%2.20e");}
inline std::string toString_f(const mv & obj) {return toString(obj, "%f");}
inline std::string toString_e(const mv & obj) {return toString(obj, "%e");}
inline std::string toString_e20(const mv & obj) {return toString(obj, "%2.20e");}
class mv {
public:
typedef float Float;
/// zero constructor
inline mv () {
set();
}
/// copy constructor (MUST PASS BY REFERENCE)
inline mv(const mv &arg1) {
set(arg1);
}
/// scalar constructor
inline mv(Float scalar) {
set(scalar);
}
/// pointer to coordinates constructor
inline mv(unsigned int gradeUsage, const Float *coordinates) {
set(gradeUsage, coordinates);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0) {
set(gradeUsage
, c0);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1) {
set(gradeUsage
, c0, c1);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2) {
set(gradeUsage
, c0, c1, c2);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3) {
set(gradeUsage
, c0, c1, c2, c3);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4) {
set(gradeUsage
, c0, c1, c2, c3, c4);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13, Float c14) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14);
}
/// all 'coordinates specified' constructors
inline mv(unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13, Float c14, Float c15) {
set(gradeUsage
, c0, c1, c2, c3, c4, c5, c6, c7, c8, c9, c10, c11, c12, c13, c14, c15);
}
/// init from no_t constructor
inline mv(const no_t &arg1) {
set(arg1);
}
/// init from e1_t constructor
inline mv(const e1_t &arg1) {
set(arg1);
}
/// init from e2_t constructor
inline mv(const e2_t &arg1) {
set(arg1);
}
/// init from ni_t constructor
inline mv(const ni_t &arg1) {
set(arg1);
}
/// init from scalar constructor
inline mv(const scalar &arg1) {
set(arg1);
}
/// init from point constructor
inline mv(const point &arg1) {
set(arg1);
}
/// init from normalizedPoint constructor
inline mv(const normalizedPoint &arg1) {
set(arg1);
}
/// init from flatPoint constructor
inline mv(const flatPoint &arg1) {
set(arg1);
}
/// init from normalizedFlatPoint constructor
inline mv(const normalizedFlatPoint &arg1) {
set(arg1);
}
/// init from pointPair constructor
inline mv(const pointPair &arg1) {
set(arg1);
}
/// init from TRversorLog constructor
inline mv(const TRversorLog &arg1) {
set(arg1);
}
/// init from line constructor
inline mv(const line &arg1) {
set(arg1);
}
/// init from dualLine constructor
inline mv(const dualLine &arg1) {
set(arg1);
}
/// init from circle constructor
inline mv(const circle &arg1) {
set(arg1);
}
/// init from freeVector constructor
inline mv(const freeVector &arg1) {
set(arg1);
}
/// init from freeBivector constructor
inline mv(const freeBivector &arg1) {
set(arg1);
}
/// init from tangentVector constructor
inline mv(const tangentVector &arg1) {
set(arg1);
}
/// init from tangentBivector constructor
inline mv(const tangentBivector &arg1) {
set(arg1);
}
/// init from vectorE2GA constructor
inline mv(const vectorE2GA &arg1) {
set(arg1);
}
/// init from bivectorE2GA constructor
inline mv(const bivectorE2GA &arg1) {
set(arg1);
}
/// init from TRversor constructor
inline mv(const TRversor &arg1) {
set(arg1);
}
/// init from TRSversor constructor
inline mv(const TRSversor &arg1) {
set(arg1);
}
/// init from evenVersor constructor
inline mv(const evenVersor &arg1) {
set(arg1);
}
/// init from translator constructor
inline mv(const translator &arg1) {
set(arg1);
}
/// init from normalizedTranslator constructor
inline mv(const normalizedTranslator &arg1) {
set(arg1);
}
/// init from rotor constructor
inline mv(const rotor &arg1) {
set(arg1);
}
/// init from scalor constructor
inline mv(const scalor &arg1) {
set(arg1);
}
/// init from __no_ct__ constructor
inline mv(const __no_ct__ &arg1) {
set(arg1);
}
/// init from __e1_ct__ constructor
inline mv(const __e1_ct__ &arg1) {
set(arg1);
}
/// init from __e2_ct__ constructor
inline mv(const __e2_ct__ &arg1) {
set(arg1);
}
/// init from __ni_ct__ constructor
inline mv(const __ni_ct__ &arg1) {
set(arg1);
}
/// init from __I4i_ct__ constructor
inline mv(const __I4i_ct__ &arg1) {
set(arg1);
}
/// init from __I4_ct__ constructor
inline mv(const __I4_ct__ &arg1) {
set(arg1);
}
/// init from __I2_ct__ constructor
inline mv(const __I2_ct__ &arg1) {
set(arg1);
}
/// init from __noni_ct__ constructor
inline mv(const __noni_ct__ &arg1) {
set(arg1);
}
/// init from __e2ni_ct__ constructor
inline mv(const __e2ni_ct__ &arg1) {
set(arg1);
}
/// init from __e1ni_ct__ constructor
inline mv(const __e1ni_ct__ &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_nof1_0 constructor
inline mv(const __syn_smv___e1_e2_nof1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___e1e2nif1_0 constructor
inline mv(const __syn_smv___e1e2nif1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_ni_nof_1_0 constructor
inline mv(const __syn_smv___e1_e2_ni_nof_1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni constructor
inline mv(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_noe1_noe2_noni constructor
inline mv(const __syn_smv___scalar_noe1_noe2_noni &arg1) {
set(arg1);
}
/// init from __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni constructor
inline mv(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_noe1_e1e2_e1ni constructor
inline mv(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
set(arg1);
}
/// init from __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni constructor
inline mv(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_noe2_e1e2_e2ni constructor
inline mv(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni constructor
inline mv(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_noni_e1ni_e2ni constructor
inline mv(const __syn_smv___scalar_noni_e1ni_e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni constructor
inline mv(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___e1ni_e2ni_nonif_1_0 constructor
inline mv(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___scalarf_1_0 constructor
inline mv(const __syn_smv___scalarf_1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___nif_1_0 constructor
inline mv(const __syn_smv___nif_1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___nif1_0 constructor
inline mv(const __syn_smv___nif1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 constructor
inline mv(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_ni_nof2_0 constructor
inline mv(const __syn_smv___e1_e2_ni_nof2_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_ni constructor
inline mv(const __syn_smv___e1_e2_ni &arg1) {
set(arg1);
}
/// init from __syn_smv___noe1_noe2_noni constructor
inline mv(const __syn_smv___noe1_noe2_noni &arg1) {
set(arg1);
}
/// init from __syn_smv___no_noe1e2_noe1ni_noe2ni constructor
inline mv(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_e1e2_e1ni constructor
inline mv(const __syn_smv___scalar_e1e2_e1ni &arg1) {
set(arg1);
}
/// init from __syn_smv___e1_e2_ni_e1e2ni constructor
inline mv(const __syn_smv___e1_e2_ni_e1e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalar_e1e2_e2ni constructor
inline mv(const __syn_smv___scalar_e1e2_e2ni &arg1) {
set(arg1);
}
/// init from __syn_smv___scalarf0_0 constructor
inline mv(const __syn_smv___scalarf0_0 &arg1) {
set(arg1);
}
/// init from __syn_smv___ni_e1e2ni constructor
inline mv(const __syn_smv___ni_e1e2ni &arg1) {
set(arg1);
}
/// set to null
void set();
/// set to copy
void set(const mv &arg1);
/// set to scalar
void set(Float scalar);
/// pointer to coordinates constructor
void set(unsigned int gradeUsage, const Float *coordinates);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13, Float c14);
/// set to 'coordinates specified'
void set (unsigned int gradeUsage
, Float c0, Float c1, Float c2, Float c3, Float c4, Float c5, Float c6, Float c7, Float c8, Float c9, Float c10, Float c11, Float c12, Float c13, Float c14, Float c15);
/// set to no_t
void set(const no_t &arg1);
/// set to e1_t
void set(const e1_t &arg1);
/// set to e2_t
void set(const e2_t &arg1);
/// set to ni_t
void set(const ni_t &arg1);
/// set to scalar
void set(const scalar &arg1);
/// set to point
void set(const point &arg1);
/// set to normalizedPoint
void set(const normalizedPoint &arg1);
/// set to flatPoint
void set(const flatPoint &arg1);
/// set to normalizedFlatPoint
void set(const normalizedFlatPoint &arg1);
/// set to pointPair
void set(const pointPair &arg1);
/// set to TRversorLog
void set(const TRversorLog &arg1);
/// set to line
void set(const line &arg1);
/// set to dualLine
void set(const dualLine &arg1);
/// set to circle
void set(const circle &arg1);
/// set to freeVector
void set(const freeVector &arg1);
/// set to freeBivector
void set(const freeBivector &arg1);
/// set to tangentVector
void set(const tangentVector &arg1);
/// set to tangentBivector
void set(const tangentBivector &arg1);
/// set to vectorE2GA
void set(const vectorE2GA &arg1);
/// set to bivectorE2GA
void set(const bivectorE2GA &arg1);
/// set to TRversor
void set(const TRversor &arg1);
/// set to TRSversor
void set(const TRSversor &arg1);
/// set to evenVersor
void set(const evenVersor &arg1);
/// set to translator
void set(const translator &arg1);
/// set to normalizedTranslator
void set(const normalizedTranslator &arg1);
/// set to rotor
void set(const rotor &arg1);
/// set to scalor
void set(const scalor &arg1);
/// set to __no_ct__
void set(const __no_ct__ &arg1);
/// set to __e1_ct__
void set(const __e1_ct__ &arg1);
/// set to __e2_ct__
void set(const __e2_ct__ &arg1);
/// set to __ni_ct__
void set(const __ni_ct__ &arg1);
/// set to __I4i_ct__
void set(const __I4i_ct__ &arg1);
/// set to __I4_ct__
void set(const __I4_ct__ &arg1);
/// set to __I2_ct__
void set(const __I2_ct__ &arg1);
/// set to __noni_ct__
void set(const __noni_ct__ &arg1);
/// set to __e2ni_ct__
void set(const __e2ni_ct__ &arg1);
/// set to __e1ni_ct__
void set(const __e1ni_ct__ &arg1);
/// set to __syn_smv___e1_e2_nof1_0
void set(const __syn_smv___e1_e2_nof1_0 &arg1);
/// set to __syn_smv___e1e2nif1_0
void set(const __syn_smv___e1e2nif1_0 &arg1);
/// set to __syn_smv___e1_e2_ni_nof_1_0
void set(const __syn_smv___e1_e2_ni_nof_1_0 &arg1);
/// set to __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
void set(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1);
/// set to __syn_smv___scalar_noe1_noe2_noni
void set(const __syn_smv___scalar_noe1_noe2_noni &arg1);
/// set to __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1);
/// set to __syn_smv___scalar_noe1_e1e2_e1ni
void set(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1);
/// set to __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1);
/// set to __syn_smv___scalar_noe2_e1e2_e2ni
void set(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1);
/// set to __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1);
/// set to __syn_smv___scalar_noni_e1ni_e2ni
void set(const __syn_smv___scalar_noni_e1ni_e2ni &arg1);
/// set to __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
void set(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1);
/// set to __syn_smv___e1ni_e2ni_nonif_1_0
void set(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1);
/// set to __syn_smv___scalarf_1_0
void set(const __syn_smv___scalarf_1_0 &arg1);
/// set to __syn_smv___nif_1_0
void set(const __syn_smv___nif_1_0 &arg1);
/// set to __syn_smv___nif1_0
void set(const __syn_smv___nif1_0 &arg1);
/// set to __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
void set(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1);
/// set to __syn_smv___e1_e2_ni_nof2_0
void set(const __syn_smv___e1_e2_ni_nof2_0 &arg1);
/// set to __syn_smv___e1_e2_ni
void set(const __syn_smv___e1_e2_ni &arg1);
/// set to __syn_smv___noe1_noe2_noni
void set(const __syn_smv___noe1_noe2_noni &arg1);
/// set to __syn_smv___no_noe1e2_noe1ni_noe2ni
void set(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1);
/// set to __syn_smv___scalar_e1e2_e1ni
void set(const __syn_smv___scalar_e1e2_e1ni &arg1);
/// set to __syn_smv___e1_e2_ni_e1e2ni
void set(const __syn_smv___e1_e2_ni_e1e2ni &arg1);
/// set to __syn_smv___scalar_e1e2_e2ni
void set(const __syn_smv___scalar_e1e2_e2ni &arg1);
/// set to __syn_smv___scalarf0_0
void set(const __syn_smv___scalarf0_0 &arg1);
/// set to __syn_smv___ni_e1e2ni
void set(const __syn_smv___ni_e1e2ni &arg1);
/// assign copy
mv &operator=(const mv &arg1);
/// assign scalar
mv &operator=(Float scalar);
/// assign no_t
mv&operator=(const no_t& arg1);
/// assign e1_t
mv&operator=(const e1_t& arg1);
/// assign e2_t
mv&operator=(const e2_t& arg1);
/// assign ni_t
mv&operator=(const ni_t& arg1);
/// assign scalar
mv&operator=(const scalar& arg1);
/// assign point
mv&operator=(const point& arg1);
/// assign normalizedPoint
mv&operator=(const normalizedPoint& arg1);
/// assign flatPoint
mv&operator=(const flatPoint& arg1);
/// assign normalizedFlatPoint
mv&operator=(const normalizedFlatPoint& arg1);
/// assign pointPair
mv&operator=(const pointPair& arg1);
/// assign TRversorLog
mv&operator=(const TRversorLog& arg1);
/// assign line
mv&operator=(const line& arg1);
/// assign dualLine
mv&operator=(const dualLine& arg1);
/// assign circle
mv&operator=(const circle& arg1);
/// assign freeVector
mv&operator=(const freeVector& arg1);
/// assign freeBivector
mv&operator=(const freeBivector& arg1);
/// assign tangentVector
mv&operator=(const tangentVector& arg1);
/// assign tangentBivector
mv&operator=(const tangentBivector& arg1);
/// assign vectorE2GA
mv&operator=(const vectorE2GA& arg1);
/// assign bivectorE2GA
mv&operator=(const bivectorE2GA& arg1);
/// assign TRversor
mv&operator=(const TRversor& arg1);
/// assign TRSversor
mv&operator=(const TRSversor& arg1);
/// assign evenVersor
mv&operator=(const evenVersor& arg1);
/// assign translator
mv&operator=(const translator& arg1);
/// assign normalizedTranslator
mv&operator=(const normalizedTranslator& arg1);
/// assign rotor
mv&operator=(const rotor& arg1);
/// assign scalor
mv&operator=(const scalor& arg1);
/// assign __no_ct__
mv&operator=(const __no_ct__& arg1);
/// assign __e1_ct__
mv&operator=(const __e1_ct__& arg1);
/// assign __e2_ct__
mv&operator=(const __e2_ct__& arg1);
/// assign __ni_ct__
mv&operator=(const __ni_ct__& arg1);
/// assign __I4i_ct__
mv&operator=(const __I4i_ct__& arg1);
/// assign __I4_ct__
mv&operator=(const __I4_ct__& arg1);
/// assign __I2_ct__
mv&operator=(const __I2_ct__& arg1);
/// assign __noni_ct__
mv&operator=(const __noni_ct__& arg1);
/// assign __e2ni_ct__
mv&operator=(const __e2ni_ct__& arg1);
/// assign __e1ni_ct__
mv&operator=(const __e1ni_ct__& arg1);
/// assign __syn_smv___e1_e2_nof1_0
mv&operator=(const __syn_smv___e1_e2_nof1_0& arg1);
/// assign __syn_smv___e1e2nif1_0
mv&operator=(const __syn_smv___e1e2nif1_0& arg1);
/// assign __syn_smv___e1_e2_ni_nof_1_0
mv&operator=(const __syn_smv___e1_e2_ni_nof_1_0& arg1);
/// assign __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
mv&operator=(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1);
/// assign __syn_smv___scalar_noe1_noe2_noni
mv&operator=(const __syn_smv___scalar_noe1_noe2_noni& arg1);
/// assign __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
mv&operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1);
/// assign __syn_smv___scalar_noe1_e1e2_e1ni
mv&operator=(const __syn_smv___scalar_noe1_e1e2_e1ni& arg1);
/// assign __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
mv&operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1);
/// assign __syn_smv___scalar_noe2_e1e2_e2ni
mv&operator=(const __syn_smv___scalar_noe2_e1e2_e2ni& arg1);
/// assign __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
mv&operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1);
/// assign __syn_smv___scalar_noni_e1ni_e2ni
mv&operator=(const __syn_smv___scalar_noni_e1ni_e2ni& arg1);
/// assign __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
mv&operator=(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1);
/// assign __syn_smv___e1ni_e2ni_nonif_1_0
mv&operator=(const __syn_smv___e1ni_e2ni_nonif_1_0& arg1);
/// assign __syn_smv___scalarf_1_0
mv&operator=(const __syn_smv___scalarf_1_0& arg1);
/// assign __syn_smv___nif_1_0
mv&operator=(const __syn_smv___nif_1_0& arg1);
/// assign __syn_smv___nif1_0
mv&operator=(const __syn_smv___nif1_0& arg1);
/// assign __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
mv&operator=(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1);
/// assign __syn_smv___e1_e2_ni_nof2_0
mv&operator=(const __syn_smv___e1_e2_ni_nof2_0& arg1);
/// assign __syn_smv___e1_e2_ni
mv&operator=(const __syn_smv___e1_e2_ni& arg1);
/// assign __syn_smv___noe1_noe2_noni
mv&operator=(const __syn_smv___noe1_noe2_noni& arg1);
/// assign __syn_smv___no_noe1e2_noe1ni_noe2ni
mv&operator=(const __syn_smv___no_noe1e2_noe1ni_noe2ni& arg1);
/// assign __syn_smv___scalar_e1e2_e1ni
mv&operator=(const __syn_smv___scalar_e1e2_e1ni& arg1);
/// assign __syn_smv___e1_e2_ni_e1e2ni
mv&operator=(const __syn_smv___e1_e2_ni_e1e2ni& arg1);
/// assign __syn_smv___scalar_e1e2_e2ni
mv&operator=(const __syn_smv___scalar_e1e2_e2ni& arg1);
/// assign __syn_smv___scalarf0_0
mv&operator=(const __syn_smv___scalarf0_0& arg1);
/// assign __syn_smv___ni_e1e2ni
mv&operator=(const __syn_smv___ni_e1e2ni& arg1);
void compress(Float epsilon = 0.0);
inline Float const *nullFloats() const {
static Float *nf = NULL;
if (nf == NULL) nf = new Float[16];
return nf;
}
void expand(const Float *ptrs[], bool nulls = true) const;
/// returns the absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// converts this multvector to an array of basis blade bitmaps and coordinates (returns number of blades)
int toBasisBladeBitmapArray(unsigned int *bitmaps, Float *coords);
/// coordinate extraction by name
inline Float no() const {
if (gu() & 2)
return m_c[mv_size[gu() & 1] + 0];
else return (float)0.0;
}
inline Float e1() const {
if (gu() & 2)
return m_c[mv_size[gu() & 1] + 1];
else return (float)0.0;
}
inline Float e2() const {
if (gu() & 2)
return m_c[mv_size[gu() & 1] + 2];
else return (float)0.0;
}
inline Float ni() const {
if (gu() & 2)
return m_c[mv_size[gu() & 1] + 3];
else return (float)0.0;
}
inline Float noe1() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 0];
else return (float)0.0;
}
inline Float noe2() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 1];
else return (float)0.0;
}
inline Float e1e2() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 2];
else return (float)0.0;
}
inline Float e1ni() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 3];
else return (float)0.0;
}
inline Float e2ni() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 4];
else return (float)0.0;
}
inline Float noni() const {
if (gu() & 4)
return m_c[mv_size[gu() & 3] + 5];
else return (float)0.0;
}
inline Float e1e2ni() const {
if (gu() & 8)
return m_c[mv_size[gu() & 7] + 0];
else return (float)0.0;
}
inline Float noe1ni() const {
if (gu() & 8)
return m_c[mv_size[gu() & 7] + 1];
else return (float)0.0;
}
inline Float noe2ni() const {
if (gu() & 8)
return m_c[mv_size[gu() & 7] + 2];
else return (float)0.0;
}
inline Float noe1e2() const {
if (gu() & 8)
return m_c[mv_size[gu() & 7] + 3];
else return (float)0.0;
}
inline Float noe1e2ni() const {
if (gu() & 16)
return m_c[mv_size[gu() & 15] + 0];
else return (float)0.0;
}
// coordinate storage, grade usage
Float m_c[16]; ///< coordinate storage (TODO: if parity pure, allocate only half of the coordinates!!!)
unsigned int m_gu; ///< grade usage
inline unsigned int gu() const {return m_gu;}
inline void gu(unsigned int g) {m_gu = g;}
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class mv
char *string(const mv & obj, char *str, int maxLength, const char *fp = NULL);
// this function should be deprecated (conflicts with C++ stdlib)
char *string(const mv & obj, const char *fp = NULL);
mv mv_compress(const float *coordinates, float epsilon = (float)0.0, int gu = 16 * 2 -1);
mv mv_compress(int nbBlades, const unsigned int *bitmaps, const mv::Float *coords);
// underscore 'constructors' for float types:
/// returns scalar part of arg1 as float
inline float _float(const mv & arg1) {
return (arg1.m_gu & 1) ? (float)arg1.m_c[0] : 0.0f;
}
/// returns scalar part of arg1 as double
inline double _double(const mv & arg1) {
return (arg1.m_gu & 1) ? (double)arg1.m_c[0] : 0.0;
}
/// returns scalar part of arg1 as Float
inline float _Float(const mv & arg1) {
return (arg1.m_gu & 1) ? arg1.m_c[0] : (float)0.0;
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline const mv like(const mv &what, const mv &example) {return what;}
inline mv like(mv &what, const mv &example) {return what;}
/// converts this multvector to an array of basis blade bitmaps and coordinates (returns number of blades)
inline int mv::toBasisBladeBitmapArray(unsigned int *bitmaps, mv::Float *coords) {
int idxB = 0;
int idxC = 0;
if (m_gu & 1) {
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 0; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
}
if (m_gu & 2) {
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 1; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 2; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 4; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 8; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
}
if (m_gu & 4) {
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 3; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 5; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 6; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 10; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 12; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 9; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
}
if (m_gu & 8) {
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 14; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 11; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 13; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 7; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
}
if (m_gu & 16) {
if (m_c[idxC] != (Float)0.0) {
bitmaps[idxB] = 15; coords[idxB] = m_c[idxC]; idxB++;}
idxC++;
}
return idxB;
}
/// enum for the coordinates of no_t
enum __no_t_coordinates__ {no_t_no};
class no_t {
public:
typedef float Float;
/// zero constructor
inline no_t() {
set();
}
/// scalar constructor
inline no_t(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> no_t
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline no_t(const no_t &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline no_t(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> no_t
set(arg1);
}
/// pointer to coordinates constructor
inline no_t(__no_t_coordinates__, const Float *coordinates) {
set(no_t_no, coordinates);
}
/// coordinates constructor
inline no_t(__no_t_coordinates__, Float c_no) {
set(no_t_no, c_no);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const no_t &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__no_t_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__no_t_coordinates__, Float c_no);
/// assign copy
no_t &operator=(const no_t &arg1);
/// assign general multivector
no_t &operator=(const mv &arg1);
/// assign scalar
no_t &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__no_t_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class no_t
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline no_t _no_t(const mv &arg1) {
return no_t(arg1, 0);
}
/// from const specialization class:
inline const no_t &_no_t(const no_t &arg1) {
return arg1;
}
/// from non-const specialization class:
inline no_t &_no_t(no_t &arg1) {
return arg1;
}
/// from Float:
inline no_t _no_t(no_t::Float arg1) {
return no_t(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline no_t like(const mv &what, const no_t &example) {return _no_t(what);}
/// from const specialization class:
inline const no_t like(const no_t &what, const no_t &example) {return _no_t(what);}
/// from non-const specialization class:
inline no_t like(no_t &what, const no_t &example) {return _no_t(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const no_t & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const no_t & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const no_t & v) {
return (float)0;
}
/// enum for the coordinates of e1_t
enum __e1_t_coordinates__ {e1_t_e1};
class e1_t {
public:
typedef float Float;
/// zero constructor
inline e1_t() {
set();
}
/// scalar constructor
inline e1_t(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> e1_t
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline e1_t(const e1_t &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline e1_t(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> e1_t
set(arg1);
}
/// pointer to coordinates constructor
inline e1_t(__e1_t_coordinates__, const Float *coordinates) {
set(e1_t_e1, coordinates);
}
/// coordinates constructor
inline e1_t(__e1_t_coordinates__, Float c_e1) {
set(e1_t_e1, c_e1);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const e1_t &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__e1_t_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__e1_t_coordinates__, Float c_e1);
/// assign copy
e1_t &operator=(const e1_t &arg1);
/// assign general multivector
e1_t &operator=(const mv &arg1);
/// assign scalar
e1_t &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__e1_t_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class e1_t
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline e1_t _e1_t(const mv &arg1) {
return e1_t(arg1, 0);
}
/// from const specialization class:
inline const e1_t &_e1_t(const e1_t &arg1) {
return arg1;
}
/// from non-const specialization class:
inline e1_t &_e1_t(e1_t &arg1) {
return arg1;
}
/// from Float:
inline e1_t _e1_t(e1_t::Float arg1) {
return e1_t(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline e1_t like(const mv &what, const e1_t &example) {return _e1_t(what);}
/// from const specialization class:
inline const e1_t like(const e1_t &what, const e1_t &example) {return _e1_t(what);}
/// from non-const specialization class:
inline e1_t like(e1_t &what, const e1_t &example) {return _e1_t(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const e1_t & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const e1_t & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const e1_t & v) {
return (float)0;
}
/// enum for the coordinates of e2_t
enum __e2_t_coordinates__ {e2_t_e2};
class e2_t {
public:
typedef float Float;
/// zero constructor
inline e2_t() {
set();
}
/// scalar constructor
inline e2_t(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> e2_t
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline e2_t(const e2_t &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline e2_t(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> e2_t
set(arg1);
}
/// pointer to coordinates constructor
inline e2_t(__e2_t_coordinates__, const Float *coordinates) {
set(e2_t_e2, coordinates);
}
/// coordinates constructor
inline e2_t(__e2_t_coordinates__, Float c_e2) {
set(e2_t_e2, c_e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const e2_t &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__e2_t_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__e2_t_coordinates__, Float c_e2);
/// assign copy
e2_t &operator=(const e2_t &arg1);
/// assign general multivector
e2_t &operator=(const mv &arg1);
/// assign scalar
e2_t &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e2() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__e2_t_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class e2_t
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline e2_t _e2_t(const mv &arg1) {
return e2_t(arg1, 0);
}
/// from const specialization class:
inline const e2_t &_e2_t(const e2_t &arg1) {
return arg1;
}
/// from non-const specialization class:
inline e2_t &_e2_t(e2_t &arg1) {
return arg1;
}
/// from Float:
inline e2_t _e2_t(e2_t::Float arg1) {
return e2_t(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline e2_t like(const mv &what, const e2_t &example) {return _e2_t(what);}
/// from const specialization class:
inline const e2_t like(const e2_t &what, const e2_t &example) {return _e2_t(what);}
/// from non-const specialization class:
inline e2_t like(e2_t &what, const e2_t &example) {return _e2_t(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const e2_t & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const e2_t & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const e2_t & v) {
return (float)0;
}
/// enum for the coordinates of ni_t
enum __ni_t_coordinates__ {ni_t_ni};
class ni_t {
public:
typedef float Float;
/// zero constructor
inline ni_t() {
set();
}
/// scalar constructor
inline ni_t(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> ni_t
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline ni_t(const ni_t &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline ni_t(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> ni_t
set(arg1);
}
/// pointer to coordinates constructor
inline ni_t(__ni_t_coordinates__, const Float *coordinates) {
set(ni_t_ni, coordinates);
}
/// coordinates constructor
inline ni_t(__ni_t_coordinates__, Float c_ni) {
set(ni_t_ni, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const ni_t &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__ni_t_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__ni_t_coordinates__, Float c_ni);
/// assign copy
ni_t &operator=(const ni_t &arg1);
/// assign general multivector
ni_t &operator=(const mv &arg1);
/// assign scalar
ni_t &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float ni() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__ni_t_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class ni_t
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline ni_t _ni_t(const mv &arg1) {
return ni_t(arg1, 0);
}
/// from const specialization class:
inline const ni_t &_ni_t(const ni_t &arg1) {
return arg1;
}
/// from non-const specialization class:
inline ni_t &_ni_t(ni_t &arg1) {
return arg1;
}
/// from Float:
inline ni_t _ni_t(ni_t::Float arg1) {
return ni_t(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline ni_t like(const mv &what, const ni_t &example) {return _ni_t(what);}
/// from const specialization class:
inline const ni_t like(const ni_t &what, const ni_t &example) {return _ni_t(what);}
/// from non-const specialization class:
inline ni_t like(ni_t &what, const ni_t &example) {return _ni_t(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const ni_t & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const ni_t & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const ni_t & v) {
return (float)0;
}
/// enum for the coordinates of scalar
enum __scalar_coordinates__ {scalar_scalar};
class scalar {
public:
typedef float Float;
/// zero constructor
inline scalar() {
set();
}
/// scalar constructor
inline scalar(Float s) {
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline scalar(const scalar &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline scalar(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> scalar
set(arg1);
}
/// pointer to coordinates constructor
inline scalar(__scalar_coordinates__, const Float *coordinates) {
set(scalar_scalar, coordinates);
}
/// coordinates constructor
inline scalar(__scalar_coordinates__, Float c_scalar) {
set(scalar_scalar, c_scalar);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const scalar &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__scalar_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__scalar_coordinates__, Float c_scalar);
/// assign copy
scalar &operator=(const scalar &arg1);
/// assign general multivector
scalar &operator=(const mv &arg1);
/// assign scalar
scalar &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__scalar_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class scalar
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline scalar _scalar(const mv &arg1) {
return scalar(arg1, 0);
}
/// from const specialization class:
inline const scalar &_scalar(const scalar &arg1) {
return arg1;
}
/// from non-const specialization class:
inline scalar &_scalar(scalar &arg1) {
return arg1;
}
/// from Float:
inline scalar _scalar(scalar::Float arg1) {
return scalar(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline scalar like(const mv &what, const scalar &example) {return _scalar(what);}
/// from const specialization class:
inline const scalar like(const scalar &what, const scalar &example) {return _scalar(what);}
/// from non-const specialization class:
inline scalar like(scalar &what, const scalar &example) {return _scalar(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const scalar & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const scalar & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const scalar & v) {
return v.m_c[0];
}
/// enum for the coordinates of point
enum __point_coordinates__ {point_no_e1_e2_ni};
class point {
public:
typedef float Float;
/// zero constructor
inline point() {
set();
}
/// scalar constructor
inline point(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> point
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline point(const point &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline point(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> point
set(arg1);
}
/// pointer to coordinates constructor
inline point(__point_coordinates__, const Float *coordinates) {
set(point_no_e1_e2_ni, coordinates);
}
/// coordinates constructor
inline point(__point_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_ni) {
set(point_no_e1_e2_ni, c_no, c_e1, c_e2, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const point &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__point_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__point_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_ni);
/// assign copy
point &operator=(const point &arg1);
/// assign general multivector
point &operator=(const mv &arg1);
/// assign scalar
point &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
inline Float e1() const {
return m_c[1];
}
inline Float e2() const {
return m_c[2];
}
inline Float ni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__point_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class point
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline point _point(const mv &arg1) {
return point(arg1, 0);
}
/// from const specialization class:
inline const point &_point(const point &arg1) {
return arg1;
}
/// from non-const specialization class:
inline point &_point(point &arg1) {
return arg1;
}
/// from Float:
inline point _point(point::Float arg1) {
return point(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline point like(const mv &what, const point &example) {return _point(what);}
/// from const specialization class:
inline const point like(const point &what, const point &example) {return _point(what);}
/// from non-const specialization class:
inline point like(point &what, const point &example) {return _point(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const point & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const point & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const point & v) {
return (float)0;
}
/// enum for the coordinates of normalizedPoint
enum __normalizedPoint_coordinates__ {normalizedPoint_e1_e2_ni_nof1_0};
class normalizedPoint {
public:
typedef float Float;
/// zero constructor
inline normalizedPoint() {
set();
}
/// scalar constructor
inline normalizedPoint(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> normalizedPoint
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline normalizedPoint(const normalizedPoint &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline normalizedPoint(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> normalizedPoint
set(arg1);
}
/// pointer to coordinates constructor
inline normalizedPoint(__normalizedPoint_coordinates__, const Float *coordinates) {
set(normalizedPoint_e1_e2_ni_nof1_0, coordinates);
}
/// coordinates constructor
inline normalizedPoint(__normalizedPoint_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
set(normalizedPoint_e1_e2_ni_nof1_0, c_e1, c_e2, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const normalizedPoint &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__normalizedPoint_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__normalizedPoint_coordinates__, Float c_e1, Float c_e2, Float c_ni);
/// assign copy
normalizedPoint &operator=(const normalizedPoint &arg1);
/// assign general multivector
normalizedPoint &operator=(const mv &arg1);
/// assign scalar
normalizedPoint &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
inline Float ni() const {
return m_c[2];
}
/// const coordinate extraction by name
inline Float no() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__normalizedPoint_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class normalizedPoint
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline normalizedPoint _normalizedPoint(const mv &arg1) {
return normalizedPoint(arg1, 0);
}
/// from const specialization class:
inline const normalizedPoint &_normalizedPoint(const normalizedPoint &arg1) {
return arg1;
}
/// from non-const specialization class:
inline normalizedPoint &_normalizedPoint(normalizedPoint &arg1) {
return arg1;
}
/// from Float:
inline normalizedPoint _normalizedPoint(normalizedPoint::Float arg1) {
return normalizedPoint(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline normalizedPoint like(const mv &what, const normalizedPoint &example) {return _normalizedPoint(what);}
/// from const specialization class:
inline const normalizedPoint like(const normalizedPoint &what, const normalizedPoint &example) {return _normalizedPoint(what);}
/// from non-const specialization class:
inline normalizedPoint like(normalizedPoint &what, const normalizedPoint &example) {return _normalizedPoint(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const normalizedPoint & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const normalizedPoint & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const normalizedPoint & v) {
return (float)0;
}
/// enum for the coordinates of flatPoint
enum __flatPoint_coordinates__ {flatPoint_e1ni_e2ni_noni};
class flatPoint {
public:
typedef float Float;
/// zero constructor
inline flatPoint() {
set();
}
/// scalar constructor
inline flatPoint(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> flatPoint
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline flatPoint(const flatPoint &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline flatPoint(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> flatPoint
set(arg1);
}
/// pointer to coordinates constructor
inline flatPoint(__flatPoint_coordinates__, const Float *coordinates) {
set(flatPoint_e1ni_e2ni_noni, coordinates);
}
/// coordinates constructor
inline flatPoint(__flatPoint_coordinates__, Float c_e1ni, Float c_e2ni, Float c_noni) {
set(flatPoint_e1ni_e2ni_noni, c_e1ni, c_e2ni, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const flatPoint &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__flatPoint_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__flatPoint_coordinates__, Float c_e1ni, Float c_e2ni, Float c_noni);
/// assign copy
flatPoint &operator=(const flatPoint &arg1);
/// assign general multivector
flatPoint &operator=(const mv &arg1);
/// assign scalar
flatPoint &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[0];
}
inline Float e2ni() const {
return m_c[1];
}
inline Float noni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__flatPoint_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class flatPoint
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline flatPoint _flatPoint(const mv &arg1) {
return flatPoint(arg1, 0);
}
/// from const specialization class:
inline const flatPoint &_flatPoint(const flatPoint &arg1) {
return arg1;
}
/// from non-const specialization class:
inline flatPoint &_flatPoint(flatPoint &arg1) {
return arg1;
}
/// from Float:
inline flatPoint _flatPoint(flatPoint::Float arg1) {
return flatPoint(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline flatPoint like(const mv &what, const flatPoint &example) {return _flatPoint(what);}
/// from const specialization class:
inline const flatPoint like(const flatPoint &what, const flatPoint &example) {return _flatPoint(what);}
/// from non-const specialization class:
inline flatPoint like(flatPoint &what, const flatPoint &example) {return _flatPoint(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const flatPoint & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const flatPoint & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const flatPoint & v) {
return (float)0;
}
/// enum for the coordinates of normalizedFlatPoint
enum __normalizedFlatPoint_coordinates__ {normalizedFlatPoint_e1ni_e2ni_nonif1_0};
class normalizedFlatPoint {
public:
typedef float Float;
/// zero constructor
inline normalizedFlatPoint() {
set();
}
/// scalar constructor
inline normalizedFlatPoint(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> normalizedFlatPoint
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline normalizedFlatPoint(const normalizedFlatPoint &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline normalizedFlatPoint(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> normalizedFlatPoint
set(arg1);
}
/// pointer to coordinates constructor
inline normalizedFlatPoint(__normalizedFlatPoint_coordinates__, const Float *coordinates) {
set(normalizedFlatPoint_e1ni_e2ni_nonif1_0, coordinates);
}
/// coordinates constructor
inline normalizedFlatPoint(__normalizedFlatPoint_coordinates__, Float c_e1ni, Float c_e2ni) {
set(normalizedFlatPoint_e1ni_e2ni_nonif1_0, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const normalizedFlatPoint &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__normalizedFlatPoint_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__normalizedFlatPoint_coordinates__, Float c_e1ni, Float c_e2ni);
/// assign copy
normalizedFlatPoint &operator=(const normalizedFlatPoint &arg1);
/// assign general multivector
normalizedFlatPoint &operator=(const mv &arg1);
/// assign scalar
normalizedFlatPoint &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[0];
}
inline Float e2ni() const {
return m_c[1];
}
/// const coordinate extraction by name
inline Float noni() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__normalizedFlatPoint_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class normalizedFlatPoint
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline normalizedFlatPoint _normalizedFlatPoint(const mv &arg1) {
return normalizedFlatPoint(arg1, 0);
}
/// from const specialization class:
inline const normalizedFlatPoint &_normalizedFlatPoint(const normalizedFlatPoint &arg1) {
return arg1;
}
/// from non-const specialization class:
inline normalizedFlatPoint &_normalizedFlatPoint(normalizedFlatPoint &arg1) {
return arg1;
}
/// from Float:
inline normalizedFlatPoint _normalizedFlatPoint(normalizedFlatPoint::Float arg1) {
return normalizedFlatPoint(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline normalizedFlatPoint like(const mv &what, const normalizedFlatPoint &example) {return _normalizedFlatPoint(what);}
/// from const specialization class:
inline const normalizedFlatPoint like(const normalizedFlatPoint &what, const normalizedFlatPoint &example) {return _normalizedFlatPoint(what);}
/// from non-const specialization class:
inline normalizedFlatPoint like(normalizedFlatPoint &what, const normalizedFlatPoint &example) {return _normalizedFlatPoint(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const normalizedFlatPoint & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const normalizedFlatPoint & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const normalizedFlatPoint & v) {
return (float)0;
}
/// enum for the coordinates of pointPair
enum __pointPair_coordinates__ {pointPair_noe1_noe2_e1e2_e1ni_e2ni_noni};
class pointPair {
public:
typedef float Float;
/// zero constructor
inline pointPair() {
set();
}
/// scalar constructor
inline pointPair(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> pointPair
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline pointPair(const pointPair &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline pointPair(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> pointPair
set(arg1);
}
/// pointer to coordinates constructor
inline pointPair(__pointPair_coordinates__, const Float *coordinates) {
set(pointPair_noe1_noe2_e1e2_e1ni_e2ni_noni, coordinates);
}
/// coordinates constructor
inline pointPair(__pointPair_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni) {
set(pointPair_noe1_noe2_e1e2_e1ni_e2ni_noni, c_noe1, c_noe2, c_e1e2, c_e1ni, c_e2ni, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const pointPair &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__pointPair_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__pointPair_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni);
/// assign copy
pointPair &operator=(const pointPair &arg1);
/// assign general multivector
pointPair &operator=(const mv &arg1);
/// assign scalar
pointPair &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[0];
}
inline Float noe2() const {
return m_c[1];
}
inline Float e1e2() const {
return m_c[2];
}
inline Float e1ni() const {
return m_c[3];
}
inline Float e2ni() const {
return m_c[4];
}
inline Float noni() const {
return m_c[5];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__pointPair_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[6];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class pointPair
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline pointPair _pointPair(const mv &arg1) {
return pointPair(arg1, 0);
}
/// from const specialization class:
inline const pointPair &_pointPair(const pointPair &arg1) {
return arg1;
}
/// from non-const specialization class:
inline pointPair &_pointPair(pointPair &arg1) {
return arg1;
}
/// from Float:
inline pointPair _pointPair(pointPair::Float arg1) {
return pointPair(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline pointPair like(const mv &what, const pointPair &example) {return _pointPair(what);}
/// from const specialization class:
inline const pointPair like(const pointPair &what, const pointPair &example) {return _pointPair(what);}
/// from non-const specialization class:
inline pointPair like(pointPair &what, const pointPair &example) {return _pointPair(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const pointPair & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const pointPair & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const pointPair & v) {
return (float)0;
}
/// enum for the coordinates of TRversorLog
enum __TRversorLog_coordinates__ {TRversorLog_e1e2_e1ni_e2ni};
class TRversorLog {
public:
typedef float Float;
/// zero constructor
inline TRversorLog() {
set();
}
/// scalar constructor
inline TRversorLog(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> TRversorLog
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline TRversorLog(const TRversorLog &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline TRversorLog(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> TRversorLog
set(arg1);
}
/// pointer to coordinates constructor
inline TRversorLog(__TRversorLog_coordinates__, const Float *coordinates) {
set(TRversorLog_e1e2_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline TRversorLog(__TRversorLog_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
set(TRversorLog_e1e2_e1ni_e2ni, c_e1e2, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const TRversorLog &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__TRversorLog_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__TRversorLog_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni);
/// assign copy
TRversorLog &operator=(const TRversorLog &arg1);
/// assign general multivector
TRversorLog &operator=(const mv &arg1);
/// assign scalar
TRversorLog &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[0];
}
inline Float e1ni() const {
return m_c[1];
}
inline Float e2ni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__TRversorLog_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class TRversorLog
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline TRversorLog _TRversorLog(const mv &arg1) {
return TRversorLog(arg1, 0);
}
/// from const specialization class:
inline const TRversorLog &_TRversorLog(const TRversorLog &arg1) {
return arg1;
}
/// from non-const specialization class:
inline TRversorLog &_TRversorLog(TRversorLog &arg1) {
return arg1;
}
/// from Float:
inline TRversorLog _TRversorLog(TRversorLog::Float arg1) {
return TRversorLog(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline TRversorLog like(const mv &what, const TRversorLog &example) {return _TRversorLog(what);}
/// from const specialization class:
inline const TRversorLog like(const TRversorLog &what, const TRversorLog &example) {return _TRversorLog(what);}
/// from non-const specialization class:
inline TRversorLog like(TRversorLog &what, const TRversorLog &example) {return _TRversorLog(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const TRversorLog & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const TRversorLog & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const TRversorLog & v) {
return (float)0;
}
/// enum for the coordinates of line
enum __line_coordinates__ {line_e1e2ni_e1noni_e2noni};
class line {
public:
typedef float Float;
/// zero constructor
inline line() {
set();
}
/// scalar constructor
inline line(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> line
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline line(const line &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline line(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> line
set(arg1);
}
/// pointer to coordinates constructor
inline line(__line_coordinates__, const Float *coordinates) {
set(line_e1e2ni_e1noni_e2noni, coordinates);
}
/// coordinates constructor
inline line(__line_coordinates__, Float c_e1e2ni, Float c_e1noni, Float c_e2noni) {
set(line_e1e2ni_e1noni_e2noni, c_e1e2ni, c_e1noni, c_e2noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const line &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__line_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__line_coordinates__, Float c_e1e2ni, Float c_e1noni, Float c_e2noni);
/// assign copy
line &operator=(const line &arg1);
/// assign general multivector
line &operator=(const mv &arg1);
/// assign scalar
line &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2ni() const {
return m_c[0];
}
inline Float e1noni() const {
return m_c[1];
}
inline Float e2noni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__line_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class line
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline line _line(const mv &arg1) {
return line(arg1, 0);
}
/// from const specialization class:
inline const line &_line(const line &arg1) {
return arg1;
}
/// from non-const specialization class:
inline line &_line(line &arg1) {
return arg1;
}
/// from Float:
inline line _line(line::Float arg1) {
return line(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline line like(const mv &what, const line &example) {return _line(what);}
/// from const specialization class:
inline const line like(const line &what, const line &example) {return _line(what);}
/// from non-const specialization class:
inline line like(line &what, const line &example) {return _line(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const line & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const line & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const line & v) {
return (float)0;
}
/// enum for the coordinates of dualLine
enum __dualLine_coordinates__ {dualLine_e1e2_e1ni_e2ni};
class dualLine {
public:
typedef float Float;
/// zero constructor
inline dualLine() {
set();
}
/// scalar constructor
inline dualLine(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> dualLine
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline dualLine(const dualLine &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline dualLine(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> dualLine
set(arg1);
}
/// pointer to coordinates constructor
inline dualLine(__dualLine_coordinates__, const Float *coordinates) {
set(dualLine_e1e2_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline dualLine(__dualLine_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
set(dualLine_e1e2_e1ni_e2ni, c_e1e2, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const dualLine &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__dualLine_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__dualLine_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni);
/// assign copy
dualLine &operator=(const dualLine &arg1);
/// assign general multivector
dualLine &operator=(const mv &arg1);
/// assign scalar
dualLine &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[0];
}
inline Float e1ni() const {
return m_c[1];
}
inline Float e2ni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__dualLine_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class dualLine
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline dualLine _dualLine(const mv &arg1) {
return dualLine(arg1, 0);
}
/// from const specialization class:
inline const dualLine &_dualLine(const dualLine &arg1) {
return arg1;
}
/// from non-const specialization class:
inline dualLine &_dualLine(dualLine &arg1) {
return arg1;
}
/// from Float:
inline dualLine _dualLine(dualLine::Float arg1) {
return dualLine(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline dualLine like(const mv &what, const dualLine &example) {return _dualLine(what);}
/// from const specialization class:
inline const dualLine like(const dualLine &what, const dualLine &example) {return _dualLine(what);}
/// from non-const specialization class:
inline dualLine like(dualLine &what, const dualLine &example) {return _dualLine(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const dualLine & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const dualLine & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const dualLine & v) {
return (float)0;
}
/// enum for the coordinates of circle
enum __circle_coordinates__ {circle_e1e2ni_noe1ni_noe2ni_noe1e2};
class circle {
public:
typedef float Float;
/// zero constructor
inline circle() {
set();
}
/// scalar constructor
inline circle(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> circle
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline circle(const circle &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline circle(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> circle
set(arg1);
}
/// pointer to coordinates constructor
inline circle(__circle_coordinates__, const Float *coordinates) {
set(circle_e1e2ni_noe1ni_noe2ni_noe1e2, coordinates);
}
/// coordinates constructor
inline circle(__circle_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2) {
set(circle_e1e2ni_noe1ni_noe2ni_noe1e2, c_e1e2ni, c_noe1ni, c_noe2ni, c_noe1e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const circle &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__circle_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__circle_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2);
/// assign copy
circle &operator=(const circle &arg1);
/// assign general multivector
circle &operator=(const mv &arg1);
/// assign scalar
circle &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2ni() const {
return m_c[0];
}
inline Float noe1ni() const {
return m_c[1];
}
inline Float noe2ni() const {
return m_c[2];
}
inline Float noe1e2() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__circle_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class circle
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline circle _circle(const mv &arg1) {
return circle(arg1, 0);
}
/// from const specialization class:
inline const circle &_circle(const circle &arg1) {
return arg1;
}
/// from non-const specialization class:
inline circle &_circle(circle &arg1) {
return arg1;
}
/// from Float:
inline circle _circle(circle::Float arg1) {
return circle(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline circle like(const mv &what, const circle &example) {return _circle(what);}
/// from const specialization class:
inline const circle like(const circle &what, const circle &example) {return _circle(what);}
/// from non-const specialization class:
inline circle like(circle &what, const circle &example) {return _circle(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const circle & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const circle & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const circle & v) {
return (float)0;
}
/// enum for the coordinates of freeVector
enum __freeVector_coordinates__ {freeVector_e1ni_e2ni};
class freeVector {
public:
typedef float Float;
/// zero constructor
inline freeVector() {
set();
}
/// scalar constructor
inline freeVector(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> freeVector
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline freeVector(const freeVector &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline freeVector(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> freeVector
set(arg1);
}
/// pointer to coordinates constructor
inline freeVector(__freeVector_coordinates__, const Float *coordinates) {
set(freeVector_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline freeVector(__freeVector_coordinates__, Float c_e1ni, Float c_e2ni) {
set(freeVector_e1ni_e2ni, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const freeVector &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__freeVector_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__freeVector_coordinates__, Float c_e1ni, Float c_e2ni);
/// assign copy
freeVector &operator=(const freeVector &arg1);
/// assign general multivector
freeVector &operator=(const mv &arg1);
/// assign scalar
freeVector &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[0];
}
inline Float e2ni() const {
return m_c[1];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__freeVector_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class freeVector
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline freeVector _freeVector(const mv &arg1) {
return freeVector(arg1, 0);
}
/// from const specialization class:
inline const freeVector &_freeVector(const freeVector &arg1) {
return arg1;
}
/// from non-const specialization class:
inline freeVector &_freeVector(freeVector &arg1) {
return arg1;
}
/// from Float:
inline freeVector _freeVector(freeVector::Float arg1) {
return freeVector(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline freeVector like(const mv &what, const freeVector &example) {return _freeVector(what);}
/// from const specialization class:
inline const freeVector like(const freeVector &what, const freeVector &example) {return _freeVector(what);}
/// from non-const specialization class:
inline freeVector like(freeVector &what, const freeVector &example) {return _freeVector(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const freeVector & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const freeVector & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const freeVector & v) {
return (float)0;
}
/// enum for the coordinates of freeBivector
enum __freeBivector_coordinates__ {freeBivector_e1e2ni};
class freeBivector {
public:
typedef float Float;
/// zero constructor
inline freeBivector() {
set();
}
/// scalar constructor
inline freeBivector(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> freeBivector
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline freeBivector(const freeBivector &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline freeBivector(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> freeBivector
set(arg1);
}
/// pointer to coordinates constructor
inline freeBivector(__freeBivector_coordinates__, const Float *coordinates) {
set(freeBivector_e1e2ni, coordinates);
}
/// coordinates constructor
inline freeBivector(__freeBivector_coordinates__, Float c_e1e2ni) {
set(freeBivector_e1e2ni, c_e1e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const freeBivector &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__freeBivector_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__freeBivector_coordinates__, Float c_e1e2ni);
/// assign copy
freeBivector &operator=(const freeBivector &arg1);
/// assign general multivector
freeBivector &operator=(const mv &arg1);
/// assign scalar
freeBivector &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2ni() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__freeBivector_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class freeBivector
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline freeBivector _freeBivector(const mv &arg1) {
return freeBivector(arg1, 0);
}
/// from const specialization class:
inline const freeBivector &_freeBivector(const freeBivector &arg1) {
return arg1;
}
/// from non-const specialization class:
inline freeBivector &_freeBivector(freeBivector &arg1) {
return arg1;
}
/// from Float:
inline freeBivector _freeBivector(freeBivector::Float arg1) {
return freeBivector(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline freeBivector like(const mv &what, const freeBivector &example) {return _freeBivector(what);}
/// from const specialization class:
inline const freeBivector like(const freeBivector &what, const freeBivector &example) {return _freeBivector(what);}
/// from non-const specialization class:
inline freeBivector like(freeBivector &what, const freeBivector &example) {return _freeBivector(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const freeBivector & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const freeBivector & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const freeBivector & v) {
return (float)0;
}
/// enum for the coordinates of tangentVector
enum __tangentVector_coordinates__ {tangentVector_noe1_noe2_e1e2_e1ni_e2ni_noni};
class tangentVector {
public:
typedef float Float;
/// zero constructor
inline tangentVector() {
set();
}
/// scalar constructor
inline tangentVector(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> tangentVector
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline tangentVector(const tangentVector &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline tangentVector(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> tangentVector
set(arg1);
}
/// pointer to coordinates constructor
inline tangentVector(__tangentVector_coordinates__, const Float *coordinates) {
set(tangentVector_noe1_noe2_e1e2_e1ni_e2ni_noni, coordinates);
}
/// coordinates constructor
inline tangentVector(__tangentVector_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni) {
set(tangentVector_noe1_noe2_e1e2_e1ni_e2ni_noni, c_noe1, c_noe2, c_e1e2, c_e1ni, c_e2ni, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const tangentVector &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__tangentVector_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__tangentVector_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni);
/// assign copy
tangentVector &operator=(const tangentVector &arg1);
/// assign general multivector
tangentVector &operator=(const mv &arg1);
/// assign scalar
tangentVector &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[0];
}
inline Float noe2() const {
return m_c[1];
}
inline Float e1e2() const {
return m_c[2];
}
inline Float e1ni() const {
return m_c[3];
}
inline Float e2ni() const {
return m_c[4];
}
inline Float noni() const {
return m_c[5];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__tangentVector_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[6];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class tangentVector
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline tangentVector _tangentVector(const mv &arg1) {
return tangentVector(arg1, 0);
}
/// from const specialization class:
inline const tangentVector &_tangentVector(const tangentVector &arg1) {
return arg1;
}
/// from non-const specialization class:
inline tangentVector &_tangentVector(tangentVector &arg1) {
return arg1;
}
/// from Float:
inline tangentVector _tangentVector(tangentVector::Float arg1) {
return tangentVector(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline tangentVector like(const mv &what, const tangentVector &example) {return _tangentVector(what);}
/// from const specialization class:
inline const tangentVector like(const tangentVector &what, const tangentVector &example) {return _tangentVector(what);}
/// from non-const specialization class:
inline tangentVector like(tangentVector &what, const tangentVector &example) {return _tangentVector(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const tangentVector & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const tangentVector & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const tangentVector & v) {
return (float)0;
}
/// enum for the coordinates of tangentBivector
enum __tangentBivector_coordinates__ {tangentBivector_e1e2ni_noe1ni_noe2ni_noe1e2};
class tangentBivector {
public:
typedef float Float;
/// zero constructor
inline tangentBivector() {
set();
}
/// scalar constructor
inline tangentBivector(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> tangentBivector
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline tangentBivector(const tangentBivector &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline tangentBivector(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> tangentBivector
set(arg1);
}
/// pointer to coordinates constructor
inline tangentBivector(__tangentBivector_coordinates__, const Float *coordinates) {
set(tangentBivector_e1e2ni_noe1ni_noe2ni_noe1e2, coordinates);
}
/// coordinates constructor
inline tangentBivector(__tangentBivector_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2) {
set(tangentBivector_e1e2ni_noe1ni_noe2ni_noe1e2, c_e1e2ni, c_noe1ni, c_noe2ni, c_noe1e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const tangentBivector &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__tangentBivector_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__tangentBivector_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2);
/// assign copy
tangentBivector &operator=(const tangentBivector &arg1);
/// assign general multivector
tangentBivector &operator=(const mv &arg1);
/// assign scalar
tangentBivector &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2ni() const {
return m_c[0];
}
inline Float noe1ni() const {
return m_c[1];
}
inline Float noe2ni() const {
return m_c[2];
}
inline Float noe1e2() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__tangentBivector_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class tangentBivector
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline tangentBivector _tangentBivector(const mv &arg1) {
return tangentBivector(arg1, 0);
}
/// from const specialization class:
inline const tangentBivector &_tangentBivector(const tangentBivector &arg1) {
return arg1;
}
/// from non-const specialization class:
inline tangentBivector &_tangentBivector(tangentBivector &arg1) {
return arg1;
}
/// from Float:
inline tangentBivector _tangentBivector(tangentBivector::Float arg1) {
return tangentBivector(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline tangentBivector like(const mv &what, const tangentBivector &example) {return _tangentBivector(what);}
/// from const specialization class:
inline const tangentBivector like(const tangentBivector &what, const tangentBivector &example) {return _tangentBivector(what);}
/// from non-const specialization class:
inline tangentBivector like(tangentBivector &what, const tangentBivector &example) {return _tangentBivector(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const tangentBivector & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const tangentBivector & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const tangentBivector & v) {
return (float)0;
}
/// enum for the coordinates of vectorE2GA
enum __vectorE2GA_coordinates__ {vectorE2GA_e1_e2};
class vectorE2GA {
public:
typedef float Float;
/// zero constructor
inline vectorE2GA() {
set();
}
/// scalar constructor
inline vectorE2GA(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> vectorE2GA
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline vectorE2GA(const vectorE2GA &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline vectorE2GA(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> vectorE2GA
set(arg1);
}
/// pointer to coordinates constructor
inline vectorE2GA(__vectorE2GA_coordinates__, const Float *coordinates) {
set(vectorE2GA_e1_e2, coordinates);
}
/// coordinates constructor
inline vectorE2GA(__vectorE2GA_coordinates__, Float c_e1, Float c_e2) {
set(vectorE2GA_e1_e2, c_e1, c_e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const vectorE2GA &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__vectorE2GA_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__vectorE2GA_coordinates__, Float c_e1, Float c_e2);
/// assign copy
vectorE2GA &operator=(const vectorE2GA &arg1);
/// assign general multivector
vectorE2GA &operator=(const mv &arg1);
/// assign scalar
vectorE2GA &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__vectorE2GA_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class vectorE2GA
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline vectorE2GA _vectorE2GA(const mv &arg1) {
return vectorE2GA(arg1, 0);
}
/// from const specialization class:
inline const vectorE2GA &_vectorE2GA(const vectorE2GA &arg1) {
return arg1;
}
/// from non-const specialization class:
inline vectorE2GA &_vectorE2GA(vectorE2GA &arg1) {
return arg1;
}
/// from Float:
inline vectorE2GA _vectorE2GA(vectorE2GA::Float arg1) {
return vectorE2GA(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline vectorE2GA like(const mv &what, const vectorE2GA &example) {return _vectorE2GA(what);}
/// from const specialization class:
inline const vectorE2GA like(const vectorE2GA &what, const vectorE2GA &example) {return _vectorE2GA(what);}
/// from non-const specialization class:
inline vectorE2GA like(vectorE2GA &what, const vectorE2GA &example) {return _vectorE2GA(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const vectorE2GA & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const vectorE2GA & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const vectorE2GA & v) {
return (float)0;
}
/// enum for the coordinates of bivectorE2GA
enum __bivectorE2GA_coordinates__ {bivectorE2GA_e1e2};
class bivectorE2GA {
public:
typedef float Float;
/// zero constructor
inline bivectorE2GA() {
set();
}
/// scalar constructor
inline bivectorE2GA(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> bivectorE2GA
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline bivectorE2GA(const bivectorE2GA &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline bivectorE2GA(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> bivectorE2GA
set(arg1);
}
/// pointer to coordinates constructor
inline bivectorE2GA(__bivectorE2GA_coordinates__, const Float *coordinates) {
set(bivectorE2GA_e1e2, coordinates);
}
/// coordinates constructor
inline bivectorE2GA(__bivectorE2GA_coordinates__, Float c_e1e2) {
set(bivectorE2GA_e1e2, c_e1e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const bivectorE2GA &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__bivectorE2GA_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__bivectorE2GA_coordinates__, Float c_e1e2);
/// assign copy
bivectorE2GA &operator=(const bivectorE2GA &arg1);
/// assign general multivector
bivectorE2GA &operator=(const mv &arg1);
/// assign scalar
bivectorE2GA &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[0];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__bivectorE2GA_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[1];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class bivectorE2GA
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline bivectorE2GA _bivectorE2GA(const mv &arg1) {
return bivectorE2GA(arg1, 0);
}
/// from const specialization class:
inline const bivectorE2GA &_bivectorE2GA(const bivectorE2GA &arg1) {
return arg1;
}
/// from non-const specialization class:
inline bivectorE2GA &_bivectorE2GA(bivectorE2GA &arg1) {
return arg1;
}
/// from Float:
inline bivectorE2GA _bivectorE2GA(bivectorE2GA::Float arg1) {
return bivectorE2GA(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline bivectorE2GA like(const mv &what, const bivectorE2GA &example) {return _bivectorE2GA(what);}
/// from const specialization class:
inline const bivectorE2GA like(const bivectorE2GA &what, const bivectorE2GA &example) {return _bivectorE2GA(what);}
/// from non-const specialization class:
inline bivectorE2GA like(bivectorE2GA &what, const bivectorE2GA &example) {return _bivectorE2GA(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const bivectorE2GA & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const bivectorE2GA & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const bivectorE2GA & v) {
return (float)0;
}
/// enum for the coordinates of TRversor
enum __TRversor_coordinates__ {TRversor_scalar_e1e2_e1ni_e2ni};
class TRversor {
public:
typedef float Float;
/// zero constructor
inline TRversor() {
set();
}
/// scalar constructor
inline TRversor(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> TRversor
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline TRversor(const TRversor &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline TRversor(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> TRversor
set(arg1);
}
/// pointer to coordinates constructor
inline TRversor(__TRversor_coordinates__, const Float *coordinates) {
set(TRversor_scalar_e1e2_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline TRversor(__TRversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
set(TRversor_scalar_e1e2_e1ni_e2ni, c_scalar, c_e1e2, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const TRversor &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__TRversor_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__TRversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni);
/// assign copy
TRversor &operator=(const TRversor &arg1);
/// assign general multivector
TRversor &operator=(const mv &arg1);
/// assign scalar
TRversor &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[1];
}
inline Float e1ni() const {
return m_c[2];
}
inline Float e2ni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__TRversor_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class TRversor
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline TRversor _TRversor(const mv &arg1) {
return TRversor(arg1, 0);
}
/// from const specialization class:
inline const TRversor &_TRversor(const TRversor &arg1) {
return arg1;
}
/// from non-const specialization class:
inline TRversor &_TRversor(TRversor &arg1) {
return arg1;
}
/// from Float:
inline TRversor _TRversor(TRversor::Float arg1) {
return TRversor(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline TRversor like(const mv &what, const TRversor &example) {return _TRversor(what);}
/// from const specialization class:
inline const TRversor like(const TRversor &what, const TRversor &example) {return _TRversor(what);}
/// from non-const specialization class:
inline TRversor like(TRversor &what, const TRversor &example) {return _TRversor(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const TRversor & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const TRversor & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const TRversor & v) {
return v.m_c[0];
}
/// enum for the coordinates of TRSversor
enum __TRSversor_coordinates__ {TRSversor_scalar_e1e2_e1ni_e2ni_noni_e1e2noni};
class TRSversor {
public:
typedef float Float;
/// zero constructor
inline TRSversor() {
set();
}
/// scalar constructor
inline TRSversor(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> TRSversor
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline TRSversor(const TRSversor &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline TRSversor(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> TRSversor
set(arg1);
}
/// pointer to coordinates constructor
inline TRSversor(__TRSversor_coordinates__, const Float *coordinates) {
set(TRSversor_scalar_e1e2_e1ni_e2ni_noni_e1e2noni, coordinates);
}
/// coordinates constructor
inline TRSversor(__TRSversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni, Float c_e1e2noni) {
set(TRSversor_scalar_e1e2_e1ni_e2ni_noni_e1e2noni, c_scalar, c_e1e2, c_e1ni, c_e2ni, c_noni, c_e1e2noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const TRSversor &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__TRSversor_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__TRSversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni, Float c_e1e2noni);
/// assign copy
TRSversor &operator=(const TRSversor &arg1);
/// assign general multivector
TRSversor &operator=(const mv &arg1);
/// assign scalar
TRSversor &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[1];
}
inline Float e1ni() const {
return m_c[2];
}
inline Float e2ni() const {
return m_c[3];
}
inline Float noni() const {
return m_c[4];
}
inline Float e1e2noni() const {
return m_c[5];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__TRSversor_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[6];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class TRSversor
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline TRSversor _TRSversor(const mv &arg1) {
return TRSversor(arg1, 0);
}
/// from const specialization class:
inline const TRSversor &_TRSversor(const TRSversor &arg1) {
return arg1;
}
/// from non-const specialization class:
inline TRSversor &_TRSversor(TRSversor &arg1) {
return arg1;
}
/// from Float:
inline TRSversor _TRSversor(TRSversor::Float arg1) {
return TRSversor(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline TRSversor like(const mv &what, const TRSversor &example) {return _TRSversor(what);}
/// from const specialization class:
inline const TRSversor like(const TRSversor &what, const TRSversor &example) {return _TRSversor(what);}
/// from non-const specialization class:
inline TRSversor like(TRSversor &what, const TRSversor &example) {return _TRSversor(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const TRSversor & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const TRSversor & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const TRSversor & v) {
return v.m_c[0];
}
/// enum for the coordinates of evenVersor
enum __evenVersor_coordinates__ {evenVersor_scalar_noe1_noe2_e1e2_e1ni_e2ni_noni_e1e2noni};
class evenVersor {
public:
typedef float Float;
/// zero constructor
inline evenVersor() {
set();
}
/// scalar constructor
inline evenVersor(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> evenVersor
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline evenVersor(const evenVersor &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline evenVersor(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> evenVersor
set(arg1);
}
/// pointer to coordinates constructor
inline evenVersor(__evenVersor_coordinates__, const Float *coordinates) {
set(evenVersor_scalar_noe1_noe2_e1e2_e1ni_e2ni_noni_e1e2noni, coordinates);
}
/// coordinates constructor
inline evenVersor(__evenVersor_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni, Float c_e1e2noni) {
set(evenVersor_scalar_noe1_noe2_e1e2_e1ni_e2ni_noni_e1e2noni, c_scalar, c_noe1, c_noe2, c_e1e2, c_e1ni, c_e2ni, c_noni, c_e1e2noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const evenVersor &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__evenVersor_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__evenVersor_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni, Float c_e1e2noni);
/// assign copy
evenVersor &operator=(const evenVersor &arg1);
/// assign general multivector
evenVersor &operator=(const mv &arg1);
/// assign scalar
evenVersor &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[1];
}
inline Float noe2() const {
return m_c[2];
}
inline Float e1e2() const {
return m_c[3];
}
inline Float e1ni() const {
return m_c[4];
}
inline Float e2ni() const {
return m_c[5];
}
inline Float noni() const {
return m_c[6];
}
inline Float e1e2noni() const {
return m_c[7];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__evenVersor_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[8];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class evenVersor
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline evenVersor _evenVersor(const mv &arg1) {
return evenVersor(arg1, 0);
}
/// from const specialization class:
inline const evenVersor &_evenVersor(const evenVersor &arg1) {
return arg1;
}
/// from non-const specialization class:
inline evenVersor &_evenVersor(evenVersor &arg1) {
return arg1;
}
/// from Float:
inline evenVersor _evenVersor(evenVersor::Float arg1) {
return evenVersor(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline evenVersor like(const mv &what, const evenVersor &example) {return _evenVersor(what);}
/// from const specialization class:
inline const evenVersor like(const evenVersor &what, const evenVersor &example) {return _evenVersor(what);}
/// from non-const specialization class:
inline evenVersor like(evenVersor &what, const evenVersor &example) {return _evenVersor(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const evenVersor & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const evenVersor & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const evenVersor & v) {
return v.m_c[0];
}
/// enum for the coordinates of translator
enum __translator_coordinates__ {translator_scalar_e1ni_e2ni};
class translator {
public:
typedef float Float;
/// zero constructor
inline translator() {
set();
}
/// scalar constructor
inline translator(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> translator
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline translator(const translator &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline translator(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> translator
set(arg1);
}
/// pointer to coordinates constructor
inline translator(__translator_coordinates__, const Float *coordinates) {
set(translator_scalar_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline translator(__translator_coordinates__, Float c_scalar, Float c_e1ni, Float c_e2ni) {
set(translator_scalar_e1ni_e2ni, c_scalar, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const translator &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__translator_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__translator_coordinates__, Float c_scalar, Float c_e1ni, Float c_e2ni);
/// assign copy
translator &operator=(const translator &arg1);
/// assign general multivector
translator &operator=(const mv &arg1);
/// assign scalar
translator &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[1];
}
inline Float e2ni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__translator_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class translator
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline translator _translator(const mv &arg1) {
return translator(arg1, 0);
}
/// from const specialization class:
inline const translator &_translator(const translator &arg1) {
return arg1;
}
/// from non-const specialization class:
inline translator &_translator(translator &arg1) {
return arg1;
}
/// from Float:
inline translator _translator(translator::Float arg1) {
return translator(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline translator like(const mv &what, const translator &example) {return _translator(what);}
/// from const specialization class:
inline const translator like(const translator &what, const translator &example) {return _translator(what);}
/// from non-const specialization class:
inline translator like(translator &what, const translator &example) {return _translator(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const translator & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const translator & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const translator & v) {
return v.m_c[0];
}
/// enum for the coordinates of normalizedTranslator
enum __normalizedTranslator_coordinates__ {normalizedTranslator_e1ni_e2ni_scalarf1_0};
class normalizedTranslator {
public:
typedef float Float;
/// zero constructor
inline normalizedTranslator() {
set();
}
/// scalar constructor
inline normalizedTranslator(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> normalizedTranslator
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline normalizedTranslator(const normalizedTranslator &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline normalizedTranslator(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> normalizedTranslator
set(arg1);
}
/// pointer to coordinates constructor
inline normalizedTranslator(__normalizedTranslator_coordinates__, const Float *coordinates) {
set(normalizedTranslator_e1ni_e2ni_scalarf1_0, coordinates);
}
/// coordinates constructor
inline normalizedTranslator(__normalizedTranslator_coordinates__, Float c_e1ni, Float c_e2ni) {
set(normalizedTranslator_e1ni_e2ni_scalarf1_0, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const normalizedTranslator &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__normalizedTranslator_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__normalizedTranslator_coordinates__, Float c_e1ni, Float c_e2ni);
/// assign copy
normalizedTranslator &operator=(const normalizedTranslator &arg1);
/// assign general multivector
normalizedTranslator &operator=(const mv &arg1);
/// assign scalar
normalizedTranslator &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[0];
}
inline Float e2ni() const {
return m_c[1];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__normalizedTranslator_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class normalizedTranslator
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline normalizedTranslator _normalizedTranslator(const mv &arg1) {
return normalizedTranslator(arg1, 0);
}
/// from const specialization class:
inline const normalizedTranslator &_normalizedTranslator(const normalizedTranslator &arg1) {
return arg1;
}
/// from non-const specialization class:
inline normalizedTranslator &_normalizedTranslator(normalizedTranslator &arg1) {
return arg1;
}
/// from Float:
inline normalizedTranslator _normalizedTranslator(normalizedTranslator::Float arg1) {
return normalizedTranslator(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline normalizedTranslator like(const mv &what, const normalizedTranslator &example) {return _normalizedTranslator(what);}
/// from const specialization class:
inline const normalizedTranslator like(const normalizedTranslator &what, const normalizedTranslator &example) {return _normalizedTranslator(what);}
/// from non-const specialization class:
inline normalizedTranslator like(normalizedTranslator &what, const normalizedTranslator &example) {return _normalizedTranslator(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const normalizedTranslator & v) {
return (float)1.0f;
}
/// returns scalar part of v as double
inline double _double(const normalizedTranslator & v) {
return (double)1.0f;
}
/// returns scalar part of v as Float
inline float _Float(const normalizedTranslator & v) {
return (float)1.0f;
}
/// enum for the coordinates of rotor
enum __rotor_coordinates__ {rotor_scalar_e1e2};
class rotor {
public:
typedef float Float;
/// zero constructor
inline rotor() {
set();
}
/// scalar constructor
inline rotor(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> rotor
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline rotor(const rotor &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline rotor(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> rotor
set(arg1);
}
/// pointer to coordinates constructor
inline rotor(__rotor_coordinates__, const Float *coordinates) {
set(rotor_scalar_e1e2, coordinates);
}
/// coordinates constructor
inline rotor(__rotor_coordinates__, Float c_scalar, Float c_e1e2) {
set(rotor_scalar_e1e2, c_scalar, c_e1e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const rotor &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__rotor_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__rotor_coordinates__, Float c_scalar, Float c_e1e2);
/// assign copy
rotor &operator=(const rotor &arg1);
/// assign general multivector
rotor &operator=(const mv &arg1);
/// assign scalar
rotor &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1e2() const {
return m_c[1];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__rotor_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class rotor
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline rotor _rotor(const mv &arg1) {
return rotor(arg1, 0);
}
/// from const specialization class:
inline const rotor &_rotor(const rotor &arg1) {
return arg1;
}
/// from non-const specialization class:
inline rotor &_rotor(rotor &arg1) {
return arg1;
}
/// from Float:
inline rotor _rotor(rotor::Float arg1) {
return rotor(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline rotor like(const mv &what, const rotor &example) {return _rotor(what);}
/// from const specialization class:
inline const rotor like(const rotor &what, const rotor &example) {return _rotor(what);}
/// from non-const specialization class:
inline rotor like(rotor &what, const rotor &example) {return _rotor(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const rotor & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const rotor & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const rotor & v) {
return v.m_c[0];
}
/// enum for the coordinates of scalor
enum __scalor_coordinates__ {scalor_scalar_noni};
class scalor {
public:
typedef float Float;
/// zero constructor
inline scalor() {
set();
}
/// scalar constructor
inline scalor(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> scalor
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline scalor(const scalor &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline scalor(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> scalor
set(arg1);
}
/// pointer to coordinates constructor
inline scalor(__scalor_coordinates__, const Float *coordinates) {
set(scalor_scalar_noni, coordinates);
}
/// coordinates constructor
inline scalor(__scalor_coordinates__, Float c_scalar, Float c_noni) {
set(scalor_scalar_noni, c_scalar, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const scalor &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(__scalor_coordinates__, const Float *coordinates);
/// set to coordinates
void set(__scalor_coordinates__, Float c_scalar, Float c_noni);
/// assign copy
scalor &operator=(const scalor &arg1);
/// assign general multivector
scalor &operator=(const mv &arg1);
/// assign scalar
scalor &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noni() const {
return m_c[1];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(__scalor_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class scalor
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline scalor _scalor(const mv &arg1) {
return scalor(arg1, 0);
}
/// from const specialization class:
inline const scalor &_scalor(const scalor &arg1) {
return arg1;
}
/// from non-const specialization class:
inline scalor &_scalor(scalor &arg1) {
return arg1;
}
/// from Float:
inline scalor _scalor(scalor::Float arg1) {
return scalor(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline scalor like(const mv &what, const scalor &example) {return _scalor(what);}
/// from const specialization class:
inline const scalor like(const scalor &what, const scalor &example) {return _scalor(what);}
/// from non-const specialization class:
inline scalor like(scalor &what, const scalor &example) {return _scalor(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const scalor & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const scalor & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const scalor & v) {
return v.m_c[0];
}
/// enum for the coordinates of __no_ct__
enum ____no_ct___coordinates__ {__no_ct___nof1_0};
class __no_ct__ {
public:
typedef float Float;
/// zero constructor
inline __no_ct__() {
set();
}
/// scalar constructor
inline __no_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __no_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __no_ct__(const __no_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __no_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __no_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __no_ct__(____no_ct___coordinates__, const Float *coordinates) {
set(__no_ct___nof1_0, coordinates);
}
/// coordinates constructor
inline __no_ct__(____no_ct___coordinates__) {
set(__no_ct___nof1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __no_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____no_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____no_ct___coordinates__);
/// assign copy
__no_ct__ &operator=(const __no_ct__ &arg1);
/// assign general multivector
__no_ct__ &operator=(const mv &arg1);
/// assign scalar
__no_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float nof1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____no_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __no_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __no_ct__ ___no_ct__(const mv &arg1) {
return __no_ct__(arg1, 0);
}
/// from const specialization class:
inline const __no_ct__ &___no_ct__(const __no_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __no_ct__ &___no_ct__(__no_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __no_ct__ ___no_ct__(__no_ct__::Float arg1) {
return __no_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __no_ct__ like(const mv &what, const __no_ct__ &example) {return ___no_ct__(what);}
/// from const specialization class:
inline const __no_ct__ like(const __no_ct__ &what, const __no_ct__ &example) {return ___no_ct__(what);}
/// from non-const specialization class:
inline __no_ct__ like(__no_ct__ &what, const __no_ct__ &example) {return ___no_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __no_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __no_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __no_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __e1_ct__
enum ____e1_ct___coordinates__ {__e1_ct___e1f1_0};
class __e1_ct__ {
public:
typedef float Float;
/// zero constructor
inline __e1_ct__() {
set();
}
/// scalar constructor
inline __e1_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __e1_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __e1_ct__(const __e1_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __e1_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __e1_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __e1_ct__(____e1_ct___coordinates__, const Float *coordinates) {
set(__e1_ct___e1f1_0, coordinates);
}
/// coordinates constructor
inline __e1_ct__(____e1_ct___coordinates__) {
set(__e1_ct___e1f1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __e1_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____e1_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____e1_ct___coordinates__);
/// assign copy
__e1_ct__ &operator=(const __e1_ct__ &arg1);
/// assign general multivector
__e1_ct__ &operator=(const mv &arg1);
/// assign scalar
__e1_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e1f1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____e1_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __e1_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __e1_ct__ ___e1_ct__(const mv &arg1) {
return __e1_ct__(arg1, 0);
}
/// from const specialization class:
inline const __e1_ct__ &___e1_ct__(const __e1_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __e1_ct__ &___e1_ct__(__e1_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __e1_ct__ ___e1_ct__(__e1_ct__::Float arg1) {
return __e1_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __e1_ct__ like(const mv &what, const __e1_ct__ &example) {return ___e1_ct__(what);}
/// from const specialization class:
inline const __e1_ct__ like(const __e1_ct__ &what, const __e1_ct__ &example) {return ___e1_ct__(what);}
/// from non-const specialization class:
inline __e1_ct__ like(__e1_ct__ &what, const __e1_ct__ &example) {return ___e1_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __e1_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __e1_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __e1_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __e2_ct__
enum ____e2_ct___coordinates__ {__e2_ct___e2f1_0};
class __e2_ct__ {
public:
typedef float Float;
/// zero constructor
inline __e2_ct__() {
set();
}
/// scalar constructor
inline __e2_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __e2_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __e2_ct__(const __e2_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __e2_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __e2_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __e2_ct__(____e2_ct___coordinates__, const Float *coordinates) {
set(__e2_ct___e2f1_0, coordinates);
}
/// coordinates constructor
inline __e2_ct__(____e2_ct___coordinates__) {
set(__e2_ct___e2f1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __e2_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____e2_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____e2_ct___coordinates__);
/// assign copy
__e2_ct__ &operator=(const __e2_ct__ &arg1);
/// assign general multivector
__e2_ct__ &operator=(const mv &arg1);
/// assign scalar
__e2_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e2f1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____e2_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __e2_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __e2_ct__ ___e2_ct__(const mv &arg1) {
return __e2_ct__(arg1, 0);
}
/// from const specialization class:
inline const __e2_ct__ &___e2_ct__(const __e2_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __e2_ct__ &___e2_ct__(__e2_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __e2_ct__ ___e2_ct__(__e2_ct__::Float arg1) {
return __e2_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __e2_ct__ like(const mv &what, const __e2_ct__ &example) {return ___e2_ct__(what);}
/// from const specialization class:
inline const __e2_ct__ like(const __e2_ct__ &what, const __e2_ct__ &example) {return ___e2_ct__(what);}
/// from non-const specialization class:
inline __e2_ct__ like(__e2_ct__ &what, const __e2_ct__ &example) {return ___e2_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __e2_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __e2_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __e2_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __ni_ct__
enum ____ni_ct___coordinates__ {__ni_ct___nif1_0};
class __ni_ct__ {
public:
typedef float Float;
/// zero constructor
inline __ni_ct__() {
set();
}
/// scalar constructor
inline __ni_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __ni_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __ni_ct__(const __ni_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __ni_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __ni_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __ni_ct__(____ni_ct___coordinates__, const Float *coordinates) {
set(__ni_ct___nif1_0, coordinates);
}
/// coordinates constructor
inline __ni_ct__(____ni_ct___coordinates__) {
set(__ni_ct___nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __ni_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____ni_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____ni_ct___coordinates__);
/// assign copy
__ni_ct__ &operator=(const __ni_ct__ &arg1);
/// assign general multivector
__ni_ct__ &operator=(const mv &arg1);
/// assign scalar
__ni_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float nif1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____ni_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __ni_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __ni_ct__ ___ni_ct__(const mv &arg1) {
return __ni_ct__(arg1, 0);
}
/// from const specialization class:
inline const __ni_ct__ &___ni_ct__(const __ni_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __ni_ct__ &___ni_ct__(__ni_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __ni_ct__ ___ni_ct__(__ni_ct__::Float arg1) {
return __ni_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __ni_ct__ like(const mv &what, const __ni_ct__ &example) {return ___ni_ct__(what);}
/// from const specialization class:
inline const __ni_ct__ like(const __ni_ct__ &what, const __ni_ct__ &example) {return ___ni_ct__(what);}
/// from non-const specialization class:
inline __ni_ct__ like(__ni_ct__ &what, const __ni_ct__ &example) {return ___ni_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __ni_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __ni_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __ni_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __I4i_ct__
enum ____I4i_ct___coordinates__ {__I4i_ct___noe1e2nif_1_0};
class __I4i_ct__ {
public:
typedef float Float;
/// zero constructor
inline __I4i_ct__() {
set();
}
/// scalar constructor
inline __I4i_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __I4i_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __I4i_ct__(const __I4i_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __I4i_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __I4i_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __I4i_ct__(____I4i_ct___coordinates__, const Float *coordinates) {
set(__I4i_ct___noe1e2nif_1_0, coordinates);
}
/// coordinates constructor
inline __I4i_ct__(____I4i_ct___coordinates__) {
set(__I4i_ct___noe1e2nif_1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __I4i_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____I4i_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____I4i_ct___coordinates__);
/// assign copy
__I4i_ct__ &operator=(const __I4i_ct__ &arg1);
/// assign general multivector
__I4i_ct__ &operator=(const mv &arg1);
/// assign scalar
__I4i_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float noe1e2nif_1_0() const {
return -1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____I4i_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __I4i_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __I4i_ct__ ___I4i_ct__(const mv &arg1) {
return __I4i_ct__(arg1, 0);
}
/// from const specialization class:
inline const __I4i_ct__ &___I4i_ct__(const __I4i_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __I4i_ct__ &___I4i_ct__(__I4i_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __I4i_ct__ ___I4i_ct__(__I4i_ct__::Float arg1) {
return __I4i_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __I4i_ct__ like(const mv &what, const __I4i_ct__ &example) {return ___I4i_ct__(what);}
/// from const specialization class:
inline const __I4i_ct__ like(const __I4i_ct__ &what, const __I4i_ct__ &example) {return ___I4i_ct__(what);}
/// from non-const specialization class:
inline __I4i_ct__ like(__I4i_ct__ &what, const __I4i_ct__ &example) {return ___I4i_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __I4i_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __I4i_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __I4i_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __I4_ct__
enum ____I4_ct___coordinates__ {__I4_ct___noe1e2nif1_0};
class __I4_ct__ {
public:
typedef float Float;
/// zero constructor
inline __I4_ct__() {
set();
}
/// scalar constructor
inline __I4_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __I4_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __I4_ct__(const __I4_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __I4_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __I4_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __I4_ct__(____I4_ct___coordinates__, const Float *coordinates) {
set(__I4_ct___noe1e2nif1_0, coordinates);
}
/// coordinates constructor
inline __I4_ct__(____I4_ct___coordinates__) {
set(__I4_ct___noe1e2nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __I4_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____I4_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____I4_ct___coordinates__);
/// assign copy
__I4_ct__ &operator=(const __I4_ct__ &arg1);
/// assign general multivector
__I4_ct__ &operator=(const mv &arg1);
/// assign scalar
__I4_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float noe1e2nif1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____I4_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __I4_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __I4_ct__ ___I4_ct__(const mv &arg1) {
return __I4_ct__(arg1, 0);
}
/// from const specialization class:
inline const __I4_ct__ &___I4_ct__(const __I4_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __I4_ct__ &___I4_ct__(__I4_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __I4_ct__ ___I4_ct__(__I4_ct__::Float arg1) {
return __I4_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __I4_ct__ like(const mv &what, const __I4_ct__ &example) {return ___I4_ct__(what);}
/// from const specialization class:
inline const __I4_ct__ like(const __I4_ct__ &what, const __I4_ct__ &example) {return ___I4_ct__(what);}
/// from non-const specialization class:
inline __I4_ct__ like(__I4_ct__ &what, const __I4_ct__ &example) {return ___I4_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __I4_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __I4_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __I4_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __I2_ct__
enum ____I2_ct___coordinates__ {__I2_ct___e1e2f1_0};
class __I2_ct__ {
public:
typedef float Float;
/// zero constructor
inline __I2_ct__() {
set();
}
/// scalar constructor
inline __I2_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __I2_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __I2_ct__(const __I2_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __I2_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __I2_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __I2_ct__(____I2_ct___coordinates__, const Float *coordinates) {
set(__I2_ct___e1e2f1_0, coordinates);
}
/// coordinates constructor
inline __I2_ct__(____I2_ct___coordinates__) {
set(__I2_ct___e1e2f1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __I2_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____I2_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____I2_ct___coordinates__);
/// assign copy
__I2_ct__ &operator=(const __I2_ct__ &arg1);
/// assign general multivector
__I2_ct__ &operator=(const mv &arg1);
/// assign scalar
__I2_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e1e2f1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____I2_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __I2_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __I2_ct__ ___I2_ct__(const mv &arg1) {
return __I2_ct__(arg1, 0);
}
/// from const specialization class:
inline const __I2_ct__ &___I2_ct__(const __I2_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __I2_ct__ &___I2_ct__(__I2_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __I2_ct__ ___I2_ct__(__I2_ct__::Float arg1) {
return __I2_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __I2_ct__ like(const mv &what, const __I2_ct__ &example) {return ___I2_ct__(what);}
/// from const specialization class:
inline const __I2_ct__ like(const __I2_ct__ &what, const __I2_ct__ &example) {return ___I2_ct__(what);}
/// from non-const specialization class:
inline __I2_ct__ like(__I2_ct__ &what, const __I2_ct__ &example) {return ___I2_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __I2_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __I2_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __I2_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __noni_ct__
enum ____noni_ct___coordinates__ {__noni_ct___nonif1_0};
class __noni_ct__ {
public:
typedef float Float;
/// zero constructor
inline __noni_ct__() {
set();
}
/// scalar constructor
inline __noni_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __noni_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __noni_ct__(const __noni_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __noni_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __noni_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __noni_ct__(____noni_ct___coordinates__, const Float *coordinates) {
set(__noni_ct___nonif1_0, coordinates);
}
/// coordinates constructor
inline __noni_ct__(____noni_ct___coordinates__) {
set(__noni_ct___nonif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __noni_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____noni_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____noni_ct___coordinates__);
/// assign copy
__noni_ct__ &operator=(const __noni_ct__ &arg1);
/// assign general multivector
__noni_ct__ &operator=(const mv &arg1);
/// assign scalar
__noni_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float nonif1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____noni_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __noni_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __noni_ct__ ___noni_ct__(const mv &arg1) {
return __noni_ct__(arg1, 0);
}
/// from const specialization class:
inline const __noni_ct__ &___noni_ct__(const __noni_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __noni_ct__ &___noni_ct__(__noni_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __noni_ct__ ___noni_ct__(__noni_ct__::Float arg1) {
return __noni_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __noni_ct__ like(const mv &what, const __noni_ct__ &example) {return ___noni_ct__(what);}
/// from const specialization class:
inline const __noni_ct__ like(const __noni_ct__ &what, const __noni_ct__ &example) {return ___noni_ct__(what);}
/// from non-const specialization class:
inline __noni_ct__ like(__noni_ct__ &what, const __noni_ct__ &example) {return ___noni_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __noni_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __noni_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __noni_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __e2ni_ct__
enum ____e2ni_ct___coordinates__ {__e2ni_ct___e2nif1_0};
class __e2ni_ct__ {
public:
typedef float Float;
/// zero constructor
inline __e2ni_ct__() {
set();
}
/// scalar constructor
inline __e2ni_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __e2ni_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __e2ni_ct__(const __e2ni_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __e2ni_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __e2ni_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __e2ni_ct__(____e2ni_ct___coordinates__, const Float *coordinates) {
set(__e2ni_ct___e2nif1_0, coordinates);
}
/// coordinates constructor
inline __e2ni_ct__(____e2ni_ct___coordinates__) {
set(__e2ni_ct___e2nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __e2ni_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____e2ni_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____e2ni_ct___coordinates__);
/// assign copy
__e2ni_ct__ &operator=(const __e2ni_ct__ &arg1);
/// assign general multivector
__e2ni_ct__ &operator=(const mv &arg1);
/// assign scalar
__e2ni_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e2nif1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____e2ni_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __e2ni_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __e2ni_ct__ ___e2ni_ct__(const mv &arg1) {
return __e2ni_ct__(arg1, 0);
}
/// from const specialization class:
inline const __e2ni_ct__ &___e2ni_ct__(const __e2ni_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __e2ni_ct__ &___e2ni_ct__(__e2ni_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __e2ni_ct__ ___e2ni_ct__(__e2ni_ct__::Float arg1) {
return __e2ni_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __e2ni_ct__ like(const mv &what, const __e2ni_ct__ &example) {return ___e2ni_ct__(what);}
/// from const specialization class:
inline const __e2ni_ct__ like(const __e2ni_ct__ &what, const __e2ni_ct__ &example) {return ___e2ni_ct__(what);}
/// from non-const specialization class:
inline __e2ni_ct__ like(__e2ni_ct__ &what, const __e2ni_ct__ &example) {return ___e2ni_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __e2ni_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __e2ni_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __e2ni_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __e1ni_ct__
enum ____e1ni_ct___coordinates__ {__e1ni_ct___e1nif1_0};
class __e1ni_ct__ {
public:
typedef float Float;
/// zero constructor
inline __e1ni_ct__() {
set();
}
/// scalar constructor
inline __e1ni_ct__(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __e1ni_ct__
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __e1ni_ct__(const __e1ni_ct__ &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __e1ni_ct__(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __e1ni_ct__
set(arg1);
}
/// pointer to coordinates constructor
inline __e1ni_ct__(____e1ni_ct___coordinates__, const Float *coordinates) {
set(__e1ni_ct___e1nif1_0, coordinates);
}
/// coordinates constructor
inline __e1ni_ct__(____e1ni_ct___coordinates__) {
set(__e1ni_ct___e1nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __e1ni_ct__ &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____e1ni_ct___coordinates__, const Float *coordinates);
/// set to coordinates
void set(____e1ni_ct___coordinates__);
/// assign copy
__e1ni_ct__ &operator=(const __e1ni_ct__ &arg1);
/// assign general multivector
__e1ni_ct__ &operator=(const mv &arg1);
/// assign scalar
__e1ni_ct__ &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e1nif1_0() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____e1ni_ct___coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __e1ni_ct__
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __e1ni_ct__ ___e1ni_ct__(const mv &arg1) {
return __e1ni_ct__(arg1, 0);
}
/// from const specialization class:
inline const __e1ni_ct__ &___e1ni_ct__(const __e1ni_ct__ &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __e1ni_ct__ &___e1ni_ct__(__e1ni_ct__ &arg1) {
return arg1;
}
/// from Float:
inline __e1ni_ct__ ___e1ni_ct__(__e1ni_ct__::Float arg1) {
return __e1ni_ct__(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __e1ni_ct__ like(const mv &what, const __e1ni_ct__ &example) {return ___e1ni_ct__(what);}
/// from const specialization class:
inline const __e1ni_ct__ like(const __e1ni_ct__ &what, const __e1ni_ct__ &example) {return ___e1ni_ct__(what);}
/// from non-const specialization class:
inline __e1ni_ct__ like(__e1ni_ct__ &what, const __e1ni_ct__ &example) {return ___e1ni_ct__(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __e1ni_ct__ & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __e1ni_ct__ & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __e1ni_ct__ & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1_e2_nof1_0
enum ____syn_smv___e1_e2_nof1_0_coordinates__ {__syn_smv___e1_e2_nof1_0_e1_e2_nof1_0};
class __syn_smv___e1_e2_nof1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1_e2_nof1_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1_e2_nof1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_nof1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1_e2_nof1_0(const __syn_smv___e1_e2_nof1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1_e2_nof1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_nof1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1_e2_nof1_0(____syn_smv___e1_e2_nof1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1_e2_nof1_0_e1_e2_nof1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1_e2_nof1_0(____syn_smv___e1_e2_nof1_0_coordinates__, Float c_e1, Float c_e2) {
set(__syn_smv___e1_e2_nof1_0_e1_e2_nof1_0, c_e1, c_e2);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1_e2_nof1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1_e2_nof1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1_e2_nof1_0_coordinates__, Float c_e1, Float c_e2);
/// assign copy
__syn_smv___e1_e2_nof1_0 &operator=(const __syn_smv___e1_e2_nof1_0 &arg1);
/// assign general multivector
__syn_smv___e1_e2_nof1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1_e2_nof1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
/// const coordinate extraction by name
inline Float no() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1_e2_nof1_0_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1_e2_nof1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_nof1_0 ___syn_smv___e1_e2_nof1_0(const mv &arg1) {
return __syn_smv___e1_e2_nof1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1_e2_nof1_0 &___syn_smv___e1_e2_nof1_0(const __syn_smv___e1_e2_nof1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1_e2_nof1_0 &___syn_smv___e1_e2_nof1_0(__syn_smv___e1_e2_nof1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1_e2_nof1_0 ___syn_smv___e1_e2_nof1_0(__syn_smv___e1_e2_nof1_0::Float arg1) {
return __syn_smv___e1_e2_nof1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_nof1_0 like(const mv &what, const __syn_smv___e1_e2_nof1_0 &example) {return ___syn_smv___e1_e2_nof1_0(what);}
/// from const specialization class:
inline const __syn_smv___e1_e2_nof1_0 like(const __syn_smv___e1_e2_nof1_0 &what, const __syn_smv___e1_e2_nof1_0 &example) {return ___syn_smv___e1_e2_nof1_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1_e2_nof1_0 like(__syn_smv___e1_e2_nof1_0 &what, const __syn_smv___e1_e2_nof1_0 &example) {return ___syn_smv___e1_e2_nof1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1_e2_nof1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1_e2_nof1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1_e2_nof1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1e2nif1_0
enum ____syn_smv___e1e2nif1_0_coordinates__ {__syn_smv___e1e2nif1_0_e1e2nif1_0};
class __syn_smv___e1e2nif1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1e2nif1_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1e2nif1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1e2nif1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1e2nif1_0(const __syn_smv___e1e2nif1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1e2nif1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1e2nif1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1e2nif1_0(____syn_smv___e1e2nif1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1e2nif1_0_e1e2nif1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1e2nif1_0(____syn_smv___e1e2nif1_0_coordinates__) {
set(__syn_smv___e1e2nif1_0_e1e2nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1e2nif1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1e2nif1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1e2nif1_0_coordinates__);
/// assign copy
__syn_smv___e1e2nif1_0 &operator=(const __syn_smv___e1e2nif1_0 &arg1);
/// assign general multivector
__syn_smv___e1e2nif1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1e2nif1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float e1e2ni() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1e2nif1_0_coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1e2nif1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1e2nif1_0 ___syn_smv___e1e2nif1_0(const mv &arg1) {
return __syn_smv___e1e2nif1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1e2nif1_0 &___syn_smv___e1e2nif1_0(const __syn_smv___e1e2nif1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1e2nif1_0 &___syn_smv___e1e2nif1_0(__syn_smv___e1e2nif1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1e2nif1_0 ___syn_smv___e1e2nif1_0(__syn_smv___e1e2nif1_0::Float arg1) {
return __syn_smv___e1e2nif1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1e2nif1_0 like(const mv &what, const __syn_smv___e1e2nif1_0 &example) {return ___syn_smv___e1e2nif1_0(what);}
/// from const specialization class:
inline const __syn_smv___e1e2nif1_0 like(const __syn_smv___e1e2nif1_0 &what, const __syn_smv___e1e2nif1_0 &example) {return ___syn_smv___e1e2nif1_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1e2nif1_0 like(__syn_smv___e1e2nif1_0 &what, const __syn_smv___e1e2nif1_0 &example) {return ___syn_smv___e1e2nif1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1e2nif1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1e2nif1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1e2nif1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1_e2_ni_nof_1_0
enum ____syn_smv___e1_e2_ni_nof_1_0_coordinates__ {__syn_smv___e1_e2_ni_nof_1_0_e1_e2_ni_nof_1_0};
class __syn_smv___e1_e2_ni_nof_1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1_e2_ni_nof_1_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1_e2_ni_nof_1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_ni_nof_1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1_e2_ni_nof_1_0(const __syn_smv___e1_e2_ni_nof_1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1_e2_ni_nof_1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_ni_nof_1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1_e2_ni_nof_1_0(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1_e2_ni_nof_1_0_e1_e2_ni_nof_1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1_e2_ni_nof_1_0(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
set(__syn_smv___e1_e2_ni_nof_1_0_e1_e2_ni_nof_1_0, c_e1, c_e2, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1_e2_ni_nof_1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, Float c_e1, Float c_e2, Float c_ni);
/// assign copy
__syn_smv___e1_e2_ni_nof_1_0 &operator=(const __syn_smv___e1_e2_ni_nof_1_0 &arg1);
/// assign general multivector
__syn_smv___e1_e2_ni_nof_1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1_e2_ni_nof_1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
inline Float ni() const {
return m_c[2];
}
/// const coordinate extraction by name
inline Float no() const {
return -1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1_e2_ni_nof_1_0_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1_e2_ni_nof_1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_nof_1_0 ___syn_smv___e1_e2_ni_nof_1_0(const mv &arg1) {
return __syn_smv___e1_e2_ni_nof_1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_nof_1_0 &___syn_smv___e1_e2_ni_nof_1_0(const __syn_smv___e1_e2_ni_nof_1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_nof_1_0 &___syn_smv___e1_e2_ni_nof_1_0(__syn_smv___e1_e2_ni_nof_1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1_e2_ni_nof_1_0 ___syn_smv___e1_e2_ni_nof_1_0(__syn_smv___e1_e2_ni_nof_1_0::Float arg1) {
return __syn_smv___e1_e2_ni_nof_1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_nof_1_0 like(const mv &what, const __syn_smv___e1_e2_ni_nof_1_0 &example) {return ___syn_smv___e1_e2_ni_nof_1_0(what);}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_nof_1_0 like(const __syn_smv___e1_e2_ni_nof_1_0 &what, const __syn_smv___e1_e2_ni_nof_1_0 &example) {return ___syn_smv___e1_e2_ni_nof_1_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_nof_1_0 like(__syn_smv___e1_e2_ni_nof_1_0 &what, const __syn_smv___e1_e2_ni_nof_1_0 &example) {return ___syn_smv___e1_e2_ni_nof_1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1_e2_ni_nof_1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1_e2_ni_nof_1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1_e2_ni_nof_1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
enum ____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__ {__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni};
class __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_noni, Float c_e1ni, Float c_e2ni) {
set(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, c_scalar, c_noe1, c_noe2, c_e1e2, c_noni, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_noni, Float c_e1ni, Float c_e2ni);
/// assign copy
__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &operator=(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1);
/// assign general multivector
__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[1];
}
inline Float noe2() const {
return m_c[2];
}
inline Float e1e2() const {
return m_c[3];
}
inline Float noni() const {
return m_c[4];
}
inline Float e1ni() const {
return m_c[5];
}
inline Float e2ni() const {
return m_c[6];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[7];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni ___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(const mv &arg1) {
return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni ___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::Float arg1) {
return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni like(const mv &what, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(what);}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni like(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &what, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni like(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &what, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni & v) {
return v.m_c[0];
}
/// enum for the coordinates of __syn_smv___scalar_noe1_noe2_noni
enum ____syn_smv___scalar_noe1_noe2_noni_coordinates__ {__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni};
class __syn_smv___scalar_noe1_noe2_noni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalar_noe1_noe2_noni() {
set();
}
/// scalar constructor
inline __syn_smv___scalar_noe1_noe2_noni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_noe1_noe2_noni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalar_noe1_noe2_noni(const __syn_smv___scalar_noe1_noe2_noni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalar_noe1_noe2_noni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_noe1_noe2_noni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalar_noe1_noe2_noni(____syn_smv___scalar_noe1_noe2_noni_coordinates__, const Float *coordinates) {
set(__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalar_noe1_noe2_noni(____syn_smv___scalar_noe1_noe2_noni_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_noni) {
set(__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni, c_scalar, c_noe1, c_noe2, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalar_noe1_noe2_noni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalar_noe1_noe2_noni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalar_noe1_noe2_noni_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_noni);
/// assign copy
__syn_smv___scalar_noe1_noe2_noni &operator=(const __syn_smv___scalar_noe1_noe2_noni &arg1);
/// assign general multivector
__syn_smv___scalar_noe1_noe2_noni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalar_noe1_noe2_noni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[1];
}
inline Float noe2() const {
return m_c[2];
}
inline Float noni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalar_noe1_noe2_noni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalar_noe1_noe2_noni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_noe2_noni ___syn_smv___scalar_noe1_noe2_noni(const mv &arg1) {
return __syn_smv___scalar_noe1_noe2_noni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_noe2_noni &___syn_smv___scalar_noe1_noe2_noni(const __syn_smv___scalar_noe1_noe2_noni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_noe2_noni &___syn_smv___scalar_noe1_noe2_noni(__syn_smv___scalar_noe1_noe2_noni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalar_noe1_noe2_noni ___syn_smv___scalar_noe1_noe2_noni(__syn_smv___scalar_noe1_noe2_noni::Float arg1) {
return __syn_smv___scalar_noe1_noe2_noni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_noe2_noni like(const mv &what, const __syn_smv___scalar_noe1_noe2_noni &example) {return ___syn_smv___scalar_noe1_noe2_noni(what);}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_noe2_noni like(const __syn_smv___scalar_noe1_noe2_noni &what, const __syn_smv___scalar_noe1_noe2_noni &example) {return ___syn_smv___scalar_noe1_noe2_noni(what);}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_noe2_noni like(__syn_smv___scalar_noe1_noe2_noni &what, const __syn_smv___scalar_noe1_noe2_noni &example) {return ___syn_smv___scalar_noe1_noe2_noni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalar_noe1_noe2_noni & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalar_noe1_noe2_noni & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalar_noe1_noe2_noni & v) {
return v.m_c[0];
}
/// enum for the coordinates of __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
enum ____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__ {__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni};
class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni() {
set();
}
/// scalar constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe1ni, Float c_noe2ni) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, c_no, c_e1, c_e2, c_noe1e2, c_ni, c_noe1ni, c_noe2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe1ni, Float c_noe2ni);
/// assign copy
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1);
/// assign general multivector
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
inline Float e1() const {
return m_c[1];
}
inline Float e2() const {
return m_c[2];
}
inline Float noe1e2() const {
return m_c[3];
}
inline Float ni() const {
return m_c[4];
}
inline Float noe1ni() const {
return m_c[5];
}
inline Float noe2ni() const {
return m_c[6];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[7];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(const mv &arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::Float arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni like(const mv &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(what);}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni like(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(what);}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni like(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___scalar_noe1_e1e2_e1ni
enum ____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__ {__syn_smv___scalar_noe1_e1e2_e1ni_scalar_noe1_e1e2_e1ni};
class __syn_smv___scalar_noe1_e1e2_e1ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalar_noe1_e1e2_e1ni() {
set();
}
/// scalar constructor
inline __syn_smv___scalar_noe1_e1e2_e1ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_noe1_e1e2_e1ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalar_noe1_e1e2_e1ni(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalar_noe1_e1e2_e1ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_noe1_e1e2_e1ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalar_noe1_e1e2_e1ni(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, const Float *coordinates) {
set(__syn_smv___scalar_noe1_e1e2_e1ni_scalar_noe1_e1e2_e1ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalar_noe1_e1e2_e1ni(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, Float c_scalar, Float c_noe1, Float c_e1e2, Float c_e1ni) {
set(__syn_smv___scalar_noe1_e1e2_e1ni_scalar_noe1_e1e2_e1ni, c_scalar, c_noe1, c_e1e2, c_e1ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, Float c_scalar, Float c_noe1, Float c_e1e2, Float c_e1ni);
/// assign copy
__syn_smv___scalar_noe1_e1e2_e1ni &operator=(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1);
/// assign general multivector
__syn_smv___scalar_noe1_e1e2_e1ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalar_noe1_e1e2_e1ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe1() const {
return m_c[1];
}
inline Float e1e2() const {
return m_c[2];
}
inline Float e1ni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalar_noe1_e1e2_e1ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_e1e2_e1ni ___syn_smv___scalar_noe1_e1e2_e1ni(const mv &arg1) {
return __syn_smv___scalar_noe1_e1e2_e1ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_e1e2_e1ni &___syn_smv___scalar_noe1_e1e2_e1ni(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_e1e2_e1ni &___syn_smv___scalar_noe1_e1e2_e1ni(__syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalar_noe1_e1e2_e1ni ___syn_smv___scalar_noe1_e1e2_e1ni(__syn_smv___scalar_noe1_e1e2_e1ni::Float arg1) {
return __syn_smv___scalar_noe1_e1e2_e1ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe1_e1e2_e1ni like(const mv &what, const __syn_smv___scalar_noe1_e1e2_e1ni &example) {return ___syn_smv___scalar_noe1_e1e2_e1ni(what);}
/// from const specialization class:
inline const __syn_smv___scalar_noe1_e1e2_e1ni like(const __syn_smv___scalar_noe1_e1e2_e1ni &what, const __syn_smv___scalar_noe1_e1e2_e1ni &example) {return ___syn_smv___scalar_noe1_e1e2_e1ni(what);}
/// from non-const specialization class:
inline __syn_smv___scalar_noe1_e1e2_e1ni like(__syn_smv___scalar_noe1_e1e2_e1ni &what, const __syn_smv___scalar_noe1_e1e2_e1ni &example) {return ___syn_smv___scalar_noe1_e1e2_e1ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalar_noe1_e1e2_e1ni & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalar_noe1_e1e2_e1ni & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalar_noe1_e1e2_e1ni & v) {
return v.m_c[0];
}
/// enum for the coordinates of __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
enum ____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__ {__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni};
class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe1ni, Float c_e1e2ni) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni, c_no, c_e1, c_e2, c_noe1e2, c_ni, c_noe1ni, c_e1e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe1ni, Float c_e1e2ni);
/// assign copy
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1);
/// assign general multivector
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
inline Float e1() const {
return m_c[1];
}
inline Float e2() const {
return m_c[2];
}
inline Float noe1e2() const {
return m_c[3];
}
inline Float ni() const {
return m_c[4];
}
inline Float noe1ni() const {
return m_c[5];
}
inline Float e1e2ni() const {
return m_c[6];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[7];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(const mv &arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::Float arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni like(const mv &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(what);}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni like(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni like(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___scalar_noe2_e1e2_e2ni
enum ____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__ {__syn_smv___scalar_noe2_e1e2_e2ni_scalar_noe2_e1e2_e2ni};
class __syn_smv___scalar_noe2_e1e2_e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalar_noe2_e1e2_e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___scalar_noe2_e1e2_e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_noe2_e1e2_e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalar_noe2_e1e2_e2ni(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalar_noe2_e1e2_e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_noe2_e1e2_e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalar_noe2_e1e2_e2ni(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___scalar_noe2_e1e2_e2ni_scalar_noe2_e1e2_e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalar_noe2_e1e2_e2ni(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, Float c_scalar, Float c_noe2, Float c_e1e2, Float c_e2ni) {
set(__syn_smv___scalar_noe2_e1e2_e2ni_scalar_noe2_e1e2_e2ni, c_scalar, c_noe2, c_e1e2, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, Float c_scalar, Float c_noe2, Float c_e1e2, Float c_e2ni);
/// assign copy
__syn_smv___scalar_noe2_e1e2_e2ni &operator=(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1);
/// assign general multivector
__syn_smv___scalar_noe2_e1e2_e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalar_noe2_e1e2_e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noe2() const {
return m_c[1];
}
inline Float e1e2() const {
return m_c[2];
}
inline Float e2ni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalar_noe2_e1e2_e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe2_e1e2_e2ni ___syn_smv___scalar_noe2_e1e2_e2ni(const mv &arg1) {
return __syn_smv___scalar_noe2_e1e2_e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalar_noe2_e1e2_e2ni &___syn_smv___scalar_noe2_e1e2_e2ni(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalar_noe2_e1e2_e2ni &___syn_smv___scalar_noe2_e1e2_e2ni(__syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalar_noe2_e1e2_e2ni ___syn_smv___scalar_noe2_e1e2_e2ni(__syn_smv___scalar_noe2_e1e2_e2ni::Float arg1) {
return __syn_smv___scalar_noe2_e1e2_e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noe2_e1e2_e2ni like(const mv &what, const __syn_smv___scalar_noe2_e1e2_e2ni &example) {return ___syn_smv___scalar_noe2_e1e2_e2ni(what);}
/// from const specialization class:
inline const __syn_smv___scalar_noe2_e1e2_e2ni like(const __syn_smv___scalar_noe2_e1e2_e2ni &what, const __syn_smv___scalar_noe2_e1e2_e2ni &example) {return ___syn_smv___scalar_noe2_e1e2_e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___scalar_noe2_e1e2_e2ni like(__syn_smv___scalar_noe2_e1e2_e2ni &what, const __syn_smv___scalar_noe2_e1e2_e2ni &example) {return ___syn_smv___scalar_noe2_e1e2_e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalar_noe2_e1e2_e2ni & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalar_noe2_e1e2_e2ni & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalar_noe2_e1e2_e2ni & v) {
return v.m_c[0];
}
/// enum for the coordinates of __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
enum ____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__ {__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni};
class __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe2ni, Float c_e1e2ni) {
set(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni, c_no, c_e1, c_e2, c_noe1e2, c_ni, c_noe2ni, c_e1e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_noe1e2, Float c_ni, Float c_noe2ni, Float c_e1e2ni);
/// assign copy
__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1);
/// assign general multivector
__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
inline Float e1() const {
return m_c[1];
}
inline Float e2() const {
return m_c[2];
}
inline Float noe1e2() const {
return m_c[3];
}
inline Float ni() const {
return m_c[4];
}
inline Float noe2ni() const {
return m_c[5];
}
inline Float e1e2ni() const {
return m_c[6];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[7];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(const mv &arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni ___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::Float arg1) {
return __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni like(const mv &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(what);}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni like(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni like(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &what, const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___scalar_noni_e1ni_e2ni
enum ____syn_smv___scalar_noni_e1ni_e2ni_coordinates__ {__syn_smv___scalar_noni_e1ni_e2ni_scalar_noni_e1ni_e2ni};
class __syn_smv___scalar_noni_e1ni_e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalar_noni_e1ni_e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___scalar_noni_e1ni_e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_noni_e1ni_e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalar_noni_e1ni_e2ni(const __syn_smv___scalar_noni_e1ni_e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalar_noni_e1ni_e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_noni_e1ni_e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalar_noni_e1ni_e2ni(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___scalar_noni_e1ni_e2ni_scalar_noni_e1ni_e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalar_noni_e1ni_e2ni(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, Float c_scalar, Float c_noni, Float c_e1ni, Float c_e2ni) {
set(__syn_smv___scalar_noni_e1ni_e2ni_scalar_noni_e1ni_e2ni, c_scalar, c_noni, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalar_noni_e1ni_e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, Float c_scalar, Float c_noni, Float c_e1ni, Float c_e2ni);
/// assign copy
__syn_smv___scalar_noni_e1ni_e2ni &operator=(const __syn_smv___scalar_noni_e1ni_e2ni &arg1);
/// assign general multivector
__syn_smv___scalar_noni_e1ni_e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalar_noni_e1ni_e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float noni() const {
return m_c[1];
}
inline Float e1ni() const {
return m_c[2];
}
inline Float e2ni() const {
return m_c[3];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[4];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalar_noni_e1ni_e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noni_e1ni_e2ni ___syn_smv___scalar_noni_e1ni_e2ni(const mv &arg1) {
return __syn_smv___scalar_noni_e1ni_e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalar_noni_e1ni_e2ni &___syn_smv___scalar_noni_e1ni_e2ni(const __syn_smv___scalar_noni_e1ni_e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalar_noni_e1ni_e2ni &___syn_smv___scalar_noni_e1ni_e2ni(__syn_smv___scalar_noni_e1ni_e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalar_noni_e1ni_e2ni ___syn_smv___scalar_noni_e1ni_e2ni(__syn_smv___scalar_noni_e1ni_e2ni::Float arg1) {
return __syn_smv___scalar_noni_e1ni_e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalar_noni_e1ni_e2ni like(const mv &what, const __syn_smv___scalar_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noni_e1ni_e2ni(what);}
/// from const specialization class:
inline const __syn_smv___scalar_noni_e1ni_e2ni like(const __syn_smv___scalar_noni_e1ni_e2ni &what, const __syn_smv___scalar_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noni_e1ni_e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___scalar_noni_e1ni_e2ni like(__syn_smv___scalar_noni_e1ni_e2ni &what, const __syn_smv___scalar_noni_e1ni_e2ni &example) {return ___syn_smv___scalar_noni_e1ni_e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalar_noni_e1ni_e2ni & v) {
return (float)v.m_c[0];
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalar_noni_e1ni_e2ni & v) {
return (double)v.m_c[0];
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalar_noni_e1ni_e2ni & v) {
return v.m_c[0];
}
/// enum for the coordinates of __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
enum ____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__ {__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni};
class __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni() {
set();
}
/// scalar constructor
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates) {
set(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_ni, Float c_noe1ni, Float c_noe2ni, Float c_e1e2ni) {
set(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, c_no, c_e1, c_e2, c_ni, c_noe1ni, c_noe2ni, c_e1e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_ni, Float c_noe1ni, Float c_noe2ni, Float c_e1e2ni);
/// assign copy
__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &operator=(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1);
/// assign general multivector
__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float no() const {
return m_c[0];
}
inline Float e1() const {
return m_c[1];
}
inline Float e2() const {
return m_c[2];
}
inline Float ni() const {
return m_c[3];
}
inline Float noe1ni() const {
return m_c[4];
}
inline Float noe2ni() const {
return m_c[5];
}
inline Float e1e2ni() const {
return m_c[6];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[7];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni ___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(const mv &arg1) {
return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni ___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::Float arg1) {
return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni like(const mv &what, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(what);}
/// from const specialization class:
inline const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni like(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &what, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(what);}
/// from non-const specialization class:
inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni like(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &what, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &example) {return ___syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1ni_e2ni_nonif_1_0
enum ____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__ {__syn_smv___e1ni_e2ni_nonif_1_0_e1ni_e2ni_nonif_1_0};
class __syn_smv___e1ni_e2ni_nonif_1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1ni_e2ni_nonif_1_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1ni_e2ni_nonif_1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1ni_e2ni_nonif_1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1ni_e2ni_nonif_1_0(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1ni_e2ni_nonif_1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1ni_e2ni_nonif_1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1ni_e2ni_nonif_1_0(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1ni_e2ni_nonif_1_0_e1ni_e2ni_nonif_1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1ni_e2ni_nonif_1_0(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, Float c_e1ni, Float c_e2ni) {
set(__syn_smv___e1ni_e2ni_nonif_1_0_e1ni_e2ni_nonif_1_0, c_e1ni, c_e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, Float c_e1ni, Float c_e2ni);
/// assign copy
__syn_smv___e1ni_e2ni_nonif_1_0 &operator=(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1);
/// assign general multivector
__syn_smv___e1ni_e2ni_nonif_1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1ni_e2ni_nonif_1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1ni() const {
return m_c[0];
}
inline Float e2ni() const {
return m_c[1];
}
/// const coordinate extraction by name
inline Float noni() const {
return -1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[2];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1ni_e2ni_nonif_1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1ni_e2ni_nonif_1_0 ___syn_smv___e1ni_e2ni_nonif_1_0(const mv &arg1) {
return __syn_smv___e1ni_e2ni_nonif_1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1ni_e2ni_nonif_1_0 &___syn_smv___e1ni_e2ni_nonif_1_0(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1ni_e2ni_nonif_1_0 &___syn_smv___e1ni_e2ni_nonif_1_0(__syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1ni_e2ni_nonif_1_0 ___syn_smv___e1ni_e2ni_nonif_1_0(__syn_smv___e1ni_e2ni_nonif_1_0::Float arg1) {
return __syn_smv___e1ni_e2ni_nonif_1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1ni_e2ni_nonif_1_0 like(const mv &what, const __syn_smv___e1ni_e2ni_nonif_1_0 &example) {return ___syn_smv___e1ni_e2ni_nonif_1_0(what);}
/// from const specialization class:
inline const __syn_smv___e1ni_e2ni_nonif_1_0 like(const __syn_smv___e1ni_e2ni_nonif_1_0 &what, const __syn_smv___e1ni_e2ni_nonif_1_0 &example) {return ___syn_smv___e1ni_e2ni_nonif_1_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1ni_e2ni_nonif_1_0 like(__syn_smv___e1ni_e2ni_nonif_1_0 &what, const __syn_smv___e1ni_e2ni_nonif_1_0 &example) {return ___syn_smv___e1ni_e2ni_nonif_1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1ni_e2ni_nonif_1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1ni_e2ni_nonif_1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1ni_e2ni_nonif_1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___scalarf_1_0
enum ____syn_smv___scalarf_1_0_coordinates__ {__syn_smv___scalarf_1_0_scalarf_1_0};
class __syn_smv___scalarf_1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___scalarf_1_0() {
set();
}
/// scalar constructor
inline __syn_smv___scalarf_1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalarf_1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___scalarf_1_0(const __syn_smv___scalarf_1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___scalarf_1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalarf_1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___scalarf_1_0(____syn_smv___scalarf_1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___scalarf_1_0_scalarf_1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___scalarf_1_0(____syn_smv___scalarf_1_0_coordinates__) {
set(__syn_smv___scalarf_1_0_scalarf_1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___scalarf_1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___scalarf_1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___scalarf_1_0_coordinates__);
/// assign copy
__syn_smv___scalarf_1_0 &operator=(const __syn_smv___scalarf_1_0 &arg1);
/// assign general multivector
__syn_smv___scalarf_1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___scalarf_1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___scalarf_1_0_coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___scalarf_1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___scalarf_1_0 ___syn_smv___scalarf_1_0(const mv &arg1) {
return __syn_smv___scalarf_1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___scalarf_1_0 &___syn_smv___scalarf_1_0(const __syn_smv___scalarf_1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___scalarf_1_0 &___syn_smv___scalarf_1_0(__syn_smv___scalarf_1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___scalarf_1_0 ___syn_smv___scalarf_1_0(__syn_smv___scalarf_1_0::Float arg1) {
return __syn_smv___scalarf_1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___scalarf_1_0 like(const mv &what, const __syn_smv___scalarf_1_0 &example) {return ___syn_smv___scalarf_1_0(what);}
/// from const specialization class:
inline const __syn_smv___scalarf_1_0 like(const __syn_smv___scalarf_1_0 &what, const __syn_smv___scalarf_1_0 &example) {return ___syn_smv___scalarf_1_0(what);}
/// from non-const specialization class:
inline __syn_smv___scalarf_1_0 like(__syn_smv___scalarf_1_0 &what, const __syn_smv___scalarf_1_0 &example) {return ___syn_smv___scalarf_1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___scalarf_1_0 & v) {
return (float)-1.0f;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___scalarf_1_0 & v) {
return (double)-1.0f;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___scalarf_1_0 & v) {
return (float)-1.0f;
}
/// enum for the coordinates of __syn_smv___nif_1_0
enum ____syn_smv___nif_1_0_coordinates__ {__syn_smv___nif_1_0_nif_1_0};
class __syn_smv___nif_1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___nif_1_0() {
set();
}
/// scalar constructor
inline __syn_smv___nif_1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___nif_1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___nif_1_0(const __syn_smv___nif_1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___nif_1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___nif_1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___nif_1_0(____syn_smv___nif_1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___nif_1_0_nif_1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___nif_1_0(____syn_smv___nif_1_0_coordinates__) {
set(__syn_smv___nif_1_0_nif_1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___nif_1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___nif_1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___nif_1_0_coordinates__);
/// assign copy
__syn_smv___nif_1_0 &operator=(const __syn_smv___nif_1_0 &arg1);
/// assign general multivector
__syn_smv___nif_1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___nif_1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float ni() const {
return -1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___nif_1_0_coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___nif_1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___nif_1_0 ___syn_smv___nif_1_0(const mv &arg1) {
return __syn_smv___nif_1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___nif_1_0 &___syn_smv___nif_1_0(const __syn_smv___nif_1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___nif_1_0 &___syn_smv___nif_1_0(__syn_smv___nif_1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___nif_1_0 ___syn_smv___nif_1_0(__syn_smv___nif_1_0::Float arg1) {
return __syn_smv___nif_1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___nif_1_0 like(const mv &what, const __syn_smv___nif_1_0 &example) {return ___syn_smv___nif_1_0(what);}
/// from const specialization class:
inline const __syn_smv___nif_1_0 like(const __syn_smv___nif_1_0 &what, const __syn_smv___nif_1_0 &example) {return ___syn_smv___nif_1_0(what);}
/// from non-const specialization class:
inline __syn_smv___nif_1_0 like(__syn_smv___nif_1_0 &what, const __syn_smv___nif_1_0 &example) {return ___syn_smv___nif_1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___nif_1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___nif_1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___nif_1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___nif1_0
enum ____syn_smv___nif1_0_coordinates__ {__syn_smv___nif1_0_nif1_0};
class __syn_smv___nif1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___nif1_0() {
set();
}
/// scalar constructor
inline __syn_smv___nif1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___nif1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___nif1_0(const __syn_smv___nif1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___nif1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___nif1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___nif1_0(____syn_smv___nif1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___nif1_0_nif1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___nif1_0(____syn_smv___nif1_0_coordinates__) {
set(__syn_smv___nif1_0_nif1_0);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___nif1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___nif1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___nif1_0_coordinates__);
/// assign copy
__syn_smv___nif1_0 &operator=(const __syn_smv___nif1_0 &arg1);
/// assign general multivector
__syn_smv___nif1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___nif1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
/// const coordinate extraction by name
inline Float ni() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___nif1_0_coordinates__ sanityCheckValue) const {
return NULL;
}
// constants, so no coordinate storage
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___nif1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___nif1_0 ___syn_smv___nif1_0(const mv &arg1) {
return __syn_smv___nif1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___nif1_0 &___syn_smv___nif1_0(const __syn_smv___nif1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___nif1_0 &___syn_smv___nif1_0(__syn_smv___nif1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___nif1_0 ___syn_smv___nif1_0(__syn_smv___nif1_0::Float arg1) {
return __syn_smv___nif1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___nif1_0 like(const mv &what, const __syn_smv___nif1_0 &example) {return ___syn_smv___nif1_0(what);}
/// from const specialization class:
inline const __syn_smv___nif1_0 like(const __syn_smv___nif1_0 &what, const __syn_smv___nif1_0 &example) {return ___syn_smv___nif1_0(what);}
/// from non-const specialization class:
inline __syn_smv___nif1_0 like(__syn_smv___nif1_0 &what, const __syn_smv___nif1_0 &example) {return ___syn_smv___nif1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___nif1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___nif1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___nif1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
enum ____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__ {__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0};
class __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__, Float c_e1, Float c_e2, Float c_ni, Float c_noe1ni, Float c_noe2ni, Float c_e1e2ni) {
set(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0, c_e1, c_e2, c_ni, c_noe1ni, c_noe2ni, c_e1e2ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__, Float c_e1, Float c_e2, Float c_ni, Float c_noe1ni, Float c_noe2ni, Float c_e1e2ni);
/// assign copy
__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &operator=(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1);
/// assign general multivector
__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
inline Float ni() const {
return m_c[2];
}
inline Float noe1ni() const {
return m_c[3];
}
inline Float noe2ni() const {
return m_c[4];
}
inline Float e1e2ni() const {
return m_c[5];
}
/// const coordinate extraction by name
inline Float no() const {
return 1.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[6];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 ___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(const mv &arg1) {
return __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 ___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::Float arg1) {
return __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 like(const mv &what, const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &example) {return ___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(what);}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 like(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &what, const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &example) {return ___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 like(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &what, const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &example) {return ___syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1_e2_ni_nof2_0
enum ____syn_smv___e1_e2_ni_nof2_0_coordinates__ {__syn_smv___e1_e2_ni_nof2_0_e1_e2_ni_nof2_0};
class __syn_smv___e1_e2_ni_nof2_0 {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1_e2_ni_nof2_0() {
set();
}
/// scalar constructor
inline __syn_smv___e1_e2_ni_nof2_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_ni_nof2_0
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1_e2_ni_nof2_0(const __syn_smv___e1_e2_ni_nof2_0 &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1_e2_ni_nof2_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_ni_nof2_0
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1_e2_ni_nof2_0(____syn_smv___e1_e2_ni_nof2_0_coordinates__, const Float *coordinates) {
set(__syn_smv___e1_e2_ni_nof2_0_e1_e2_ni_nof2_0, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1_e2_ni_nof2_0(____syn_smv___e1_e2_ni_nof2_0_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
set(__syn_smv___e1_e2_ni_nof2_0_e1_e2_ni_nof2_0, c_e1, c_e2, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1_e2_ni_nof2_0 &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1_e2_ni_nof2_0_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1_e2_ni_nof2_0_coordinates__, Float c_e1, Float c_e2, Float c_ni);
/// assign copy
__syn_smv___e1_e2_ni_nof2_0 &operator=(const __syn_smv___e1_e2_ni_nof2_0 &arg1);
/// assign general multivector
__syn_smv___e1_e2_ni_nof2_0 &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1_e2_ni_nof2_0 &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
inline Float ni() const {
return m_c[2];
}
/// const coordinate extraction by name
inline Float no() const {
return 2.0f;
}
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1_e2_ni_nof2_0_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1_e2_ni_nof2_0
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_nof2_0 ___syn_smv___e1_e2_ni_nof2_0(const mv &arg1) {
return __syn_smv___e1_e2_ni_nof2_0(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_nof2_0 &___syn_smv___e1_e2_ni_nof2_0(const __syn_smv___e1_e2_ni_nof2_0 &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_nof2_0 &___syn_smv___e1_e2_ni_nof2_0(__syn_smv___e1_e2_ni_nof2_0 &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1_e2_ni_nof2_0 ___syn_smv___e1_e2_ni_nof2_0(__syn_smv___e1_e2_ni_nof2_0::Float arg1) {
return __syn_smv___e1_e2_ni_nof2_0(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni_nof2_0 like(const mv &what, const __syn_smv___e1_e2_ni_nof2_0 &example) {return ___syn_smv___e1_e2_ni_nof2_0(what);}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni_nof2_0 like(const __syn_smv___e1_e2_ni_nof2_0 &what, const __syn_smv___e1_e2_ni_nof2_0 &example) {return ___syn_smv___e1_e2_ni_nof2_0(what);}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni_nof2_0 like(__syn_smv___e1_e2_ni_nof2_0 &what, const __syn_smv___e1_e2_ni_nof2_0 &example) {return ___syn_smv___e1_e2_ni_nof2_0(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1_e2_ni_nof2_0 & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1_e2_ni_nof2_0 & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1_e2_ni_nof2_0 & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___e1_e2_ni
enum ____syn_smv___e1_e2_ni_coordinates__ {__syn_smv___e1_e2_ni_e1_e2_ni};
class __syn_smv___e1_e2_ni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___e1_e2_ni() {
set();
}
/// scalar constructor
inline __syn_smv___e1_e2_ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_ni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___e1_e2_ni(const __syn_smv___e1_e2_ni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___e1_e2_ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_ni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___e1_e2_ni(____syn_smv___e1_e2_ni_coordinates__, const Float *coordinates) {
set(__syn_smv___e1_e2_ni_e1_e2_ni, coordinates);
}
/// coordinates constructor
inline __syn_smv___e1_e2_ni(____syn_smv___e1_e2_ni_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
set(__syn_smv___e1_e2_ni_e1_e2_ni, c_e1, c_e2, c_ni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___e1_e2_ni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___e1_e2_ni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___e1_e2_ni_coordinates__, Float c_e1, Float c_e2, Float c_ni);
/// assign copy
__syn_smv___e1_e2_ni &operator=(const __syn_smv___e1_e2_ni &arg1);
/// assign general multivector
__syn_smv___e1_e2_ni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___e1_e2_ni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;
/// coordinate extraction by name
inline Float e1() const {
return m_c[0];
}
inline Float e2() const {
return m_c[1];
}
inline Float ni() const {
return m_c[2];
}
/// const coordinate extraction by name
/// get all coordinates (returns NULL for fully constant specialization
const Float *getC(____syn_smv___e1_e2_ni_coordinates__ sanityCheckValue) const {
return m_c;
}
/// coordinate storage
Float m_c[3];
inline const char * c_str(const char *fp = NULL) const {
return ::c2ga::c_str(*this, fp);
}
inline const char * c_str_f() const {return c_str("%f");}
inline const char * c_str_e() const {return c_str("%e");}
inline const char * c_str_e20() const {return c_str("%2.20e");}
inline std::string toString(const char *fp = NULL) const {
return ::c2ga::toString(*this, fp);
}
inline std::string toString_f() const {return toString("%f");}
inline std::string toString_e() const {return toString("%e");}
inline std::string toString_e20() const {return toString("%2.20e");}
}; // end of class __syn_smv___e1_e2_ni
/* 'underscore constructors' */
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni ___syn_smv___e1_e2_ni(const mv &arg1) {
return __syn_smv___e1_e2_ni(arg1, 0);
}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni &___syn_smv___e1_e2_ni(const __syn_smv___e1_e2_ni &arg1) {
return arg1;
}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni &___syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni &arg1) {
return arg1;
}
/// from Float:
inline __syn_smv___e1_e2_ni ___syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni::Float arg1) {
return __syn_smv___e1_e2_ni(arg1, 0); // 0 = filler; can have any value, it simply prevents implicit conversion from mv -> vector
}
// like example constructors, for use with templates
/// underscore constructor from general multivector:
inline __syn_smv___e1_e2_ni like(const mv &what, const __syn_smv___e1_e2_ni &example) {return ___syn_smv___e1_e2_ni(what);}
/// from const specialization class:
inline const __syn_smv___e1_e2_ni like(const __syn_smv___e1_e2_ni &what, const __syn_smv___e1_e2_ni &example) {return ___syn_smv___e1_e2_ni(what);}
/// from non-const specialization class:
inline __syn_smv___e1_e2_ni like(__syn_smv___e1_e2_ni &what, const __syn_smv___e1_e2_ni &example) {return ___syn_smv___e1_e2_ni(what);}
// underscore 'constructors' for float types:
/// returns scalar part of v as float
inline float _float(const __syn_smv___e1_e2_ni & v) {
return (float)0;
}
/// returns scalar part of v as double
inline double _double(const __syn_smv___e1_e2_ni & v) {
return (double)0;
}
/// returns scalar part of v as Float
inline float _Float(const __syn_smv___e1_e2_ni & v) {
return (float)0;
}
/// enum for the coordinates of __syn_smv___noe1_noe2_noni
enum ____syn_smv___noe1_noe2_noni_coordinates__ {__syn_smv___noe1_noe2_noni_noe1_noe2_noni};
class __syn_smv___noe1_noe2_noni {
public:
typedef float Float;
/// zero constructor
inline __syn_smv___noe1_noe2_noni() {
set();
}
/// scalar constructor
inline __syn_smv___noe1_noe2_noni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___noe1_noe2_noni
set(s);
}
/// copy constructor (MUST PASS BY REFERENCE)
inline __syn_smv___noe1_noe2_noni(const __syn_smv___noe1_noe2_noni &arg1) {
set(arg1);
}
/// general multivector constructor (that can not be selected for implicit conversion by C++)
inline __syn_smv___noe1_noe2_noni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___noe1_noe2_noni
set(arg1);
}
/// pointer to coordinates constructor
inline __syn_smv___noe1_noe2_noni(____syn_smv___noe1_noe2_noni_coordinates__, const Float *coordinates) {
set(__syn_smv___noe1_noe2_noni_noe1_noe2_noni, coordinates);
}
/// coordinates constructor
inline __syn_smv___noe1_noe2_noni(____syn_smv___noe1_noe2_noni_coordinates__, Float c_noe1, Float c_noe2, Float c_noni) {
set(__syn_smv___noe1_noe2_noni_noe1_noe2_noni, c_noe1, c_noe2, c_noni);
}
/// set to null
void set();
/// set to scalar
void set(Float s);
/// set to copy
void set(const __syn_smv___noe1_noe2_noni &arg1);
/// set to copy of general multivector
void set(const mv &arg1);
/// pointer to coordinates constructor
void set(____syn_smv___noe1_noe2_noni_coordinates__, const Float *coordinates);
/// set to coordinates
void set(____syn_smv___noe1_noe2_noni_coordinates__, Float c_noe1, Float c_noe2, Float c_noni);
/// assign copy
__syn_smv___noe1_noe2_noni &operator=(const __syn_smv___noe1_noe2_noni &arg1);
/// assign general multivector
__syn_smv___noe1_noe2_noni &operator=(const mv &arg1);
/// assign scalar
__syn_smv___noe1_noe2_noni &operator=(Float scalarVal);
/// returns absolute largest coordinate
Float largestCoordinate() const;
/// returns the absolute largest coordinate, and the corresponding basis blade bitmap
Float largestBasisBlade(unsigned int &bm) const;