// 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;

        /// coordinate extraction by name
        inline Float noe1() const {
            return m_c[0];
        }
        inline Float noe2() 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(____syn_smv___noe1_noe2_noni_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___noe1_noe2_noni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___noe1_noe2_noni ___syn_smv___noe1_noe2_noni(const mv &arg1) {
        return __syn_smv___noe1_noe2_noni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___noe1_noe2_noni &___syn_smv___noe1_noe2_noni(const __syn_smv___noe1_noe2_noni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___noe1_noe2_noni &___syn_smv___noe1_noe2_noni(__syn_smv___noe1_noe2_noni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___noe1_noe2_noni ___syn_smv___noe1_noe2_noni(__syn_smv___noe1_noe2_noni::Float arg1) {
        return __syn_smv___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___noe1_noe2_noni like(const mv &what, const __syn_smv___noe1_noe2_noni &example) {return ___syn_smv___noe1_noe2_noni(what);}
    /// from const specialization class:
    inline const __syn_smv___noe1_noe2_noni like(const __syn_smv___noe1_noe2_noni &what, const __syn_smv___noe1_noe2_noni &example) {return ___syn_smv___noe1_noe2_noni(what);}
    /// from non-const specialization class:
    inline __syn_smv___noe1_noe2_noni like(__syn_smv___noe1_noe2_noni &what, const __syn_smv___noe1_noe2_noni &example) {return ___syn_smv___noe1_noe2_noni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___noe1_noe2_noni & v) {
        return (float)0;
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___noe1_noe2_noni & v) {
        return (double)0;
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___noe1_noe2_noni & v) {
        return (float)0;
    }


    /// enum for the coordinates of __syn_smv___no_noe1e2_noe1ni_noe2ni 
    enum ____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__ {__syn_smv___no_noe1e2_noe1ni_noe2ni_no_noe1e2_noe1ni_noe2ni};

    class __syn_smv___no_noe1e2_noe1ni_noe2ni {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___no_noe1e2_noe1ni_noe2ni     
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___no_noe1e2_noe1ni_noe2ni     
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, const Float *coordinates) {

            set(__syn_smv___no_noe1e2_noe1ni_noe2ni_no_noe1e2_noe1ni_noe2ni, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___no_noe1e2_noe1ni_noe2ni(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, Float c_no, Float c_noe1e2, Float c_noe1ni, Float c_noe2ni) {

            set(__syn_smv___no_noe1e2_noe1ni_noe2ni_no_noe1e2_noe1ni_noe2ni, c_no, c_noe1e2, 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_noe1e2_noe1ni_noe2ni &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, Float c_no, Float c_noe1e2, Float c_noe1ni, Float c_noe2ni);

        /// assign copy
        __syn_smv___no_noe1e2_noe1ni_noe2ni &operator=(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1);

        /// assign general multivector
        __syn_smv___no_noe1e2_noe1ni_noe2ni &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___no_noe1e2_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 noe1e2() const {
            return m_c[1];
        }
        inline Float noe1ni() const {
            return m_c[2];
        }
        inline Float noe2ni() const {
            return m_c[3];
        }

        /// const coordinate extraction by name

        /// get all coordinates (returns NULL for fully constant specialization
        const Float *getC(____syn_smv___no_noe1e2_noe1ni_noe2ni_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___no_noe1e2_noe1ni_noe2ni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni ___syn_smv___no_noe1e2_noe1ni_noe2ni(const mv &arg1) {
        return __syn_smv___no_noe1e2_noe1ni_noe2ni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___no_noe1e2_noe1ni_noe2ni &___syn_smv___no_noe1e2_noe1ni_noe2ni(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni &___syn_smv___no_noe1e2_noe1ni_noe2ni(__syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni ___syn_smv___no_noe1e2_noe1ni_noe2ni(__syn_smv___no_noe1e2_noe1ni_noe2ni::Float arg1) {
        return __syn_smv___no_noe1e2_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_noe1e2_noe1ni_noe2ni like(const mv &what, const __syn_smv___no_noe1e2_noe1ni_noe2ni &example) {return ___syn_smv___no_noe1e2_noe1ni_noe2ni(what);}
    /// from const specialization class:
    inline const __syn_smv___no_noe1e2_noe1ni_noe2ni like(const __syn_smv___no_noe1e2_noe1ni_noe2ni &what, const __syn_smv___no_noe1e2_noe1ni_noe2ni &example) {return ___syn_smv___no_noe1e2_noe1ni_noe2ni(what);}
    /// from non-const specialization class:
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni like(__syn_smv___no_noe1e2_noe1ni_noe2ni &what, const __syn_smv___no_noe1e2_noe1ni_noe2ni &example) {return ___syn_smv___no_noe1e2_noe1ni_noe2ni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___no_noe1e2_noe1ni_noe2ni & v) {
        return (float)0;
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___no_noe1e2_noe1ni_noe2ni & v) {
        return (double)0;
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___no_noe1e2_noe1ni_noe2ni & v) {
        return (float)0;
    }


    /// enum for the coordinates of __syn_smv___scalar_e1e2_e1ni 
    enum ____syn_smv___scalar_e1e2_e1ni_coordinates__ {__syn_smv___scalar_e1e2_e1ni_scalar_e1e2_e1ni};

    class __syn_smv___scalar_e1e2_e1ni {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___scalar_e1e2_e1ni() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___scalar_e1e2_e1ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_e1e2_e1ni   
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___scalar_e1e2_e1ni(const __syn_smv___scalar_e1e2_e1ni &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___scalar_e1e2_e1ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_e1e2_e1ni   
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___scalar_e1e2_e1ni(____syn_smv___scalar_e1e2_e1ni_coordinates__, const Float *coordinates) {

            set(__syn_smv___scalar_e1e2_e1ni_scalar_e1e2_e1ni, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___scalar_e1e2_e1ni(____syn_smv___scalar_e1e2_e1ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni) {

            set(__syn_smv___scalar_e1e2_e1ni_scalar_e1e2_e1ni, c_scalar, 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_e1e2_e1ni &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___scalar_e1e2_e1ni_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___scalar_e1e2_e1ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni);

        /// assign copy
        __syn_smv___scalar_e1e2_e1ni &operator=(const __syn_smv___scalar_e1e2_e1ni &arg1);

        /// assign general multivector
        __syn_smv___scalar_e1e2_e1ni &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___scalar_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 e1e2() const {
            return m_c[1];
        }
        inline Float e1ni() const {
            return m_c[2];
        }

        /// const coordinate extraction by name

        /// get all coordinates (returns NULL for fully constant specialization
        const Float *getC(____syn_smv___scalar_e1e2_e1ni_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___scalar_e1e2_e1ni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___scalar_e1e2_e1ni ___syn_smv___scalar_e1e2_e1ni(const mv &arg1) {
        return __syn_smv___scalar_e1e2_e1ni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___scalar_e1e2_e1ni &___syn_smv___scalar_e1e2_e1ni(const __syn_smv___scalar_e1e2_e1ni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___scalar_e1e2_e1ni &___syn_smv___scalar_e1e2_e1ni(__syn_smv___scalar_e1e2_e1ni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___scalar_e1e2_e1ni ___syn_smv___scalar_e1e2_e1ni(__syn_smv___scalar_e1e2_e1ni::Float arg1) {
        return __syn_smv___scalar_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_e1e2_e1ni like(const mv &what, const __syn_smv___scalar_e1e2_e1ni &example) {return ___syn_smv___scalar_e1e2_e1ni(what);}
    /// from const specialization class:
    inline const __syn_smv___scalar_e1e2_e1ni like(const __syn_smv___scalar_e1e2_e1ni &what, const __syn_smv___scalar_e1e2_e1ni &example) {return ___syn_smv___scalar_e1e2_e1ni(what);}
    /// from non-const specialization class:
    inline __syn_smv___scalar_e1e2_e1ni like(__syn_smv___scalar_e1e2_e1ni &what, const __syn_smv___scalar_e1e2_e1ni &example) {return ___syn_smv___scalar_e1e2_e1ni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___scalar_e1e2_e1ni & v) {
        return (float)v.m_c[0];
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___scalar_e1e2_e1ni & v) {
        return (double)v.m_c[0];
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___scalar_e1e2_e1ni & v) {
        return v.m_c[0];
    }


    /// enum for the coordinates of __syn_smv___e1_e2_ni_e1e2ni 
    enum ____syn_smv___e1_e2_ni_e1e2ni_coordinates__ {__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni};

    class __syn_smv___e1_e2_ni_e1e2ni {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___e1_e2_ni_e1e2ni() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___e1_e2_ni_e1e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___e1_e2_ni_e1e2ni     
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___e1_e2_ni_e1e2ni(const __syn_smv___e1_e2_ni_e1e2ni &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___e1_e2_ni_e1e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___e1_e2_ni_e1e2ni     
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___e1_e2_ni_e1e2ni(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, const Float *coordinates) {

            set(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___e1_e2_ni_e1e2ni(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, Float c_e1, Float c_e2, Float c_ni, Float c_e1e2ni) {

            set(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, c_e1, c_e2, c_ni, 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_e1e2ni &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, Float c_e1, Float c_e2, Float c_ni, Float c_e1e2ni);

        /// assign copy
        __syn_smv___e1_e2_ni_e1e2ni &operator=(const __syn_smv___e1_e2_ni_e1e2ni &arg1);

        /// assign general multivector
        __syn_smv___e1_e2_ni_e1e2ni &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___e1_e2_ni_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 e1() const {
            return m_c[0];
        }
        inline Float e2() const {
            return m_c[1];
        }
        inline Float ni() const {
            return m_c[2];
        }
        inline Float e1e2ni() const {
            return m_c[3];
        }

        /// const coordinate extraction by name

        /// get all coordinates (returns NULL for fully constant specialization
        const Float *getC(____syn_smv___e1_e2_ni_e1e2ni_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___e1_e2_ni_e1e2ni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___e1_e2_ni_e1e2ni ___syn_smv___e1_e2_ni_e1e2ni(const mv &arg1) {
        return __syn_smv___e1_e2_ni_e1e2ni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___e1_e2_ni_e1e2ni &___syn_smv___e1_e2_ni_e1e2ni(const __syn_smv___e1_e2_ni_e1e2ni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___e1_e2_ni_e1e2ni &___syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___e1_e2_ni_e1e2ni ___syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni::Float arg1) {
        return __syn_smv___e1_e2_ni_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___e1_e2_ni_e1e2ni like(const mv &what, const __syn_smv___e1_e2_ni_e1e2ni &example) {return ___syn_smv___e1_e2_ni_e1e2ni(what);}
    /// from const specialization class:
    inline const __syn_smv___e1_e2_ni_e1e2ni like(const __syn_smv___e1_e2_ni_e1e2ni &what, const __syn_smv___e1_e2_ni_e1e2ni &example) {return ___syn_smv___e1_e2_ni_e1e2ni(what);}
    /// from non-const specialization class:
    inline __syn_smv___e1_e2_ni_e1e2ni like(__syn_smv___e1_e2_ni_e1e2ni &what, const __syn_smv___e1_e2_ni_e1e2ni &example) {return ___syn_smv___e1_e2_ni_e1e2ni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___e1_e2_ni_e1e2ni & v) {
        return (float)0;
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___e1_e2_ni_e1e2ni & v) {
        return (double)0;
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___e1_e2_ni_e1e2ni & v) {
        return (float)0;
    }


    /// enum for the coordinates of __syn_smv___scalar_e1e2_e2ni 
    enum ____syn_smv___scalar_e1e2_e2ni_coordinates__ {__syn_smv___scalar_e1e2_e2ni_scalar_e1e2_e2ni};

    class __syn_smv___scalar_e1e2_e2ni {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___scalar_e1e2_e2ni() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___scalar_e1e2_e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalar_e1e2_e2ni   
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___scalar_e1e2_e2ni(const __syn_smv___scalar_e1e2_e2ni &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___scalar_e1e2_e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalar_e1e2_e2ni   
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___scalar_e1e2_e2ni(____syn_smv___scalar_e1e2_e2ni_coordinates__, const Float *coordinates) {

            set(__syn_smv___scalar_e1e2_e2ni_scalar_e1e2_e2ni, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___scalar_e1e2_e2ni(____syn_smv___scalar_e1e2_e2ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e2ni) {

            set(__syn_smv___scalar_e1e2_e2ni_scalar_e1e2_e2ni, c_scalar, 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_e1e2_e2ni &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___scalar_e1e2_e2ni_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___scalar_e1e2_e2ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e2ni);

        /// assign copy
        __syn_smv___scalar_e1e2_e2ni &operator=(const __syn_smv___scalar_e1e2_e2ni &arg1);

        /// assign general multivector
        __syn_smv___scalar_e1e2_e2ni &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___scalar_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 e1e2() 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(____syn_smv___scalar_e1e2_e2ni_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___scalar_e1e2_e2ni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___scalar_e1e2_e2ni ___syn_smv___scalar_e1e2_e2ni(const mv &arg1) {
        return __syn_smv___scalar_e1e2_e2ni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___scalar_e1e2_e2ni &___syn_smv___scalar_e1e2_e2ni(const __syn_smv___scalar_e1e2_e2ni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___scalar_e1e2_e2ni &___syn_smv___scalar_e1e2_e2ni(__syn_smv___scalar_e1e2_e2ni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___scalar_e1e2_e2ni ___syn_smv___scalar_e1e2_e2ni(__syn_smv___scalar_e1e2_e2ni::Float arg1) {
        return __syn_smv___scalar_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_e1e2_e2ni like(const mv &what, const __syn_smv___scalar_e1e2_e2ni &example) {return ___syn_smv___scalar_e1e2_e2ni(what);}
    /// from const specialization class:
    inline const __syn_smv___scalar_e1e2_e2ni like(const __syn_smv___scalar_e1e2_e2ni &what, const __syn_smv___scalar_e1e2_e2ni &example) {return ___syn_smv___scalar_e1e2_e2ni(what);}
    /// from non-const specialization class:
    inline __syn_smv___scalar_e1e2_e2ni like(__syn_smv___scalar_e1e2_e2ni &what, const __syn_smv___scalar_e1e2_e2ni &example) {return ___syn_smv___scalar_e1e2_e2ni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___scalar_e1e2_e2ni & v) {
        return (float)v.m_c[0];
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___scalar_e1e2_e2ni & v) {
        return (double)v.m_c[0];
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___scalar_e1e2_e2ni & v) {
        return v.m_c[0];
    }


    /// enum for the coordinates of __syn_smv___scalarf0_0 
    enum ____syn_smv___scalarf0_0_coordinates__ {__syn_smv___scalarf0_0_scalarf0_0};

    class __syn_smv___scalarf0_0 {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___scalarf0_0() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___scalarf0_0(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___scalarf0_0   
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___scalarf0_0(const __syn_smv___scalarf0_0 &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___scalarf0_0(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___scalarf0_0   
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___scalarf0_0(____syn_smv___scalarf0_0_coordinates__, const Float *coordinates) {

            set(__syn_smv___scalarf0_0_scalarf0_0, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___scalarf0_0(____syn_smv___scalarf0_0_coordinates__) {

            set(__syn_smv___scalarf0_0_scalarf0_0);
        }

        /// set to null
        void set();

        /// set to scalar
        void set(Float s);

        /// set to copy
        void set(const __syn_smv___scalarf0_0 &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___scalarf0_0_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___scalarf0_0_coordinates__);

        /// assign copy
        __syn_smv___scalarf0_0 &operator=(const __syn_smv___scalarf0_0 &arg1);

        /// assign general multivector
        __syn_smv___scalarf0_0 &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___scalarf0_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___scalarf0_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___scalarf0_0 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___scalarf0_0 ___syn_smv___scalarf0_0(const mv &arg1) {
        return __syn_smv___scalarf0_0(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___scalarf0_0 &___syn_smv___scalarf0_0(const __syn_smv___scalarf0_0 &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___scalarf0_0 &___syn_smv___scalarf0_0(__syn_smv___scalarf0_0 &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___scalarf0_0 ___syn_smv___scalarf0_0(__syn_smv___scalarf0_0::Float arg1) {
        return __syn_smv___scalarf0_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___scalarf0_0 like(const mv &what, const __syn_smv___scalarf0_0 &example) {return ___syn_smv___scalarf0_0(what);}
    /// from const specialization class:
    inline const __syn_smv___scalarf0_0 like(const __syn_smv___scalarf0_0 &what, const __syn_smv___scalarf0_0 &example) {return ___syn_smv___scalarf0_0(what);}
    /// from non-const specialization class:
    inline __syn_smv___scalarf0_0 like(__syn_smv___scalarf0_0 &what, const __syn_smv___scalarf0_0 &example) {return ___syn_smv___scalarf0_0(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___scalarf0_0 & v) {
        return (float)0.0f;
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___scalarf0_0 & v) {
        return (double)0.0f;
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___scalarf0_0 & v) {
        return (float)0.0f;
    }


    /// enum for the coordinates of __syn_smv___ni_e1e2ni 
    enum ____syn_smv___ni_e1e2ni_coordinates__ {__syn_smv___ni_e1e2ni_ni_e1e2ni};

    class __syn_smv___ni_e1e2ni {
        public:
            typedef float Float;

        /// zero constructor
        inline __syn_smv___ni_e1e2ni() {

            set();
        }

        /// scalar constructor 
        inline __syn_smv___ni_e1e2ni(Float s, int filler) { // filler can have any value, it simply prevents implicit conversion from Float -> __syn_smv___ni_e1e2ni     
            set(s);
        }




        /// copy constructor (MUST PASS BY REFERENCE)
        inline __syn_smv___ni_e1e2ni(const __syn_smv___ni_e1e2ni &arg1) {

            set(arg1);
        }

        /// general multivector constructor (that can not be selected for implicit conversion by C++)
        inline __syn_smv___ni_e1e2ni(const mv &arg1, int filler) { // filler can have any value, it simply prevents implicit conversion from mv -> __syn_smv___ni_e1e2ni     
            set(arg1);
        }

        /// pointer to coordinates constructor
        inline __syn_smv___ni_e1e2ni(____syn_smv___ni_e1e2ni_coordinates__, const Float *coordinates) {

            set(__syn_smv___ni_e1e2ni_ni_e1e2ni, coordinates);
        }

        /// coordinates constructor
        inline __syn_smv___ni_e1e2ni(____syn_smv___ni_e1e2ni_coordinates__, Float c_ni, Float c_e1e2ni) {

            set(__syn_smv___ni_e1e2ni_ni_e1e2ni, c_ni, c_e1e2ni);
        }

        /// set to null
        void set();

        /// set to scalar
        void set(Float s);

        /// set to copy
        void set(const __syn_smv___ni_e1e2ni &arg1);

        /// set to copy of general multivector
        void set(const mv &arg1);

        /// pointer to coordinates constructor
        void set(____syn_smv___ni_e1e2ni_coordinates__, const Float *coordinates);

        /// set to coordinates
        void set(____syn_smv___ni_e1e2ni_coordinates__, Float c_ni, Float c_e1e2ni);

        /// assign copy
        __syn_smv___ni_e1e2ni &operator=(const __syn_smv___ni_e1e2ni &arg1);

        /// assign general multivector
        __syn_smv___ni_e1e2ni &operator=(const mv &arg1);

        /// assign scalar
        __syn_smv___ni_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 ni() const {
            return m_c[0];
        }
        inline Float e1e2ni() const {
            return m_c[1];
        }

        /// const coordinate extraction by name

        /// get all coordinates (returns NULL for fully constant specialization
        const Float *getC(____syn_smv___ni_e1e2ni_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___ni_e1e2ni 

    /* 'underscore constructors' */
    /// underscore constructor from general multivector:
    inline __syn_smv___ni_e1e2ni ___syn_smv___ni_e1e2ni(const mv &arg1) {
        return __syn_smv___ni_e1e2ni(arg1, 0);
    }
    /// from const specialization class:
    inline const __syn_smv___ni_e1e2ni &___syn_smv___ni_e1e2ni(const __syn_smv___ni_e1e2ni &arg1) {
        return arg1;
    }
    /// from non-const specialization class:
    inline __syn_smv___ni_e1e2ni &___syn_smv___ni_e1e2ni(__syn_smv___ni_e1e2ni &arg1) {
        return arg1;
    }
    /// from Float:
    inline __syn_smv___ni_e1e2ni ___syn_smv___ni_e1e2ni(__syn_smv___ni_e1e2ni::Float arg1) {
        return __syn_smv___ni_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___ni_e1e2ni like(const mv &what, const __syn_smv___ni_e1e2ni &example) {return ___syn_smv___ni_e1e2ni(what);}
    /// from const specialization class:
    inline const __syn_smv___ni_e1e2ni like(const __syn_smv___ni_e1e2ni &what, const __syn_smv___ni_e1e2ni &example) {return ___syn_smv___ni_e1e2ni(what);}
    /// from non-const specialization class:
    inline __syn_smv___ni_e1e2ni like(__syn_smv___ni_e1e2ni &what, const __syn_smv___ni_e1e2ni &example) {return ___syn_smv___ni_e1e2ni(what);}




    // underscore 'constructors' for float types:

    /// returns scalar part of v as float
    inline float _float(const __syn_smv___ni_e1e2ni & v) {
        return (float)0;
    }
    /// returns scalar part of v as double
    inline double _double(const __syn_smv___ni_e1e2ni & v) {
        return (double)0;
    }
    /// returns scalar part of v as Float
    inline float _Float(const __syn_smv___ni_e1e2ni & v) {
        return (float)0;
    }


    class om {
        public:
            typedef float Float;

        /// identity 'I' constructor
        inline om() {
            set();
        }

        /// copy constructor (MUST PASS BY REFERENCE!)
        inline om(const om &arg1) {
            set(arg1);
        }

        /// scalar constructor (creates scalar * 'I' outermorphism)
        inline om(Float scalar) {
            set(scalar);
        }

        /// pointer to coordinates constructor
        inline om(const Float *coordinates) {
            set(coordinates);
        }

        /// pointer to coordinates/transpose constructor
        inline om(const Float *coordinates, bool transpose) {
            set(coordinates, transpose);
        }

        /// constructor from basis vectors array
        inline om(const point *vectors) {
            set(vectors);
        }

        /// constructor from basis vectors 
        inline om(const point & image_of_no, const point & image_of_e1, const point & image_of_e2, const point & image_of_ni) {
            set(image_of_no, image_of_e1, image_of_e2, image_of_ni);
        }


        /// set to identity 'I'
        void set();

        /// set to copy
        void set(const om &arg1);

        /// set to scalar (creates scalar * 'I' outermorphism)
        void set(Float scalarVal);

        /// set to coordinates 
        void set(const Float *coordinates);

        /// set to coordinates/transpose 
        void set(const Float *coordinates, bool transpose);

        /// set from basis vectors array
        void set(const point *vectors);

        /// set from basis vectors 
        void set(
            const point & image_of_no, const point & image_of_e1, const point & image_of_e2, const point & image_of_ni);


        /// assign copy
        om &operator=(const om &arg1);

        /// assign scalar (creates scalar * 'I' outermorphism)
        om &operator=(Float scalarVal);

        /// assign specialization:


        Float m_c[69]; ///< coordinate storage




    }; // end of class om



    // multivector type
    class mvType : public mvTypeBase {
        public:

            inline mvType() {
        }

        /** Creates a new instance of MultivectorInfo */
        inline mvType(const mv &X) {
            init(X, (mv::Float)0.0);
        }

        /** Creates a new instance of MultivectorInfo */
        inline mvType(const mv &X, mv::Float epsilon) {
            init(X, epsilon);
        }

        inline mvType(const mvType &T) {
        }


        void init(const mv &X, mv::Float epsilon);

        std::string toString() const;

        protected:
            void init(const mv &X, mv::Float epsilon, bool useAlgebraMetric, int guCnt);
    };



    mv::Float fastFactorBlade(const mv &X, point factor[], int gradeOfX = -1);
    void fastJoinBlades(const mv &A, const mv &B, mv &J, mv *M = NULL);



    // extra underscore constructors from profile:
    inline vectorE2GA _vectorE2GA(const point &arg1) {

        return vectorE2GA(vectorE2GA_e1_e2  , (float)arg1.m_c[1], (float)arg1.m_c[2]);
    }
    inline normalizedPoint _normalizedPoint(const __no_ct__ &arg1) {

        return normalizedPoint(normalizedPoint_e1_e2_ni_nof1_0  , (float)0, (float)0, (float)0);
    }
    inline normalizedTranslator _normalizedTranslator(const translator &arg1) {

        return normalizedTranslator(normalizedTranslator_e1ni_e2ni_scalarf1_0   , (float)arg1.m_c[1], (float)arg1.m_c[2]);
    }
    inline normalizedPoint _normalizedPoint(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {

        return normalizedPoint(normalizedPoint_e1_e2_ni_nof1_0  , (float)arg1.m_c[1], (float)arg1.m_c[2], (float)arg1.m_c[3]);
    }
    inline vectorE2GA _vectorE2GA(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {

        return vectorE2GA(vectorE2GA_e1_e2  , (float)arg1.m_c[1], (float)arg1.m_c[2]);
    }
    inline vectorE2GA _vectorE2GA(const normalizedPoint &arg1) {

        return vectorE2GA(vectorE2GA_e1_e2  , (float)arg1.m_c[0], (float)arg1.m_c[1]);
    }


    extern __I2_ct__ I2;
    extern __e1ni_ct__ e1ni;
    extern __no_ct__ no;
    extern __I4_ct__ I4;
    extern __e2ni_ct__ e2ni;
    extern __noni_ct__ noni;
    extern __I4i_ct__ I4i;
    extern __ni_ct__ ni;
    extern __e1_ct__ e1;
    extern __e2_ct__ e2;
    mv lcont(const mv& x, const mv& y);
    scalar scp(const mv& x, const mv& y);
    mv gp(const mv& x, const mv& y);
    mv gpEM(const mv& x, const mv& y);
    scalar scpEM(const mv& x, const mv& y);
    mv lcontEM(const mv& x, const mv& y);
    mv op(const mv& x, const mv& y);
    mv add(const mv& x, const mv& y);
    mv subtract(const mv& x, const mv& y);
    scalar norm_e2(const mv& x);
    scalar norm_e(const mv& x);
    mv unit_e(const mv& x);
    scalar norm_r2(const mv& x);
    scalar norm_r(const mv& x);
    mv unit_r(const mv& x);
    mv reverse(const mv& x);
    mv negate(const mv& x);
    mv dual(const mv& x);
    mv undual(const mv& x);
    mv inverse(const mv& x);
    mv inverseEM(const mv& x);
    mv apply_om(const om& x, const mv& y);
    mv gradeInvolution(const mv& x);
    namespace __G2_GENERATED__ {
        void set(om& __x__, const point& __image_of_no__, const point& __image_of_e1__, const point& __image_of_e2__, const point& __image_of_ni__);
    } /* end of namespace __G2_GENERATED__ */
    inline __syn_smv___ni_e1e2ni gp(const freeVector& x, const __syn_smv___e1_e2_ni& y);
    inline scalar norm_e(const __syn_smv___scalarf0_0& x);
    inline scalar norm_r(const bivectorE2GA& x);
    inline TRversorLog inverse(const TRversorLog& x);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const circle& x, const TRversorLog& y);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni subtract(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& x, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y);
    inline __syn_smv___e1_e2_ni subtract(const normalizedPoint& x, const normalizedPoint& y);
    inline scalar gp(const scalar& x, const scalar& y);
    inline scalar inverse(const scalar& x);
    inline point inverse(const point& x);
    inline ni_t op(const scalar& x, const __ni_ct__& y);
    inline scalar scp(const normalizedPoint& x, const normalizedPoint& y);
    inline __syn_smv___e1_e2_ni gradeInvolution(const __syn_smv___e1_e2_ni& x);
    inline vectorE2GA lcont(const __no_ct__& x, const freeVector& y);
    inline vectorE2GA negate(const vectorE2GA& x);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const point& y);
    inline ni_t negate(const ni_t& x);
    inline flatPoint op(const __ni_ct__& x, const point& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gp(const __syn_smv___scalar_noe1_noe2_noni& x, const point& y);
    inline scalar scp(const __ni_ct__& x, const point& y);
    inline circle dual(const point& x);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& x, const scalar& y);
    inline scalar norm_r2(const normalizedPoint& x);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const __syn_smv___e1_e2_ni_nof_1_0& x, const point& y);
    inline line inverse(const line& x);
    inline __syn_smv___e1_e2_ni_e1e2ni gp(const __syn_smv___scalar_e1e2_e1ni& x, const __syn_smv___e1_e2_ni& y);
    inline scalar negate(const scalar& x);
    inline scalar norm_e(const flatPoint& x);
    inline scalar scpEM(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y);
    inline scalar norm_e(const __syn_smv___scalarf_1_0& x);
    inline __syn_smv___nif_1_0 op(const __syn_smv___scalarf_1_0& x, const __ni_ct__& y);
    inline __syn_smv___scalar_noe1_e1e2_e1ni gpEM(const point& x, const __e1_ct__& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gp(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const point& y);
    inline scalar lcont(const __syn_smv___e1_e2_ni& x, const normalizedPoint& y);
    inline freeVector lcont(const __ni_ct__& x, const line& y);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const point& x, const point& y);
    inline scalar lcont(const circle& x, const __syn_smv___e1e2nif1_0& y);
    inline point inverseEM(const normalizedPoint& x);
    inline point gp(const scalar& x, const normalizedPoint& y);
    inline __syn_smv___scalar_e1e2_e2ni gp(const __syn_smv___e1_e2_ni& x, const __e2_ct__& y);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& x, const translator& y);
    inline scalar norm_e(const scalar& x);
    inline vectorE2GA gp(const scalar& x, const vectorE2GA& y);
    inline scalar norm_r2(const __syn_smv___e1_e2_ni& x);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni gpEM(const __syn_smv___noe1_noe2_noni& x, const __syn_smv___e1_e2_ni& y);
    inline scalar scp(const point& x, const point& y);
    inline point add(const point& x, const point& y);
    inline scalar scp(const __ni_ct__& x, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gpEM(const __syn_smv___scalar_noe1_noe2_noni& x, const point& y);
    inline scalar norm_e(const __syn_smv___e1ni_e2ni_nonif_1_0& x);
    inline __syn_smv___scalar_e1e2_e2ni gpEM(const __syn_smv___e1_e2_ni& x, const __e2_ct__& y);
    inline point gp(const point& x, const scalar& y);
    inline scalar norm_e(const freeVector& x);
    inline __syn_smv___scalar_noe2_e1e2_e2ni gp(const point& x, const __e2_ct__& y);
    inline __I2_ct__ op(const __e1_ct__& x, const __e2_ct__& y);
    inline point reverse(const point& x);
    inline __syn_smv___scalar_noe1_noe2_noni gpEM(const point& x, const __no_ct__& y);
    inline __syn_smv___e1e2nif1_0 op(const __I2_ct__& x, const __ni_ct__& y);
    inline __syn_smv___e1_e2_ni inverseEM(const __syn_smv___e1_e2_ni& x);
    inline line dual(const __syn_smv___e1_e2_ni& x);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 gp(const normalizedTranslator& x, const normalizedPoint& y);
    inline scalar norm_r(const line& x);
    inline __syn_smv___scalar_noe1_noe2_noni gp(const point& x, const __no_ct__& y);
    inline circle gradeInvolution(const circle& x);
    inline __syn_smv___noe1_noe2_noni gpEM(const __syn_smv___e1_e2_ni& x, const __no_ct__& y);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const circle& x, const circle& y);
    inline ni_t gp(const scalar& x, const __ni_ct__& y);
    inline __syn_smv___scalarf_1_0 lcont(const __ni_ct__& x, const normalizedPoint& y);
    inline __syn_smv___scalar_noe2_e1e2_e2ni gpEM(const point& x, const __e2_ct__& y);
    inline normalizedPoint reverse(const normalizedPoint& x);
    inline freeVector negate(const freeVector& x);
    inline scalar scp(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y);
    inline freeBivector op(const TRversorLog& x, const __ni_ct__& y);
    inline scalar lcont(const __ni_ct__& x, const point& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gp(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const point& y);
    inline circle negate(const circle& x);
    inline scalar scpEM(const point& x, const point& y);
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const __syn_smv___scalar_e1e2_e2ni& x, const __syn_smv___e1_e2_ni& y);
    inline __syn_smv___e1_e2_ni_nof_1_0 gradeInvolution(const normalizedPoint& x);
    inline point inverseEM(const point& x);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noni_e1ni_e2ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y);
    inline __syn_smv___e1_e2_nof1_0 add(const vectorE2GA& x, const __no_ct__& y);
    inline point subtract(const point& x, const normalizedPoint& y);
    inline __syn_smv___nif1_0 negate(const __syn_smv___nif_1_0& x);
    inline point lcont(const pointPair& x, const line& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gpEM(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const point& y);
    inline scalar norm_e2(const vectorE2GA& x);
    inline __syn_smv___e1_e2_ni inverse(const __syn_smv___e1_e2_ni& x);
    inline translator gpEM(const __syn_smv___e1_e2_ni& x, const __ni_ct__& y);
    inline scalar inverse(const __syn_smv___scalarf_1_0& x);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& x, const scalar& y);
    inline vectorE2GA subtract(const vectorE2GA& x, const vectorE2GA& y);
    inline freeVector op(const vectorE2GA& x, const __ni_ct__& y);
    inline scalar scpEM(const normalizedPoint& x, const normalizedPoint& y);
    inline point gp(const normalizedPoint& x, const scalar& y);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const point& x, const point& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gpEM(const __syn_smv___scalar_noe1_noe2_noni& x, const __syn_smv___e1_e2_ni_nof_1_0& y);
    inline vectorE2GA subtract(const e1_t& x, const e2_t& y);
    inline circle op(const pointPair& x, const normalizedPoint& y);
    inline __syn_smv___scalar_noni_e1ni_e2ni gp(const point& x, const __ni_ct__& y);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___scalar_noni_e1ni_e2ni& x, const point& y);
    inline TRversor gp(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gpEM(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y);
    inline TRversor gpEM(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y);
    inline freeBivector negate(const freeBivector& x);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noni_e1ni_e2ni& x, const point& y);
    inline TRversor subtract(const TRversor& x, const TRversor& y);
    inline __syn_smv___scalar_noe1_noe2_noni gp(const __syn_smv___e1_e2_ni& x, const __no_ct__& y);
    inline __syn_smv___e1_e2_ni dual(const line& x);
    inline vectorE2GA unit_e(const vectorE2GA& x);
    inline point gradeInvolution(const point& x);
    inline __syn_smv___scalar_noe1_e1e2_e1ni gp(const point& x, const __e1_ct__& y);
    inline e1_t gp(const scalar& x, const __e1_ct__& y);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const point& x, const __syn_smv___e1_e2_ni_nof_1_0& y);
    inline translator inverse(const normalizedTranslator& x);
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const __syn_smv___scalar_e1e2_e1ni& x, const __syn_smv___e1_e2_ni& y);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 op(const __ni_ct__& x, const normalizedPoint& y);
    inline point gp(const scalar& x, const __syn_smv___e1_e2_ni_nof2_0& y);
    inline TRversorLog lcont(const __ni_ct__& x, const circle& y);
    inline __syn_smv___scalar_noni_e1ni_e2ni gpEM(const point& x, const __ni_ct__& y);
    inline freeVector op(const __ni_ct__& x, const __syn_smv___e1_e2_ni& y);
    inline scalar scp(const TRversorLog& x, const TRversorLog& y);
    inline line op(const pointPair& x, const __ni_ct__& y);
    inline __syn_smv___scalarf0_0 lcont(const __ni_ct__& x, const __syn_smv___e1_e2_ni& y);
    inline pointPair lcont(const normalizedPoint& x, const line& y);
    inline __syn_smv___e1_e2_ni reverse(const __syn_smv___e1_e2_ni& x);
    inline normalizedPoint add(const __syn_smv___e1_e2_nof1_0& x, const ni_t& y);
    inline pointPair op(const normalizedPoint& x, const normalizedPoint& y);
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const translator& x, const __syn_smv___e1_e2_ni& y);
    inline bivectorE2GA lcont(const __no_ct__& x, const freeBivector& y);
    inline scalar norm_r2(const point& x);
    inline translator subtract(const scalar& x, const freeVector& y);
    inline __syn_smv___e1_e2_ni_e1e2ni gp(const __syn_smv___scalar_e1e2_e2ni& x, const __syn_smv___e1_e2_ni& y);
    inline __syn_smv___scalar_e1e2_e1ni gpEM(const __syn_smv___e1_e2_ni& x, const __e1_ct__& y);
    inline __syn_smv___e1_e2_ni_nof2_0 add(const normalizedPoint& x, const normalizedPoint& y);
    inline freeVector gp(const __syn_smv___e1_e2_ni& x, const __ni_ct__& y);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gp(const __syn_smv___scalar_noe1_noe2_noni& x, const __syn_smv___e1_e2_ni& y);
    inline e2_t gp(const scalar& x, const __e2_ct__& y);
    inline __syn_smv___scalar_e1e2_e1ni gp(const __syn_smv___e1_e2_ni& x, const __e1_ct__& y);
    inline mv operator+=(mv& arg1, const mv& arg2);
    inline point operator+=(point& arg1, const point& arg2);
    inline vectorE2GA operator+=(vectorE2GA& arg1, const __no_ct__& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator+=(__syn_smv___e1_e2_nof1_0& arg1, const ni_t& arg2);
    inline normalizedPoint operator+=(normalizedPoint& arg1, const normalizedPoint& arg2);
    inline no_t operator+=(no_t& arg1, const mv& arg2);
    inline e1_t operator+=(e1_t& arg1, const mv& arg2);
    inline e2_t operator+=(e2_t& arg1, const mv& arg2);
    inline ni_t operator+=(ni_t& arg1, const mv& arg2);
    inline scalar operator+=(scalar& arg1, const mv& arg2);
    inline flatPoint operator+=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator+=(normalizedFlatPoint& arg1, const mv& arg2);
    inline pointPair operator+=(pointPair& arg1, const mv& arg2);
    inline TRversorLog operator+=(TRversorLog& arg1, const mv& arg2);
    inline line operator+=(line& arg1, const mv& arg2);
    inline dualLine operator+=(dualLine& arg1, const mv& arg2);
    inline circle operator+=(circle& arg1, const mv& arg2);
    inline freeVector operator+=(freeVector& arg1, const mv& arg2);
    inline freeBivector operator+=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator+=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator+=(tangentBivector& arg1, const mv& arg2);
    inline bivectorE2GA operator+=(bivectorE2GA& arg1, const mv& arg2);
    inline TRversor operator+=(TRversor& arg1, const mv& arg2);
    inline TRSversor operator+=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator+=(evenVersor& arg1, const mv& arg2);
    inline translator operator+=(translator& arg1, const mv& arg2);
    inline normalizedTranslator operator+=(normalizedTranslator& arg1, const mv& arg2);
    inline rotor operator+=(rotor& arg1, const mv& arg2);
    inline scalor operator+=(scalor& arg1, const mv& arg2);
    inline __no_ct__ operator+=(__no_ct__& arg1, const mv& arg2);
    inline __e1_ct__ operator+=(__e1_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator+=(__e2_ct__& arg1, const mv& arg2);
    inline __ni_ct__ operator+=(__ni_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator+=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator+=(__I4_ct__& arg1, const mv& arg2);
    inline __I2_ct__ operator+=(__I2_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator+=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator+=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator+=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator+=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator+=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator+=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator+=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator+=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator+=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator+=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator+=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator+=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalarf_1_0 operator+=(__syn_smv___scalarf_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator+=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator+=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator+=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator+=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni operator+=(__syn_smv___e1_e2_ni& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator+=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator+=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator+=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator+=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator+=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator+=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator+=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline mv operator+(const mv& arg1, const mv& arg2);
    inline point operator+(const point& arg1, const point& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator+(const vectorE2GA& arg1, const __no_ct__& arg2);
    inline normalizedPoint operator+(const __syn_smv___e1_e2_nof1_0& arg1, const ni_t& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator+(const normalizedPoint& arg1, const normalizedPoint& arg2);
    inline mv operator-=(mv& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator-=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg2);
    inline normalizedPoint operator-=(normalizedPoint& arg1, const normalizedPoint& arg2);
    inline point operator-=(point& arg1, const normalizedPoint& arg2);
    inline vectorE2GA operator-=(vectorE2GA& arg1, const vectorE2GA& arg2);
    inline e1_t operator-=(e1_t& arg1, const e2_t& arg2);
    inline TRversor operator-=(TRversor& arg1, const TRversor& arg2);
    inline scalar operator-=(scalar& arg1, const freeVector& arg2);
    inline no_t operator-=(no_t& arg1, const mv& arg2);
    inline e2_t operator-=(e2_t& arg1, const mv& arg2);
    inline ni_t operator-=(ni_t& arg1, const mv& arg2);
    inline flatPoint operator-=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator-=(normalizedFlatPoint& arg1, const mv& arg2);
    inline pointPair operator-=(pointPair& arg1, const mv& arg2);
    inline TRversorLog operator-=(TRversorLog& arg1, const mv& arg2);
    inline line operator-=(line& arg1, const mv& arg2);
    inline dualLine operator-=(dualLine& arg1, const mv& arg2);
    inline circle operator-=(circle& arg1, const mv& arg2);
    inline freeVector operator-=(freeVector& arg1, const mv& arg2);
    inline freeBivector operator-=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator-=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator-=(tangentBivector& arg1, const mv& arg2);
    inline bivectorE2GA operator-=(bivectorE2GA& arg1, const mv& arg2);
    inline TRSversor operator-=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator-=(evenVersor& arg1, const mv& arg2);
    inline translator operator-=(translator& arg1, const mv& arg2);
    inline normalizedTranslator operator-=(normalizedTranslator& arg1, const mv& arg2);
    inline rotor operator-=(rotor& arg1, const mv& arg2);
    inline scalor operator-=(scalor& arg1, const mv& arg2);
    inline __no_ct__ operator-=(__no_ct__& arg1, const mv& arg2);
    inline __e1_ct__ operator-=(__e1_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator-=(__e2_ct__& arg1, const mv& arg2);
    inline __ni_ct__ operator-=(__ni_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator-=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator-=(__I4_ct__& arg1, const mv& arg2);
    inline __I2_ct__ operator-=(__I2_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator-=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator-=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator-=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator-=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator-=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator-=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator-=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator-=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator-=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator-=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator-=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator-=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalarf_1_0 operator-=(__syn_smv___scalarf_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator-=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator-=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator-=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator-=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni operator-=(__syn_smv___e1_e2_ni& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator-=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator-=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator-=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator-=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator-=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator-=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator-=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline mv operator-(const mv& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator-(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg2);
    inline __syn_smv___e1_e2_ni operator-(const normalizedPoint& arg1, const normalizedPoint& arg2);
    inline point operator-(const point& arg1, const normalizedPoint& arg2);
    inline vectorE2GA operator-(const vectorE2GA& arg1, const vectorE2GA& arg2);
    inline vectorE2GA operator-(const e1_t& arg1, const e2_t& arg2);
    inline TRversor operator-(const TRversor& arg1, const TRversor& arg2);
    inline translator operator-(const scalar& arg1, const freeVector& arg2);
    inline translator operator-(float arg1, const freeVector& arg2);
    inline mv operator-(const mv& arg1);
    inline vectorE2GA operator-(const vectorE2GA& arg1);
    inline ni_t operator-(const ni_t& arg1);
    inline scalar operator-(const scalar& arg1);
    inline freeVector operator-(const freeVector& arg1);
    inline circle operator-(const circle& arg1);
    inline __syn_smv___nif1_0 operator-(const __syn_smv___nif_1_0& arg1);
    inline freeBivector operator-(const freeBivector& arg1);
    inline mv operator%=(mv& arg1, const mv& arg2);
    inline normalizedPoint operator%=(normalizedPoint& arg1, const normalizedPoint& arg2);
    inline __ni_ct__ operator%=(__ni_ct__& arg1, const point& arg2);
    inline point operator%=(point& arg1, const point& arg2);
    inline __ni_ct__ operator%=(__ni_ct__& arg1, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg2);
    inline __syn_smv___e1_e2_ni operator%=(__syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline TRversorLog operator%=(TRversorLog& arg1, const TRversorLog& arg2);
    inline no_t operator%=(no_t& arg1, const mv& arg2);
    inline e1_t operator%=(e1_t& arg1, const mv& arg2);
    inline e2_t operator%=(e2_t& arg1, const mv& arg2);
    inline ni_t operator%=(ni_t& arg1, const mv& arg2);
    inline scalar operator%=(scalar& arg1, const mv& arg2);
    inline flatPoint operator%=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator%=(normalizedFlatPoint& arg1, const mv& arg2);
    inline pointPair operator%=(pointPair& arg1, const mv& arg2);
    inline line operator%=(line& arg1, const mv& arg2);
    inline dualLine operator%=(dualLine& arg1, const mv& arg2);
    inline circle operator%=(circle& arg1, const mv& arg2);
    inline freeVector operator%=(freeVector& arg1, const mv& arg2);
    inline freeBivector operator%=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator%=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator%=(tangentBivector& arg1, const mv& arg2);
    inline vectorE2GA operator%=(vectorE2GA& arg1, const mv& arg2);
    inline bivectorE2GA operator%=(bivectorE2GA& arg1, const mv& arg2);
    inline TRversor operator%=(TRversor& arg1, const mv& arg2);
    inline TRSversor operator%=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator%=(evenVersor& arg1, const mv& arg2);
    inline translator operator%=(translator& arg1, const mv& arg2);
    inline normalizedTranslator operator%=(normalizedTranslator& arg1, const mv& arg2);
    inline rotor operator%=(rotor& arg1, const mv& arg2);
    inline scalor operator%=(scalor& arg1, const mv& arg2);
    inline __no_ct__ operator%=(__no_ct__& arg1, const mv& arg2);
    inline __e1_ct__ operator%=(__e1_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator%=(__e2_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator%=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator%=(__I4_ct__& arg1, const mv& arg2);
    inline __I2_ct__ operator%=(__I2_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator%=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator%=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator%=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator%=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator%=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator%=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator%=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator%=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator%=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator%=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator%=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator%=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator%=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalarf_1_0 operator%=(__syn_smv___scalarf_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator%=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator%=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator%=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator%=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator%=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator%=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator%=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator%=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator%=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator%=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator%=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline scalar operator%(const mv& arg1, const mv& arg2);
    inline scalar operator%(const normalizedPoint& arg1, const normalizedPoint& arg2);
    inline scalar operator%(const __ni_ct__& arg1, const point& arg2);
    inline scalar operator%(const point& arg1, const point& arg2);
    inline scalar operator%(const __ni_ct__& arg1, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg2);
    inline scalar operator%(const __syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline scalar operator%(const TRversorLog& arg1, const TRversorLog& arg2);
    inline mv operator^=(mv& arg1, const mv& arg2);
    inline scalar operator^=(scalar& arg1, const __ni_ct__& arg2);
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const point& arg2);
    inline __syn_smv___scalarf_1_0 operator^=(__syn_smv___scalarf_1_0& arg1, const __ni_ct__& arg2);
    inline __e1_ct__ operator^=(__e1_ct__& arg1, const __e2_ct__& arg2);
    inline __I2_ct__ operator^=(__I2_ct__& arg1, const __ni_ct__& arg2);
    inline TRversorLog operator^=(TRversorLog& arg1, const __ni_ct__& arg2);
    inline vectorE2GA operator^=(vectorE2GA& arg1, const __ni_ct__& arg2);
    inline pointPair operator^=(pointPair& arg1, const normalizedPoint& arg2);
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const normalizedPoint& arg2);
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline pointPair operator^=(pointPair& arg1, const __ni_ct__& arg2);
    inline normalizedPoint operator^=(normalizedPoint& arg1, const normalizedPoint& arg2);
    inline no_t operator^=(no_t& arg1, const mv& arg2);
    inline e1_t operator^=(e1_t& arg1, const mv& arg2);
    inline e2_t operator^=(e2_t& arg1, const mv& arg2);
    inline ni_t operator^=(ni_t& arg1, const mv& arg2);
    inline point operator^=(point& arg1, const mv& arg2);
    inline flatPoint operator^=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator^=(normalizedFlatPoint& arg1, const mv& arg2);
    inline line operator^=(line& arg1, const mv& arg2);
    inline dualLine operator^=(dualLine& arg1, const mv& arg2);
    inline circle operator^=(circle& arg1, const mv& arg2);
    inline freeVector operator^=(freeVector& arg1, const mv& arg2);
    inline freeBivector operator^=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator^=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator^=(tangentBivector& arg1, const mv& arg2);
    inline bivectorE2GA operator^=(bivectorE2GA& arg1, const mv& arg2);
    inline TRversor operator^=(TRversor& arg1, const mv& arg2);
    inline TRSversor operator^=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator^=(evenVersor& arg1, const mv& arg2);
    inline translator operator^=(translator& arg1, const mv& arg2);
    inline normalizedTranslator operator^=(normalizedTranslator& arg1, const mv& arg2);
    inline rotor operator^=(rotor& arg1, const mv& arg2);
    inline scalor operator^=(scalor& arg1, const mv& arg2);
    inline __no_ct__ operator^=(__no_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator^=(__e2_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator^=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator^=(__I4_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator^=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator^=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator^=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator^=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator^=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator^=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator^=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator^=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator^=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator^=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator^=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator^=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator^=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator^=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator^=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator^=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator^=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni operator^=(__syn_smv___e1_e2_ni& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator^=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator^=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator^=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator^=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator^=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator^=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator^=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline mv operator^(const mv& arg1, const mv& arg2);
    inline ni_t operator^(const scalar& arg1, const __ni_ct__& arg2);
    inline ni_t operator^(float arg1, const __ni_ct__& arg2);
    inline flatPoint operator^(const __ni_ct__& arg1, const point& arg2);
    inline __syn_smv___nif_1_0 operator^(const __syn_smv___scalarf_1_0& arg1, const __ni_ct__& arg2);
    inline __I2_ct__ operator^(const __e1_ct__& arg1, const __e2_ct__& arg2);
    inline __syn_smv___e1e2nif1_0 operator^(const __I2_ct__& arg1, const __ni_ct__& arg2);
    inline freeBivector operator^(const TRversorLog& arg1, const __ni_ct__& arg2);
    inline freeVector operator^(const vectorE2GA& arg1, const __ni_ct__& arg2);
    inline circle operator^(const pointPair& arg1, const normalizedPoint& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator^(const __ni_ct__& arg1, const normalizedPoint& arg2);
    inline freeVector operator^(const __ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline line operator^(const pointPair& arg1, const __ni_ct__& arg2);
    inline pointPair operator^(const normalizedPoint& arg1, const normalizedPoint& arg2);
    inline mv operator*=(mv& arg1, const mv& arg2);
    inline freeVector operator*=(freeVector& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline circle operator*=(circle& arg1, const TRversorLog& arg2);
    inline scalar operator*=(scalar& arg1, const scalar& arg2);
    inline scalar operator*=(scalar& arg1, float arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator*=(__syn_smv___scalar_noe1_noe2_noni& arg1, const point& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const scalar& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, float arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator*=(__syn_smv___scalar_e1e2_e1ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator*=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const point& arg2);
    inline point operator*=(point& arg1, const point& arg2);
    inline scalar operator*=(scalar& arg1, const normalizedPoint& arg2);
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __e2_ct__& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator*=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const translator& arg2);
    inline scalar operator*=(scalar& arg1, const vectorE2GA& arg2);
    inline point operator*=(point& arg1, const scalar& arg2);
    inline point operator*=(point& arg1, float arg2);
    inline point operator*=(point& arg1, const __e2_ct__& arg2);
    inline normalizedTranslator operator*=(normalizedTranslator& arg1, const normalizedPoint& arg2);
    inline point operator*=(point& arg1, const __no_ct__& arg2);
    inline circle operator*=(circle& arg1, const circle& arg2);
    inline scalar operator*=(scalar& arg1, const __ni_ct__& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator*=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const point& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const scalar& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, float arg2);
    inline normalizedPoint operator*=(normalizedPoint& arg1, const scalar& arg2);
    inline normalizedPoint operator*=(normalizedPoint& arg1, float arg2);
    inline point operator*=(point& arg1, const __ni_ct__& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const point& arg2);
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __no_ct__& arg2);
    inline point operator*=(point& arg1, const __e1_ct__& arg2);
    inline scalar operator*=(scalar& arg1, const __e1_ct__& arg2);
    inline scalar operator*=(scalar& arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator*=(__syn_smv___scalar_e1e2_e2ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __ni_ct__& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator*=(__syn_smv___scalar_noe1_noe2_noni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline scalar operator*=(scalar& arg1, const __e2_ct__& arg2);
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __e1_ct__& arg2);
    inline no_t operator*=(no_t& arg1, const mv& arg2);
    inline e1_t operator*=(e1_t& arg1, const mv& arg2);
    inline e2_t operator*=(e2_t& arg1, const mv& arg2);
    inline ni_t operator*=(ni_t& arg1, const mv& arg2);
    inline flatPoint operator*=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator*=(normalizedFlatPoint& arg1, const mv& arg2);
    inline pointPair operator*=(pointPair& arg1, const mv& arg2);
    inline TRversorLog operator*=(TRversorLog& arg1, const mv& arg2);
    inline line operator*=(line& arg1, const mv& arg2);
    inline dualLine operator*=(dualLine& arg1, const mv& arg2);
    inline freeBivector operator*=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator*=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator*=(tangentBivector& arg1, const mv& arg2);
    inline vectorE2GA operator*=(vectorE2GA& arg1, const mv& arg2);
    inline bivectorE2GA operator*=(bivectorE2GA& arg1, const mv& arg2);
    inline TRversor operator*=(TRversor& arg1, const mv& arg2);
    inline TRSversor operator*=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator*=(evenVersor& arg1, const mv& arg2);
    inline translator operator*=(translator& arg1, const mv& arg2);
    inline rotor operator*=(rotor& arg1, const mv& arg2);
    inline scalor operator*=(scalor& arg1, const mv& arg2);
    inline __no_ct__ operator*=(__no_ct__& arg1, const mv& arg2);
    inline __e1_ct__ operator*=(__e1_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator*=(__e2_ct__& arg1, const mv& arg2);
    inline __ni_ct__ operator*=(__ni_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator*=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator*=(__I4_ct__& arg1, const mv& arg2);
    inline __I2_ct__ operator*=(__I2_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator*=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator*=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator*=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator*=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator*=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator*=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator*=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalarf_1_0 operator*=(__syn_smv___scalarf_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator*=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator*=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator*=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator*=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator*=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator*=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator*=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator*=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline mv operator*(const mv& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator*(const freeVector& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const circle& arg1, const TRversorLog& arg2);
    inline scalar operator*(const scalar& arg1, const scalar& arg2);
    inline scalar operator*(float arg1, const scalar& arg2);
    inline scalar operator*(const scalar& arg1, float arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*(const __syn_smv___scalar_noe1_noe2_noni& arg1, const point& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const scalar& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, float arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator*(const __syn_smv___scalar_e1e2_e1ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator*(const __syn_smv___scalar_noe1_e1e2_e1ni& arg1, const point& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const point& arg1, const point& arg2);
    inline point operator*(const scalar& arg1, const normalizedPoint& arg2);
    inline point operator*(float arg1, const normalizedPoint& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator*(const __syn_smv___e1_e2_ni& arg1, const __e2_ct__& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const translator& arg2);
    inline vectorE2GA operator*(const scalar& arg1, const vectorE2GA& arg2);
    inline vectorE2GA operator*(float arg1, const vectorE2GA& arg2);
    inline point operator*(const point& arg1, const scalar& arg2);
    inline point operator*(const point& arg1, float arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator*(const point& arg1, const __e2_ct__& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator*(const normalizedTranslator& arg1, const normalizedPoint& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator*(const point& arg1, const __no_ct__& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const circle& arg1, const circle& arg2);
    inline ni_t operator*(const scalar& arg1, const __ni_ct__& arg2);
    inline ni_t operator*(float arg1, const __ni_ct__& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator*(const __syn_smv___scalar_noe2_e1e2_e2ni& arg1, const point& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const scalar& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, float arg2);
    inline point operator*(const normalizedPoint& arg1, const scalar& arg2);
    inline point operator*(const normalizedPoint& arg1, float arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator*(const point& arg1, const __ni_ct__& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___scalar_noni_e1ni_e2ni& arg1, const point& arg2);
    inline TRversor operator*(const __syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator*(const __syn_smv___e1_e2_ni& arg1, const __no_ct__& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator*(const point& arg1, const __e1_ct__& arg2);
    inline e1_t operator*(const scalar& arg1, const __e1_ct__& arg2);
    inline e1_t operator*(float arg1, const __e1_ct__& arg2);
    inline point operator*(const scalar& arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2);
    inline point operator*(float arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator*(const __syn_smv___scalar_e1e2_e2ni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline freeVector operator*(const __syn_smv___e1_e2_ni& arg1, const __ni_ct__& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*(const __syn_smv___scalar_noe1_noe2_noni& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline e2_t operator*(const scalar& arg1, const __e2_ct__& arg2);
    inline e2_t operator*(float arg1, const __e2_ct__& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator*(const __syn_smv___e1_e2_ni& arg1, const __e1_ct__& arg2);
    inline mv operator<<=(mv& arg1, const mv& arg2);
    inline __no_ct__ operator<<=(__no_ct__& arg1, const freeVector& arg2);
    inline __syn_smv___e1_e2_ni operator<<=(__syn_smv___e1_e2_ni& arg1, const normalizedPoint& arg2);
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const line& arg2);
    inline circle operator<<=(circle& arg1, const __syn_smv___e1e2nif1_0& arg2);
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const normalizedPoint& arg2);
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const point& arg2);
    inline pointPair operator<<=(pointPair& arg1, const line& arg2);
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const circle& arg2);
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline normalizedPoint operator<<=(normalizedPoint& arg1, const line& arg2);
    inline __no_ct__ operator<<=(__no_ct__& arg1, const freeBivector& arg2);
    inline no_t operator<<=(no_t& arg1, const mv& arg2);
    inline e1_t operator<<=(e1_t& arg1, const mv& arg2);
    inline e2_t operator<<=(e2_t& arg1, const mv& arg2);
    inline ni_t operator<<=(ni_t& arg1, const mv& arg2);
    inline scalar operator<<=(scalar& arg1, const mv& arg2);
    inline point operator<<=(point& arg1, const mv& arg2);
    inline flatPoint operator<<=(flatPoint& arg1, const mv& arg2);
    inline normalizedFlatPoint operator<<=(normalizedFlatPoint& arg1, const mv& arg2);
    inline TRversorLog operator<<=(TRversorLog& arg1, const mv& arg2);
    inline line operator<<=(line& arg1, const mv& arg2);
    inline dualLine operator<<=(dualLine& arg1, const mv& arg2);
    inline freeVector operator<<=(freeVector& arg1, const mv& arg2);
    inline freeBivector operator<<=(freeBivector& arg1, const mv& arg2);
    inline tangentVector operator<<=(tangentVector& arg1, const mv& arg2);
    inline tangentBivector operator<<=(tangentBivector& arg1, const mv& arg2);
    inline vectorE2GA operator<<=(vectorE2GA& arg1, const mv& arg2);
    inline bivectorE2GA operator<<=(bivectorE2GA& arg1, const mv& arg2);
    inline TRversor operator<<=(TRversor& arg1, const mv& arg2);
    inline TRSversor operator<<=(TRSversor& arg1, const mv& arg2);
    inline evenVersor operator<<=(evenVersor& arg1, const mv& arg2);
    inline translator operator<<=(translator& arg1, const mv& arg2);
    inline normalizedTranslator operator<<=(normalizedTranslator& arg1, const mv& arg2);
    inline rotor operator<<=(rotor& arg1, const mv& arg2);
    inline scalor operator<<=(scalor& arg1, const mv& arg2);
    inline __e1_ct__ operator<<=(__e1_ct__& arg1, const mv& arg2);
    inline __e2_ct__ operator<<=(__e2_ct__& arg1, const mv& arg2);
    inline __I4i_ct__ operator<<=(__I4i_ct__& arg1, const mv& arg2);
    inline __I4_ct__ operator<<=(__I4_ct__& arg1, const mv& arg2);
    inline __I2_ct__ operator<<=(__I2_ct__& arg1, const mv& arg2);
    inline __noni_ct__ operator<<=(__noni_ct__& arg1, const mv& arg2);
    inline __e2ni_ct__ operator<<=(__e2ni_ct__& arg1, const mv& arg2);
    inline __e1ni_ct__ operator<<=(__e1ni_ct__& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_nof1_0 operator<<=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1e2nif1_0 operator<<=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof_1_0 operator<<=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator<<=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_noe2_noni operator<<=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator<<=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator<<=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_noni_e1ni_e2ni operator<<=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2);
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator<<=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2);
    inline __syn_smv___scalarf_1_0 operator<<=(__syn_smv___scalarf_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif_1_0 operator<<=(__syn_smv___nif_1_0& arg1, const mv& arg2);
    inline __syn_smv___nif1_0 operator<<=(__syn_smv___nif1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator<<=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_nof2_0 operator<<=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2);
    inline __syn_smv___noe1_noe2_noni operator<<=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2);
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator<<=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e1ni operator<<=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2);
    inline __syn_smv___e1_e2_ni_e1e2ni operator<<=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalar_e1e2_e2ni operator<<=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2);
    inline __syn_smv___scalarf0_0 operator<<=(__syn_smv___scalarf0_0& arg1, const mv& arg2);
    inline __syn_smv___ni_e1e2ni operator<<=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2);
    inline mv operator<<(const mv& arg1, const mv& arg2);
    inline vectorE2GA operator<<(const __no_ct__& arg1, const freeVector& arg2);
    inline scalar operator<<(const __syn_smv___e1_e2_ni& arg1, const normalizedPoint& arg2);
    inline freeVector operator<<(const __ni_ct__& arg1, const line& arg2);
    inline scalar operator<<(const circle& arg1, const __syn_smv___e1e2nif1_0& arg2);
    inline __syn_smv___scalarf_1_0 operator<<(const __ni_ct__& arg1, const normalizedPoint& arg2);
    inline scalar operator<<(const __ni_ct__& arg1, const point& arg2);
    inline point operator<<(const pointPair& arg1, const line& arg2);
    inline TRversorLog operator<<(const __ni_ct__& arg1, const circle& arg2);
    inline __syn_smv___scalarf0_0 operator<<(const __ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2);
    inline pointPair operator<<(const normalizedPoint& arg1, const line& arg2);
    inline bivectorE2GA operator<<(const __no_ct__& arg1, const freeBivector& arg2);
    inline mv operator*(const mv& arg1);
    inline circle operator*(const point& arg1);
    inline line operator*(const __syn_smv___e1_e2_ni& arg1);
    inline __syn_smv___e1_e2_ni operator*(const line& arg1);
    inline mv operator!(const mv& arg1);
    inline TRversorLog operator!(const TRversorLog& arg1);
    inline scalar operator!(const scalar& arg1);
    inline point operator!(const point& arg1);
    inline line operator!(const line& arg1);
    inline __syn_smv___e1_e2_ni operator!(const __syn_smv___e1_e2_ni& arg1);
    inline scalar operator!(const __syn_smv___scalarf_1_0& arg1);
    inline translator operator!(const normalizedTranslator& arg1);
    inline mv operator~(const mv& arg1);
    inline point operator~(const point& arg1);
    inline normalizedPoint operator~(const normalizedPoint& arg1);
    inline __syn_smv___e1_e2_ni operator~(const __syn_smv___e1_e2_ni& arg1);














    // set to zero
    inline void no_t::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void no_t::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void no_t::set(const no_t &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void no_t::set(__no_t_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void no_t::set(__no_t_coordinates__, Float c_no) {
        // set coordinates
        m_c[0] = c_no;

    }





    // assign copy
    inline no_t &no_t::operator=(const no_t &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline no_t &no_t::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline no_t &no_t::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void e1_t::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void e1_t::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void e1_t::set(const e1_t &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void e1_t::set(__e1_t_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void e1_t::set(__e1_t_coordinates__, Float c_e1) {
        // set coordinates
        m_c[0] = c_e1;

    }





    // assign copy
    inline e1_t &e1_t::operator=(const e1_t &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline e1_t &e1_t::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline e1_t &e1_t::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void e2_t::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void e2_t::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void e2_t::set(const e2_t &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void e2_t::set(__e2_t_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void e2_t::set(__e2_t_coordinates__, Float c_e2) {
        // set coordinates
        m_c[0] = c_e2;

    }





    // assign copy
    inline e2_t &e2_t::operator=(const e2_t &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline e2_t &e2_t::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline e2_t &e2_t::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void ni_t::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void ni_t::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void ni_t::set(const ni_t &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void ni_t::set(__ni_t_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void ni_t::set(__ni_t_coordinates__, Float c_ni) {
        // set coordinates
        m_c[0] = c_ni;

    }





    // assign copy
    inline ni_t &ni_t::operator=(const ni_t &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline ni_t &ni_t::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline ni_t &ni_t::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void scalar::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void scalar::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;

    }


    // set to copy
    inline void scalar::set(const scalar &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void scalar::set(__scalar_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void scalar::set(__scalar_coordinates__, Float c_scalar) {
        // set coordinates
        m_c[0] = c_scalar;

    }





    // assign copy
    inline scalar &scalar::operator=(const scalar &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline scalar &scalar::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline scalar &scalar::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void point::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void point::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void point::set(const point &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void point::set(__point_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void point::set(__point_coordinates__, Float c_no, Float c_e1, Float c_e2, Float c_ni) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_e1;
        m_c[2] = c_e2;
        m_c[3] = c_ni;

    }





    // assign copy
    inline point &point::operator=(const point &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline point &point::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline point &point::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void normalizedPoint::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void normalizedPoint::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void normalizedPoint::set(const normalizedPoint &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void normalizedPoint::set(__normalizedPoint_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void normalizedPoint::set(__normalizedPoint_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;

    }





    // assign copy
    inline normalizedPoint &normalizedPoint::operator=(const normalizedPoint &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline normalizedPoint &normalizedPoint::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline normalizedPoint &normalizedPoint::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void flatPoint::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void flatPoint::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void flatPoint::set(const flatPoint &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void flatPoint::set(__flatPoint_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void flatPoint::set(__flatPoint_coordinates__, Float c_e1ni, Float c_e2ni, Float c_noni) {
        // set coordinates
        m_c[0] = c_e1ni;
        m_c[1] = c_e2ni;
        m_c[2] = c_noni;

    }





    // assign copy
    inline flatPoint &flatPoint::operator=(const flatPoint &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline flatPoint &flatPoint::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline flatPoint &flatPoint::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void normalizedFlatPoint::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void normalizedFlatPoint::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void normalizedFlatPoint::set(const normalizedFlatPoint &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void normalizedFlatPoint::set(__normalizedFlatPoint_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void normalizedFlatPoint::set(__normalizedFlatPoint_coordinates__, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1ni;
        m_c[1] = c_e2ni;

    }





    // assign copy
    inline normalizedFlatPoint &normalizedFlatPoint::operator=(const normalizedFlatPoint &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline normalizedFlatPoint &normalizedFlatPoint::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline normalizedFlatPoint &normalizedFlatPoint::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void pointPair::set() {
        // set coordinates to 0
        mv_zero(m_c, 6);

    }

    // set to scalar 
    inline void pointPair::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;

    }


    // set to copy
    inline void pointPair::set(const pointPair &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 6);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];

    }

    // set to pointer to coordinates
    inline void pointPair::set(__pointPair_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 6);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];

    }

    // set to 'coordinates specified' 
    inline void pointPair::set(__pointPair_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni) {
        // set coordinates
        m_c[0] = c_noe1;
        m_c[1] = c_noe2;
        m_c[2] = c_e1e2;
        m_c[3] = c_e1ni;
        m_c[4] = c_e2ni;
        m_c[5] = c_noni;

    }





    // assign copy
    inline pointPair &pointPair::operator=(const pointPair &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline pointPair &pointPair::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline pointPair &pointPair::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void TRversorLog::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void TRversorLog::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void TRversorLog::set(const TRversorLog &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void TRversorLog::set(__TRversorLog_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void TRversorLog::set(__TRversorLog_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1e2;
        m_c[1] = c_e1ni;
        m_c[2] = c_e2ni;

    }





    // assign copy
    inline TRversorLog &TRversorLog::operator=(const TRversorLog &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline TRversorLog &TRversorLog::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline TRversorLog &TRversorLog::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void line::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void line::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void line::set(const line &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void line::set(__line_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void line::set(__line_coordinates__, Float c_e1e2ni, Float c_e1noni, Float c_e2noni) {
        // set coordinates
        m_c[0] = c_e1e2ni;
        m_c[1] = c_e1noni;
        m_c[2] = c_e2noni;

    }





    // assign copy
    inline line &line::operator=(const line &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline line &line::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline line &line::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void dualLine::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void dualLine::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void dualLine::set(const dualLine &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void dualLine::set(__dualLine_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void dualLine::set(__dualLine_coordinates__, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1e2;
        m_c[1] = c_e1ni;
        m_c[2] = c_e2ni;

    }





    // assign copy
    inline dualLine &dualLine::operator=(const dualLine &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline dualLine &dualLine::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline dualLine &dualLine::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void circle::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void circle::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void circle::set(const circle &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void circle::set(__circle_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void circle::set(__circle_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2) {
        // set coordinates
        m_c[0] = c_e1e2ni;
        m_c[1] = c_noe1ni;
        m_c[2] = c_noe2ni;
        m_c[3] = c_noe1e2;

    }





    // assign copy
    inline circle &circle::operator=(const circle &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline circle &circle::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline circle &circle::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void freeVector::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void freeVector::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void freeVector::set(const freeVector &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void freeVector::set(__freeVector_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void freeVector::set(__freeVector_coordinates__, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1ni;
        m_c[1] = c_e2ni;

    }





    // assign copy
    inline freeVector &freeVector::operator=(const freeVector &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline freeVector &freeVector::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline freeVector &freeVector::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void freeBivector::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void freeBivector::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void freeBivector::set(const freeBivector &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void freeBivector::set(__freeBivector_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void freeBivector::set(__freeBivector_coordinates__, Float c_e1e2ni) {
        // set coordinates
        m_c[0] = c_e1e2ni;

    }





    // assign copy
    inline freeBivector &freeBivector::operator=(const freeBivector &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline freeBivector &freeBivector::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline freeBivector &freeBivector::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void tangentVector::set() {
        // set coordinates to 0
        mv_zero(m_c, 6);

    }

    // set to scalar 
    inline void tangentVector::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;

    }


    // set to copy
    inline void tangentVector::set(const tangentVector &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 6);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];

    }

    // set to pointer to coordinates
    inline void tangentVector::set(__tangentVector_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 6);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];

    }

    // set to 'coordinates specified' 
    inline void tangentVector::set(__tangentVector_coordinates__, Float c_noe1, Float c_noe2, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni) {
        // set coordinates
        m_c[0] = c_noe1;
        m_c[1] = c_noe2;
        m_c[2] = c_e1e2;
        m_c[3] = c_e1ni;
        m_c[4] = c_e2ni;
        m_c[5] = c_noni;

    }





    // assign copy
    inline tangentVector &tangentVector::operator=(const tangentVector &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline tangentVector &tangentVector::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline tangentVector &tangentVector::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void tangentBivector::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void tangentBivector::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void tangentBivector::set(const tangentBivector &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void tangentBivector::set(__tangentBivector_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void tangentBivector::set(__tangentBivector_coordinates__, Float c_e1e2ni, Float c_noe1ni, Float c_noe2ni, Float c_noe1e2) {
        // set coordinates
        m_c[0] = c_e1e2ni;
        m_c[1] = c_noe1ni;
        m_c[2] = c_noe2ni;
        m_c[3] = c_noe1e2;

    }





    // assign copy
    inline tangentBivector &tangentBivector::operator=(const tangentBivector &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline tangentBivector &tangentBivector::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline tangentBivector &tangentBivector::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void vectorE2GA::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void vectorE2GA::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void vectorE2GA::set(const vectorE2GA &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void vectorE2GA::set(__vectorE2GA_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void vectorE2GA::set(__vectorE2GA_coordinates__, Float c_e1, Float c_e2) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;

    }





    // assign copy
    inline vectorE2GA &vectorE2GA::operator=(const vectorE2GA &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline vectorE2GA &vectorE2GA::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline vectorE2GA &vectorE2GA::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void bivectorE2GA::set() {
        // set coordinates to 0
        mv_zero(m_c, 1);

    }

    // set to scalar 
    inline void bivectorE2GA::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;

    }


    // set to copy
    inline void bivectorE2GA::set(const bivectorE2GA &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 1);
        m_c[0] = arg1.m_c[0];

    }

    // set to pointer to coordinates
    inline void bivectorE2GA::set(__bivectorE2GA_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 1);
        m_c[0] = coordinates[0];

    }

    // set to 'coordinates specified' 
    inline void bivectorE2GA::set(__bivectorE2GA_coordinates__, Float c_e1e2) {
        // set coordinates
        m_c[0] = c_e1e2;

    }





    // assign copy
    inline bivectorE2GA &bivectorE2GA::operator=(const bivectorE2GA &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline bivectorE2GA &bivectorE2GA::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline bivectorE2GA &bivectorE2GA::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void TRversor::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void TRversor::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void TRversor::set(const TRversor &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void TRversor::set(__TRversor_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void TRversor::set(__TRversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1e2;
        m_c[2] = c_e1ni;
        m_c[3] = c_e2ni;

    }





    // assign copy
    inline TRversor &TRversor::operator=(const TRversor &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline TRversor &TRversor::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline TRversor &TRversor::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void TRSversor::set() {
        // set coordinates to 0
        mv_zero(m_c, 6);

    }

    // set to scalar 
    inline void TRSversor::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;

    }


    // set to copy
    inline void TRSversor::set(const TRSversor &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 6);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];

    }

    // set to pointer to coordinates
    inline void TRSversor::set(__TRSversor_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 6);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];

    }

    // set to 'coordinates specified' 
    inline void TRSversor::set(__TRSversor_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni, Float c_e2ni, Float c_noni, Float c_e1e2noni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1e2;
        m_c[2] = c_e1ni;
        m_c[3] = c_e2ni;
        m_c[4] = c_noni;
        m_c[5] = c_e1e2noni;

    }





    // assign copy
    inline TRSversor &TRSversor::operator=(const TRSversor &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline TRSversor &TRSversor::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline TRSversor &TRSversor::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void evenVersor::set() {
        // set coordinates to 0
        mv_zero(m_c, 8);

    }

    // set to scalar 
    inline void evenVersor::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;
        m_c[7] = (Float)0.0;

    }


    // set to copy
    inline void evenVersor::set(const evenVersor &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 8);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];
        m_c[7] = arg1.m_c[7];

    }

    // set to pointer to coordinates
    inline void evenVersor::set(__evenVersor_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 8);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];
        m_c[7] = coordinates[7];

    }

    // set to 'coordinates specified' 
    inline void evenVersor::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) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noe1;
        m_c[2] = c_noe2;
        m_c[3] = c_e1e2;
        m_c[4] = c_e1ni;
        m_c[5] = c_e2ni;
        m_c[6] = c_noni;
        m_c[7] = c_e1e2noni;

    }





    // assign copy
    inline evenVersor &evenVersor::operator=(const evenVersor &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline evenVersor &evenVersor::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline evenVersor &evenVersor::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void translator::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void translator::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void translator::set(const translator &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void translator::set(__translator_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void translator::set(__translator_coordinates__, Float c_scalar, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1ni;
        m_c[2] = c_e2ni;

    }





    // assign copy
    inline translator &translator::operator=(const translator &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline translator &translator::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline translator &translator::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void normalizedTranslator::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void normalizedTranslator::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void normalizedTranslator::set(const normalizedTranslator &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void normalizedTranslator::set(__normalizedTranslator_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void normalizedTranslator::set(__normalizedTranslator_coordinates__, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1ni;
        m_c[1] = c_e2ni;

    }





    // assign copy
    inline normalizedTranslator &normalizedTranslator::operator=(const normalizedTranslator &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline normalizedTranslator &normalizedTranslator::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline normalizedTranslator &normalizedTranslator::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void rotor::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void rotor::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void rotor::set(const rotor &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void rotor::set(__rotor_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void rotor::set(__rotor_coordinates__, Float c_scalar, Float c_e1e2) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1e2;

    }





    // assign copy
    inline rotor &rotor::operator=(const rotor &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline rotor &rotor::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline rotor &rotor::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void scalor::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void scalor::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void scalor::set(const scalor &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void scalor::set(__scalor_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void scalor::set(__scalor_coordinates__, Float c_scalar, Float c_noni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noni;

    }





    // assign copy
    inline scalor &scalor::operator=(const scalor &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline scalor &scalor::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline scalor &scalor::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __no_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __no_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __no_ct__::set(const __no_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __no_ct__::set(____no_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __no_ct__::set(____no_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __no_ct__ &__no_ct__::operator=(const __no_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __no_ct__ &__no_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __no_ct__ &__no_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __e1_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __e1_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __e1_ct__::set(const __e1_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __e1_ct__::set(____e1_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __e1_ct__::set(____e1_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __e1_ct__ &__e1_ct__::operator=(const __e1_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __e1_ct__ &__e1_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __e1_ct__ &__e1_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __e2_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __e2_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __e2_ct__::set(const __e2_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __e2_ct__::set(____e2_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __e2_ct__::set(____e2_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __e2_ct__ &__e2_ct__::operator=(const __e2_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __e2_ct__ &__e2_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __e2_ct__ &__e2_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __ni_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __ni_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __ni_ct__::set(const __ni_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __ni_ct__::set(____ni_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __ni_ct__::set(____ni_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __ni_ct__ &__ni_ct__::operator=(const __ni_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __ni_ct__ &__ni_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __ni_ct__ &__ni_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __I4i_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __I4i_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __I4i_ct__::set(const __I4i_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __I4i_ct__::set(____I4i_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __I4i_ct__::set(____I4i_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __I4i_ct__ &__I4i_ct__::operator=(const __I4i_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __I4i_ct__ &__I4i_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __I4i_ct__ &__I4i_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __I4_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __I4_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __I4_ct__::set(const __I4_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __I4_ct__::set(____I4_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __I4_ct__::set(____I4_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __I4_ct__ &__I4_ct__::operator=(const __I4_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __I4_ct__ &__I4_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __I4_ct__ &__I4_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __I2_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __I2_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __I2_ct__::set(const __I2_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __I2_ct__::set(____I2_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __I2_ct__::set(____I2_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __I2_ct__ &__I2_ct__::operator=(const __I2_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __I2_ct__ &__I2_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __I2_ct__ &__I2_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __noni_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __noni_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __noni_ct__::set(const __noni_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __noni_ct__::set(____noni_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __noni_ct__::set(____noni_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __noni_ct__ &__noni_ct__::operator=(const __noni_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __noni_ct__ &__noni_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __noni_ct__ &__noni_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __e2ni_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __e2ni_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __e2ni_ct__::set(const __e2ni_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __e2ni_ct__::set(____e2ni_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __e2ni_ct__::set(____e2ni_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __e2ni_ct__ &__e2ni_ct__::operator=(const __e2ni_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __e2ni_ct__ &__e2ni_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __e2ni_ct__ &__e2ni_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __e1ni_ct__::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __e1ni_ct__::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __e1ni_ct__::set(const __e1ni_ct__ &arg1) {
    }

    // set to pointer to coordinates
    inline void __e1ni_ct__::set(____e1ni_ct___coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __e1ni_ct__::set(____e1ni_ct___coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __e1ni_ct__ &__e1ni_ct__::operator=(const __e1ni_ct__ &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __e1ni_ct__ &__e1ni_ct__::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __e1ni_ct__ &__e1ni_ct__::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_nof1_0::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_nof1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_nof1_0::set(const __syn_smv___e1_e2_nof1_0 &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_nof1_0::set(____syn_smv___e1_e2_nof1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_nof1_0::set(____syn_smv___e1_e2_nof1_0_coordinates__, Float c_e1, Float c_e2) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;

    }





    // assign copy
    inline __syn_smv___e1_e2_nof1_0 &__syn_smv___e1_e2_nof1_0::operator=(const __syn_smv___e1_e2_nof1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_nof1_0 &__syn_smv___e1_e2_nof1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_nof1_0 &__syn_smv___e1_e2_nof1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1e2nif1_0::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __syn_smv___e1e2nif1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __syn_smv___e1e2nif1_0::set(const __syn_smv___e1e2nif1_0 &arg1) {
    }

    // set to pointer to coordinates
    inline void __syn_smv___e1e2nif1_0::set(____syn_smv___e1e2nif1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1e2nif1_0::set(____syn_smv___e1e2nif1_0_coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __syn_smv___e1e2nif1_0 &__syn_smv___e1e2nif1_0::operator=(const __syn_smv___e1e2nif1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1e2nif1_0 &__syn_smv___e1e2nif1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1e2nif1_0 &__syn_smv___e1e2nif1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_ni_nof_1_0::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_ni_nof_1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_ni_nof_1_0::set(const __syn_smv___e1_e2_ni_nof_1_0 &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_ni_nof_1_0::set(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_ni_nof_1_0::set(____syn_smv___e1_e2_ni_nof_1_0_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;

    }





    // assign copy
    inline __syn_smv___e1_e2_ni_nof_1_0 &__syn_smv___e1_e2_ni_nof_1_0::operator=(const __syn_smv___e1_e2_ni_nof_1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_ni_nof_1_0 &__syn_smv___e1_e2_ni_nof_1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_ni_nof_1_0 &__syn_smv___e1_e2_ni_nof_1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 7);

    }

    // set to scalar 
    inline void __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::set(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 7);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::set(____syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 7);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::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) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noe1;
        m_c[2] = c_noe2;
        m_c[3] = c_e1e2;
        m_c[4] = c_noni;
        m_c[5] = c_e1ni;
        m_c[6] = c_e2ni;

    }





    // assign copy
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::operator=(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni &__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_noe1_noe2_noni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___scalar_noe1_noe2_noni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_noe1_noe2_noni::set(const __syn_smv___scalar_noe1_noe2_noni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_noe1_noe2_noni::set(____syn_smv___scalar_noe1_noe2_noni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_noe1_noe2_noni::set(____syn_smv___scalar_noe1_noe2_noni_coordinates__, Float c_scalar, Float c_noe1, Float c_noe2, Float c_noni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noe1;
        m_c[2] = c_noe2;
        m_c[3] = c_noni;

    }





    // assign copy
    inline __syn_smv___scalar_noe1_noe2_noni &__syn_smv___scalar_noe1_noe2_noni::operator=(const __syn_smv___scalar_noe1_noe2_noni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_noe1_noe2_noni &__syn_smv___scalar_noe1_noe2_noni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_noe1_noe2_noni &__syn_smv___scalar_noe1_noe2_noni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 7);

    }

    // set to scalar 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 7);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];

    }

    // set to pointer to coordinates
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 7);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::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) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_e1;
        m_c[2] = c_e2;
        m_c[3] = c_noe1e2;
        m_c[4] = c_ni;
        m_c[5] = c_noe1ni;
        m_c[6] = c_noe2ni;

    }





    // assign copy
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_noe1_e1e2_e1ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___scalar_noe1_e1e2_e1ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_noe1_e1e2_e1ni::set(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_noe1_e1e2_e1ni::set(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_noe1_e1e2_e1ni::set(____syn_smv___scalar_noe1_e1e2_e1ni_coordinates__, Float c_scalar, Float c_noe1, Float c_e1e2, Float c_e1ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noe1;
        m_c[2] = c_e1e2;
        m_c[3] = c_e1ni;

    }





    // assign copy
    inline __syn_smv___scalar_noe1_e1e2_e1ni &__syn_smv___scalar_noe1_e1e2_e1ni::operator=(const __syn_smv___scalar_noe1_e1e2_e1ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_noe1_e1e2_e1ni &__syn_smv___scalar_noe1_e1e2_e1ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_noe1_e1e2_e1ni &__syn_smv___scalar_noe1_e1e2_e1ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 7);

    }

    // set to scalar 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::set(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 7);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];

    }

    // set to pointer to coordinates
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::set(____syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 7);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::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) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_e1;
        m_c[2] = c_e2;
        m_c[3] = c_noe1e2;
        m_c[4] = c_ni;
        m_c[5] = c_noe1ni;
        m_c[6] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_noe2_e1e2_e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___scalar_noe2_e1e2_e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_noe2_e1e2_e2ni::set(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_noe2_e1e2_e2ni::set(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_noe2_e1e2_e2ni::set(____syn_smv___scalar_noe2_e1e2_e2ni_coordinates__, Float c_scalar, Float c_noe2, Float c_e1e2, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noe2;
        m_c[2] = c_e1e2;
        m_c[3] = c_e2ni;

    }





    // assign copy
    inline __syn_smv___scalar_noe2_e1e2_e2ni &__syn_smv___scalar_noe2_e1e2_e2ni::operator=(const __syn_smv___scalar_noe2_e1e2_e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_noe2_e1e2_e2ni &__syn_smv___scalar_noe2_e1e2_e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_noe2_e1e2_e2ni &__syn_smv___scalar_noe2_e1e2_e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 7);

    }

    // set to scalar 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::set(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 7);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];

    }

    // set to pointer to coordinates
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::set(____syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 7);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::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) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_e1;
        m_c[2] = c_e2;
        m_c[3] = c_noe1e2;
        m_c[4] = c_ni;
        m_c[5] = c_noe2ni;
        m_c[6] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::operator=(const __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_noni_e1ni_e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___scalar_noni_e1ni_e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_noni_e1ni_e2ni::set(const __syn_smv___scalar_noni_e1ni_e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_noni_e1ni_e2ni::set(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_noni_e1ni_e2ni::set(____syn_smv___scalar_noni_e1ni_e2ni_coordinates__, Float c_scalar, Float c_noni, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_noni;
        m_c[2] = c_e1ni;
        m_c[3] = c_e2ni;

    }





    // assign copy
    inline __syn_smv___scalar_noni_e1ni_e2ni &__syn_smv___scalar_noni_e1ni_e2ni::operator=(const __syn_smv___scalar_noni_e1ni_e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_noni_e1ni_e2ni &__syn_smv___scalar_noni_e1ni_e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_noni_e1ni_e2ni &__syn_smv___scalar_noni_e1ni_e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 7);

    }

    // set to scalar 
    inline void __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;
        m_c[6] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::set(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 7);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];
        m_c[6] = arg1.m_c[6];

    }

    // set to pointer to coordinates
    inline void __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::set(____syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 7);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];
        m_c[6] = coordinates[6];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::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) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_e1;
        m_c[2] = c_e2;
        m_c[3] = c_ni;
        m_c[4] = c_noe1ni;
        m_c[5] = c_noe2ni;
        m_c[6] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::operator=(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni &__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1ni_e2ni_nonif_1_0::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void __syn_smv___e1ni_e2ni_nonif_1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1ni_e2ni_nonif_1_0::set(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1ni_e2ni_nonif_1_0::set(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1ni_e2ni_nonif_1_0::set(____syn_smv___e1ni_e2ni_nonif_1_0_coordinates__, Float c_e1ni, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_e1ni;
        m_c[1] = c_e2ni;

    }





    // assign copy
    inline __syn_smv___e1ni_e2ni_nonif_1_0 &__syn_smv___e1ni_e2ni_nonif_1_0::operator=(const __syn_smv___e1ni_e2ni_nonif_1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1ni_e2ni_nonif_1_0 &__syn_smv___e1ni_e2ni_nonif_1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1ni_e2ni_nonif_1_0 &__syn_smv___e1ni_e2ni_nonif_1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalarf_1_0::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __syn_smv___scalarf_1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __syn_smv___scalarf_1_0::set(const __syn_smv___scalarf_1_0 &arg1) {
    }

    // set to pointer to coordinates
    inline void __syn_smv___scalarf_1_0::set(____syn_smv___scalarf_1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalarf_1_0::set(____syn_smv___scalarf_1_0_coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __syn_smv___scalarf_1_0 &__syn_smv___scalarf_1_0::operator=(const __syn_smv___scalarf_1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalarf_1_0 &__syn_smv___scalarf_1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalarf_1_0 &__syn_smv___scalarf_1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___nif_1_0::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __syn_smv___nif_1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __syn_smv___nif_1_0::set(const __syn_smv___nif_1_0 &arg1) {
    }

    // set to pointer to coordinates
    inline void __syn_smv___nif_1_0::set(____syn_smv___nif_1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __syn_smv___nif_1_0::set(____syn_smv___nif_1_0_coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __syn_smv___nif_1_0 &__syn_smv___nif_1_0::operator=(const __syn_smv___nif_1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___nif_1_0 &__syn_smv___nif_1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___nif_1_0 &__syn_smv___nif_1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___nif1_0::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __syn_smv___nif1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __syn_smv___nif1_0::set(const __syn_smv___nif1_0 &arg1) {
    }

    // set to pointer to coordinates
    inline void __syn_smv___nif1_0::set(____syn_smv___nif1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __syn_smv___nif1_0::set(____syn_smv___nif1_0_coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __syn_smv___nif1_0 &__syn_smv___nif1_0::operator=(const __syn_smv___nif1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___nif1_0 &__syn_smv___nif1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___nif1_0 &__syn_smv___nif1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::set() {
        // set coordinates to 0
        mv_zero(m_c, 6);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;
        m_c[4] = (Float)0.0;
        m_c[5] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::set(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 6);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];
        m_c[4] = arg1.m_c[4];
        m_c[5] = arg1.m_c[5];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::set(____syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 6);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];
        m_c[4] = coordinates[4];
        m_c[5] = coordinates[5];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::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) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;
        m_c[3] = c_noe1ni;
        m_c[4] = c_noe2ni;
        m_c[5] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::operator=(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 &__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_ni_nof2_0::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_ni_nof2_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_ni_nof2_0::set(const __syn_smv___e1_e2_ni_nof2_0 &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_ni_nof2_0::set(____syn_smv___e1_e2_ni_nof2_0_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_ni_nof2_0::set(____syn_smv___e1_e2_ni_nof2_0_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;

    }





    // assign copy
    inline __syn_smv___e1_e2_ni_nof2_0 &__syn_smv___e1_e2_ni_nof2_0::operator=(const __syn_smv___e1_e2_ni_nof2_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_ni_nof2_0 &__syn_smv___e1_e2_ni_nof2_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_ni_nof2_0 &__syn_smv___e1_e2_ni_nof2_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_ni::set(const __syn_smv___e1_e2_ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_ni::set(____syn_smv___e1_e2_ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_ni::set(____syn_smv___e1_e2_ni_coordinates__, Float c_e1, Float c_e2, Float c_ni) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;

    }





    // assign copy
    inline __syn_smv___e1_e2_ni &__syn_smv___e1_e2_ni::operator=(const __syn_smv___e1_e2_ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_ni &__syn_smv___e1_e2_ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_ni &__syn_smv___e1_e2_ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___noe1_noe2_noni::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___noe1_noe2_noni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___noe1_noe2_noni::set(const __syn_smv___noe1_noe2_noni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___noe1_noe2_noni::set(____syn_smv___noe1_noe2_noni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___noe1_noe2_noni::set(____syn_smv___noe1_noe2_noni_coordinates__, Float c_noe1, Float c_noe2, Float c_noni) {
        // set coordinates
        m_c[0] = c_noe1;
        m_c[1] = c_noe2;
        m_c[2] = c_noni;

    }





    // assign copy
    inline __syn_smv___noe1_noe2_noni &__syn_smv___noe1_noe2_noni::operator=(const __syn_smv___noe1_noe2_noni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___noe1_noe2_noni &__syn_smv___noe1_noe2_noni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___noe1_noe2_noni &__syn_smv___noe1_noe2_noni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___no_noe1e2_noe1ni_noe2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___no_noe1e2_noe1ni_noe2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___no_noe1e2_noe1ni_noe2ni::set(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___no_noe1e2_noe1ni_noe2ni::set(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___no_noe1e2_noe1ni_noe2ni::set(____syn_smv___no_noe1e2_noe1ni_noe2ni_coordinates__, Float c_no, Float c_noe1e2, Float c_noe1ni, Float c_noe2ni) {
        // set coordinates
        m_c[0] = c_no;
        m_c[1] = c_noe1e2;
        m_c[2] = c_noe1ni;
        m_c[3] = c_noe2ni;

    }





    // assign copy
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni &__syn_smv___no_noe1e2_noe1ni_noe2ni::operator=(const __syn_smv___no_noe1e2_noe1ni_noe2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni &__syn_smv___no_noe1e2_noe1ni_noe2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni &__syn_smv___no_noe1e2_noe1ni_noe2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_e1e2_e1ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___scalar_e1e2_e1ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_e1e2_e1ni::set(const __syn_smv___scalar_e1e2_e1ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_e1e2_e1ni::set(____syn_smv___scalar_e1e2_e1ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_e1e2_e1ni::set(____syn_smv___scalar_e1e2_e1ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e1ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1e2;
        m_c[2] = c_e1ni;

    }





    // assign copy
    inline __syn_smv___scalar_e1e2_e1ni &__syn_smv___scalar_e1e2_e1ni::operator=(const __syn_smv___scalar_e1e2_e1ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_e1e2_e1ni &__syn_smv___scalar_e1e2_e1ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_e1e2_e1ni &__syn_smv___scalar_e1e2_e1ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___e1_e2_ni_e1e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 4);

    }

    // set to scalar 
    inline void __syn_smv___e1_e2_ni_e1e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;
        m_c[3] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___e1_e2_ni_e1e2ni::set(const __syn_smv___e1_e2_ni_e1e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 4);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];
        m_c[3] = arg1.m_c[3];

    }

    // set to pointer to coordinates
    inline void __syn_smv___e1_e2_ni_e1e2ni::set(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 4);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];
        m_c[3] = coordinates[3];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___e1_e2_ni_e1e2ni::set(____syn_smv___e1_e2_ni_e1e2ni_coordinates__, Float c_e1, Float c_e2, Float c_ni, Float c_e1e2ni) {
        // set coordinates
        m_c[0] = c_e1;
        m_c[1] = c_e2;
        m_c[2] = c_ni;
        m_c[3] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___e1_e2_ni_e1e2ni &__syn_smv___e1_e2_ni_e1e2ni::operator=(const __syn_smv___e1_e2_ni_e1e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___e1_e2_ni_e1e2ni &__syn_smv___e1_e2_ni_e1e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___e1_e2_ni_e1e2ni &__syn_smv___e1_e2_ni_e1e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalar_e1e2_e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 3);

    }

    // set to scalar 
    inline void __syn_smv___scalar_e1e2_e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = s ;
        m_c[1] = (Float)0.0;
        m_c[2] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___scalar_e1e2_e2ni::set(const __syn_smv___scalar_e1e2_e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 3);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];
        m_c[2] = arg1.m_c[2];

    }

    // set to pointer to coordinates
    inline void __syn_smv___scalar_e1e2_e2ni::set(____syn_smv___scalar_e1e2_e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 3);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];
        m_c[2] = coordinates[2];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalar_e1e2_e2ni::set(____syn_smv___scalar_e1e2_e2ni_coordinates__, Float c_scalar, Float c_e1e2, Float c_e2ni) {
        // set coordinates
        m_c[0] = c_scalar;
        m_c[1] = c_e1e2;
        m_c[2] = c_e2ni;

    }





    // assign copy
    inline __syn_smv___scalar_e1e2_e2ni &__syn_smv___scalar_e1e2_e2ni::operator=(const __syn_smv___scalar_e1e2_e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalar_e1e2_e2ni &__syn_smv___scalar_e1e2_e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalar_e1e2_e2ni &__syn_smv___scalar_e1e2_e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___scalarf0_0::set() {
        // set coordinates to 0
    }

    // set to scalar 
    inline void __syn_smv___scalarf0_0::set(Float s) {
        // set coordinates 0, except for scalar (if any)

    }


    // set to copy
    inline void __syn_smv___scalarf0_0::set(const __syn_smv___scalarf0_0 &arg1) {
    }

    // set to pointer to coordinates
    inline void __syn_smv___scalarf0_0::set(____syn_smv___scalarf0_0_coordinates__, const Float *coordinates) {
        // copy coordinates
    }

    // set to 'coordinates specified' 
    inline void __syn_smv___scalarf0_0::set(____syn_smv___scalarf0_0_coordinates__) {
        // set coordinates

    }





    // assign copy
    inline __syn_smv___scalarf0_0 &__syn_smv___scalarf0_0::operator=(const __syn_smv___scalarf0_0 &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___scalarf0_0 &__syn_smv___scalarf0_0::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___scalarf0_0 &__syn_smv___scalarf0_0::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }






    // set to zero
    inline void __syn_smv___ni_e1e2ni::set() {
        // set coordinates to 0
        mv_zero(m_c, 2);

    }

    // set to scalar 
    inline void __syn_smv___ni_e1e2ni::set(Float s) {
        // set coordinates 0, except for scalar (if any)
        m_c[0] = (Float)0.0;
        m_c[1] = (Float)0.0;

    }


    // set to copy
    inline void __syn_smv___ni_e1e2ni::set(const __syn_smv___ni_e1e2ni &arg1) {
        // copy coordinates
        //mv_memcpy(m_c, arg1.m_c, 2);
        m_c[0] = arg1.m_c[0];
        m_c[1] = arg1.m_c[1];

    }

    // set to pointer to coordinates
    inline void __syn_smv___ni_e1e2ni::set(____syn_smv___ni_e1e2ni_coordinates__, const Float *coordinates) {
        // copy coordinates
        //mv_memcpy(m_c, coordinates, 2);
        m_c[0] = coordinates[0];
        m_c[1] = coordinates[1];

    }

    // set to 'coordinates specified' 
    inline void __syn_smv___ni_e1e2ni::set(____syn_smv___ni_e1e2ni_coordinates__, Float c_ni, Float c_e1e2ni) {
        // set coordinates
        m_c[0] = c_ni;
        m_c[1] = c_e1e2ni;

    }





    // assign copy
    inline __syn_smv___ni_e1e2ni &__syn_smv___ni_e1e2ni::operator=(const __syn_smv___ni_e1e2ni &arg1) {
        set(arg1);
        return *this;
    }

    // assign general multivector
    inline __syn_smv___ni_e1e2ni &__syn_smv___ni_e1e2ni::operator=(const mv &arg1) {
        set(arg1);
        return *this;
    }

    // assign scalar
    inline __syn_smv___ni_e1e2ni &__syn_smv___ni_e1e2ni::operator=(Float scalarVal) {
        set(scalarVal);
        return *this;
    }










    inline mv operator+=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline point operator+=(point& arg1, const point& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator+=(vectorE2GA& arg1, const __no_ct__& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator+=(__syn_smv___e1_e2_nof1_0& arg1, const ni_t& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator+=(normalizedPoint& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline no_t operator+=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline e1_t operator+=(e1_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline e2_t operator+=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline ni_t operator+=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline scalar operator+=(scalar& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator+=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator+=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline pointPair operator+=(pointPair& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator+=(TRversorLog& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline line operator+=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline dualLine operator+=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline circle operator+=(circle& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline freeVector operator+=(freeVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator+=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator+=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator+=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator+=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline TRversor operator+=(TRversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator+=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator+=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline translator operator+=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator+=(normalizedTranslator& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline rotor operator+=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline scalor operator+=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator+=(__no_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator+=(__e1_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator+=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator+=(__ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator+=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator+=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator+=(__I2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator+=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator+=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator+=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator+=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator+=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator+=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator+=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator+=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator+=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator+=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator+=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator+=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator+=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator+=(__syn_smv___scalarf_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator+=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator+=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator+=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator+=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator+=(__syn_smv___e1_e2_ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator+=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator+=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator+=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator+=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator+=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator+=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator+=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::add(arg1, arg2));
        return arg1;
    }
    inline mv operator+(const mv& arg1, const mv& arg2) {
        return ::c2ga::add(arg1, arg2);
    }
    inline point operator+(const point& arg1, const point& arg2) {
        return ::c2ga::add(arg1, arg2);
    }
    inline __syn_smv___e1_e2_nof1_0 operator+(const vectorE2GA& arg1, const __no_ct__& arg2) {
        return ::c2ga::add(arg1, arg2);
    }
    inline normalizedPoint operator+(const __syn_smv___e1_e2_nof1_0& arg1, const ni_t& arg2) {
        return ::c2ga::add(arg1, arg2);
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator+(const normalizedPoint& arg1, const normalizedPoint& arg2) {
        return ::c2ga::add(arg1, arg2);
    }
    inline mv operator-=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator-=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator-=(normalizedPoint& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline point operator-=(point& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator-=(vectorE2GA& arg1, const vectorE2GA& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline e1_t operator-=(e1_t& arg1, const e2_t& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline TRversor operator-=(TRversor& arg1, const TRversor& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline scalar operator-=(scalar& arg1, const freeVector& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline no_t operator-=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline e2_t operator-=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline ni_t operator-=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator-=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator-=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline pointPair operator-=(pointPair& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator-=(TRversorLog& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline line operator-=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline dualLine operator-=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline circle operator-=(circle& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline freeVector operator-=(freeVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator-=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator-=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator-=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator-=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator-=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator-=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline translator operator-=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator-=(normalizedTranslator& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline rotor operator-=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline scalor operator-=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator-=(__no_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator-=(__e1_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator-=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator-=(__ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator-=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator-=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator-=(__I2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator-=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator-=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator-=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator-=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator-=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator-=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator-=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator-=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator-=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator-=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator-=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator-=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator-=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator-=(__syn_smv___scalarf_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator-=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator-=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator-=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator-=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator-=(__syn_smv___e1_e2_ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator-=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator-=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator-=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator-=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator-=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator-=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator-=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::subtract(arg1, arg2));
        return arg1;
    }
    inline mv operator-(const mv& arg1, const mv& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator-(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline __syn_smv___e1_e2_ni operator-(const normalizedPoint& arg1, const normalizedPoint& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline point operator-(const point& arg1, const normalizedPoint& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline vectorE2GA operator-(const vectorE2GA& arg1, const vectorE2GA& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline vectorE2GA operator-(const e1_t& arg1, const e2_t& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline TRversor operator-(const TRversor& arg1, const TRversor& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline translator operator-(const scalar& arg1, const freeVector& arg2) {
        return ::c2ga::subtract(arg1, arg2);
    }
    inline translator operator-(float arg1, const freeVector& arg2) {
        return ::c2ga::subtract(::c2ga::scalar(arg1), arg2);
    }
    inline mv operator-(const mv& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline vectorE2GA operator-(const vectorE2GA& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline ni_t operator-(const ni_t& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline scalar operator-(const scalar& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline freeVector operator-(const freeVector& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline circle operator-(const circle& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline __syn_smv___nif1_0 operator-(const __syn_smv___nif_1_0& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline freeBivector operator-(const freeBivector& arg1) {
        return ::c2ga::negate(arg1);
    }
    inline mv operator%=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator%=(normalizedPoint& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator%=(__ni_ct__& arg1, const point& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline point operator%=(point& arg1, const point& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator%=(__ni_ct__& arg1, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator%=(__syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator%=(TRversorLog& arg1, const TRversorLog& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline no_t operator%=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline e1_t operator%=(e1_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline e2_t operator%=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline ni_t operator%=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline scalar operator%=(scalar& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator%=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator%=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline pointPair operator%=(pointPair& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline line operator%=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline dualLine operator%=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline circle operator%=(circle& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline freeVector operator%=(freeVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator%=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator%=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator%=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator%=(vectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator%=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline TRversor operator%=(TRversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator%=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator%=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline translator operator%=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator%=(normalizedTranslator& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline rotor operator%=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline scalor operator%=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator%=(__no_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator%=(__e1_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator%=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator%=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator%=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator%=(__I2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator%=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator%=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator%=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator%=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator%=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator%=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator%=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator%=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator%=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator%=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator%=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator%=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator%=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator%=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator%=(__syn_smv___scalarf_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator%=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator%=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator%=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator%=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator%=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator%=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator%=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator%=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator%=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator%=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator%=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::scp(arg1, arg2));
        return arg1;
    }
    inline scalar operator%(const mv& arg1, const mv& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const normalizedPoint& arg1, const normalizedPoint& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const __ni_ct__& arg1, const point& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const point& arg1, const point& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const __ni_ct__& arg1, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const __syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline scalar operator%(const TRversorLog& arg1, const TRversorLog& arg2) {
        return ::c2ga::scp(arg1, arg2);
    }
    inline mv operator^=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline scalar operator^=(scalar& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const point& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator^=(__syn_smv___scalarf_1_0& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator^=(__e1_ct__& arg1, const __e2_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator^=(__I2_ct__& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator^=(TRversorLog& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator^=(vectorE2GA& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline pointPair operator^=(pointPair& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator^=(__ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline pointPair operator^=(pointPair& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator^=(normalizedPoint& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline no_t operator^=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline e1_t operator^=(e1_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline e2_t operator^=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline ni_t operator^=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline point operator^=(point& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator^=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator^=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline line operator^=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline dualLine operator^=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline circle operator^=(circle& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline freeVector operator^=(freeVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator^=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator^=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator^=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator^=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline TRversor operator^=(TRversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator^=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator^=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline translator operator^=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator^=(normalizedTranslator& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline rotor operator^=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline scalor operator^=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator^=(__no_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator^=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator^=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator^=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator^=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator^=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator^=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator^=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator^=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator^=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator^=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator^=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator^=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator^=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator^=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator^=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator^=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator^=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator^=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator^=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator^=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator^=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator^=(__syn_smv___e1_e2_ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator^=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator^=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator^=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator^=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator^=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator^=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator^=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::op(arg1, arg2));
        return arg1;
    }
    inline mv operator^(const mv& arg1, const mv& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline ni_t operator^(const scalar& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline ni_t operator^(float arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(::c2ga::scalar(arg1), arg2);
    }
    inline flatPoint operator^(const __ni_ct__& arg1, const point& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline __syn_smv___nif_1_0 operator^(const __syn_smv___scalarf_1_0& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline __I2_ct__ operator^(const __e1_ct__& arg1, const __e2_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline __syn_smv___e1e2nif1_0 operator^(const __I2_ct__& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline freeBivector operator^(const TRversorLog& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline freeVector operator^(const vectorE2GA& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline circle operator^(const pointPair& arg1, const normalizedPoint& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator^(const __ni_ct__& arg1, const normalizedPoint& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline freeVector operator^(const __ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline line operator^(const pointPair& arg1, const __ni_ct__& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline pointPair operator^(const normalizedPoint& arg1, const normalizedPoint& arg2) {
        return ::c2ga::op(arg1, arg2);
    }
    inline mv operator*=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline freeVector operator*=(freeVector& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline circle operator*=(circle& arg1, const TRversorLog& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const scalar& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, float arg2) {
        arg1.set(::c2ga::gp(arg1, ::c2ga::scalar(arg2)));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator*=(__syn_smv___scalar_noe1_noe2_noni& arg1, const point& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const scalar& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, float arg2) {
        arg1.set(::c2ga::gp(arg1, ::c2ga::scalar(arg2)));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator*=(__syn_smv___scalar_e1e2_e1ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator*=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const point& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline point operator*=(point& arg1, const point& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __e2_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator*=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const translator& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const vectorE2GA& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline point operator*=(point& arg1, const scalar& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline point operator*=(point& arg1, float arg2) {
        arg1.set(::c2ga::gp(arg1, ::c2ga::scalar(arg2)));
        return arg1;
    }
    inline point operator*=(point& arg1, const __e2_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator*=(normalizedTranslator& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline point operator*=(point& arg1, const __no_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline circle operator*=(circle& arg1, const circle& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator*=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const point& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const scalar& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, float arg2) {
        arg1.set(::c2ga::gp(arg1, ::c2ga::scalar(arg2)));
        return arg1;
    }
    inline normalizedPoint operator*=(normalizedPoint& arg1, const scalar& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator*=(normalizedPoint& arg1, float arg2) {
        arg1.set(::c2ga::gp(arg1, ::c2ga::scalar(arg2)));
        return arg1;
    }
    inline point operator*=(point& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator*=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const point& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __no_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline point operator*=(point& arg1, const __e1_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const __e1_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator*=(__syn_smv___scalar_e1e2_e2ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __ni_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator*=(__syn_smv___scalar_noe1_noe2_noni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalar operator*=(scalar& arg1, const __e2_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator*=(__syn_smv___e1_e2_ni& arg1, const __e1_ct__& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline no_t operator*=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline e1_t operator*=(e1_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline e2_t operator*=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline ni_t operator*=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator*=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator*=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline pointPair operator*=(pointPair& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator*=(TRversorLog& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline line operator*=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline dualLine operator*=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator*=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator*=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator*=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator*=(vectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator*=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline TRversor operator*=(TRversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator*=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator*=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline translator operator*=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline rotor operator*=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline scalor operator*=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator*=(__no_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator*=(__e1_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator*=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator*=(__ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator*=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator*=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator*=(__I2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator*=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator*=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator*=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator*=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator*=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator*=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator*=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator*=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator*=(__syn_smv___scalarf_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator*=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator*=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator*=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator*=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator*=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator*=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator*=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator*=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::gp(arg1, arg2));
        return arg1;
    }
    inline mv operator*(const mv& arg1, const mv& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___ni_e1e2ni operator*(const freeVector& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const circle& arg1, const TRversorLog& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline scalar operator*(const scalar& arg1, const scalar& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline scalar operator*(float arg1, const scalar& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline scalar operator*(const scalar& arg1, float arg2) {
        return ::c2ga::gp(arg1, ::c2ga::scalar(arg2));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*(const __syn_smv___scalar_noe1_noe2_noni& arg1, const point& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const scalar& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, float arg2) {
        return ::c2ga::gp(arg1, ::c2ga::scalar(arg2));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator*(const __syn_smv___scalar_e1e2_e1ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator*(const __syn_smv___scalar_noe1_e1e2_e1ni& arg1, const point& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const point& arg1, const point& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline point operator*(const scalar& arg1, const normalizedPoint& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline point operator*(float arg1, const normalizedPoint& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline __syn_smv___scalar_e1e2_e2ni operator*(const __syn_smv___e1_e2_ni& arg1, const __e2_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const translator& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline vectorE2GA operator*(const scalar& arg1, const vectorE2GA& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline vectorE2GA operator*(float arg1, const vectorE2GA& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline point operator*(const point& arg1, const scalar& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline point operator*(const point& arg1, float arg2) {
        return ::c2ga::gp(arg1, ::c2ga::scalar(arg2));
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator*(const point& arg1, const __e2_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator*(const normalizedTranslator& arg1, const normalizedPoint& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator*(const point& arg1, const __no_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const circle& arg1, const circle& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline ni_t operator*(const scalar& arg1, const __ni_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline ni_t operator*(float arg1, const __ni_ct__& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator*(const __syn_smv___scalar_noe2_e1e2_e2ni& arg1, const point& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const scalar& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator*(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, float arg2) {
        return ::c2ga::gp(arg1, ::c2ga::scalar(arg2));
    }
    inline point operator*(const normalizedPoint& arg1, const scalar& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline point operator*(const normalizedPoint& arg1, float arg2) {
        return ::c2ga::gp(arg1, ::c2ga::scalar(arg2));
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator*(const point& arg1, const __ni_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator*(const __syn_smv___scalar_noni_e1ni_e2ni& arg1, const point& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline TRversor operator*(const __syn_smv___e1_e2_ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator*(const __syn_smv___e1_e2_ni& arg1, const __no_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator*(const point& arg1, const __e1_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline e1_t operator*(const scalar& arg1, const __e1_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline e1_t operator*(float arg1, const __e1_ct__& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline point operator*(const scalar& arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline point operator*(float arg1, const __syn_smv___e1_e2_ni_nof2_0& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator*(const __syn_smv___scalar_e1e2_e2ni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline freeVector operator*(const __syn_smv___e1_e2_ni& arg1, const __ni_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator*(const __syn_smv___scalar_noe1_noe2_noni& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline e2_t operator*(const scalar& arg1, const __e2_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline e2_t operator*(float arg1, const __e2_ct__& arg2) {
        return ::c2ga::gp(::c2ga::scalar(arg1), arg2);
    }
    inline __syn_smv___scalar_e1e2_e1ni operator*(const __syn_smv___e1_e2_ni& arg1, const __e1_ct__& arg2) {
        return ::c2ga::gp(arg1, arg2);
    }
    inline mv operator<<=(mv& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator<<=(__no_ct__& arg1, const freeVector& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni operator<<=(__syn_smv___e1_e2_ni& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const line& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline circle operator<<=(circle& arg1, const __syn_smv___e1e2nif1_0& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const normalizedPoint& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const point& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline pointPair operator<<=(pointPair& arg1, const line& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const circle& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __ni_ct__ operator<<=(__ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline normalizedPoint operator<<=(normalizedPoint& arg1, const line& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __no_ct__ operator<<=(__no_ct__& arg1, const freeBivector& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline no_t operator<<=(no_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline e1_t operator<<=(e1_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline e2_t operator<<=(e2_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline ni_t operator<<=(ni_t& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline scalar operator<<=(scalar& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline point operator<<=(point& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline flatPoint operator<<=(flatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline normalizedFlatPoint operator<<=(normalizedFlatPoint& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline TRversorLog operator<<=(TRversorLog& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline line operator<<=(line& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline dualLine operator<<=(dualLine& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline freeVector operator<<=(freeVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline freeBivector operator<<=(freeBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline tangentVector operator<<=(tangentVector& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline tangentBivector operator<<=(tangentBivector& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline vectorE2GA operator<<=(vectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline bivectorE2GA operator<<=(bivectorE2GA& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline TRversor operator<<=(TRversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline TRSversor operator<<=(TRSversor& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline evenVersor operator<<=(evenVersor& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline translator operator<<=(translator& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline normalizedTranslator operator<<=(normalizedTranslator& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline rotor operator<<=(rotor& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline scalor operator<<=(scalor& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __e1_ct__ operator<<=(__e1_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __e2_ct__ operator<<=(__e2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __I4i_ct__ operator<<=(__I4i_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __I4_ct__ operator<<=(__I4_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __I2_ct__ operator<<=(__I2_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __noni_ct__ operator<<=(__noni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __e2ni_ct__ operator<<=(__e2ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __e1ni_ct__ operator<<=(__e1ni_ct__& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_nof1_0 operator<<=(__syn_smv___e1_e2_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1e2nif1_0 operator<<=(__syn_smv___e1e2nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 operator<<=(__syn_smv___e1_e2_ni_nof_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni operator<<=(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_noe2_noni operator<<=(__syn_smv___scalar_noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni operator<<=(__syn_smv___scalar_noe1_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni operator<<=(__syn_smv___scalar_noe2_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni operator<<=(__syn_smv___scalar_noni_e1ni_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni operator<<=(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 operator<<=(__syn_smv___e1ni_e2ni_nonif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf_1_0 operator<<=(__syn_smv___scalarf_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif_1_0 operator<<=(__syn_smv___nif_1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___nif1_0 operator<<=(__syn_smv___nif1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 operator<<=(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_nof2_0 operator<<=(__syn_smv___e1_e2_ni_nof2_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___noe1_noe2_noni operator<<=(__syn_smv___noe1_noe2_noni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni operator<<=(__syn_smv___no_noe1e2_noe1ni_noe2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e1ni operator<<=(__syn_smv___scalar_e1e2_e1ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___e1_e2_ni_e1e2ni operator<<=(__syn_smv___e1_e2_ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalar_e1e2_e2ni operator<<=(__syn_smv___scalar_e1e2_e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___scalarf0_0 operator<<=(__syn_smv___scalarf0_0& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline __syn_smv___ni_e1e2ni operator<<=(__syn_smv___ni_e1e2ni& arg1, const mv& arg2) {
        arg1.set(::c2ga::lcont(arg1, arg2));
        return arg1;
    }
    inline mv operator<<(const mv& arg1, const mv& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline vectorE2GA operator<<(const __no_ct__& arg1, const freeVector& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline scalar operator<<(const __syn_smv___e1_e2_ni& arg1, const normalizedPoint& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline freeVector operator<<(const __ni_ct__& arg1, const line& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline scalar operator<<(const circle& arg1, const __syn_smv___e1e2nif1_0& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline __syn_smv___scalarf_1_0 operator<<(const __ni_ct__& arg1, const normalizedPoint& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline scalar operator<<(const __ni_ct__& arg1, const point& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline point operator<<(const pointPair& arg1, const line& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline TRversorLog operator<<(const __ni_ct__& arg1, const circle& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline __syn_smv___scalarf0_0 operator<<(const __ni_ct__& arg1, const __syn_smv___e1_e2_ni& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline pointPair operator<<(const normalizedPoint& arg1, const line& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline bivectorE2GA operator<<(const __no_ct__& arg1, const freeBivector& arg2) {
        return ::c2ga::lcont(arg1, arg2);
    }
    inline mv operator*(const mv& arg1) {
        return ::c2ga::dual(arg1);
    }
    inline circle operator*(const point& arg1) {
        return ::c2ga::dual(arg1);
    }
    inline line operator*(const __syn_smv___e1_e2_ni& arg1) {
        return ::c2ga::dual(arg1);
    }
    inline __syn_smv___e1_e2_ni operator*(const line& arg1) {
        return ::c2ga::dual(arg1);
    }
    inline mv operator!(const mv& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline TRversorLog operator!(const TRversorLog& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline scalar operator!(const scalar& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline point operator!(const point& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline line operator!(const line& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline __syn_smv___e1_e2_ni operator!(const __syn_smv___e1_e2_ni& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline scalar operator!(const __syn_smv___scalarf_1_0& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline translator operator!(const normalizedTranslator& arg1) {
        return ::c2ga::inverse(arg1);
    }
    inline mv operator~(const mv& arg1) {
        return ::c2ga::reverse(arg1);
    }
    inline point operator~(const point& arg1) {
        return ::c2ga::reverse(arg1);
    }
    inline normalizedPoint operator~(const normalizedPoint& arg1) {
        return ::c2ga::reverse(arg1);
    }
    inline __syn_smv___e1_e2_ni operator~(const __syn_smv___e1_e2_ni& arg1) {
        return ::c2ga::reverse(arg1);
    }


    // G2 functions:
    inline __syn_smv___ni_e1e2ni gp(const freeVector& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___ni_e1e2ni(__syn_smv___ni_e1e2ni_ni_e1e2ni, ((-1.0f * x.m_c[0] * y.m_c[0]) + (-1.0f * x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[0] * y.m_c[1]) + (x.m_c[1] * y.m_c[0])));
    }
    inline scalar norm_e(const __syn_smv___scalarf0_0& x) {
        scalar e2;
        e2.m_c[0] = 0.0f;
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline scalar norm_r(const bivectorE2GA& x) {
        scalar r2;
        r2.m_c[0] = (x.m_c[0] * x.m_c[0]);
        return scalar(scalar_scalar, ((((r2.m_c[0] < (char)0)) ? (char)-1 : ((((r2.m_c[0] > (char)0)) ? (char)1 : (char)0))) * sqrt((((r2.m_c[0] < (char)0)) ? ((-r2.m_c[0])) : (r2.m_c[0])))));
    }
    inline TRversorLog inverse(const TRversorLog& x) {
        scalar n;
        n.m_c[0] = (x.m_c[0] * x.m_c[0]);
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return TRversorLog(TRversorLog_e1e2_e1ni_e2ni, (-1.0f * x.m_c[0] * in.m_c[0]), (-1.0f * x.m_c[1] * in.m_c[0]), (-1.0f * x.m_c[2] * in.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const circle& x, const TRversorLog& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, (-1.0f * x.m_c[3] * y.m_c[0]), (x.m_c[3] * y.m_c[2]), (-1.0f * x.m_c[3] * y.m_c[1]), ((-1.0f * x.m_c[0] * y.m_c[0]) + (-1.0f * x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[3] * y.m_c[2])), ((-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[1] * y.m_c[0])), ((x.m_c[2] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[2])));
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni subtract(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& x, const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((-1.0f * y.m_c[0]) + x.m_c[0]), ((-1.0f * y.m_c[1]) + x.m_c[1]), ((-1.0f * y.m_c[2]) + x.m_c[2]), (x.m_c[3] + (-1.0f * y.m_c[3])), ((-1.0f * y.m_c[4]) + x.m_c[4]), ((-1.0f * y.m_c[5]) + x.m_c[5]), (x.m_c[6] + (-1.0f * y.m_c[6])));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni, ((x.m_c[1] * y.m_c[1]) + (-1.0f * x.m_c[0])), ((x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[1])), ((x.m_c[3] * y.m_c[2]) + (x.m_c[0] * y.m_c[1]) + x.m_c[1] + (-1.0f * x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[3]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[3] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])));
    }
    inline __syn_smv___e1_e2_ni subtract(const normalizedPoint& x, const normalizedPoint& y) {
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, ((-1.0f * y.m_c[0]) + x.m_c[0]), (x.m_c[1] + (-1.0f * y.m_c[1])), (x.m_c[2] + (-1.0f * y.m_c[2])));
    }
    inline scalar gp(const scalar& x, const scalar& y) {
        return scalar(scalar_scalar, (x.m_c[0] * y.m_c[0]));
    }
    inline scalar inverse(const scalar& x) {
        scalar n;
        n.m_c[0] = (x.m_c[0] * x.m_c[0]);
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return scalar(scalar_scalar, (x.m_c[0] * in.m_c[0]));
    }
    inline point inverse(const point& x) {
        scalar n;
        n.m_c[0] = ((x.m_c[2] * x.m_c[2]) + (-1.0f * x.m_c[3] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]) + (-1.0f * x.m_c[0] * x.m_c[3]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return point(point_no_e1_e2_ni, (x.m_c[0] * in.m_c[0]), (x.m_c[1] * in.m_c[0]), (x.m_c[2] * in.m_c[0]), (x.m_c[3] * in.m_c[0]));
    }
    inline ni_t op(const scalar& x, const __ni_ct__& y) {
        return ni_t(ni_t_ni, x.m_c[0]);
    }
    inline scalar scp(const normalizedPoint& x, const normalizedPoint& y) {
        return scalar(scalar_scalar, ((-1.0f * x.m_c[2]) + (x.m_c[1] * y.m_c[1]) + (-1.0f * y.m_c[2]) + (x.m_c[0] * y.m_c[0])));
    }
    inline __syn_smv___e1_e2_ni gradeInvolution(const __syn_smv___e1_e2_ni& x) {
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }
    inline vectorE2GA lcont(const __no_ct__& x, const freeVector& y) {
        return vectorE2GA(vectorE2GA_e1_e2, y.m_c[0], y.m_c[1]);
    }
    inline vectorE2GA negate(const vectorE2GA& x) {
        return vectorE2GA(vectorE2GA_e1_e2, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[3] * y.m_c[3]) + (-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[2] * y.m_c[0]) + (-1.0f * x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[2])), ((x.m_c[3] * y.m_c[0]) + (x.m_c[1] * y.m_c[3])), ((x.m_c[2] * y.m_c[3]) + (x.m_c[3] * y.m_c[1])));
    }
    inline ni_t negate(const ni_t& x) {
        return ni_t(ni_t_ni, (-1.0f * x.m_c[0]));
    }
    inline flatPoint op(const __ni_ct__& x, const point& y) {
        return flatPoint(flatPoint_e1ni_e2ni_noni, (-1.0f * y.m_c[1]), (-1.0f * y.m_c[2]), (-1.0f * y.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gp(const __syn_smv___scalar_noe1_noe2_noni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, ((-1.0f * x.m_c[3] * y.m_c[0]) + (x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (x.m_c[1] * y.m_c[3])), ((x.m_c[0] * y.m_c[2]) + (x.m_c[2] * y.m_c[3])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((x.m_c[3] * y.m_c[3]) + (x.m_c[0] * y.m_c[3])), ((x.m_c[1] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (x.m_c[2] * y.m_c[3])));
    }
    inline scalar scp(const __ni_ct__& x, const point& y) {
        return scalar(scalar_scalar, (-1.0f * y.m_c[0]));
    }
    inline circle dual(const point& x) {
        return circle(circle_e1e2ni_noe1ni_noe2ni_noe1e2, x.m_c[3], (-1.0f * x.m_c[2]), x.m_c[1], (-1.0f * x.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& x, const scalar& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, (x.m_c[0] * y.m_c[0]), (x.m_c[1] * y.m_c[0]), (x.m_c[2] * y.m_c[0]), (x.m_c[3] * y.m_c[0]), (x.m_c[4] * y.m_c[0]), (x.m_c[5] * y.m_c[0]), (x.m_c[6] * y.m_c[0]));
    }
    inline scalar norm_r2(const normalizedPoint& x) {
        return scalar(scalar_scalar, ((x.m_c[1] * x.m_c[1]) + (x.m_c[0] * x.m_c[0])));
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const __syn_smv___e1_e2_ni_nof_1_0& x, const point& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((x.m_c[2] * y.m_c[3]) + (-1.0f * y.m_c[0]) + (x.m_c[0] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])), ((-1.0f * y.m_c[1]) + (-1.0f * x.m_c[0] * y.m_c[0])), ((-1.0f * y.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * y.m_c[3]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[3])), ((-1.0f * x.m_c[2] * y.m_c[2]) + (x.m_c[1] * y.m_c[3])));
    }
    inline line inverse(const line& x) {
        scalar n;
        n.m_c[0] = ((-1.0f * x.m_c[2] * x.m_c[2]) + (-1.0f * x.m_c[1] * x.m_c[1]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return line(line_e1e2ni_e1noni_e2noni, (-1.0f * x.m_c[0] * in.m_c[0]), (-1.0f * x.m_c[1] * in.m_c[0]), (-1.0f * x.m_c[2] * in.m_c[0]));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni gp(const __syn_smv___scalar_e1e2_e1ni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])));
    }
    inline scalar negate(const scalar& x) {
        return scalar(scalar_scalar, (-1.0f * x.m_c[0]));
    }
    inline scalar norm_e(const flatPoint& x) {
        scalar e2;
        e2.m_c[0] = ((x.m_c[1] * x.m_c[1]) + (x.m_c[2] * x.m_c[2]) + (x.m_c[0] * x.m_c[0]));
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline scalar scpEM(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y) {
        return scalar(scalar_scalar, ((x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])));
    }
    inline scalar norm_e(const __syn_smv___scalarf_1_0& x) {
        scalar e2;
        e2.m_c[0] = 1.0f;
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline __syn_smv___nif_1_0 op(const __syn_smv___scalarf_1_0& x, const __ni_ct__& y) {
        return __syn_smv___nif_1_0(__syn_smv___nif_1_0_nif_1_0);
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni gpEM(const point& x, const __e1_ct__& y) {
        return __syn_smv___scalar_noe1_e1e2_e1ni(__syn_smv___scalar_noe1_e1e2_e1ni_scalar_noe1_e1e2_e1ni, x.m_c[1], x.m_c[0], (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gp(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[3] * y.m_c[0]) + (x.m_c[2] * y.m_c[2]) + (x.m_c[1] * y.m_c[3])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((x.m_c[3] * y.m_c[0]) + (x.m_c[1] * y.m_c[3])), ((x.m_c[2] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[2])));
    }
    inline scalar lcont(const __syn_smv___e1_e2_ni& x, const normalizedPoint& y) {
        return scalar(scalar_scalar, ((-1.0f * x.m_c[2]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])));
    }
    inline freeVector lcont(const __ni_ct__& x, const line& y) {
        return freeVector(freeVector_e1ni_e2ni, y.m_c[1], y.m_c[2]);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const point& x, const point& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0]) + (-1.0f * x.m_c[0] * y.m_c[3]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])), ((-1.0f * x.m_c[3] * y.m_c[0]) + (x.m_c[0] * y.m_c[3])), ((x.m_c[1] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((x.m_c[2] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[2])));
    }
    inline scalar lcont(const circle& x, const __syn_smv___e1e2nif1_0& y) {
        return scalar(scalar_scalar, x.m_c[3]);
    }
    inline point inverseEM(const normalizedPoint& x) {
        scalar n;
        n.m_c[0] = (1.0f + (x.m_c[2] * x.m_c[2]) + (x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return point(point_no_e1_e2_ni, in.m_c[0], (x.m_c[0] * in.m_c[0]), (x.m_c[1] * in.m_c[0]), (x.m_c[2] * in.m_c[0]));
    }
    inline point gp(const scalar& x, const normalizedPoint& y) {
        return point(point_no_e1_e2_ni, x.m_c[0], (x.m_c[0] * y.m_c[0]), (x.m_c[0] * y.m_c[1]), (x.m_c[0] * y.m_c[2]));
    }
    inline __syn_smv___scalar_e1e2_e2ni gp(const __syn_smv___e1_e2_ni& x, const __e2_ct__& y) {
        return __syn_smv___scalar_e1e2_e2ni(__syn_smv___scalar_e1e2_e2ni_scalar_e1e2_e2ni, x.m_c[1], x.m_c[0], (-1.0f * x.m_c[2]));
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0& x, const translator& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, y.m_c[0], ((x.m_c[0] * y.m_c[0]) + y.m_c[1]), (y.m_c[2] + (x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[4] * y.m_c[2]) + (x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[0] * y.m_c[1])), ((x.m_c[3] * y.m_c[0]) + y.m_c[1]), (y.m_c[2] + (x.m_c[4] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[1]) + (x.m_c[5] * y.m_c[0]) + (x.m_c[0] * y.m_c[2]) + (x.m_c[4] * y.m_c[1])));
    }
    inline scalar norm_e(const scalar& x) {
        scalar e2;
        e2.m_c[0] = (x.m_c[0] * x.m_c[0]);
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline vectorE2GA gp(const scalar& x, const vectorE2GA& y) {
        return vectorE2GA(vectorE2GA_e1_e2, (x.m_c[0] * y.m_c[0]), (x.m_c[0] * y.m_c[1]));
    }
    inline scalar norm_r2(const __syn_smv___e1_e2_ni& x) {
        return scalar(scalar_scalar, ((x.m_c[1] * x.m_c[1]) + (x.m_c[0] * x.m_c[0])));
    }
    inline __syn_smv___no_noe1e2_noe1ni_noe2ni gpEM(const __syn_smv___noe1_noe2_noni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___no_noe1e2_noe1ni_noe2ni(__syn_smv___no_noe1e2_noe1ni_noe2ni_no_noe1e2_noe1ni_noe2ni, ((x.m_c[1] * y.m_c[1]) + (x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])));
    }
    inline scalar scp(const point& x, const point& y) {
        return scalar(scalar_scalar, ((-1.0f * x.m_c[3] * y.m_c[0]) + (-1.0f * x.m_c[0] * y.m_c[3]) + (x.m_c[1] * y.m_c[1]) + (x.m_c[2] * y.m_c[2])));
    }
    inline point add(const point& x, const point& y) {
        return point(point_no_e1_e2_ni, (y.m_c[0] + x.m_c[0]), (x.m_c[1] + y.m_c[1]), (x.m_c[2] + y.m_c[2]), (x.m_c[3] + y.m_c[3]));
    }
    inline scalar scp(const __ni_ct__& x, const __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni& y) {
        return scalar(scalar_scalar, (-1.0f * y.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gpEM(const __syn_smv___scalar_noe1_noe2_noni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, ((x.m_c[3] * y.m_c[3]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[1] * y.m_c[3])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (x.m_c[2] * y.m_c[3])));
    }
    inline scalar norm_e(const __syn_smv___e1ni_e2ni_nonif_1_0& x) {
        scalar e2;
        e2.m_c[0] = (1.0f + (x.m_c[1] * x.m_c[1]) + (x.m_c[0] * x.m_c[0]));
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline __syn_smv___scalar_e1e2_e2ni gpEM(const __syn_smv___e1_e2_ni& x, const __e2_ct__& y) {
        return __syn_smv___scalar_e1e2_e2ni(__syn_smv___scalar_e1e2_e2ni_scalar_e1e2_e2ni, x.m_c[1], x.m_c[0], (-1.0f * x.m_c[2]));
    }
    inline point gp(const point& x, const scalar& y) {
        return point(point_no_e1_e2_ni, (x.m_c[0] * y.m_c[0]), (x.m_c[1] * y.m_c[0]), (x.m_c[2] * y.m_c[0]), (x.m_c[3] * y.m_c[0]));
    }
    inline scalar norm_e(const freeVector& x) {
        scalar e2;
        e2.m_c[0] = ((x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]));
        return scalar(scalar_scalar, sqrt(e2.m_c[0]));
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni gp(const point& x, const __e2_ct__& y) {
        return __syn_smv___scalar_noe2_e1e2_e2ni(__syn_smv___scalar_noe2_e1e2_e2ni_scalar_noe2_e1e2_e2ni, x.m_c[2], x.m_c[0], x.m_c[1], (-1.0f * x.m_c[3]));
    }
    inline __I2_ct__ op(const __e1_ct__& x, const __e2_ct__& y) {
        return __I2_ct__(__I2_ct___e1e2f1_0);
    }
    inline point reverse(const point& x) {
        return point(point_no_e1_e2_ni, x.m_c[0], x.m_c[1], x.m_c[2], x.m_c[3]);
    }
    inline __syn_smv___scalar_noe1_noe2_noni gpEM(const point& x, const __no_ct__& y) {
        return __syn_smv___scalar_noe1_noe2_noni(__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni, x.m_c[0], (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline __syn_smv___e1e2nif1_0 op(const __I2_ct__& x, const __ni_ct__& y) {
        return __syn_smv___e1e2nif1_0(__syn_smv___e1e2nif1_0_e1e2nif1_0);
    }
    inline __syn_smv___e1_e2_ni inverseEM(const __syn_smv___e1_e2_ni& x) {
        scalar n;
        n.m_c[0] = ((x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]) + (x.m_c[2] * x.m_c[2]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, (x.m_c[0] * in.m_c[0]), (x.m_c[1] * in.m_c[0]), (x.m_c[2] * in.m_c[0]));
    }
    inline line dual(const __syn_smv___e1_e2_ni& x) {
        return line(line_e1e2ni_e1noni_e2noni, x.m_c[2], x.m_c[1], (-1.0f * x.m_c[0]));
    }
    inline __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0 gp(const normalizedTranslator& x, const normalizedPoint& y) {
        return __syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0(__syn_smv___e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0_e1_e2_ni_noe1ni_noe2ni_e1e2ni_nof1_0, (y.m_c[0] + (-1.0f * x.m_c[0])), ((-1.0f * x.m_c[1]) + y.m_c[1]), ((-1.0f * x.m_c[0] * y.m_c[0]) + (-1.0f * x.m_c[1] * y.m_c[1]) + y.m_c[2]), x.m_c[0], x.m_c[1], ((-1.0f * x.m_c[0] * y.m_c[1]) + (x.m_c[1] * y.m_c[0])));
    }
    inline scalar norm_r(const line& x) {
        scalar r2;
        r2.m_c[0] = ((-1.0f * x.m_c[2] * x.m_c[2]) + (-1.0f * x.m_c[1] * x.m_c[1]));
        return scalar(scalar_scalar, ((((r2.m_c[0] < (char)0)) ? (char)-1 : ((((r2.m_c[0] > (char)0)) ? (char)1 : (char)0))) * sqrt((((r2.m_c[0] < (char)0)) ? ((-r2.m_c[0])) : (r2.m_c[0])))));
    }
    inline __syn_smv___scalar_noe1_noe2_noni gp(const point& x, const __no_ct__& y) {
        return __syn_smv___scalar_noe1_noe2_noni(__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni, (-1.0f * x.m_c[3]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline circle gradeInvolution(const circle& x) {
        return circle(circle_e1e2ni_noe1ni_noe2ni_noe1e2, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline __syn_smv___noe1_noe2_noni gpEM(const __syn_smv___e1_e2_ni& x, const __no_ct__& y) {
        return __syn_smv___noe1_noe2_noni(__syn_smv___noe1_noe2_noni_noe1_noe2_noni, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const circle& x, const circle& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((x.m_c[2] * y.m_c[2]) + (x.m_c[3] * y.m_c[0]) + (x.m_c[0] * y.m_c[3]) + (x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (x.m_c[2] * y.m_c[3])), ((-1.0f * x.m_c[1] * y.m_c[3]) + (x.m_c[3] * y.m_c[1])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((-1.0f * x.m_c[3] * y.m_c[0]) + (x.m_c[0] * y.m_c[3])), ((-1.0f * x.m_c[0] * y.m_c[2]) + (x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[0] * y.m_c[1])));
    }
    inline ni_t gp(const scalar& x, const __ni_ct__& y) {
        return ni_t(ni_t_ni, x.m_c[0]);
    }
    inline __syn_smv___scalarf_1_0 lcont(const __ni_ct__& x, const normalizedPoint& y) {
        return __syn_smv___scalarf_1_0(__syn_smv___scalarf_1_0_scalarf_1_0);
    }
    inline __syn_smv___scalar_noe2_e1e2_e2ni gpEM(const point& x, const __e2_ct__& y) {
        return __syn_smv___scalar_noe2_e1e2_e2ni(__syn_smv___scalar_noe2_e1e2_e2ni_scalar_noe2_e1e2_e2ni, x.m_c[2], x.m_c[0], x.m_c[1], (-1.0f * x.m_c[3]));
    }
    inline normalizedPoint reverse(const normalizedPoint& x) {
        return normalizedPoint(normalizedPoint_e1_e2_ni_nof1_0, x.m_c[0], x.m_c[1], x.m_c[2]);
    }
    inline freeVector negate(const freeVector& x) {
        return freeVector(freeVector_e1ni_e2ni, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]));
    }
    inline scalar scp(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y) {
        return scalar(scalar_scalar, ((x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0])));
    }
    inline freeBivector op(const TRversorLog& x, const __ni_ct__& y) {
        return freeBivector(freeBivector_e1e2ni, x.m_c[0]);
    }
    inline scalar lcont(const __ni_ct__& x, const point& y) {
        return scalar(scalar_scalar, (-1.0f * y.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni gp(const __syn_smv___scalar_noe2_e1e2_e2ni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe2ni_e1e2ni_no_e1_e2_noe1e2_ni_noe2ni_e1e2ni, ((x.m_c[1] * y.m_c[2]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + (x.m_c[2] * y.m_c[2])), ((-1.0f * x.m_c[3] * y.m_c[0]) + (-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[3]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[1] * y.m_c[1]) + (x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (x.m_c[0] * y.m_c[3])), ((x.m_c[3] * y.m_c[0]) + (x.m_c[1] * y.m_c[3])), ((x.m_c[3] * y.m_c[1]) + (x.m_c[2] * y.m_c[3])));
    }
    inline circle negate(const circle& x) {
        return circle(circle_e1e2ni_noe1ni_noe2ni_noe1e2, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline scalar scpEM(const point& x, const point& y) {
        return scalar(scalar_scalar, ((x.m_c[2] * y.m_c[2]) + (x.m_c[3] * y.m_c[3]) + (x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0])));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const __syn_smv___scalar_e1e2_e2ni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, ((x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + (x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])));
    }
    inline __syn_smv___e1_e2_ni_nof_1_0 gradeInvolution(const normalizedPoint& x) {
        return __syn_smv___e1_e2_ni_nof_1_0(__syn_smv___e1_e2_ni_nof_1_0_e1_e2_ni_nof_1_0, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }
    inline point inverseEM(const point& x) {
        scalar n;
        n.m_c[0] = ((x.m_c[3] * x.m_c[3]) + (x.m_c[2] * x.m_c[2]) + (x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return point(point_no_e1_e2_ni, (x.m_c[0] * in.m_c[0]), (x.m_c[1] * in.m_c[0]), (x.m_c[2] * in.m_c[0]), (x.m_c[3] * in.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noni_e1ni_e2ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, ((-1.0f * x.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[3] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[0]) + x.m_c[1] + (-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (-1.0f * x.m_c[2])), ((-1.0f * x.m_c[1] * y.m_c[1]) + (-1.0f * x.m_c[3])), ((x.m_c[3] * y.m_c[0]) + (-1.0f * x.m_c[2] * y.m_c[1])));
    }
    inline __syn_smv___e1_e2_nof1_0 add(const vectorE2GA& x, const __no_ct__& y) {
        return __syn_smv___e1_e2_nof1_0(__syn_smv___e1_e2_nof1_0_e1_e2_nof1_0, x.m_c[0], x.m_c[1]);
    }
    inline point subtract(const point& x, const normalizedPoint& y) {
        return point(point_no_e1_e2_ni, (-1.0f + x.m_c[0]), (x.m_c[1] + (-1.0f * y.m_c[0])), (x.m_c[2] + (-1.0f * y.m_c[1])), ((-1.0f * y.m_c[2]) + x.m_c[3]));
    }
    inline __syn_smv___nif1_0 negate(const __syn_smv___nif_1_0& x) {
        return __syn_smv___nif1_0(__syn_smv___nif1_0_nif1_0);
    }
    inline point lcont(const pointPair& x, const line& y) {
        return point(point_no_e1_e2_ni, ((x.m_c[1] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[5] * y.m_c[1])), ((x.m_c[5] * y.m_c[2]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[4] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[3] * y.m_c[1])));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gpEM(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const point& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[3] * y.m_c[3]) + (x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((x.m_c[1] * y.m_c[3]) + (x.m_c[3] * y.m_c[0])), ((x.m_c[2] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[2])));
    }
    inline scalar norm_e2(const vectorE2GA& x) {
        return scalar(scalar_scalar, ((x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1])));
    }
    inline __syn_smv___e1_e2_ni inverse(const __syn_smv___e1_e2_ni& x) {
        scalar n;
        n.m_c[0] = ((x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]));
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, (x.m_c[0] * in.m_c[0]), (x.m_c[1] * in.m_c[0]), (x.m_c[2] * in.m_c[0]));
    }
    inline translator gpEM(const __syn_smv___e1_e2_ni& x, const __ni_ct__& y) {
        return translator(translator_scalar_e1ni_e2ni, x.m_c[2], x.m_c[0], x.m_c[1]);
    }
    inline scalar inverse(const __syn_smv___scalarf_1_0& x) {
        scalar n;
        n.m_c[0] = 1.0f;
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return scalar(scalar_scalar, (-1.0f * in.m_c[0]));
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gp(const __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni& x, const scalar& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, (x.m_c[0] * y.m_c[0]), (x.m_c[1] * y.m_c[0]), (x.m_c[2] * y.m_c[0]), (x.m_c[3] * y.m_c[0]), (x.m_c[4] * y.m_c[0]), (x.m_c[5] * y.m_c[0]), (x.m_c[6] * y.m_c[0]));
    }
    inline vectorE2GA subtract(const vectorE2GA& x, const vectorE2GA& y) {
        return vectorE2GA(vectorE2GA_e1_e2, (x.m_c[0] + (-1.0f * y.m_c[0])), (x.m_c[1] + (-1.0f * y.m_c[1])));
    }
    inline freeVector op(const vectorE2GA& x, const __ni_ct__& y) {
        return freeVector(freeVector_e1ni_e2ni, x.m_c[0], x.m_c[1]);
    }
    inline scalar scpEM(const normalizedPoint& x, const normalizedPoint& y) {
        return scalar(scalar_scalar, (1.0f + (x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])));
    }
    inline point gp(const normalizedPoint& x, const scalar& y) {
        return point(point_no_e1_e2_ni, y.m_c[0], (x.m_c[0] * y.m_c[0]), (x.m_c[1] * y.m_c[0]), (x.m_c[2] * y.m_c[0]));
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const point& x, const point& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((x.m_c[3] * y.m_c[3]) + (x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((x.m_c[1] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((-1.0f * x.m_c[3] * y.m_c[2]) + (x.m_c[2] * y.m_c[3])));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gpEM(const __syn_smv___scalar_noe1_noe2_noni& x, const __syn_smv___e1_e2_ni_nof_1_0& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, ((x.m_c[2] * y.m_c[1]) + (-1.0f * x.m_c[0]) + (x.m_c[3] * y.m_c[2]) + (x.m_c[1] * y.m_c[0])), (x.m_c[1] + (x.m_c[0] * y.m_c[0])), (x.m_c[2] + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), (x.m_c[3] + (x.m_c[0] * y.m_c[2])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[2] * y.m_c[2])));
    }
    inline vectorE2GA subtract(const e1_t& x, const e2_t& y) {
        return vectorE2GA(vectorE2GA_e1_e2, x.m_c[0], (-1.0f * y.m_c[0]));
    }
    inline circle op(const pointPair& x, const normalizedPoint& y) {
        return circle(circle_e1e2ni_noe1ni_noe2ni_noe1e2, ((x.m_c[4] * y.m_c[0]) + (x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[1])), ((-1.0f * x.m_c[5] * y.m_c[0]) + x.m_c[3] + (x.m_c[0] * y.m_c[2])), (x.m_c[4] + (x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[5] * y.m_c[1])), (x.m_c[2] + (x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])));
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni gp(const point& x, const __ni_ct__& y) {
        return __syn_smv___scalar_noni_e1ni_e2ni(__syn_smv___scalar_noni_e1ni_e2ni_scalar_noni_e1ni_e2ni, (-1.0f * x.m_c[0]), x.m_c[0], x.m_c[1], x.m_c[2]);
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gp(const __syn_smv___scalar_noni_e1ni_e2ni& x, const point& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[1])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((x.m_c[1] * y.m_c[3]) + (-1.0f * x.m_c[3] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[0] * y.m_c[3])), ((-1.0f * x.m_c[1] * y.m_c[1]) + (x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[1] * y.m_c[2]) + (x.m_c[3] * y.m_c[0])), ((x.m_c[3] * y.m_c[1]) + (-1.0f * x.m_c[2] * y.m_c[2])));
    }
    inline TRversor gp(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y) {
        return TRversor(TRversor_scalar_e1e2_e1ni_e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])));
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni gpEM(const __syn_smv___scalar_noe1_e1e2_e1ni& x, const __syn_smv___e1_e2_ni_nof_1_0& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_e1e2ni_no_e1_e2_noe1e2_ni_noe1ni_e1e2ni, ((x.m_c[1] * y.m_c[0]) + (-1.0f * x.m_c[0])), (x.m_c[1] + (x.m_c[2] * y.m_c[1]) + (x.m_c[3] * y.m_c[2]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((-1.0f * x.m_c[2]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[3])), ((x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[1])));
    }
    inline TRversor gpEM(const __syn_smv___e1_e2_ni& x, const __syn_smv___e1_e2_ni& y) {
        return TRversor(TRversor_scalar_e1e2_e1ni_e2ni, ((x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((-1.0f * x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])));
    }
    inline freeBivector negate(const freeBivector& x) {
        return freeBivector(freeBivector_e1e2ni, (-1.0f * x.m_c[0]));
    }
    inline __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni gpEM(const __syn_smv___scalar_noni_e1ni_e2ni& x, const point& y) {
        return __syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni(__syn_smv___no_e1_e2_ni_noe1ni_noe2ni_e1e2ni_no_e1_e2_ni_noe1ni_noe2ni_e1e2ni, ((x.m_c[1] * y.m_c[3]) + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + (x.m_c[2] * y.m_c[3])), ((x.m_c[3] * y.m_c[3]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[0] * y.m_c[3]) + (-1.0f * x.m_c[1] * y.m_c[0]) + (-1.0f * x.m_c[3] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((x.m_c[2] * y.m_c[0]) + (-1.0f * x.m_c[1] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[2]) + (x.m_c[3] * y.m_c[0])), ((x.m_c[3] * y.m_c[1]) + (-1.0f * x.m_c[2] * y.m_c[2])));
    }
    inline TRversor subtract(const TRversor& x, const TRversor& y) {
        return TRversor(TRversor_scalar_e1e2_e1ni_e2ni, ((-1.0f * y.m_c[0]) + x.m_c[0]), (x.m_c[1] + (-1.0f * y.m_c[1])), ((-1.0f * y.m_c[2]) + x.m_c[2]), ((-1.0f * y.m_c[3]) + x.m_c[3]));
    }
    inline __syn_smv___scalar_noe1_noe2_noni gp(const __syn_smv___e1_e2_ni& x, const __no_ct__& y) {
        return __syn_smv___scalar_noe1_noe2_noni(__syn_smv___scalar_noe1_noe2_noni_scalar_noe1_noe2_noni, (-1.0f * x.m_c[2]), (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }
    inline __syn_smv___e1_e2_ni dual(const line& x) {
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, x.m_c[2], (-1.0f * x.m_c[1]), (-1.0f * x.m_c[0]));
    }
    inline vectorE2GA unit_e(const vectorE2GA& x) {
        scalar e2;
        e2.m_c[0] = ((x.m_c[0] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]));
        scalar ie;
        ie.m_c[0] = ((char)1 / sqrt(e2.m_c[0]));
        return vectorE2GA(vectorE2GA_e1_e2, (x.m_c[0] * ie.m_c[0]), (x.m_c[1] * ie.m_c[0]));
    }
    inline point gradeInvolution(const point& x) {
        return point(point_no_e1_e2_ni, (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline __syn_smv___scalar_noe1_e1e2_e1ni gp(const point& x, const __e1_ct__& y) {
        return __syn_smv___scalar_noe1_e1e2_e1ni(__syn_smv___scalar_noe1_e1e2_e1ni_scalar_noe1_e1e2_e1ni, x.m_c[1], x.m_c[0], (-1.0f * x.m_c[2]), (-1.0f * x.m_c[3]));
    }
    inline e1_t gp(const scalar& x, const __e1_ct__& y) {
        return e1_t(e1_t_e1, x.m_c[0]);
    }
    inline __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni gpEM(const point& x, const __syn_smv___e1_e2_ni_nof_1_0& y) {
        return __syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni(__syn_smv___scalar_noe1_noe2_e1e2_noni_e1ni_e2ni_scalar_noe1_noe2_e1e2_noni_e1ni_e2ni, ((-1.0f * x.m_c[0]) + (x.m_c[1] * y.m_c[0]) + (x.m_c[2] * y.m_c[1]) + (x.m_c[3] * y.m_c[2])), (x.m_c[1] + (x.m_c[0] * y.m_c[0])), ((x.m_c[0] * y.m_c[1]) + x.m_c[2]), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), (x.m_c[3] + (x.m_c[0] * y.m_c[2])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((-1.0f * x.m_c[3] * y.m_c[1]) + (x.m_c[2] * y.m_c[2])));
    }
    inline translator inverse(const normalizedTranslator& x) {
        scalar n;
        n.m_c[0] = 1.0f;
        scalar in;
        in.m_c[0] = ((char)1 / n.m_c[0]);
        return translator(translator_scalar_e1ni_e2ni, in.m_c[0], (-1.0f * x.m_c[0] * in.m_c[0]), (-1.0f * x.m_c[1] * in.m_c[0]));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const __syn_smv___scalar_e1e2_e1ni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, ((x.m_c[1] * y.m_c[1]) + (x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])), ((-1.0f * x.m_c[1] * y.m_c[0]) + (x.m_c[0] * y.m_c[1])), ((-1.0f * x.m_c[2] * y.m_c[0]) + (x.m_c[0] * y.m_c[2])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])));
    }
    inline __syn_smv___e1ni_e2ni_nonif_1_0 op(const __ni_ct__& x, const normalizedPoint& y) {
        return __syn_smv___e1ni_e2ni_nonif_1_0(__syn_smv___e1ni_e2ni_nonif_1_0_e1ni_e2ni_nonif_1_0, (-1.0f * y.m_c[0]), (-1.0f * y.m_c[1]));
    }
    inline point gp(const scalar& x, const __syn_smv___e1_e2_ni_nof2_0& y) {
        return point(point_no_e1_e2_ni, (2.0f * x.m_c[0]), (x.m_c[0] * y.m_c[0]), (x.m_c[0] * y.m_c[1]), (x.m_c[0] * y.m_c[2]));
    }
    inline TRversorLog lcont(const __ni_ct__& x, const circle& y) {
        return TRversorLog(TRversorLog_e1e2_e1ni_e2ni, (-1.0f * y.m_c[3]), (-1.0f * y.m_c[1]), (-1.0f * y.m_c[2]));
    }
    inline __syn_smv___scalar_noni_e1ni_e2ni gpEM(const point& x, const __ni_ct__& y) {
        return __syn_smv___scalar_noni_e1ni_e2ni(__syn_smv___scalar_noni_e1ni_e2ni_scalar_noni_e1ni_e2ni, x.m_c[3], x.m_c[0], x.m_c[1], x.m_c[2]);
    }
    inline freeVector op(const __ni_ct__& x, const __syn_smv___e1_e2_ni& y) {
        return freeVector(freeVector_e1ni_e2ni, (-1.0f * y.m_c[0]), (-1.0f * y.m_c[1]));
    }
    inline scalar scp(const TRversorLog& x, const TRversorLog& y) {
        return scalar(scalar_scalar, (-1.0f * x.m_c[0] * y.m_c[0]));
    }
    inline line op(const pointPair& x, const __ni_ct__& y) {
        return line(line_e1e2ni_e1noni_e2noni, x.m_c[2], (-1.0f * x.m_c[0]), (-1.0f * x.m_c[1]));
    }
    inline __syn_smv___scalarf0_0 lcont(const __ni_ct__& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___scalarf0_0(__syn_smv___scalarf0_0_scalarf0_0);
    }
    inline pointPair lcont(const normalizedPoint& x, const line& y) {
        return pointPair(pointPair_noe1_noe2_e1e2_e1ni_e2ni_noni, y.m_c[1], y.m_c[2], (-1.0f * y.m_c[0]), ((x.m_c[2] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[0]) + (x.m_c[2] * y.m_c[2])), ((x.m_c[0] * y.m_c[1]) + (x.m_c[1] * y.m_c[2])));
    }
    inline __syn_smv___e1_e2_ni reverse(const __syn_smv___e1_e2_ni& x) {
        return __syn_smv___e1_e2_ni(__syn_smv___e1_e2_ni_e1_e2_ni, x.m_c[0], x.m_c[1], x.m_c[2]);
    }
    inline normalizedPoint add(const __syn_smv___e1_e2_nof1_0& x, const ni_t& y) {
        return normalizedPoint(normalizedPoint_e1_e2_ni_nof1_0, x.m_c[0], x.m_c[1], y.m_c[0]);
    }
    inline pointPair op(const normalizedPoint& x, const normalizedPoint& y) {
        return pointPair(pointPair_noe1_noe2_e1e2_e1ni_e2ni_noni, ((-1.0f * x.m_c[0]) + y.m_c[0]), ((-1.0f * x.m_c[1]) + y.m_c[1]), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((-1.0f * x.m_c[2]) + y.m_c[2]));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni gpEM(const translator& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[1] * y.m_c[0]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((-1.0f * x.m_c[1] * y.m_c[1]) + (x.m_c[2] * y.m_c[0])));
    }
    inline bivectorE2GA lcont(const __no_ct__& x, const freeBivector& y) {
        return bivectorE2GA(bivectorE2GA_e1e2, (-1.0f * y.m_c[0]));
    }
    inline scalar norm_r2(const point& x) {
        return scalar(scalar_scalar, ((-1.0f * x.m_c[3] * x.m_c[0]) + (x.m_c[1] * x.m_c[1]) + (-1.0f * x.m_c[0] * x.m_c[3]) + (x.m_c[2] * x.m_c[2])));
    }
    inline translator subtract(const scalar& x, const freeVector& y) {
        return translator(translator_scalar_e1ni_e2ni, x.m_c[0], (-1.0f * y.m_c[0]), (-1.0f * y.m_c[1]));
    }
    inline __syn_smv___e1_e2_ni_e1e2ni gp(const __syn_smv___scalar_e1e2_e2ni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___e1_e2_ni_e1e2ni(__syn_smv___e1_e2_ni_e1e2ni_e1_e2_ni_e1e2ni, ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[1])), ((x.m_c[0] * y.m_c[1]) + (-1.0f * x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[2]) + (-1.0f * x.m_c[2] * y.m_c[1])), ((x.m_c[2] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])));
    }
    inline __syn_smv___scalar_e1e2_e1ni gpEM(const __syn_smv___e1_e2_ni& x, const __e1_ct__& y) {
        return __syn_smv___scalar_e1e2_e1ni(__syn_smv___scalar_e1e2_e1ni_scalar_e1e2_e1ni, x.m_c[0], (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }
    inline __syn_smv___e1_e2_ni_nof2_0 add(const normalizedPoint& x, const normalizedPoint& y) {
        return __syn_smv___e1_e2_ni_nof2_0(__syn_smv___e1_e2_ni_nof2_0_e1_e2_ni_nof2_0, (x.m_c[0] + y.m_c[0]), (y.m_c[1] + x.m_c[1]), (x.m_c[2] + y.m_c[2]));
    }
    inline freeVector gp(const __syn_smv___e1_e2_ni& x, const __ni_ct__& y) {
        return freeVector(freeVector_e1ni_e2ni, x.m_c[0], x.m_c[1]);
    }
    inline __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni gp(const __syn_smv___scalar_noe1_noe2_noni& x, const __syn_smv___e1_e2_ni& y) {
        return __syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni(__syn_smv___no_e1_e2_noe1e2_ni_noe1ni_noe2ni_no_e1_e2_noe1e2_ni_noe1ni_noe2ni, ((x.m_c[2] * y.m_c[1]) + (x.m_c[1] * y.m_c[0])), ((x.m_c[0] * y.m_c[0]) + (x.m_c[1] * y.m_c[2])), ((x.m_c[2] * y.m_c[2]) + (x.m_c[0] * y.m_c[1])), ((x.m_c[1] * y.m_c[1]) + (-1.0f * x.m_c[2] * y.m_c[0])), ((x.m_c[0] * y.m_c[2]) + (x.m_c[3] * y.m_c[2])), ((x.m_c[1] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[0])), ((x.m_c[2] * y.m_c[2]) + (-1.0f * x.m_c[3] * y.m_c[1])));
    }
    inline e2_t gp(const scalar& x, const __e2_ct__& y) {
        return e2_t(e2_t_e2, x.m_c[0]);
    }
    inline __syn_smv___scalar_e1e2_e1ni gp(const __syn_smv___e1_e2_ni& x, const __e1_ct__& y) {
        return __syn_smv___scalar_e1e2_e1ni(__syn_smv___scalar_e1e2_e1ni_scalar_e1e2_e1ni, x.m_c[0], (-1.0f * x.m_c[1]), (-1.0f * x.m_c[2]));
    }









} // end of namespace c2ga
// post_h_include


#endif //  _GA_c2ga_h_H_