private static void WriteDefinition(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // assume only SMV constants for now G25.SMV smv = C.Type as G25.SMV; ConstantSMV Csmv = C as ConstantSMV; string className = FT.GetMangledName(S, smv.Name); // MANGLED_TYPENAME MANGLED_CONSTANT_NAME = {...} SB.Append(className); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); if (smv.NbNonConstBasisBlade > 0) { // MANGLED_TYPENAME MANGLED_CONSTANT_NAME(...) SB.Append("(" + className + "::" + G25.CG.Shared.SmvUtil.GetCoordinateOrderConstant(S, smv)); for (int c = 0; c < smv.NbNonConstBasisBlade; c++) { SB.Append(", "); SB.Append(FT.DoubleToString(S, Csmv.Value[c])); } SB.Append(")"); } SB.AppendLine(";"); }
private static void WriteDefinition(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // assume only SMV constants for now G25.SMV smv = C.Type as G25.SMV; ConstantSMV Csmv = C as ConstantSMV; string className = FT.GetMangledName(S, smv.Name); // MANGLED_TYPENAME MANGLED_CONSTANT_NAME = {...} SB.Append(className); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); if (smv.NbNonConstBasisBlade > 0) { // MANGLED_TYPENAME MANGLED_CONSTANT_NAME(...) SB.Append("(" + className + "::" + G25.CG.Shared.SmvUtil.GetCoordinateOrderConstant(S, smv)); for (int c = 0; c < smv.NbNonConstBasisBlade; c++) { SB.Append(", "); SB.Append(FT.DoubleToString(S, Csmv.Value[c])); } SB.Append(")"); } SB.AppendLine(";"); }
/// <summary> /// Writes constructors of a SOM class to 'SB'. /// </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 'SOM'.</param> /// <param name="som">The specialized outermorphism for which the class should be written.</param> /// <param name="rangeVectorSMVname">The name of the SMV which can represent a column of the OM.</param> public static void WriteConstructors(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som, string rangeVectorSMVname) { string className = FT.GetMangledName(S, som.Name); string gomClassName = (S.m_GOM == null) ? "" : FT.GetMangledName(S, S.m_GOM.Name); cgd.m_cog.EmitTemplate(SB, "SOMconstructors", "S=", S, "FT=", FT, "som=", som, "className=", className, "gomClassName=", gomClassName, "rangeVectorSMVname=", rangeVectorSMVname); }
private static void WriteDefinition(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // assume only SMV constants for now G25.SMV smv = C.Type as G25.SMV; ConstantSMV Csmv = C as ConstantSMV; // MANGLED_TYPENAME MANGLED_CONSTANT_NAME = {...} SB.Append(FT.GetMangledName(S, C.Type.GetName())); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); SB.Append(" = {"); if (smv.NbNonConstBasisBlade == 0) { // 'C' does not allow empty structs, so there is a filler that must be initialized SB.Append("0"); } else { if (S.m_coordStorage == COORD_STORAGE.ARRAY) SB.Append("{"); for (int c = 0; c < smv.NbNonConstBasisBlade; c++) { if (c > 0) SB.Append(", "); SB.Append(FT.DoubleToString(S, Csmv.Value[c])); } if (S.m_coordStorage == COORD_STORAGE.ARRAY) SB.Append("}"); } SB.AppendLine("};"); }
/// <summary> /// Writes the definition of an GOM 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 'GOM'.</param> /// <param name="gom">The general outermorphism for which the struct should be written.</param> public static void WriteGOMclass(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GOM gom) { SB.AppendLine(""); string className = FT.GetMangledName(S, gom.Name); // get range vector type G25.SMV rangeVectorType = G25.CG.Shared.OMinit.getRangeVectorType(S, FT, cgd, gom); string rangeVectorSMVname = FT.GetMangledName(S, rangeVectorType.Name); WriteComment(SB, S, cgd, FT, gom); // typedef SB.AppendLine("class " + className); SB.AppendLine("{"); // member vars WriteMemberVariables(SB, S, cgd, FT, gom); SB.AppendLine("public:"); // Float type WriteFloatType(SB, S, cgd, FT, gom, className); // constructors WriteConstructors(SB, S, cgd, FT, gom, className, rangeVectorSMVname); // operator= WriteAssignmentOps(SB, S, cgd, FT, gom, className, rangeVectorSMVname); // set(...) WriteSetDeclarations(SB, S, cgd, FT, gom, className, rangeVectorSMVname); SB.AppendLine("}; // end of " + className); }
/// <summary> /// Generates a source file with the GOM class definition. /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <returns></returns> public static string GenerateCode(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT) { G25.GOM gom = S.m_GOM; string className = FT.GetMangledName(S, gom.Name); // get range vector type G25.SMV rangeVectorType = G25.CG.Shared.OMinit.GetRangeVectorType(S, FT, cgd, gom); string rangeVectorSMVname = FT.GetMangledName(S, rangeVectorType.Name); // get filename, list of generated filenames List<string> generatedFiles = new List<string>(); string sourceFilename = MainGenerator.GetClassOutputPath(S, className); generatedFiles.Add(sourceFilename); // get StringBuilder where all generated code goes StringBuilder SB = new StringBuilder(); // get a new 'cgd' where all ouput goes to the one StringBuilder SB cgd = new G25.CG.Shared.CGdata(cgd, SB, SB, SB); // output license, copyright G25.CG.Shared.Util.WriteCopyright(SB, S); G25.CG.Shared.Util.WriteLicense(SB, S); // open namespace G25.CG.Shared.Util.WriteOpenNamespace(SB, S); // write class comment G25.CG.CSJ.GOM.WriteComment(SB, S, cgd, FT, gom); // open class G25.CG.Shared.Util.WriteOpenClass(SB, S, G25.CG.Shared.AccessModifier.AM_public, className, null, null); // write member variables G25.CG.CSJ.GOM.WriteMemberVariables(SB, S, cgd, FT, gom); // write constructors G25.CG.CSJ.GOM.WriteConstructors(SB, S, cgd, FT, gom, className, rangeVectorSMVname); // write set functions G25.CG.CSJ.GOM.WriteSetIdentity(SB, S, cgd, FT); G25.CG.CSJ.GOM.WriteSetCopy(SB, S, cgd, FT); G25.CG.CSJ.GOM.WriteSetVectorImages(S, cgd, FT, false, false); // false, false = matrixMode, transpose G25.CG.CSJ.GOM.WriteSetVectorImages(S, cgd, FT, true, false); // true, false = matrixMode, transpose G25.CG.CSJ.GOM.WriteSOMtoGOMcopy(S, cgd, FT); // write shortcuts for functions G25.CG.Shared.Shortcut.WriteFunctionShortcuts(SB, S, cgd, FT, gom); // close class G25.CG.Shared.Util.WriteCloseClass(SB, S, className); // close namespace G25.CG.Shared.Util.WriteCloseNamespace(SB, S); // write all to file G25.CG.Shared.Util.WriteFile(sourceFilename, SB.ToString()); return sourceFilename; }
/// <summary> /// Writes the declaration/definitions of 'F' to StringBuffer 'SB', taking into account parameters specified in specification 'S'. /// </summary> public override void WriteFunction() { StringBuilder declSB = m_cgd.m_declSB; bool inline = false; // never inline GMV functions StringBuilder defSB = (inline) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string funcName = FT.GetMangledName(m_specification, m_fgs.OutputName); m_funcName[FT.type] = funcName; // setup hashtable with template arguments: System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["functionName"] = funcName; argTable["FT"] = FT; argTable["mvType"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["randomScalarFuncName"] = m_randomScalarFunc[floatName]; argTable["gpopFuncName"] = m_gpopFunc[floatName]; argTable["normFuncName"] = m_normFunc[floatName]; argTable["gpScalarFuncName"] = m_scalarGpFunc[floatName]; argTable["generatorVersor"] = (IsVersor(m_fgs) ? true : false); if (m_specification.OutputCppOrC()) { // header m_cgd.m_cog.EmitTemplate(declSB, "randomBladeVersorHeader", argTable); } // source m_cgd.m_cog.EmitTemplate(defSB, "randomBladeVersor", argTable); } } // end of WriteFunction
} // end of CheckTestingDepencies() /// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); if (m_trueGmvFunc) // GMV test { testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomVersorFuncName"] = m_randomVersorFuncName[FT.type]; argTable["subtractFuncName"] = m_subtractGmvFuncName[FT.type]; argTable["gpFuncName"] = m_gpFuncName[FT.type]; argTable["versorInverseFuncName"] = m_versorInverseFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testIGP_GMV", argTable); } else if ((m_smv1 != null) && (m_smv2 != null) && m_smv1.CanConvertToGmv(m_specification) && m_smv2.CanConvertToGmv(m_specification) && (m_specification.GetType(m_fgs.m_returnTypeName) as G25.MV).CanConvertToGmv(m_specification)) { // SMV test testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["smv1"] = m_smv1; argTable["smv2"] = m_smv2; argTable["smv1Name"] = FT.GetMangledName(m_specification, m_smv1.Name); argTable["smv2Name"] = FT.GetMangledName(m_specification, m_smv2.Name); argTable["smvRName"] = FT.GetMangledName(m_specification, m_fgs.m_returnTypeName); argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomSmv1FuncName"] = m_randomSmv1FuncName[FT.type]; argTable["randomSmv2FuncName"] = m_randomSmv2FuncName[FT.type]; argTable["gpFuncName"] = m_gpFuncName[FT.type]; argTable["subtractFuncName"] = m_subtractGmvFuncName[FT.type]; argTable["versorInverseFuncName"] = m_versorInverseFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testIGP_SMV", argTable); } } return(testFuncNames); } // end of WriteTestFunction()
/// <summary> /// Writes constructors. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> public static void WriteConstructors(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { cgd.m_cog.EmitTemplate(SB, "SMVconstructors", "S=", S, "smv=", smv, "className=", FT.GetMangledName(S, smv.Name), "gmvClassName=", FT.GetMangledName(S, S.m_GMV.Name), "FT=", FT); }
/// <summary> /// Writes set functions.. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> public static void WriteSetDeclarations(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { cgd.m_cog.EmitTemplate(SB, "SMVsetDecl", "S=", S, "smv=", smv, "className=", FT.GetMangledName(S, smv.Name), "gmvClassName=", FT.GetMangledName(S, S.m_GMV.Name), "FT=", FT); }
private static void WriteDeclaration(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // extern MANGLED_TYPENAME MANGLED_CONSTANT_NAME; if (C.Comment.Length > 0) SB.AppendLine("/** " + C.Comment + " */"); SB.Append("extern "); SB.Append(FT.GetMangledName(S, C.Type.GetName())); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); SB.AppendLine(";"); }
private static void WriteDeclaration(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // extern MANGLED_TYPENAME MANGLED_CONSTANT_NAME; if (C.Comment.Length > 0) { SB.AppendLine("/** " + C.Comment + " */"); } SB.Append("extern "); SB.Append(FT.GetMangledName(S, C.Type.GetName())); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); SB.AppendLine(";"); }
private static void WriteExplicitConverterCSharp(StringBuilder SB, Specification S, FloatType FT, G25.fgs fgs, SMV srcSmv, SMV dstSmv) { string srcTypeName = FT.GetMangledName(S, srcSmv.GetName()); string dstTypeName = FT.GetMangledName(S, dstSmv.GetName()); string argName = "x"; string extraComment = null; Comment comment = GetComment(S, srcTypeName, dstTypeName, argName, extraComment); comment.Write(SB, S, 1); SB.AppendLine("\tpublic static explicit operator " + dstTypeName + " (" + srcTypeName + " " + argName + ") {"); SB.AppendLine("\t\treturn " + S.m_namespace + "." + FT.GetMangledName(S, fgs.m_outputName) + /*dstTypeName*/ "(" + argName + ");"); SB.AppendLine("\t}"); }
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); if (m_gmvFunc) // GMV test { testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["euclideanBasisVectorBitmap"] = m_G25M.GetEuclideanBasisVectorBitmap(); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomBladeFuncName"] = m_randomBladeFuncName[FT.type]; argTable["opGmvFunc"] = m_opFuncName[FT.type]; argTable["expGmvFunc"] = m_expFuncName[FT.type]; argTable["subtractGmvFuncName"] = m_subtractGmvFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testEuclideanLogGMV", argTable); } else if ((m_smv != null) && m_smv.CanConvertToGmv(m_specification)) // SMV test { testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["rotorType"] = m_smv; argTable["rotorName"] = FT.GetMangledName(m_specification, m_smv.Name); argTable["bivectorName"] = FT.GetMangledName(m_specification, m_fgs.m_returnTypeName); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomBivectorFuncName"] = m_randomBivectorFuncName[FT.type]; argTable["expBivectorFunc"] = m_expBivectorFuncName[FT.type]; argTable["subtractRotorFuncName"] = m_subtractRotorFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testEuclideanLogSMV", argTable); } } return(testFuncNames); } // end of WriteTestFunction()
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); if (m_gmvFunc) // GMV test { testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomBladeFuncName"] = m_randomBladeFuncName[FT.type]; argTable["reverseFuncName"] = m_reverseFuncName[FT.type]; argTable["spFuncName"] = m_spFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testUnitGMV", argTable); } else if ((m_smv != null) && m_smv.CanConvertToGmv(m_specification)) // SMV test { testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["smv"] = m_smv; argTable["smvName"] = FT.GetMangledName(m_specification, m_smv.Name); argTable["resultSmvName"] = FT.GetMangledName(m_specification, m_fgs.m_returnTypeName); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["randomSmvFuncName"] = m_randomSmvFuncName[FT.type]; argTable["reverseFuncName"] = m_reverseFuncName[FT.type]; argTable["spFuncName"] = m_spFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testUnitSMV", argTable); } } return(testFuncNames); } // end of WriteTestFunction()
/// <summary> /// Writes a shortcut for 'type', 'fgs'. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'type'.</param> /// <param name="type">The type for which shortcuts should be written.</param> /// <param name="fgs"></param> /// <param name="FAI"></param> public static void WriteFunctionShortcut(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.VariableType type, G25.fgs fgs, FuncArgInfo[] FAI) { int nbTabs = 1; FuncArgInfo[] tailFAI = getTail(FAI); string shortcutCall = getShortcutCall(S, fgs, tailFAI); SB.AppendLine(""); // output comment new Comment("shortcut to " + shortcutCall).Write(SB, S, nbTabs); bool inline = false; bool staticFunc = false; string returnType = FT.GetMangledName(S, fgs.ReturnTypeName); FuncArgInfo returnArgument = null; SB.Append('\t', nbTabs); Functions.WriteDeclaration(SB, S, cgd, inline, staticFunc, returnType, fgs.OutputName, returnArgument, tailFAI); SB.AppendLine(" {"); SB.Append('\t', nbTabs+1); SB.Append("return "); SB.Append(shortcutCall); SB.AppendLine(";"); SB.Append('\t', nbTabs); SB.AppendLine("}"); }
/// <summary> /// Writes a shortcut for 'type', 'fgs'. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'type'.</param> /// <param name="type">The type for which shortcuts should be written.</param> /// <param name="fgs"></param> /// <param name="FAI"></param> public static void WriteFunctionShortcut(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.VariableType type, G25.fgs fgs, FuncArgInfo[] FAI) { int nbTabs = 1; FuncArgInfo[] tailFAI = getTail(FAI); string shortcutCall = getShortcutCall(S, fgs, tailFAI); SB.AppendLine(""); // output comment new Comment("shortcut to " + shortcutCall).Write(SB, S, nbTabs); bool inline = false; bool staticFunc = false; string returnType = FT.GetMangledName(S, fgs.ReturnTypeName); FuncArgInfo returnArgument = null; SB.Append('\t', nbTabs); Functions.WriteDeclaration(SB, S, cgd, inline, staticFunc, returnType, fgs.OutputName, returnArgument, tailFAI); SB.AppendLine(" {"); SB.Append('\t', nbTabs + 1); SB.Append("return "); SB.Append(shortcutCall); SB.AppendLine(";"); SB.Append('\t', nbTabs); SB.AppendLine("}"); }
/// <summary> /// This function should check the dependencies of this function. If dependencies are /// missing, the function can complain (throw exception) or fix it (add the required functions). /// /// If changes are made to the specification then it must be locked first because /// multiple threads run in parallel which may all modify the specification! /// </summary> public override void CheckDepencies() { string GMVname = m_specification.m_GMV.Name; // check dependencies for all float types foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); m_GMVname[floatName] = FT.GetMangledName(m_specification, GMVname); //bool returnTrueName = false; m_randomScalarFunc[floatName] = G25.CG.Shared.Dependencies.GetDependency(m_specification, m_cgd, RandomScalar.RANDOM + floatName, new string[0], floatName, FT, null); //if (m_specification.m_outputLanguage != OUTPUT_LANGUAGE.C) // m_randomScalarFunc[floatName] = FT.GetMangledName(m_specification, m_randomScalarFunc[floatName]); m_normFunc[floatName] = G25.CG.Shared.Dependencies.GetDependency(m_specification, m_cgd, "norm", new string[] { GMVname }, FT, m_G25M.m_name) + G25.CG.Shared.CANSparts.RETURNS_SCALAR; m_scalarGpFunc[floatName] = G25.CG.Shared.Dependencies.GetDependency(m_specification, m_cgd, "gp", new string[] { GMVname, floatName }, FT, null); // null = no metric for op required if (IsBlade(m_fgs)) { m_gpopFunc[floatName] = G25.CG.Shared.Dependencies.GetDependency(m_specification, m_cgd, "op", new string[] { GMVname, GMVname }, FT, null); // null = no metric for op required } else if (IsVersor(m_fgs)) { m_gpopFunc[floatName] = G25.CG.Shared.Dependencies.GetDependency(m_specification, m_cgd, "gp", new string[] { GMVname, GMVname }, FT, m_G25M.m_name); } } }
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["gmv"] = m_specification.m_GMV; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["targetFuncReturnsFloat"] = m_specification.IsFloatType(m_fgs.ReturnTypeName); argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["reverseFuncName"] = m_reverseFuncName[FT.type]; argTable["gpFuncName"] = m_gpFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testRandomGMV", argTable); } return(testFuncNames); } // end of WriteTestFunction()
/// <summary> /// Writes a increment or decrement function. /// (not based on CASN parts code, but put here anyway). /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="increment"></param> public static string WriteIncrementFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, bool increment) { // setup instructions System.Collections.Generic.List <G25.CG.Shared.Instruction> I = new System.Collections.Generic.List <G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: string code = G25.CG.Shared.CANSparts.GetIncrementCode(S, cgd, FT, FAI, fgs.RETURN_ARG_NAME, increment); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); // setup return type and argument: string returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value } // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, CF.OutputName, returnArgument, FAI, I, comment); return(CF.OutputName); }
/// <summary> /// Writes any addition or subtraction function for general multivectors, /// based on CASN parts code. /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="funcType">ADD, SUB or HP</param> /// <returns>Full name of generated function.</returns> public static string WriteAddSubHpFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, G25.CG.Shared.CANSparts.ADD_SUB_HP_TYPE funcType) { // setup instructions System.Collections.Generic.List<G25.CG.Shared.Instruction> I = new System.Collections.Generic.List<G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: string code = G25.CG.Shared.CANSparts.GetAddSubtractHpCode(S, cgd, FT, funcType, FAI, fgs.RETURN_ARG_NAME); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); // setup return type and argument: string returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value string funcName = CF.OutputName; //if (S.OutputC()) // funcName = FT.GetMangledName(S, funcName); // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); return funcName; }
/// <summary> /// Writes 'set()' declarations of a GOM class to 'SB'. /// </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 'GOM'.</param> /// <param name="gom">The general outermorphism for which the class should be written.</param> /// <param name="className">Mangled name of GOM class.</param> /// <param name="rangeVectorSMVname">The name of the SMV which can represent a column of the OM.</param> public static void WriteSetDeclarations(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GOM gom, string className, string rangeVectorSMVname) { cgd.m_cog.EmitTemplate(SB, "GOMsetDecl", "S=", S, "FT=", FT, "className=", className, "rangeVectorSMVname=", rangeVectorSMVname); { // extra code for per-grade-per-basisblade functions to set OM from vectors SB.AppendLine("\tprivate:"); bool matrixMode = false; // this value is irrelevant at this point string typeName = FT.GetMangledName(S, gom.Name); string prefix = typeName + "::"; string[] funcNames = G25.CG.Shared.OMinit.GetSetFromLowerGradeFunctionNames(S, FT, matrixMode); for (int g = 1; g < gom.Domain.Length; g++) { for (int d = 0; d < gom.DomainForGrade(g).Length; d++) { string funcName = funcNames[g] + "_" + d; if (funcName.IndexOf(prefix) == 0) { funcName = funcName.Substring(prefix.Length); } SB.AppendLine("\tvoid " + funcName + "();"); } } SB.AppendLine("\tpublic:"); } }
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["cgaPointName"] = FT.GetMangledName(m_specification, m_fgs.m_returnTypeName); argTable["cgaPointType"] = m_specification.GetType(m_fgs.m_returnTypeName); if (IsFlatPointBased(m_specification, m_fgs, FT)) { argTable["flatPointName"] = FT.GetMangledName(m_specification, m_flatPointType.GetName()); argTable["opFuncName"] = m_opFuncName[FT.type]; argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["randomFpName"] = m_randomFlatPointFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testCgaPointFromFlatPoint", argTable); } else { argTable["coordBased"] = IsCoordBased(m_specification, m_fgs, FT); argTable["vectorBased"] = IsVectorBased(m_specification, m_fgs, FT); argTable["random"] = IsRandom(m_specification, m_fgs); argTable["vectorName"] = (m_vectorType == null) ? "not_set" : FT.GetMangledName(m_specification, m_vectorType.GetName()); argTable["randomVectorFuncName"] = m_randomVectorFuncName[FT.type]; argTable["spFuncName"] = m_spFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testCgaPoint", argTable); } } return(testFuncNames); } // end of WriteTestFunction()
public static void WriteSetCopy(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som) { StringBuilder declSB = cgd.m_declSB; StringBuilder defSB = (S.m_inlineSet) ? cgd.m_inlineDefSB : cgd.m_defSB; if (S.OutputC()) { declSB.AppendLine(); } defSB.AppendLine(); string typeName = FT.GetMangledName(S, som.Name); string funcName = GetFunctionName(S, typeName, "set", "_set"); bool mustCast = false; const int NB_ARGS = 1; string srcName = "src"; bool srcPtr = S.OutputC(); G25.fgs F = new G25.fgs(funcName, funcName, "", new String[] { som.Name }, new String[] { srcName }, new String[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo[] FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, F, NB_ARGS, FT, S.m_GMV.Name, computeMultivectorValue); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, som.Name, computeMultivectorValue); } // setup instructions List <G25.CG.Shared.Instruction> I = new List <G25.CG.Shared.Instruction>(); { int nbTabs = 1; mustCast = false; string dstName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool dstPtr = (S.OutputCppOrC()); bool declareDst = false; for (int g = 1; g < som.Domain.Length; g++) { for (int c = 0; c < som.DomainForGrade(g).Length; c++) { G25.SMVOM smvOM = som.DomainSmvForGrade(g)[c]; RefGA.Multivector srcValue = G25.CG.Shared.Symbolic.SMVtoSymbolicMultivector(S, smvOM, srcName, srcPtr); I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, srcValue, dstName, dstPtr, declareDst)); } } } Comment comment = new Comment("Copies " + typeName + ".");; bool writeDecl = (S.OutputC()); bool staticFunc = false; G25.CG.Shared.Functions.WriteFunction(S, cgd, F, S.m_inlineSet, staticFunc, "void", funcName, returnArgument, FAI, I, comment, writeDecl); }
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); if (m_gmvFunc) // GMV test { testFuncNames.Add(testFuncName); m_cgd.m_cog.EmitTemplate(defSB, "testZeroGMV", "S=", m_specification, "FT=", FT, "gmvName=", FT.GetMangledName(m_specification, m_specification.m_GMV.Name), "testFuncName=", testFuncName, "targetFuncName=", m_funcName[FT.type], "randomScalarFuncName=", m_randomScalarFuncName[FT.type], "randomVersorFuncName=", m_randomVersorFuncName[FT.type] ); } else if (m_smv != null) // SMV test { testFuncNames.Add(testFuncName); m_cgd.m_cog.EmitTemplate(defSB, "testZeroSMV", "S=", m_specification, "FT=", FT, "smv=", m_smv, "smvName=", FT.GetMangledName(m_specification, m_smv.Name), "testFuncName=", testFuncName, "targetFuncName=", m_funcName[FT.type], "randomScalarFuncName=", m_randomScalarFuncName[FT.type], "randomSmvFuncName=", m_randomSmvFuncName[FT.type] ); } } return(testFuncNames); }
/// <summary> /// Writes the testing function for 'F' to 'm_defSB'. /// The generated function returns success (1) or failure (0). /// </summary> /// <returns>The list of name name of the int() function which tests the function.</returns> public override List <string> WriteTestFunction() { StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; List <string> testFuncNames = new List <string>(); foreach (string floatName in m_fgs.FloatNames) { FloatType FT = m_specification.GetFloatType(floatName); if (m_smv1.CanConvertToGmv(m_specification) && m_smv2.CanConvertToGmv(m_specification)) { string testFuncName = Util.GetTestingFunctionName(m_specification, m_cgd, m_funcName[FT.type]); testFuncNames.Add(testFuncName); System.Collections.Hashtable argTable = new System.Collections.Hashtable(); argTable["S"] = m_specification; argTable["FT"] = FT; argTable["testFuncName"] = testFuncName; argTable["targetFuncName"] = m_funcName[FT.type]; argTable["squared"] = IsDistance2(m_fgs); argTable["gmvName"] = FT.GetMangledName(m_specification, m_specification.m_GMV.Name); argTable["arg1TypeName"] = FT.GetMangledName(m_specification, m_smv1.Name); argTable["arg2TypeName"] = FT.GetMangledName(m_specification, m_smv2.Name); argTable["cgaPointName"] = FT.GetMangledName(m_specification, m_cgaPointTypeName[FT.type]); argTable["cgaPointType"] = m_specification.GetType(m_cgaPointTypeName[FT.type]); argTable["sqrt"] = CodeUtil.OpNameToLangString(m_specification, FT, UnaryScalarOp.SQRT); argTable["fabs"] = CodeUtil.OpNameToLangString(m_specification, FT, UnaryScalarOp.ABS); argTable["randomScalarFuncName"] = m_randomScalarFuncName[FT.type]; argTable["c3gaPointFuncName"] = m_cgaPointFuncName[FT.type]; m_cgd.m_cog.EmitTemplate(defSB, "testCgaPointDistance", argTable); } } return(testFuncNames); } // end of WriteTestFunction()
private static void WriteDefinition(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Constant C) { // assume only SMV constants for now G25.SMV smv = C.Type as G25.SMV; ConstantSMV Csmv = C as ConstantSMV; // MANGLED_TYPENAME MANGLED_CONSTANT_NAME = {...} SB.Append(FT.GetMangledName(S, C.Type.GetName())); SB.Append(" "); SB.Append(FT.GetMangledName(S, C.Name)); SB.Append(" = {"); if (smv.NbNonConstBasisBlade == 0) { // 'C' does not allow empty structs, so there is a filler that must be initialized SB.Append("0"); } else { if (S.m_coordStorage == COORD_STORAGE.ARRAY) { SB.Append("{"); } for (int c = 0; c < smv.NbNonConstBasisBlade; c++) { if (c > 0) { SB.Append(", "); } SB.Append(FT.DoubleToString(S, Csmv.Value[c])); } if (S.m_coordStorage == COORD_STORAGE.ARRAY) { SB.Append("}"); } } SB.AppendLine("};"); }
} // end of WriteLargestCoordinateFunctions() /// <summary> /// Writes getters and setters for the SMV coordinates.. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> public static void WriteGetSetCoord(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { int nbTabs = 1; string className = FT.GetMangledName(S, smv.Name); // for variable coordinates: for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { RefGA.BasisBlade B = smv.NonConstBasisBlade(i); string name = smv.NonConstBasisBlade(i).ToLangString(S.m_basisVectorNames); string accessName = G25.CG.Shared.SmvUtil.GetCoordAccessString(S, smv, i); // get string getComment = "Returns the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + name + "() { return " + accessName + ";}"); // set string setComment = "Sets the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(setComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " void " + G25.CG.Shared.Main.SETTER_PREFIX + name + "(" + FT.type + " " + name + ") { " + accessName + " = " + name + ";}"); } // for constant coordinates: for (int i = 0; i < smv.NbConstBasisBlade; i++) { RefGA.BasisBlade B = smv.ConstBasisBlade(i); // get string getComment = "Returns the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + B.ToLangString(S.m_basisVectorNames) + "() { return " + FT.DoubleToString(S, smv.ConstBasisBladeValue(i)) + ";}"); } // write a getter for the scalar which returns 0 if no scalar coordinate is present if (smv.GetElementIdx(RefGA.BasisBlade.ONE) < 0) { RefGA.BasisBlade B = RefGA.BasisBlade.ONE; string getComment = "Returns the scalar coordinate (which is always 0)."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + B.ToLangString(S.m_basisVectorNames) + "() { return " + FT.DoubleToString(S, 0.0) + ";}"); } // getter for the coordinates (stored in array) if ((S.m_coordStorage == COORD_STORAGE.ARRAY) && (smv.NbNonConstBasisBlade > 0)) { string constantName = G25.CG.Shared.SmvUtil.GetCoordinateOrderConstant(S, smv); string COORD_ORDER = "coordOrder"; new G25.CG.Shared.Comment("Returns array of coordinates."). SetParamComment(COORD_ORDER, "pass the value '" + className + "." + constantName + "'"). Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + "[] c(" + G25.CG.Shared.SmvUtil.COORDINATE_ORDER_ENUM + " " + COORD_ORDER + ") { return m_c;}"); } }
/// <summary> /// Writes any code to extract a grade part. /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="gradeIdx">Grade to be selected (use -1 for user-specified).</param> public static string WriteGradeFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, int gradeIdx) { // setup instructions System.Collections.Generic.List <G25.CG.Shared.Instruction> I = new System.Collections.Generic.List <G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: const string GROUP_BITMAP_NAME = "groupBitmap"; string code = G25.CG.Shared.CANSparts.GetGradeCode(S, cgd, FT, gradeIdx, FAI, fgs.RETURN_ARG_NAME, GROUP_BITMAP_NAME); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); string funcName = CF.OutputName; //if (S.OutputC()) // funcName = FT.GetMangledName(S, funcName); // setup return type and argument: string returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value } //StringBuilder tmpSB = new StringBuilder(); // G25.CG.Shared.Functions.WriteFunction() writes to this SB first so we can add the grade index if required // write function G25.CG.Shared.CGdata tmpCgd = new G25.CG.Shared.CGdata(cgd); bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, tmpCgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); if (gradeIdx < 0) // hack: if grade is func arg, then add it: { // add extra argument (int) to select the grade //if (S.OutputCppOrC()) // tmpCgd.m_declSB = AddGradeArg(S, tmpCgd.m_declSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); //tmpCgd.m_defSB = AddGradeArg(S, tmpCgd.m_defSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); //tmpCgd.m_inlineDefSB = AddGradeArg(S, tmpCgd.m_inlineDefSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); } cgd.m_declSB.Append(tmpCgd.m_declSB); cgd.m_defSB.Append(tmpCgd.m_defSB); cgd.m_inlineDefSB.Append(tmpCgd.m_inlineDefSB); return(funcName); } // end of WriteGradeFunction()
/// <summary> /// Writes the definition of an GMV class 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 WriteGMVclass(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GMV gmv) { SB.AppendLine(""); WriteComment(SB, S, cgd, FT, gmv); string className = FT.GetMangledName(S, gmv.Name); SB.AppendLine("class " + className); SB.AppendLine("{"); WriteMemberVariables(SB, S, cgd, FT, gmv); SB.AppendLine("public:"); WriteFloatType(SB, S, cgd, FT, gmv, className); WriteConstructors(SB, S, cgd, FT, gmv, className); WriteAssignmentOperators(SB, S, cgd, FT, gmv, className); WriteSetDeclarations(SB, S, cgd, FT, gmv, className); WriteGetCoord(S, cgd, FT, SB); WriteSetCoord(S, cgd, FT, SB); WriteCompressExpandDeclarations(SB, S, cgd, FT, gmv, className); WriteLargestCoordinateDeclarations(SB, S, cgd, FT, gmv, className); // grade usage SB.AppendLine("\t/// returns grade/group."); SB.AppendLine("\tinline int gu() const {return m_gu;}"); WriteToString(SB, S, cgd, FT, gmv, className); // function which returns pointer to some array of zeros SB.AppendLine("public:"); SB.AppendLine("\tinline " + FT.type + " const *nullFloats() const {"); SB.AppendLine("\t\tstatic " + FT.type + " *nf = NULL;"); SB.AppendLine("\t\treturn (nf == NULL) ? (nf = new " + FT.type + "[" + S.m_GMV.NbCoordinates + "]) : nf;"); SB.AppendLine("\t}"); // function for setting grade/group usage, reallocting memory cgd.m_cog.EmitTemplate(SB, "GMVsetGroupUsage", "S=", S, "FT=", FT, "className=", className, "gmv=", gmv); // function for allocating a group cgd.m_cog.EmitTemplate(SB, "GMVallocateGroups", "S=", S, "FT=", FT, "className=", className, "gmv=", gmv); SB.AppendLine("}; // end of class " + className); } // end of WriteGMVclass()
/// <summary> /// Writes the <c>defines</c> for indices of the smv struct to 'SB'. For example, <c>define VECTOR_E1 0</c>. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names.</param> /// <param name="FT"></param> /// <param name="smv">The specialized multivector for which the coordinate indices should be written.</param> public static void WriteSMVcoordIndices(StringBuilder SB, Specification S, FloatType FT, G25.SMV smv) { string className = FT.GetMangledName(S, smv.Name); SB.AppendLine("\t/// Array indices of " + className + " coordinates."); SB.AppendLine("\ttypedef enum {"); for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { SB.AppendLine("\t\t/// index of coordinate for " + smv.NonConstBasisBlade(i).ToString(S.m_basisVectorNames) + " in " + className); SB.AppendLine("\t\t" + GetCoordIndexDefine(S, FT, smv, i) + " = " + i + ", "); } SB.AppendLine("\t} ArrayIndex;"); }
/// <summary> /// Writes any geometric product based product for general multivectors, /// based on gp parts code. /// </summary> /// <param name="SB"></param> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="M"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="declOnly"></param> /// <param name="productType"></param> /// <returns>name of generated function</returns> public static string WriteGMVgpFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Metric M, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, G25.CG.Shared.GPparts.ProductTypes productType) { // setup instructions System.Collections.Generic.List <G25.CG.Shared.Instruction> I = new System.Collections.Generic.List <G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: string code = G25.CG.Shared.GPparts.GetGPcode(S, cgd, FT, M, productType, FAI, fgs.RETURN_ARG_NAME); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); // setup return type and argument: string returnTypeName = null; G25.CG.Shared.FuncArgInfo returnArgument = null; if (productType == G25.CG.Shared.GPparts.ProductTypes.SCALAR_PRODUCT) { // return scalar returnTypeName = FT.type; } else { // return GMV (in C, via 'return argument') returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value } } string funcName = CF.OutputName; // FAI[0].MangledTypeName; //CF.ArgumentTypeNames[0] = CF.ArgumentTypeNames[0] + G25.CG.Shared.Main.IF_SUFFIX; // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); return(funcName); } // end of WriteGMVgpFunction
/// <summary> /// Writes a function to set an SOM struct/class to identity /// </summary> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Results go here. Also intermediate data for code generation. Also contains plugins and cog.</param> /// <param name="FT"></param> /// <param name="som"></param> public static void WriteSetIdentity(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som) { StringBuilder declSB = cgd.m_declSB; StringBuilder defSB = (S.m_inlineSet) ? cgd.m_inlineDefSB : cgd.m_defSB; if (S.OutputC()) { declSB.AppendLine(); } defSB.AppendLine(); string typeName = FT.GetMangledName(S, som.Name); string funcName = GetFunctionName(S, typeName, "setIdentity", "_setIdentity"); bool mustCast = false; G25.fgs F = new G25.fgs(funcName, funcName, "", null, null, new String[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, som.Name, computeMultivectorValue); } // setup instructions List <G25.CG.Shared.Instruction> I = new List <G25.CG.Shared.Instruction>(); { int nbTabs = 1; mustCast = false; string valueName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool valuePtr = S.OutputCppOrC(); bool declareValue = false; for (int g = 1; g < som.Domain.Length; g++) { for (int c = 0; c < som.DomainForGrade(g).Length; c++) { G25.SMVOM smvOM = som.DomainSmvForGrade(g)[c]; I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, new RefGA.Multivector(som.DomainForGrade(g)[c]), valueName, valuePtr, declareValue)); } } } Comment comment = new Comment("Sets " + typeName + " to identity."); bool writeDecl = S.OutputC(); bool staticFunc = false; G25.CG.Shared.Functions.WriteFunction(S, cgd, F, S.m_inlineSet, staticFunc, "void", funcName, returnArgument, new G25.CG.Shared.FuncArgInfo[0], I, comment, writeDecl); }
private static void WriteConvertingConstructor(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.fgs fgs, SMV srcSmv, SMV dstSmv) { string srcTypeName = FT.GetMangledName(S, srcSmv.GetName()); string dstTypeName = FT.GetMangledName(S, dstSmv.GetName()); string argName = "x"; Comment comment = new Comment("Converting constructor, from " + srcTypeName + " to " + dstTypeName); comment.Write(SB, S, 1); SB.AppendLine("\tpublic " + dstTypeName + "(" + srcTypeName + " " + argName + ") {"); int nbTabs = 2; bool declareVariable = false; bool cast = false; bool srcPtr = false; bool dstPtr = false; RefGA.Multivector value = Symbolic.SMVtoSymbolicMultivector(S, srcSmv, argName, srcPtr); AssignInstruction AI = new AssignInstruction(nbTabs, dstSmv, FT, cast, value, SmvUtil.THIS, dstPtr, declareVariable); AI.Write(SB, S, cgd); SB.AppendLine("\t}"); }
public static string[] GetSetFromLowerGradeFunctionNames(Specification S, FloatType FT, bool matrixMode) { G25.GOM gom = S.m_GOM; // generate function names for all grades (basis blade names not included) string typeName = FT.GetMangledName(S, gom.Name); string[] funcNames = new string[gom.Domain.Length]; for (int g = 1; g < gom.Domain.Length; g++) { string nameC = (g > 1) ? "_set" : ((matrixMode) ? "_setMatrix" : "_setVectorImages"); string suffix = (g > 1) ? ("_grade_" + g) : ""; funcNames[g] = GetFunctionName(S, typeName, "set" + suffix, nameC + suffix); } return(funcNames); }
} // end of WriteGMVigpFunction /// <summary> /// Writes any norm function for general multivectors, based on gp parts code. /// </summary> /// <param name="SB"></param> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="M"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="declOnly"></param> /// <param name="squared"></param> /// <returns>name of generated function.</returns> public static string WriteGMVnormFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Metric M, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, bool squared) { // setup instructions System.Collections.Generic.List <G25.CG.Shared.Instruction> I = new System.Collections.Generic.List <G25.CG.Shared.Instruction>(); int nbTabs = 1; // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); string funcName = CF.OutputName; // get return info G25.SMV returnType = null; string returnTypeName = null; G25.CG.Shared.FuncArgInfo returnArgument = null; { // try to get scalar type returnType = S.GetScalarSMV(); if (returnType == null) { returnTypeName = FT.type; } else { if (S.OutputC()) { returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, returnType.Name, false); // false = compute value } returnTypeName = FT.GetMangledName(S, returnType.GetName()); } } // write this function: string code = G25.CG.Shared.GPparts.GetNormCode(S, cgd, FT, M, squared, FAI, returnType, G25.fgs.RETURN_ARG_NAME); // add the verbatim code I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); return(funcName); } // end of WriteGMVnormFunction
/// <summary> /// Writes the <c>defines</c> for indices of the smv struct to 'SB'. For example, <c>define VECTOR_E1 0</c>. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names.</param> /// <param name="FT"></param> /// <param name="smv">The specialized multivector for which the coordinate indices should be written.</param> public static void WriteSMVcoordIndices(StringBuilder SB, Specification S, FloatType FT, G25.SMV smv) { string className = FT.GetMangledName(S, smv.Name); int nbTabs = 1; new G25.CG.Shared.Comment("Array indices of " + className + " coordinates.").Write(SB, S, nbTabs); string AccessModifier = Keywords.ConstAccessModifier(S); for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { SB.AppendLine(); new G25.CG.Shared.Comment("index of coordinate for " + smv.NonConstBasisBlade(i).ToString(S.m_basisVectorNames) + " in " + className).Write(SB, S, nbTabs); SB.AppendLine("\tpublic " + AccessModifier + " int " + GetCoordIndexDefine(S, FT, smv, i) + " = " + i + ";"); } }
public static void WriteSetMatrix(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som, bool transpose) { int NB_ARGS = 1; string[] argTypes = new string[NB_ARGS]; string[] argNames = new string[NB_ARGS]; argTypes[0] = FT.type; argNames[0] = "M"; // construct image values RefGA.Multivector[] imageValue = new RefGA.Multivector[som.DomainVectors.Length]; for (int d = 0; d < som.DomainVectors.Length; d++) { //imageValue[d] = RefGA.Multivector.ZERO; RefGA.BasisBlade[] IV = new RefGA.BasisBlade[som.RangeVectors.Length]; for (int r = 0; r < som.RangeVectors.Length; r++) { int matrixIdx = (transpose) ? (d * som.RangeVectors.Length + r) : (r * som.DomainVectors.Length + d); string entryName = argNames[0] + "[" + matrixIdx + "]"; IV[r] = new RefGA.BasisBlade(som.RangeVectors[r].bitmap, 1.0, entryName); } imageValue[d] = new RefGA.Multivector(IV); } string typeName = FT.GetMangledName(S, som.Name); string funcName = GetFunctionName(S, typeName, "set", "_setMatrix"); if (transpose) funcName = funcName + "Transpose"; //argNames[0] = "*" + argNames[0]; // quick hack: add pointer to name instead of type! G25.fgs F = new G25.fgs(funcName, funcName, "", argTypes, argNames, new String[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); if (S.OutputCppOrC()) F.m_argumentPtr[0] = true; else F.m_argumentArr[0] = true; bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo[] FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, F, NB_ARGS, FT, S.m_GMV.Name, computeMultivectorValue); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, som.Name, computeMultivectorValue); // setup instructions List<G25.CG.Shared.Instruction> I = new List<G25.CG.Shared.Instruction>(); { bool mustCast = false; int nbTabs = 1; string dstName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool dstPtr = S.OutputCppOrC(); bool declareDst = false; for (int g = 1; g < som.Domain.Length; g++) { for (int c = 0; c < som.DomainForGrade(g).Length; c++) { G25.SMVOM smvOM = som.DomainSmvForGrade(g)[c]; RefGA.BasisBlade domainBlade = som.DomainForGrade(g)[c]; RefGA.Multivector value = new RefGA.Multivector(new RefGA.BasisBlade(domainBlade, 0)); // copy the scalar part, ditch the basis blade for (uint v = 0; v < som.DomainVectors.Length; v++) { if ((domainBlade.bitmap & som.DomainVectors[v].bitmap) != 0) { value = RefGA.Multivector.op(value, imageValue[v]); } } I.Add(new G25.CG.Shared.CommentInstruction(nbTabs, "Set image of " + domainBlade.ToString(S.m_basisVectorNames))); I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, value, dstName, dstPtr, declareDst)); } } } Comment comment = new Comment("Sets " + typeName + " from a " + (transpose ? "transposed " : "") + "matrix."); bool writeDecl = (S.OutputC()); bool staticFunc = false; G25.CG.Shared.Functions.WriteFunction(S, cgd, F, S.m_inlineSet, staticFunc, "void", funcName, returnArgument, FAI, I, comment, writeDecl); }
/// <summary> /// Writes a function to set a GOM struct according to vector images, for all floating point types. /// </summary> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Results go here. Also intermediate data for code generation. Also contains plugins and cog.</param> /// <param name="FT">Float type.</param> /// <param name="matrixMode">When true, generates code for setting from matrix instead of vector images.</param> /// <param name="transpose">When this parameter is true and <c>matrixMode</c> is true, generates code for setting from transpose matrix.</param> public static void WriteSetVectorImages(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, bool matrixMode, bool transpose) { G25.GOM gom = S.m_GOM; // get the 'plan' on how to initialize all domain basis blades efficiently: uint[][][] plan = G25.CG.Shared.OMinit.ComputeOmInitFromVectorsPlan(S, gom); double[][] signs = G25.CG.Shared.OMinit.ComputeOmInitFromVectorsSigns(S, gom, plan); // get range vector type G25.SMV rangeVectorType = G25.CG.Shared.OMinit.GetRangeVectorType(S, FT, cgd, gom); // setup array of arguments, function specification, etc int NB_ARGS = (matrixMode) ? 1 : gom.DomainVectors.Length; string[] argTypes = new string[NB_ARGS], argNames = new string[NB_ARGS]; RefGA.Multivector[] symbolicBBvalues = new RefGA.Multivector[1 << S.m_dimension]; // symbolic basis blade values go here if (matrixMode) { argTypes[0] = FT.type; argNames[0] = "M"; // convert matrix columns to symbolic Multivector values for (int d = 0; d < gom.DomainVectors.Length; d++) { RefGA.BasisBlade[] IV = new RefGA.BasisBlade[gom.RangeVectors.Length]; for (int r = 0; r < gom.RangeVectors.Length; r++) { int matrixIdx = (transpose) ? (d * gom.RangeVectors.Length + r) : (r * gom.DomainVectors.Length + d); string entryName = argNames[0] + "[" + matrixIdx + "]"; IV[r] = new RefGA.BasisBlade(gom.RangeVectors[r].bitmap, 1.0, entryName); } symbolicBBvalues[gom.DomainVectors[d].bitmap] = new RefGA.Multivector(IV); } } else { for (int d = 0; d < NB_ARGS; d++) { argTypes[d] = rangeVectorType.Name; argNames[d] = "i" + gom.DomainVectors[d].ToLangString(S.m_basisVectorNames); bool ptr = S.OutputC(); symbolicBBvalues[gom.DomainVectors[d].bitmap] = G25.CG.Shared.Symbolic.SMVtoSymbolicMultivector(S, rangeVectorType, argNames[d], ptr); } } // generate function names for all grades (basis blade names not included) string typeName = FT.GetMangledName(S, gom.Name); string[] funcNames = GetSetFromLowerGradeFunctionNames(S, FT, matrixMode); // setup instructions (for main function, and subfunctions for grades) List<G25.CG.Shared.Instruction> mainI = new List<G25.CG.Shared.Instruction>(); List<G25.CG.Shared.Instruction>[] bladeI = new List<G25.CG.Shared.Instruction>[1 << S.m_dimension]; { bool mustCast = false; int nbTabs = 1; string dstName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool dstPtr = S.OutputCppOrC(); bool declareDst = false; for (int g = 1; g < gom.Domain.Length; g++) { for (int d = 0; d < gom.DomainForGrade(g).Length; d++) { G25.SMVOM smvOM = gom.DomainSmvForGrade(g)[d]; RefGA.BasisBlade domainBlade = gom.DomainForGrade(g)[d]; if (g > 1) { bladeI[domainBlade.bitmap] = new List<G25.CG.Shared.Instruction>(); string funcCallCode = funcNames[g] + "_" + d + "("; if (S.OutputC()) funcCallCode += G25.fgs.RETURN_ARG_NAME; funcCallCode += ");"; mainI.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, funcCallCode)); } // follow the plan RefGA.Multivector value = new RefGA.Multivector(signs[g][d]); uint[] P = plan[g][d]; for (int p = 0; p < P.Length; p++) value = RefGA.Multivector.op(value, symbolicBBvalues[P[p]]); // add instructions List<G25.CG.Shared.Instruction> I = (g == 1) ? mainI : bladeI[domainBlade.bitmap]; I.Add(new G25.CG.Shared.CommentInstruction(nbTabs, "Set image of " + domainBlade.ToString(S.m_basisVectorNames))); I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, value, dstName, dstPtr, declareDst)); // store symbolic value symbolicBBvalues[domainBlade.bitmap] = G25.CG.Shared.Symbolic.SMVtoSymbolicMultivector(S, smvOM, dstName, dstPtr); } } } // output grade > 1 functions if (cgd.generateOmInitCode(FT.type)) { for (int g = 2; g < gom.Domain.Length; g++) { for (int d = 0; d < gom.DomainForGrade(g).Length; d++) { RefGA.BasisBlade domainBlade = gom.DomainForGrade(g)[d]; string funcName = funcNames[g] + "_" + d; G25.fgs F = new G25.fgs(funcName, funcName, "", new string[0], new string[0], new string[] { FT.type }, null, null, null); // null, null = metricName, comment, options //F.InitArgumentPtrFromTypeNames(S); bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, gom.Name, computeMultivectorValue); int nbArgs = 0; G25.CG.Shared.FuncArgInfo[] FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, F, nbArgs, FT, S.m_GMV.Name, computeMultivectorValue); Comment comment; comment = new Comment("Sets grade " + g + " part of outermorphism matrix based on lower grade parts."); bool inline = false; // do not inline this potentially huge function bool staticFunc = false; bool writeDecl = S.OutputC(); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, "void", funcName, returnArgument, FAI, bladeI[domainBlade.bitmap], comment, writeDecl); } } } { // output grade 1 function G25.fgs F = new G25.fgs(funcNames[1], funcNames[1], "", argTypes, argNames, new string[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); if (matrixMode) { F.m_argumentPtr[0] = S.OutputCppOrC(); F.m_argumentArr[0] = S.OutputCSharpOrJava(); } bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, gom.Name, computeMultivectorValue); G25.CG.Shared.FuncArgInfo[] FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, F, NB_ARGS, FT, S.m_GMV.Name, computeMultivectorValue); Comment comment; if (!matrixMode) comment = new Comment("Sets " + typeName + " from images of the domain vectors."); else comment = new Comment("Sets " + typeName + " from a " + (transpose ? "transposed " : "") + "matrix"); bool inline = false; // do not inline this potentially huge function bool staticFunc = false; bool writeDecl = S.OutputC(); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, "void", funcNames[1], returnArgument, FAI, mainI, comment, writeDecl); } }
public static void WriteSetCopy(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som) { StringBuilder declSB = cgd.m_declSB; StringBuilder defSB = (S.m_inlineSet) ? cgd.m_inlineDefSB : cgd.m_defSB; if (S.OutputC()) declSB.AppendLine(); defSB.AppendLine(); string typeName = FT.GetMangledName(S, som.Name); string funcName = GetFunctionName(S, typeName, "set", "_set"); bool mustCast = false; const int NB_ARGS = 1; string srcName = "src"; bool srcPtr = S.OutputC(); G25.fgs F = new G25.fgs(funcName, funcName, "", new String[] { som.Name }, new String[] { srcName }, new String[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo[] FAI = G25.CG.Shared.FuncArgInfo.GetAllFuncArgInfo(S, F, NB_ARGS, FT, S.m_GMV.Name, computeMultivectorValue); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, som.Name, computeMultivectorValue); // setup instructions List<G25.CG.Shared.Instruction> I = new List<G25.CG.Shared.Instruction>(); { int nbTabs = 1; mustCast = false; string dstName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool dstPtr = (S.OutputCppOrC()); bool declareDst = false; for (int g = 1; g < som.Domain.Length; g++) { for (int c = 0; c < som.DomainForGrade(g).Length; c++) { G25.SMVOM smvOM = som.DomainSmvForGrade(g)[c]; RefGA.Multivector srcValue = G25.CG.Shared.Symbolic.SMVtoSymbolicMultivector(S, smvOM, srcName, srcPtr); I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, srcValue, dstName, dstPtr, declareDst)); } } } Comment comment = new Comment("Copies " + typeName + "."); ; bool writeDecl = (S.OutputC()); bool staticFunc = false; G25.CG.Shared.Functions.WriteFunction(S, cgd, F, S.m_inlineSet, staticFunc, "void", funcName, returnArgument, FAI, I, comment, writeDecl); }
/// <summary> /// Writes a function to set an SOM struct/class to identity /// </summary> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Results go here. Also intermediate data for code generation. Also contains plugins and cog.</param> /// <param name="FT"></param> /// <param name="som"></param> public static void WriteSetIdentity(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som) { StringBuilder declSB = cgd.m_declSB; StringBuilder defSB = (S.m_inlineSet) ? cgd.m_inlineDefSB : cgd.m_defSB; if (S.OutputC()) declSB.AppendLine(); defSB.AppendLine(); string typeName = FT.GetMangledName(S, som.Name); string funcName = GetFunctionName(S, typeName, "setIdentity", "_setIdentity"); bool mustCast = false; G25.fgs F = new G25.fgs(funcName, funcName, "", null, null, new String[] { FT.type }, null, null, null); // null, null = metricName, comment, options F.InitArgumentPtrFromTypeNames(S); bool computeMultivectorValue = false; G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, F, -1, FT, som.Name, computeMultivectorValue); // setup instructions List<G25.CG.Shared.Instruction> I = new List<G25.CG.Shared.Instruction>(); { int nbTabs = 1; mustCast = false; string valueName = (S.OutputC()) ? G25.fgs.RETURN_ARG_NAME : SmvUtil.THIS; bool valuePtr = S.OutputCppOrC(); bool declareValue = false; for (int g = 1; g < som.Domain.Length; g++) { for (int c = 0; c < som.DomainForGrade(g).Length; c++) { G25.SMVOM smvOM = som.DomainSmvForGrade(g)[c]; I.Add(new G25.CG.Shared.AssignInstruction(nbTabs, smvOM, FT, mustCast, new RefGA.Multivector(som.DomainForGrade(g)[c]), valueName, valuePtr, declareValue)); } } } Comment comment = new Comment("Sets " + typeName + " to identity."); bool writeDecl = S.OutputC(); bool staticFunc = false; G25.CG.Shared.Functions.WriteFunction(S, cgd, F, S.m_inlineSet, staticFunc, "void", funcName, returnArgument, new G25.CG.Shared.FuncArgInfo[0], I, comment, writeDecl); }
/// <summary> /// Writes the SMV class 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">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> /// <param name="emitCoordIndices">Whether to emit constants for array indices to coordinates.</param> public static void WriteSMVclass(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv, bool emitCoordIndices) { string className = FT.GetMangledName(S, smv.Name); SB.AppendLine(""); WriteComment(SB, S, cgd, FT, smv, emitCoordIndices); // typedef SB.AppendLine("class " + className); SB.AppendLine("{"); WriteMemberVariables(SB, S, cgd, FT, smv); SB.AppendLine("public:"); WriteFloatType(SB, S, cgd, FT, smv, className); if (emitCoordIndices) WriteSMVcoordIndices(SB, S, FT, smv); WriteCoordinateOrder(SB, S, FT, smv); WriteConstructors(SB, S, cgd, FT, smv); WriteAssignmentOperators(SB, S, cgd, FT, smv); WriteSetDeclarations(SB, S, cgd, FT, smv); WriteLargestCoordinateDeclarations(SB, S, cgd, FT, smv); WriteToString(SB, S, cgd, FT, smv); SB.AppendLine(""); WriteGetSetCoord(SB, S, cgd, FT, smv); SB.AppendLine("}; // end of class " + className); }
public static string[] GetSetFromLowerGradeFunctionNames(Specification S, FloatType FT, bool matrixMode) { G25.GOM gom = S.m_GOM; // generate function names for all grades (basis blade names not included) string typeName = FT.GetMangledName(S, gom.Name); string[] funcNames = new string[gom.Domain.Length]; for (int g = 1; g < gom.Domain.Length; g++) { string nameC = (g > 1) ? "_set" : ((matrixMode) ? "_setMatrix" : "_setVectorImages"); string suffix = (g > 1) ? ("_grade_" + g) : ""; funcNames[g] = GetFunctionName(S, typeName, "set" + suffix, nameC + suffix); } return funcNames; }
protected void WriteNormReturnsScalar(FloatType FT, G25.CG.Shared.FuncArgInfo[] FAI, String funcName, G25.SMV scalarSMV) { StringBuilder declSB = m_cgd.m_declSB; StringBuilder defSB = (m_specification.m_inlineFunctions) ? m_cgd.m_inlineDefSB : m_cgd.m_defSB; string inlineStr = G25.CG.Shared.Util.GetInlineString(m_specification, m_specification.m_inlineFunctions, " "); string refPtrStr = ""; if (m_specification.OutputC()) refPtrStr = "*"; else if (m_specification.OutputCpp()) refPtrStr = "&"; string ACCESS = ""; if (m_specification.OutputJava()) ACCESS = "public final static "; else if (m_specification.OutputCSharp()) ACCESS = "public static "; string VAR_MOD = ""; if (m_specification.OutputCppOrC()) VAR_MOD = "const "; if (m_specification.OutputJava()) VAR_MOD = "final "; string funcDecl = FT.type + " " + funcName + G25.CG.Shared.CANSparts.RETURNS_SCALAR + "(" + VAR_MOD + FAI[0].MangledTypeName + " " + refPtrStr + FAI[0].Name + ")"; string comment = "internal conversion function (this is just a pass through)"; int nbTabs = 0; if (m_specification.OutputCppOrC()) { new Comment(comment).Write(declSB, m_specification, nbTabs); declSB.Append(funcDecl); declSB.AppendLine(";"); } else new Comment(comment).Write(defSB, m_specification, nbTabs); defSB.Append(inlineStr + ACCESS + funcDecl); defSB.AppendLine(" {"); if (m_specification.OutputC()) { defSB.AppendLine("\t" + FT.GetMangledName(m_specification, scalarSMV.Name) + " tmp;"); defSB.AppendLine("\t" + funcName + "(&tmp, " + FAI[0].Name + ");"); } else if (m_specification.OutputCpp()) { defSB.AppendLine("\t" + FT.GetMangledName(m_specification, scalarSMV.Name) + " tmp(" + funcName + "(" + FAI[0].Name + "));"); } else { defSB.AppendLine("\t" + FT.GetMangledName(m_specification, scalarSMV.Name) + " tmp = " + funcName + "(" + FAI[0].Name + ");"); } string[] accessStr; { bool ptr = false; accessStr = G25.CG.Shared.CodeUtil.GetAccessStr(m_specification, scalarSMV, "tmp", ptr); } defSB.AppendLine("\treturn " + accessStr[0] + ";"); defSB.AppendLine("}"); }
/* /// <summary> /// Writes the function to get the array of coordinates. /// Does nothing when coordinate storage is not array based or when the type has no variable coordinates. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names.</param> /// <param name="FT"></param> /// <param name="smv">The specialized multivector for which the coordinate indices should be written.</param> public static void WriteGetCoordinates(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { if (S.m_coordStorage != COORD_STORAGE.ARRAY) return; if (smv.NbNonConstBasisBlade == 0) return; //string typeName = G25.CG.Shared.SmvUtil.COORDINATE_ORDER_ENUM; string constantName = G25.CG.Shared.SmvUtil.GetCoordinateOrderConstant(S, smv); cgd.m_cog.EmitTemplate(SB, "SMVgetCoords", "FT=", FT, "COORD_TYPE_STRING=", constantName); }*/ /// <summary> /// Writes the implementation of the multivector interface. /// </summary> /// <param name="SB"></param> /// <param name="S"></param> /// <param name="cgd">Results go here. Also intermediate data for code generation. Also contains plugins and cog.</param> /// <param name="FT"></param> public static void WriteMultivectorInterface(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { string gmvName = FT.GetMangledName(S, S.m_GMV.Name); cgd.m_cog.EmitTemplate(SB, "SMVmvInterfaceImpl", "gmvName=", gmvName); }
public static string GetMvInterfaceName(Specification S, FloatType FT) { return FT.GetMangledName(S, S.m_GMV.Name) + G25.CG.Shared.Main.IF_SUFFIX; }
/// <summary> /// Writes any norm function for general multivectors, based on gp parts code. /// </summary> /// <param name="SB"></param> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="M"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="declOnly"></param> /// <param name="squared"></param> /// <returns>name of generated function.</returns> public static string WriteGMVnormFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Metric M, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, bool squared) { // setup instructions System.Collections.Generic.List<G25.CG.Shared.Instruction> I = new System.Collections.Generic.List<G25.CG.Shared.Instruction>(); int nbTabs = 1; // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); string funcName = CF.OutputName; // get return info G25.SMV returnType = null; string returnTypeName = null; G25.CG.Shared.FuncArgInfo returnArgument = null; { // try to get scalar type returnType = S.GetScalarSMV(); if (returnType == null) { returnTypeName = FT.type; } else { if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, returnType.Name, false); // false = compute value returnTypeName = FT.GetMangledName(S, returnType.GetName()); } } // write this function: string code = G25.CG.Shared.GPparts.GetNormCode(S, cgd, FT, M, squared, FAI, returnType, G25.fgs.RETURN_ARG_NAME); // add the verbatim code I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); return funcName; }
/// <summary> /// Writes getters and setters for the SMV coordinates.. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> public static void WriteGetSetCoord(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv) { int nbTabs = 1; string className = FT.GetMangledName(S, smv.Name); // for variable coordinates: for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { RefGA.BasisBlade B = smv.NonConstBasisBlade(i); string name = smv.NonConstBasisBlade(i).ToLangString(S.m_basisVectorNames); string accessName = G25.CG.Shared.SmvUtil.GetCoordAccessString(S, smv, i); // get string getComment = "Returns the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + name + "() { return " + accessName + ";}"); // set string setComment = "Sets the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(setComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " void " + G25.CG.Shared.Main.SETTER_PREFIX + name + "(" + FT.type + " " + name + ") { " + accessName + " = " + name + ";}"); } // for constant coordinates: for (int i = 0; i < smv.NbConstBasisBlade; i++) { RefGA.BasisBlade B = smv.ConstBasisBlade(i); // get string getComment = "Returns the " + B.ToString(S.m_basisVectorNames) + " coordinate."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + B.ToLangString(S.m_basisVectorNames) + "() { return " + FT.DoubleToString(S, smv.ConstBasisBladeValue(i)) + ";}"); } // write a getter for the scalar which returns 0 if no scalar coordinate is present if (smv.GetElementIdx(RefGA.BasisBlade.ONE) < 0) { RefGA.BasisBlade B = RefGA.BasisBlade.ONE; string getComment = "Returns the scalar coordinate (which is always 0)."; new G25.CG.Shared.Comment(getComment).Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + " " + G25.CG.Shared.Main.GETTER_PREFIX + B.ToLangString(S.m_basisVectorNames) + "() { return " + FT.DoubleToString(S, 0.0) + ";}"); } // getter for the coordinates (stored in array) if ((S.m_coordStorage == COORD_STORAGE.ARRAY) && (smv.NbNonConstBasisBlade > 0)) { string constantName = G25.CG.Shared.SmvUtil.GetCoordinateOrderConstant(S, smv); string COORD_ORDER = "coordOrder"; new G25.CG.Shared.Comment("Returns array of coordinates."). SetParamComment(COORD_ORDER, "pass the value '" + className + "." + constantName + "'"). Write(SB, S, nbTabs); SB.AppendLine("\t" + Keywords.PublicAccessModifier(S) + " " + FT.type + "[] c(" + G25.CG.Shared.SmvUtil.COORDINATE_ORDER_ENUM + " " + COORD_ORDER + ") { return m_c;}"); } }
/// <summary> /// Writes functions to copy SMVs to GMVs /// </summary> /// <param name="SB">Where the output goes.</param> /// <param name="S"></param> /// <param name="cgd">Results go here. Also intermediate data for code generation. Also contains plugins and cog.</param> /// <param name="FT"></param> public static void WriteSMVtoGMVcopy(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT) { int nbTabs; G25.GMV gmv = S.m_GMV; bool gmvParityPure = (S.m_GMV.MemoryAllocationMethod == G25.GMV.MEM_ALLOC_METHOD.PARITY_PURE); //string dstClassName = FT.GetMangledName(S, gmv.Name); for (int s = 0; s < S.m_SMV.Count; s++) { G25.SMV smv = S.m_SMV[s]; // do not generate converter if the GMV cannot hold the type if (gmvParityPure && (!smv.IsParityPure())) continue; string srcClassName = FT.GetMangledName(S, smv.Name); SB.AppendLine(); nbTabs = 1; new G25.CG.Shared.Comment("sets this to " + srcClassName + " value.").Write(SB, S, nbTabs); string funcName = GetSetFuncName(S); string funcDecl = "\tpublic void " + funcName + "(" + srcClassName + " src)"; SB.Append(funcDecl); { SB.AppendLine(" {"); // get a dictionary which tells you for each basis blade of 'gmv' where it is in 'smv' Dictionary<Tuple<int, int>, Tuple<int, int>> D = G25.MV.GetCoordMap(smv, gmv); // convert SMV to symbolic Multivector: bool smvPtr = false; RefGA.Multivector value = G25.CG.Shared.Symbolic.SMVtoSymbolicMultivector(S, smv, "src", smvPtr); // find out which groups are present StringBuilder guSB = new StringBuilder(); int gu = 0; foreach (KeyValuePair<Tuple<int, int>, Tuple<int, int>> KVP in D) { int bit = 1 << KVP.Value.Value1; if ((gu & bit) == 0) { gu |= 1 << KVP.Value.Value1; if (guSB.Length > 0) guSB.Append("|"); guSB.Append("GroupBitmap.GROUP_" + KVP.Value.Value1); } } // generate the code to set group usage: SB.AppendLine("\t\t" + GetAllocateGroupsString(S) + "(" + guSB.ToString() + ");"); // a helper pointer string dstArrName = "ptr"; SB.AppendLine("\t\t" + FT.type + "[] " + dstArrName + ";"); // for each used group, generate the assignment code for (int g = 0; (1 << g) <= gu; g++) { if (((1 << g) & gu) != 0) { SB.AppendLine(); SB.AppendLine("\t\tptr = m_c[" + g + "];"); int dstBaseIdx = 0; bool mustCast = false; nbTabs = 2; bool writeZeros = true; string str = G25.CG.Shared.CodeUtil.GenerateGMVassignmentCode(S, FT, mustCast, gmv, dstArrName, g, dstBaseIdx, value, nbTabs, writeZeros); SB.Append(str); } } if (S.m_reportUsage) { SB.AppendLine("\t\tm_t = " + G25.CG.CSJ.GMV.SMV_TYPE + "." + G25.CG.Shared.ReportUsage.GetSpecializedConstantName(S, smv.Name) + ";"); } SB.AppendLine("\t}"); } } // end of loop over all SMVs }
/// <summary> /// Writes the <c>defines</c> for indices of the smv struct to 'SB'. For example, <c>define VECTOR_E1 0</c>. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names.</param> /// <param name="FT"></param> /// <param name="smv">The specialized multivector for which the coordinate indices should be written.</param> public static void WriteSMVcoordIndices(StringBuilder SB, Specification S, FloatType FT, G25.SMV smv) { string className = FT.GetMangledName(S, smv.Name); SB.AppendLine("\t/// Array indices of " + className + " coordinates."); SB.AppendLine("\ttypedef enum {"); for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { SB.AppendLine("\t\t/// index of coordinate for " + smv.NonConstBasisBlade(i).ToString(S.m_basisVectorNames) + " in " + className); SB.AppendLine("\t\t" + GetCoordIndexDefine(S, FT, smv, i) + " = " + i + ", "); } SB.AppendLine("\t} ArrayIndex;"); }
/// <summary> /// Writes the definition of an SOM 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="som">The general outermorphism for which the struct should be written.</param> public static void WriteSOMstruct(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som) { SB.AppendLine(""); { // comments for type: SB.AppendLine("/**"); SB.AppendLine(" * This struct can hold a specialized outermorphism."); SB.AppendLine(" * "); SB.AppendLine(" * The coordinates are stored in type " + FT.type + "."); SB.AppendLine(" * "); SB.AppendLine(" * There are " + som.Domain.Length + " matrices, one for each grade."); SB.AppendLine(" * The columns of these matrices are the range of the outermorphism."); SB.AppendLine(" * Matrices are stored in row-major order. So the coordinates of rows are stored contiguously."); for (int g = 1; g < som.Domain.Length; g++) // start at '1' in order to skip scalar grade { SB.Append(" * Domain grade " + g + ": "); for (int i = 0; i < som.DomainForGrade(g).Length; i++) { if (i > 0) SB.Append(", "); SB.Append(som.DomainForGrade(g)[i].ToString(S.m_basisVectorNames)); } SB.AppendLine("."); } SB.AppendLine(" * "); if (!som.DomainAndRangeAreEqual()) { for (int g = 1; g < som.Range.Length; g++) // start at '1' in order to skip scalar grade { SB.Append(" * Range grade " + g + ": "); for (int i = 0; i < som.RangeForGrade(g).Length; i++) { if (i > 0) SB.Append(", "); SB.Append(som.RangeForGrade(g)[i].ToString(S.m_basisVectorNames)); } SB.AppendLine("."); } } else SB.AppendLine(" * The range and domain are equal."); SB.AppendLine(" * "); SB.AppendLine(" */"); } // end of comment // typedef SB.AppendLine("typedef struct "); SB.AppendLine("{"); for (int g = 1; g < som.Domain.Length; g++) // start at '1' in order to skip scalar grade { if (!som.EmptyGrade(g)) { SB.AppendLine("\t/** Matrix for grade " + g + "; the size is " + som.DomainForGrade(g).Length + " x " + som.RangeForGrade(g).Length + " */"); SB.AppendLine("\t" + FT.type + " m" + g + "[" + som.DomainForGrade(g).Length * som.RangeForGrade(g).Length + "];"); } } SB.AppendLine("} " + FT.GetMangledName(S, som.Name) + ";"); }
/// <summary> /// Writes the SMV class comment 'SB'. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names and output language.</param> /// <param name="cgd">Not used yet.</param> /// <param name="FT">Float point type of 'SMV'.</param> /// <param name="smv">The specialized multivector for which the struct should be written.</param> /// <param name="emitCoordIndices">Whether to emit constants for array indices to coordinates.</param> public static void WriteComment(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SMV smv, bool emitCoordIndices) { SB.AppendLine("/**"); SB.AppendLine(" * This class can hold a specialized multivector of type " + FT.GetMangledName(S, smv.Name) + "."); SB.AppendLine(" * "); SB.AppendLine(" * The coordinates are stored in type " + FT.type + "."); SB.AppendLine(" * "); if (smv.NbNonConstBasisBlade > 0) { SB.AppendLine(" * The variable non-zero coordinates are:"); for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { SB.AppendLine(" * - coordinate " + smv.NonConstBasisBlade(i).ToString(S.m_basisVectorNames) + " (array index: " + GetCoordIndexDefine(S, FT, smv, i) + " = " + i + ")"); } } else SB.AppendLine(" * The type is constant."); SB.AppendLine(" * "); if (smv.NbConstBasisBlade > 0) { SB.AppendLine(" * The constant non-zero coordinates are:"); for (int i = 0; i < smv.NbConstBasisBlade; i++) SB.AppendLine(" * - " + smv.ConstBasisBlade(i).ToString(S.m_basisVectorNames) + " = " + smv.ConstBasisBladeValue(i).ToString()); } else SB.AppendLine(" * The type has no constant coordinates."); SB.AppendLine(" * "); if ((smv.Comment != null) && (smv.Comment.Length > 0)) { SB.AppendLine(" * "); SB.AppendLine(" * " + smv.Comment); } SB.AppendLine(" */"); }
/// <summary> /// Writes any code to extract a grade part. /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="gradeIdx">Grade to be selected (use -1 for user-specified).</param> public static string WriteGradeFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, int gradeIdx) { // setup instructions System.Collections.Generic.List<G25.CG.Shared.Instruction> I = new System.Collections.Generic.List<G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: const string GROUP_BITMAP_NAME = "groupBitmap"; string code = G25.CG.Shared.CANSparts.GetGradeCode(S, cgd, FT, gradeIdx, FAI, fgs.RETURN_ARG_NAME, GROUP_BITMAP_NAME); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); string funcName = CF.OutputName; //if (S.OutputC()) // funcName = FT.GetMangledName(S, funcName); // setup return type and argument: string returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); G25.CG.Shared.FuncArgInfo returnArgument = null; if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value //StringBuilder tmpSB = new StringBuilder(); // G25.CG.Shared.Functions.WriteFunction() writes to this SB first so we can add the grade index if required // write function G25.CG.Shared.CGdata tmpCgd = new G25.CG.Shared.CGdata(cgd); bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, tmpCgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); if (gradeIdx < 0) // hack: if grade is func arg, then add it: { // add extra argument (int) to select the grade //if (S.OutputCppOrC()) // tmpCgd.m_declSB = AddGradeArg(S, tmpCgd.m_declSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); //tmpCgd.m_defSB = AddGradeArg(S, tmpCgd.m_defSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); //tmpCgd.m_inlineDefSB = AddGradeArg(S, tmpCgd.m_inlineDefSB.ToString(), gradeIdx, GROUP_BITMAP_NAME); } cgd.m_declSB.Append(tmpCgd.m_declSB); cgd.m_defSB.Append(tmpCgd.m_defSB); cgd.m_inlineDefSB.Append(tmpCgd.m_inlineDefSB); return funcName; }
/// <summary> /// Writes the definition of an GMV class 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 WriteGMVclass(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GMV gmv) { SB.AppendLine(""); WriteComment(SB, S, cgd, FT, gmv); string className = FT.GetMangledName(S, gmv.Name); SB.AppendLine("class " + className); SB.AppendLine("{"); WriteMemberVariables(SB, S, cgd, FT, gmv); SB.AppendLine("public:"); WriteFloatType(SB, S, cgd, FT, gmv, className); WriteConstructors(SB, S, cgd, FT, gmv, className); WriteAssignmentOperators(SB, S, cgd, FT, gmv, className); WriteSetDeclarations(SB, S, cgd, FT, gmv, className); WriteGetCoord(S, cgd, FT, SB); WriteSetCoord(S, cgd, FT, SB); WriteCompressExpandDeclarations(SB, S, cgd, FT, gmv, className); WriteLargestCoordinateDeclarations(SB, S, cgd, FT, gmv, className); // grade usage SB.AppendLine("\t/// returns grade/group."); SB.AppendLine("\tinline int gu() const {return m_gu;}"); WriteToString(SB, S, cgd, FT, gmv, className); // function which returns pointer to some array of zeros SB.AppendLine("public:"); SB.AppendLine("\tinline " + FT.type + " const *nullFloats() const {"); SB.AppendLine("\t\tstatic " + FT.type + " *nf = NULL;"); SB.AppendLine("\t\treturn (nf == NULL) ? (nf = new " + FT.type + "[" + S.m_GMV.NbCoordinates + "]) : nf;"); SB.AppendLine("\t}"); // function for setting grade/group usage, reallocting memory cgd.m_cog.EmitTemplate(SB, "GMVsetGroupUsage", "S=", S, "FT=", FT, "className=", className, "gmv=", gmv); // function for allocating a group cgd.m_cog.EmitTemplate(SB, "GMVallocateGroups", "S=", S, "FT=", FT, "className=", className, "gmv=", gmv); SB.AppendLine("}; // end of class " + className); }
/// <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) + ";"); }
/// <summary> /// Generates a source file with the SMV class definition. /// </summary> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="smv"></param> /// <param name="FT"></param> /// <returns></returns> public static string GenerateCode(Specification S, G25.CG.Shared.CGdata cgd, G25.SMV smv, FloatType FT) { string className = FT.GetMangledName(S, smv.Name); // get filename, list of generated filenames List<string> generatedFiles = new List<string>(); string sourceFilename = MainGenerator.GetClassOutputPath(S, className); generatedFiles.Add(sourceFilename); // get StringBuilder where all generated code goes StringBuilder SB = new StringBuilder(); // get a new 'cgd' where all ouput goes to the one StringBuilder SB cgd = new G25.CG.Shared.CGdata(cgd, SB, SB, SB); // output license, copyright G25.CG.Shared.Util.WriteCopyright(SB, S); G25.CG.Shared.Util.WriteLicense(SB, S); // using ... Util.WriteGenericUsing(SB, S); // open namespace G25.CG.Shared.Util.WriteOpenNamespace(SB, S); // write class comment G25.CG.CSJ.SMV.WriteComment(SB, S, cgd, FT, smv); // open class string[] implements = new string[] { MvInterface.GetMvInterfaceName(S, FT) }; G25.CG.Shared.Util.WriteOpenClass(SB, S, G25.CG.Shared.AccessModifier.AM_public, className, null, implements); // member variables G25.CG.CSJ.SMV.WriteMemberVariables(SB, S, cgd, FT, smv); // indices into arrays G25.CG.CSJ.SMV.WriteSMVcoordIndices(SB, S, FT, smv); // special type to safeguard coordinates order in functions G25.CG.CSJ.SMV.WriteCoordinateOrder(SB, S, FT, smv); // write multivector interface implementation G25.CG.CSJ.SMV.WriteMultivectorInterface(SB, S, cgd, FT, smv); // write constructors G25.CG.CSJ.SMV.WriteConstructors(SB, S, cgd, FT, smv); // write set functions G25.CG.CSJ.SMV.WriteSetFunctions(SB, S, cgd, FT, smv); // write largest coordinate functions G25.CG.CSJ.SMV.WriteLargestCoordinateFunctions(S, cgd, FT, smv); // write 'ToString' functions G25.CG.CSJ.GMV.WriteToString(SB, S, cgd, FT, smv); // write get/set coords G25.CG.CSJ.SMV.WriteGetSetCoord(SB, S, cgd, FT, smv); // write shortcuts for functions G25.CG.Shared.Shortcut.WriteFunctionShortcuts(SB, S, cgd, FT, smv); // close class G25.CG.Shared.Util.WriteCloseClass(SB, S, className); // close namespace G25.CG.Shared.Util.WriteCloseNamespace(SB, S); // write all to file G25.CG.Shared.Util.WriteFile(sourceFilename, SB.ToString()); return sourceFilename; }
/// <summary> /// Writes constructors of a SOM class to 'SB'. /// </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 'SOM'.</param> /// <param name="som">The specialized outermorphism for which the class should be written.</param> /// <param name="rangeVectorSMVname">The name of the SMV which can represent a column of the OM.</param> public static void WriteConstructors(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.SOM som, string rangeVectorSMVname) { string className = FT.GetMangledName(S, som.Name); string gomClassName = (S.m_GOM == null) ? "" : FT.GetMangledName(S, S.m_GOM.Name); cgd.m_cog.EmitTemplate(SB, "SOMconstructors", "S=", S, "FT=", FT, "som=", som, "className=", className, "gomClassName=", gomClassName, "rangeVectorSMVname=", rangeVectorSMVname); }
/// <summary> /// Writes the definition of an GOM 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 'GOM'.</param> /// <param name="gom">The general outermorphism for which the struct should be written.</param> public static void WriteGOMclass(StringBuilder SB, Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.GOM gom) { SB.AppendLine(""); string className = FT.GetMangledName(S, gom.Name); // get range vector type G25.SMV rangeVectorType = G25.CG.Shared.OMinit.getRangeVectorType(S, FT, cgd, gom); string rangeVectorSMVname = FT.GetMangledName(S, rangeVectorType.Name); WriteComment(SB, S, cgd, FT, gom); // typedef SB.AppendLine("class " + className); SB.AppendLine("{"); // member vars WriteMemberVariables(SB, S, cgd, FT, gom); SB.AppendLine("public:"); // Float type WriteFloatType(SB, S, cgd, FT, gom, className); // constructors WriteConstructors(SB, S, cgd, FT, gom, className, rangeVectorSMVname); // operator= WriteAssignmentOps(SB, S, cgd, FT, gom, className, rangeVectorSMVname); // set(...) WriteSetDeclarations(SB, S, cgd, FT, gom, className, rangeVectorSMVname); SB.AppendLine("}; // end of " + className); }
/// <summary> /// Writes any geometric product based product for general multivectors, /// based on gp parts code. /// </summary> /// <param name="SB"></param> /// <param name="S"></param> /// <param name="cgd"></param> /// <param name="FT"></param> /// <param name="M"></param> /// <param name="FAI"></param> /// <param name="F"></param> /// <param name="comment"></param> /// <param name="declOnly"></param> /// <param name="productType"></param> /// <returns>name of generated function</returns> public static string WriteGMVgpFunction(Specification S, G25.CG.Shared.CGdata cgd, FloatType FT, G25.Metric M, G25.CG.Shared.FuncArgInfo[] FAI, G25.fgs F, Comment comment, G25.CG.Shared.GPparts.ProductTypes productType) { // setup instructions System.Collections.Generic.List<G25.CG.Shared.Instruction> I = new System.Collections.Generic.List<G25.CG.Shared.Instruction>(); int nbTabs = 1; // write this function: string code = G25.CG.Shared.GPparts.GetGPcode(S, cgd, FT, M, productType, FAI, fgs.RETURN_ARG_NAME); // add one instruction (verbatim code) I.Add(new G25.CG.Shared.VerbatimCodeInstruction(nbTabs, code)); // because of lack of overloading, function names include names of argument types G25.fgs CF = G25.CG.Shared.Util.AppendTypenameToFuncName(S, FT, F, FAI); // setup return type and argument: string returnTypeName = null; G25.CG.Shared.FuncArgInfo returnArgument = null; if (productType == G25.CG.Shared.GPparts.ProductTypes.SCALAR_PRODUCT) { // return scalar returnTypeName = FT.type; } else { // return GMV (in C, via 'return argument') returnTypeName = FT.GetMangledName(S, S.m_GMV.Name); if (S.OutputC()) returnArgument = new G25.CG.Shared.FuncArgInfo(S, CF, -1, FT, S.m_GMV.Name, false); // false = compute value } string funcName = CF.OutputName; // FAI[0].MangledTypeName; //CF.ArgumentTypeNames[0] = CF.ArgumentTypeNames[0] + G25.CG.Shared.Main.IF_SUFFIX; // write function bool inline = false; // never inline GMV functions bool staticFunc = Functions.OutputStaticFunctions(S); G25.CG.Shared.Functions.WriteFunction(S, cgd, F, inline, staticFunc, returnTypeName, funcName, returnArgument, FAI, I, comment); return funcName; }
/// <summary> /// Writes the <c>defines</c> for indices of the smv struct to 'SB'. For example, <c>define VECTOR_E1 0</c>. /// </summary> /// <param name="SB">Where the code goes.</param> /// <param name="S">Used for basis vector names.</param> /// <param name="FT"></param> /// <param name="smv">The specialized multivector for which the coordinate indices should be written.</param> public static void WriteSMVcoordIndices(StringBuilder SB, Specification S, FloatType FT, G25.SMV smv) { string className = FT.GetMangledName(S, smv.Name); int nbTabs = 1; new G25.CG.Shared.Comment("Array indices of " + className + " coordinates.").Write(SB, S, nbTabs); string AccessModifier = Keywords.ConstAccessModifier(S); for (int i = 0; i < smv.NbNonConstBasisBlade; i++) { SB.AppendLine(); new G25.CG.Shared.Comment("index of coordinate for " + smv.NonConstBasisBlade(i).ToString(S.m_basisVectorNames) + " in " + className).Write(SB, S, nbTabs); SB.AppendLine("\tpublic " + AccessModifier + " int " + GetCoordIndexDefine(S, FT, smv, i) + " = " + i + ";"); } }