public override void Generate()
{
GenerateBladeFileStartCode();
var kvdimsText = new ListComposer(", ");
var basisnamesText = new ListComposer("," + Environment.NewLine);
var basisbladesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
kvdimsText.Add(CurrentFrame.KvSpaceDimension(grade));
basisnamesText.Add(GenerateBasisBladesNames(grade));
basisbladesText.Add(GenerateDeclarations(grade));
}
TextComposer.Append(
Templates["static"],
"frame", CurrentFrameName,
"grade", CurrentFrame.VSpaceDimension,
"double", GMacLanguage.ScalarTypeName,
"kvdims", kvdimsText,
"basisnames", basisnamesText,
"basisblades", basisbladesText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
private void GenerateMiscFunctions(int kvSpaceDim)
{
//This code can be replaced using ListTextBuilderCollection and ParametricTextBuilderCollection
//objects. See GenerateMainMiscFunctions() in this file for an example
var addCasesTemplate = Templates["add_case"];
var subtCasesTemplate = Templates["subt_case"];
var timesCasesTemplate = Templates["times_case"];
var addCasesText = new ListComposer("," + Environment.NewLine);
var subtCasesText = new ListComposer("," + Environment.NewLine);
var timesCasesText = new ListComposer("," + Environment.NewLine);
for (var index = 0; index < kvSpaceDim; index++)
{
addCasesText.Add(addCasesTemplate, "index", index);
subtCasesText.Add(subtCasesTemplate, "index", index);
timesCasesText.Add(timesCasesTemplate, "index", index);
}
var miscFuncsTemplate = Templates["misc"];
TextComposer.Append(miscFuncsTemplate,
"double", GMacLanguage.ScalarTypeName,
"num", kvSpaceDim,
"addcases", addCasesText,
"subtcases", subtCasesText,
"timescases", timesCasesText
);
}
public override void Visit(SteDeclareDataStore code)
{
if (code.LocalDataStore == false)
{
AddInternalComment("Non-local declaration not implemented: ", code.ToString());
return;
}
if (code.InitialValue == null)
{
TextComposer
.Append("declare ")
.Append(code.DataStoreName)
.Append(" : ")
.Append(code.DataStoreType);
TextComposer.AppendAtNewLine();
return;
}
TextComposer
.Append("let ")
.Append(code.DataStoreName)
.Append(" : ")
.Append(code.DataStoreType)
.Append(" = ");
code.InitialValue.AcceptVisitor(this);
TextComposer.AppendAtNewLine();
}
public void Visit(SteDeclareSimpleDataStore code)
{
TextComposer
.Append(code.DataStoreType)
.Append(" ")
.Append(code.DataStoreName);
}
public void Visit(SteImportNamespaces code)
{
foreach (var item in code.ImportedNamespaces)
{
TextComposer.Append("using ").Append(item).AppendLine(";");
}
}
public void Visit(SteDeclareMethod code)
{
var modifiersText = code.ModifiersList.Concatenate(" ");
TextComposer
.Append(modifiersText)
.Append(code.ReturnType)
.Append(code.MethodName)
.Append("(");
foreach (var item in code.Parameters)
{
item.AcceptVisitor(this);
}
TextComposer
.AppendLine(")")
.Append("{")
.IncreaseIndentation();
code.MethodCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendAtNewLine("}");
}
//private GMacInfoMacro AddEuclideanDualGMacMacro()
//{
// var codeText =
// Templates["edual_macro"].GenerateUsing(CurrentFrameName);
// var gmacMacro =
// _tempSymbolsCompiler.CompileMacro(
// codeText,
// _currentFrame.AssociatedFrame.ChildScope
// );
// return new GMacInfoMacro(gmacMacro);
//}
private void GenerateEuclideanDualFunction(int inGrade, AstMacro macroInfo)
{
var macroGenerator = LibraryComposer.CreateMacroCodeGenerator(macroInfo);
var outGrade = CurrentFrame.VSpaceDimension - inGrade;
macroGenerator.ActionSetMacroParametersBindings =
macroBinding =>
{
macroBinding.BindMultivectorPartToVariables("result", outGrade);
macroBinding.BindMultivectorPartToVariables("mv", inGrade);
};
macroGenerator.ActionSetTargetVariablesNames =
targetNaming =>
{
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "result", outGrade, "c");
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
};
//Generate code from macro binding
var computationsText = macroGenerator.Generate();
TextComposer.Append(
Templates["edual"],
"double", GMacLanguage.ScalarTypeName,
"grade", inGrade,
"num", CurrentFrame.KvSpaceDimension(inGrade),
"computations", computationsText
);
}
private void GenerateMaxCoefIdFunction(int grade)
{
var casesText = new ListComposer(Environment.NewLine);
var maxIndex = CurrentFrame.KvSpaceDimension(grade) - 1;
for (var index = 1; index < maxIndex; index++)
{
casesText.Add(
Templates["maxcoefid_case"],
"index", index,
"id", CurrentFrame.BasisBladeId(grade, index)
);
}
TextComposer.Append(
Templates["maxcoefid"],
"grade", grade,
"double", GMacLanguage.ScalarTypeName,
"initid", CurrentFrame.BasisBladeId(grade, 0),
"maxindex", maxIndex,
"maxid", CurrentFrame.BasisBladeId(grade, maxIndex),
"maxcoefid_case", casesText
);
}
internal void GenerateDotCode(DotEdge edge)
{
if (edge.IsEdgeDefaults && edge.HasAttributes == false)
{
return;
}
if (edge.IsEdge)
{
for (var i = 0; i < edge.SidesList.Count; i++)
{
if (i > 0)
{
TextComposer.Append(GraphType == DotGraphType.Undirected ? " -- " : " -> ");
}
GenerateDotCode(edge.SidesList[i]);
}
}
else
{
TextComposer.Append("edge");
}
GenerateDotCode(edge.AttrValues);
TextComposer.Append(";");
}
internal void GenerateDotCode(DotGraph graph)
{
switch (graph.GraphType)
{
case DotGraphType.StrictDirected:
TextComposer.Append("strict digraph ");
break;
case DotGraphType.Directed:
TextComposer.Append("digraph ");
break;
default:
TextComposer.Append("graph ");
break;
}
if (String.IsNullOrEmpty(graph.GraphName) == false)
{
TextComposer.Append(ToDotId(graph.GraphName));
}
TextComposer.AppendLine().Append("{").IncreaseIndentation();
foreach (var statement in graph.StatementsList)
{
GenerateDotCode(statement);
}
TextComposer
.DecreaseIndentation()
.AppendLine()
.Append("}");
}
internal void GenerateDotCode(Dictionary <string, string> attrList)
{
if (attrList.Count == 0)
{
return;
}
TextComposer.Append(" [ ");
var flag = false;
foreach (var attr in attrList)
{
if (flag)
{
TextComposer.Append(", ");
}
else
{
flag = true;
}
GenerateDotCode(attr);
}
TextComposer.Append(" ]");
}
public override void Generate()
{
GenerateBladeFileStartCode();
var casesText = new ListComposer(Environment.NewLine);
for (var grade = 2; grade <= CurrentFrame.VSpaceDimension; grade++)
{
_outGrade = grade;
GenerateVectorsOpFunction();
casesText.Add(
Templates["op_vectors_main_case"].GenerateUsing(grade)
);
}
TextComposer.Append(
Templates["op_vectors_main"],
"frame", CurrentFrameName,
"op_vectors_main_case", casesText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
public override void Visit(SteDeclareFixedSizeArray code)
{
if (code.LocalDataStore == false)
{
AddInternalComment("TODO: Non-local array declaration not yet implemented: ", code.ToString());
return;
}
TextComposer
.Append(code.DataStoreType)
.Append(" ")
.Append(code.DataStoreName)
.Append(" = ");
if (code.InitialValue != null)
{
code.InitialValue.AcceptVisitor(this);
}
else
{
TextComposer
.Append("new ")
.Append(code.DataStoreType)
.Append("[")
.Append(code.ArraySize)
.Append("]");
}
TextComposer.AppendLine(";");
}
public override void Visit(SteComment code)
{
foreach (var commentLine in code.CommentedTextLines)
{
TextComposer.Append("//").AppendLine(commentLine);
}
TextComposer.AppendAtNewLine();
}
public override void Generate()
{
TextComposer.Append(
Templates["factored_blade"],
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName
);
FileComposer.FinalizeText();
}
internal void GenerateDotCode(KeyValuePair <string, string> attr)
{
TextComposer.Append(attr.Key);
if (attr.Value != "true")
{
TextComposer
.Append(" = ")
.Append(attr.Value);
}
}
public override void Generate()
{
var textCollection = new ListComposerCollection(
"basis_vectors",
"members_declare",
"init_inputs",
"init_assign",
"init_assign_array",
"members_list",
"normalize",
"enorm2"
)
{
["basis_vectors"] = { Separator = "," + Environment.NewLine },
["members_declare"] = { Separator = Environment.NewLine },
["init_inputs"] = { Separator = ", " },
["init_assign"] = { Separator = Environment.NewLine },
["init_assign_array"] = { Separator = Environment.NewLine },
["members_list"] = { Separator = ", " },
["normalize"] = { Separator = Environment.NewLine },
["enorm2"] = { Separator = " + " }
};
var basisVectorsCoefsText = new ListComposer(", ");
for (var idx = 1; idx <= CurrentFrame.VSpaceDimension; idx++)
{
basisVectorsCoefsText.Clear();
basisVectorsCoefsText.AddRange(
(1 << (idx - 1)).PatternToSequence(CurrentFrame.VSpaceDimension, "0.0D", "1.0D")
);
textCollection["basis_vectors"].Add("new " + CurrentFrameName + "Vector(" + basisVectorsCoefsText + ")");
textCollection["members_declare"].Add("public double C" + idx + " { get; set; }");
textCollection["init_inputs"].Add(GMacLanguage.ScalarTypeName + " c" + idx);
textCollection["init_assign"].Add("C" + idx + " = c" + idx + ";");
textCollection["init_assign_array"].Add("C" + idx + " = c[" + (idx - 1) + "];");
textCollection["members_list"].Add("C" + idx);
textCollection["normalize"].Add("C" + idx + " *= invScalar;");
textCollection["enorm2"].Add("C" + idx + " * C" + idx);
}
Templates["vector"].SetParametersValues(textCollection);
TextComposer.Append(Templates["vector"],
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName,
"norm2", textCollection["enorm2"].ToString() //TODO: This must be computed from the frame
);
FileComposer.FinalizeText();
}
internal void GenerateDotCode(DotGraphAttribute graphAttr)
{
TextComposer.Append(graphAttr.AttrName);
if (graphAttr.AttrValue != "true")
{
TextComposer
.Append(" = ")
.Append(graphAttr.AttrValue)
.Append(";");
}
}
private void GenerateSelfDpGradeFunction(int inGrade, AstMacro selfEgpMacroInfo)
{
var macroGenerator = LibraryComposer.CreateMacroCodeGenerator(selfEgpMacroInfo);
var outGradesList =
CurrentFrame
.GradesOfEGp(inGrade, inGrade)
.Where(grade => grade > 0)
.OrderByDescending(g => g);
macroGenerator.ActionSetMacroParametersBindings =
macroBinding =>
{
foreach (var outGrade in outGradesList)
{
macroBinding.BindMultivectorPartToVariables("result", outGrade);
}
macroBinding.BindMultivectorPartToVariables("mv", inGrade);
};
macroGenerator.ActionSetTargetVariablesNames =
targetNaming =>
{
foreach (var outGrade in outGradesList)
{
targetNaming.SetMultivectorParameters("result", outGrade, id => "c");
}
BladesLibraryGenerator.SetBasisBladeToArrayNaming(targetNaming, "mv", inGrade, "coefs");
BladesLibraryGenerator.SetTargetTempVariablesNames(targetNaming);
};
macroGenerator.ActionBeforeGenerateSingleComputation =
TestSelfDpGradeFunctionComputationCondition;
macroGenerator.ActionAfterGenerateSingleComputation =
AddSelfDpGradeFunctionComputationCondition;
macroGenerator.MacroBinding.FixOutputComputationsOrder = true;
//Generate code from macro binding
var computationsText = macroGenerator.Generate();
TextComposer.Append(
Templates["self_dp_grade"],
"grade", inGrade,
"double", GMacLanguage.ScalarTypeName,
"computations", computationsText
);
}
internal void GenerateDotCode(DotNode node)
{
if (node.IsNodeDefaults && node.HasAttributes == false)
{
return;
}
TextComposer.Append(node.IsNode ? ToDotId(node.NodeName) : "node");
GenerateDotCode(node.AttrValues);
TextComposer.Append(";");
}
public override void Generate()
{
var classCodeText = GenerateClassCode();
TextComposer.Append(
Templates["mv_class_file"],
"frame", CurrentFrameName,
"mv_class_name", ClassData.ClassName,
"mv_class_code", classCodeText
);
FileComposer.FinalizeText();
}
internal void GenerateDotCode(DotSubGraphDefaults graphDefaults)
{
if (graphDefaults.HasAttributes == false)
{
return;
}
TextComposer.Append("graph ");
GenerateDotCode(graphDefaults.AttrValues);
TextComposer.Append(";");
}
public override void Visit(SteReturn code)
{
if (ReferenceEquals(code.ReturnedValue, null))
{
TextComposer.AppendLine("return;");
return;
}
TextComposer.Append("return ");
code.ReturnedValue.AcceptVisitor(this);
TextComposer.AppendLine(";");
}
public void Visit(SteSetNamespace code)
{
TextComposer
.Append("namespace ")
.Append(code.NamespaceName)
.AppendLineAtNewLine("{")
.IncreaseIndentation();
code.SubCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
private void GenerateVectorsOpFunction()
{
//Each time this protected method is called the internal GMacMacroCodeGenerator is initialized,
//the bindings and target names are set, and the macro code is generated automatically.
var computationsText = GenerateComputationsCode();
TextComposer.Append(
Templates["op_vectors"],
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName,
"grade", _outGrade,
"num", CurrentFrame.KvSpaceDimension(_outGrade),
"computations", computationsText
);
}
public override void Generate()
{
GenerateBladeFileStartCode();
TextComposer.Append(
Templates["blade"],
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName,
"norm2_opname", DefaultMacro.MetricUnary.NormSquared
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
private void GenerateMainMiscFunctions()
{
var miscCasesTemplates =
Templates.SubCollection(
"main_add_case",
"main_subt_case",
"main_times_case",
"main_divide_case",
"main_inverse_case",
"main_edual_case"
);
var miscCasesText = new ListComposerCollection(
"main_add_case",
"main_subt_case",
"main_times_case",
"main_divide_case",
"main_inverse_case",
"main_edual_case"
);
miscCasesText.SetSeparator(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
miscCasesText.AddTextItems(miscCasesTemplates,
"frame", CurrentFrameName,
"grade", grade,
"num", CurrentFrame.KvSpaceDimension(grade),
"sign", grade.GradeHasNegativeReverse() ? "-" : "",
"invgrade", CurrentFrame.VSpaceDimension - grade
);
}
var mainFuncsTemplate = Templates["misc_main"];
mainFuncsTemplate.SetParametersValues(miscCasesText);
TextComposer.Append(
mainFuncsTemplate,
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName,
"norm2_opname", DefaultMacro.MetricUnary.NormSquared,
"emag2_opname", DefaultMacro.EuclideanUnary.MagnitudeSquared
);
GenerateMainSelfDpGradeFunction();
}
public override void Generate()
{
var declareCoefsText = GenerateDeclareCoefsText();
var template = new ParametricComposer("#", "#", ClassCodeTemplateText);
TextComposer.Append(
template,
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName,
"zero_class_name", MvLibraryGenerator.MultivectorClassesData[0].ClassName,
"declare_coefs", declareCoefsText
);
FileComposer.FinalizeText();
}
public override void Generate()
{
var classCodeText =
MvLibraryGenerator.MacroGenDefaults.AllowGenerateMacroCode
? GenerateClassCode()
: "";
TextComposer.Append(
Templates["mv_class_file"],
"frame", CurrentFrameName,
"mv_class_name", ClassData.ClassName,
"mv_class_code", classCodeText
);
FileComposer.FinalizeText();
}
public override void Visit(SteAssign code)
{
if (code.LocalAssignment == false)
{
AddInternalComment("TODO: Non-local assignment not yet implemented: ", code.ToString());
return;
}
code.LeftHandSide.AcceptVisitor(this);
TextComposer.Append(" = ");
code.RightHandSide.AcceptVisitor(this);
TextComposer.AppendLine(";");
}
