C# G25.Group方法代码示例

        /// <summary>
        /// Returns the comment for a GMV class.
        /// </summary>
        /// <param name="S">Used for basis vector names and output language.</param>
        /// <param name="cgd">Intermediate data for code generation. Also contains plugins and cog.</param>
        /// <param name="FT">Float point type of 'GMV'.</param>
        /// <param name="gmv">The general multivector for which the class should be written.</param>
        public static Comment GetGmvComment(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GMV gmv)
        {
            StringBuilder SB = new StringBuilder();

            SB.AppendLine("This class can hold a general multivector.");
            SB.AppendLine("");

            SB.AppendLine("The coordinates are stored in type " + FT.type + ".");
            SB.AppendLine("");

            SB.AppendLine("There are " + gmv.NbGroups + " coordinate groups:");
            for (int g = 0; g < gmv.NbGroups; g++)
            {
                SB.Append("group " + g + ":");
                for (int i = 0; i < gmv.Group(g).Length; i++)
                {
                    if (i > 0) SB.Append(", ");
                    SB.Append(gmv.Group(g)[i].ToString(S.m_basisVectorNames));

                }
                if (gmv.Group(g).Length > 0)
                    SB.Append("  (grade " + gmv.Group(g)[0].Grade() + ")");

                SB.AppendLine(".");
            }
            SB.AppendLine("");

            switch (S.m_GMV.MemoryAllocationMethod)
            {
                case G25.GMV.MEM_ALLOC_METHOD.PARITY_PURE:
                    SB.AppendLine("" + (gmv.NbCoordinates / 2) + " " + FT.type + "s are allocated inside the struct ('parity pure').");
                    SB.AppendLine("Hence creating a multivector which needs more than that number of coordinates ");
                    SB.AppendLine("will result in unpredictable behaviour (buffer overflow).");
                    break;
                case G25.GMV.MEM_ALLOC_METHOD.FULL:
                    SB.AppendLine("" + gmv.NbCoordinates + " " + FT.type + "s are allocated inside the struct.");
                    break;
            }

            return new Comment(SB.ToString());
        }

        /// <summary>
        /// Takes a general multivector specification (G25.GMV) and converts it into a one symbolic multivector per group/grade part.
        /// 
        /// The symbolic weights of the multivector are the coordinates of the GMV, labelled according to 'gmvName'.
        /// Currently, the indices start at zero for each group.
        /// </summary>
        /// <param name="S">Specification of the algebra. Used for the access convention (. or ->) and for how to name the coordinates ([0] or e1, e2, e3).</param>
        /// <param name="gmv">The specification of the general multivector.</param>
        /// <param name="gmvName">Name the variable should have.</param>
        /// <param name="ptr">Is 'gmvName' a pointer? (not used currently)</param>
        /// <param name="groupIdx">Index of group/grade to convert (use -1 for all groups)</param>
        /// <returns></returns>
        public static RefGA.Multivector[] GMVtoSymbolicMultivector(Specification S, G25.GMV gmv, String gmvName, bool ptr, int groupIdx)
        {
            RefGA.Multivector[] R = new RefGA.Multivector[gmv.NbGroups];

            //String accessStr = (ptr) ? "->" : ".";

            for (int g = 0; g < gmv.NbGroups; g++) {
                if ((groupIdx >= 0) && (g != groupIdx)) continue; // only one group requested?

                RefGA.BasisBlade[] B = gmv.Group(g);
                RefGA.BasisBlade[] L = new RefGA.BasisBlade[B.Length];
                for (int i = 0; i < B.Length; i++)
                {
                    RefGA.BasisBlade b = B[i];
                    String fullCoordName = gmvName + "[" + i + "]";
                    // merge
                    L[i] = new RefGA.BasisBlade(b.bitmap, b.scale, fullCoordName);
                }
                R[g] = new RefGA.Multivector(L);
            }

            return R;
        }

        /// <summary>
        /// Writes the definition of an GMV struct to 'SB' (including comments).
        /// </summary>
        /// <param name="SB">Where the code goes.</param>
        /// <param name="S">Used for basis vector names and output language.</param>
        /// <param name="cgd">Intermediate data for code generation. Also contains plugins and cog.</param>
        /// <param name="FT">Float point type of 'SMV'.</param>
        /// <param name="gmv">The general multivector for which the struct should be written.</param>
        public static void WriteGMVstruct(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GMV gmv)
        {
            SB.AppendLine("");

            { // comments for type:
                SB.AppendLine("/**");
                SB.AppendLine(" * This struct can hold a general multivector.");
                SB.AppendLine(" * ");

                SB.AppendLine(" * The coordinates are stored in type " + FT.type + ".");
                SB.AppendLine(" * ");

                SB.AppendLine(" * There are " + gmv.NbGroups + " coordinate groups:");
                for (int g = 0; g < gmv.NbGroups; g++)
                {
                    SB.Append(" * group " + g + ":");
                    for (int i = 0; i < gmv.Group(g).Length; i++)
                    {
                        if (i > 0) SB.Append(", ");
                        SB.Append(gmv.Group(g)[i].ToString(S.m_basisVectorNames));

                    }
                    if (gmv.Group(g).Length > 0)
                        SB.Append("  (grade " + gmv.Group(g)[0].Grade() + ")");

                    SB.AppendLine(".");
                }
                SB.AppendLine(" * ");

                switch (S.m_GMV.MemoryAllocationMethod)
                {
                    case G25.GMV.MEM_ALLOC_METHOD.PARITY_PURE:
                        SB.AppendLine(" * " + (gmv.NbCoordinates / 2) + " " + FT.type + "s are allocated inside the struct ('parity pure').");
                        SB.AppendLine(" * Hence creating a multivector which needs more than that number of coordinates ");
                        SB.AppendLine(" * will result in unpredictable behaviour (buffer overflow).");
                        break;
                    case G25.GMV.MEM_ALLOC_METHOD.FULL:
                        SB.AppendLine(" * " + gmv.NbCoordinates + " " + FT.type + "s are allocated inside the struct.");
                        break;
                }

                SB.AppendLine(" */");
            } // end of comment

            // typedef
            SB.AppendLine("typedef struct ");
            SB.AppendLine("{");
            // group/grade usage
            SB.AppendLine("\t/** group/grade usage (a bitmap which specifies which groups/grades are stored in 'c', below). */");
            SB.AppendLine("\tint gu;");

            // coordinates
            switch (S.m_GMV.MemoryAllocationMethod)
            {
            //                        case G25.GMV.MEM_ALLOC_METHOD.DYNAMIC:
            //                          SB.AppendLine("\t" + FT.type + " *c; ///< the coordinates (array is allocated using realloc())");
            //                        break;
                case G25.GMV.MEM_ALLOC_METHOD.PARITY_PURE:
                    SB.AppendLine("\t/** The coordinates (note: parity pure). */");
                    SB.AppendLine("\t" + FT.type + " c[" + (gmv.NbCoordinates / 2) + "];");
                    break;
                case G25.GMV.MEM_ALLOC_METHOD.FULL:
                    SB.AppendLine("\t/** The coordinates (full). */");
                    SB.AppendLine("\t" + FT.type + " c[" + (gmv.NbCoordinates) + "];");
                    break;
            }

            // If we report non-optimized function usage, we need to know original type of GMVs:
            if (S.m_reportUsage)
            {
                SB.AppendLine("\t/** Specialized multivector type. Used to report about non-optimized function usage. */");
                SB.AppendLine("\tint t;");
            }

            SB.AppendLine("} " + FT.GetMangledName(S, gmv.Name) + ";");
        }

 /// <returns>Whether to negate group 'groupIdx' for sign toggle operation 'T'.</returns>
 private static bool NeedToNegate(G25.GMV gmv, int groupIdx, UnaryToggleSignType T)
 {
     switch (T)
     {
         case UnaryToggleSignType.NEGATE:
             return true;
         case UnaryToggleSignType.REVERSE:
             return (gmv.Group(groupIdx)[0].Reverse().scale / gmv.Group(groupIdx)[0].scale) < 0;
         case UnaryToggleSignType.GRADE_INVOLUTION:
             return (gmv.Group(groupIdx)[0].GradeInvolution().scale / gmv.Group(groupIdx)[0].scale) < 0;
         case UnaryToggleSignType.CLIFFORD_CONJUGATE:
             return (gmv.Group(groupIdx)[0].CliffordConjugate().scale / gmv.Group(groupIdx)[0].scale) < 0;
         default:
             return false;
     }
 }

        /// <summary>
        /// Returns an array of 'access strings' for a specific group of the general multivector. 
        /// Access strings are source code expressions that can be
        /// used to access the coordinates of one specific group of coordinates of <c>gmv</c>.
        /// </summary>
        /// <param name="S">Used for basis blade names, language, COORD_STORAGE , etc.</param>
        /// <param name="gmv">The specialized multivector for which access strings are generated.</param>
        /// <param name="gmvName">The variable name of the _array_ of float to be used in the access strings. 
        /// For example, specify <c>"A"</c> to get <c>"A[0]"</c> and so on.</param>
        /// <param name="groupIdx">Specifies for that group index the access strings should be generated.</param>
        /// <param name="baseIdx">Index of first coordinate of group (required for C# and Java)</param>
        /// <returns>Array of strings that can be used to access the coordinates of group <c>groupIdx</c> of the <c>gmv</c>.</returns>
        public static string[] GetAccessStr(Specification S, G25.GMV gmv, String gmvName, int groupIdx, int baseIdx)
        {
            string[] AL = new String[gmv.Group(groupIdx).Length];

            for (int i = 0; i < gmv.Group(groupIdx).Length; i++)
                AL[i] = gmvName + "[" + (baseIdx + i) + "]";

            return AL;
        }

        /// <summary>
        /// Generates the code to assign a multivector value (which may have symbolic coordinates) to one specific coordinate group of a multivector.
        /// </summary>
        /// <param name="S">Specification of algebra. Used to known names of basis vector, output language, access strings, etc.</param>
        /// <param name="FT">Floating point type of destination.</param>
        /// <param name="mustCast">set to true if a cast to 'FT' must be performed before assigned to 'dstName'.</param>
        /// <param name="dstGmv">Type of general multivector assigned to.</param>
        /// <param name="dstName">Name of specialized multivector assigned to.</param>
        /// <param name="dstGroupIdx">Write to which group in destination type?</param>
        /// <param name="dstBaseIdx">Base index of coordinate 0 of group (needed for C# and Java)</param>
        /// <param name="value">Multivector value to assign to the GMV. Must not contain basis blades inside the symbolic scalars.</param>
        /// <param name="nbTabs">Number of tabs to put before the code.</param>
        /// <param name="writeZeros">Some callers want to skip "= 0.0" assignments because they would be redundant. So they set this argument to true.</param>
        /// <returns>String of code for dstName = value;</returns>
        public static string GenerateGMVassignmentCode(Specification S, FloatType FT, bool mustCast,
            G25.GMV dstGmv, string dstName, int dstGroupIdx, int dstBaseIdx, RefGA.Multivector value, int nbTabs, bool writeZeros)
        {
            RefGA.BasisBlade[] BL = dstGmv.Group(dstGroupIdx);
            string[] accessStr = GetAccessStr(S, dstGmv, dstName, dstGroupIdx, dstBaseIdx);
            string[] assignedStr = GetAssignmentStrings(S, FT, mustCast, BL, value, writeZeros);

            return GenerateAssignmentCode(S, accessStr, assignedStr, nbTabs, writeZeros);
        }

        /// <summary>
        /// Converts a G25.SMV to an XML string representation.
        /// </summary>
        /// <param name="S"></param>
        /// <param name="smv"></param>
        /// <returns>XML string representation of 'smv'.</returns>
        public static string SMVtoXmlString(Specification S, G25.SMV smv)
        {
            StringBuilder SB = new StringBuilder();
            bool constant = smv.IsConstant() && (S.GetMatchingConstant(smv) != null);
            string name = smv.Name;

            // remove the extra constant suffix?
            if (constant && name.EndsWith(Specification.CONSTANT_TYPE_SUFFIX))
                name = name.Substring(0, name.Length - Specification.CONSTANT_TYPE_SUFFIX.Length);

            SB.Append("<" + XML_SMV);

            // name
            SB.Append(" " + XML_NAME + "=\"" + name + "\"");

            // constant?
            if (constant)
                SB.Append(" " + XML_CONST + "=\"" + XML_TRUE + "\"");

            // type
            SB.Append(" " + XML_TYPE + "=\"" + smv.MvTypeString + "\"");

            // end of XML_SMV tag
            SB.Append(">");

            { // emit coordinate order:
                string[] bvNames = (string[])S.m_basisVectorNames.ToArray();
                // loop over all basis blades
                for (int b = 0; b < smv.Group(0).Length; b++)
                {
                    if (b > 0) SB.Append(" ");
                    string bbStr = BasisBladeToString(smv.BasisBlade(0, b), bvNames);
                    SB.Append(bbStr);

                    // if constant, add '=....'
                    if (smv.IsCoordinateConstant(b))
                        SB.Append("=" + smv.ConstBasisBladeValue(smv.BladeIdxToConstBladeIdx(b)).ToString());
                }
                if (smv.Comment.Length > 0)
                    SB.Append("  <" + XML_COMMENT + ">" + smv.Comment + "</" + XML_COMMENT + ">");
            }

            SB.Append("</" + XML_SMV + ">\n");

            return SB.ToString();
        }