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
);
}
//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 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
);
}
private void GenerateMethods(int inGrade1, int inGrade2)
{
var gpCaseText = new ListComposer(Environment.NewLine);
var gradesList = CurrentFrame.GradesOfEGp(inGrade1, inGrade2).OrderByDescending(grade => grade);
foreach (var outGrade in gradesList)
{
var funcName = BladesLibraryGenerator.GetBinaryFunctionName(DefaultMacro.EuclideanBinary.GeometricProduct, inGrade1, inGrade2, outGrade);
gpCaseText.Add(Templates["dp_case"],
"name", funcName,
"num", CurrentFrame.KvSpaceDimension(outGrade),
"frame", CurrentFrameName,
"grade", outGrade
);
}
TextComposer.AppendAtNewLine(
Templates["dp"],
"frame", CurrentFrameName,
"name", BladesLibraryGenerator.GetBinaryFunctionName(OperatorName, inGrade1, inGrade2),
"double", GMacLanguage.ScalarTypeName,
"dp_case", gpCaseText
);
}
private void GenerateMainMethod()
{
var casesText = new ListComposer(Environment.NewLine);
foreach (var inGrade1 in CurrentFrame.Grades())
{
foreach (var inGrade2 in CurrentFrame.Grades())
{
var id = inGrade1 + inGrade2 * CurrentFrame.GradesCount;
casesText.Add(Templates["dp_main_case"],
"name", BladesLibraryGenerator.GetBinaryFunctionName(OperatorName, inGrade1, inGrade2),
"id", id,
"g1", inGrade1,
"g2", inGrade2,
"frame", CurrentFrameName
);
}
}
TextComposer.AppendAtNewLine(
Templates["dp_main"],
"name", OperatorName,
"frame", CurrentFrameName,
"cases", casesText
);
}
public void Visit(SteSwitchCase code)
{
TextComposer.AppendAtNewLine("switch (");
code.SwitchExpression.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.AppendLine("{")
.IncreaseIndentation();
foreach (var item in code.CasesList)
{
item.AcceptVisitor(this);
}
if (code.DefaultCode != null)
{
TextComposer.AppendLineAtNewLine("default:").IncreaseIndentation();
code.DefaultCode.AcceptVisitor(this);
TextComposer.AppendLineAtNewLine("break;");
}
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
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 void Visit(SteIfElse code)
{
TextComposer.AppendAtNewLine("if (");
code.Condition.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.AppendLine("{")
.IncreaseIndentation();
code.TrueCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
if (code.ElseCode == null)
{
return;
}
TextComposer.AppendLine("else")
.AppendLine("{")
.IncreaseIndentation();
code.ElseCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
public void Visit(SteImportNamespaces code)
{
foreach (var item in code.ImportedNamespaces)
{
TextComposer.Append("using ").Append(item).AppendLine(";");
}
}
public void Visit(SteDeclareSimpleDataStore code)
{
TextComposer
.Append(code.DataStoreType)
.Append(" ")
.Append(code.DataStoreName);
}
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("}");
}
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();
}
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();
}
private void GenerateMainIsZeroFunction()
{
var t1 = Templates["main_iszero"];
var t2 = Templates["main_iszero_case"];
var t3 = Templates["main_trimcoefs_case"];
var iszeroCasesText = new ListComposer(Environment.NewLine);
var trimcoefsCasesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
iszeroCasesText.Add(t2,
"grade", grade,
"num", CurrentFrame.KvSpaceDimension(grade)
);
trimcoefsCasesText.Add(t3,
"frame", CurrentFrameName,
"grade", grade,
"num", CurrentFrame.KvSpaceDimension(grade)
);
}
TextComposer.AppendAtNewLine(t1,
"frame", CurrentFrameName,
"main_iszero_case", iszeroCasesText,
"main_trimcoefs_case", trimcoefsCasesText
);
}
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();
}
internal void GenerateDotCode(IDotStatement statement)
{
TextComposer.AppendAtNewLine();
var fixedCode = statement as DotFixedCode;
if (fixedCode != null)
{
GenerateDotCode(fixedCode);
return;
}
var edge = statement as DotEdge;
if (edge != null)
{
GenerateDotCode(edge);
return;
}
var graphAttr = statement as DotGraphAttribute;
if (graphAttr != null)
{
GenerateDotCode(graphAttr);
return;
}
var node = statement as DotNode;
if (node != null)
{
GenerateDotCode(node);
return;
}
var subGraph = statement as DotSubGraph;
if (subGraph != null)
{
GenerateDotCode(subGraph);
return;
}
var subGraphDefault = statement as DotSubGraphDefaults;
if (subGraphDefault != null)
{
GenerateDotCode(subGraphDefault);
return;
}
throw new InvalidOperationException();
}
public override void Generate()
{
GenerateBladeFileStartCode();
var computationsText = GenerateComputationsCode();
var newVectorsText = new ListComposer("," + Environment.NewLine);
for (var i = 0; i < InputGrade; i++)
{
newVectorsText.Add("new " + CurrentFrameName + "Vector()");
}
TextComposer.AppendAtNewLine(
Templates["factor"],
"frame", CurrentFrameName,
"id", InputId,
"double", GMacLanguage.ScalarTypeName,
"newvectors", newVectorsText,
"computations", computationsText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
private void GenerateMethods(int inputGrade)
{
var gpCaseText = new ListComposer("," + Environment.NewLine);
var gradesList = CurrentFrame.GradesOfEGp(inputGrade, inputGrade);
foreach (var outputGrade in gradesList)
{
var funcName =
BladesLibraryGenerator
.GetBinaryFunctionName(OperatorName, inputGrade, inputGrade, outputGrade);
GenerateMethod(
funcName,
inputGrade,
outputGrade
);
gpCaseText.Add(Templates["selfgp_case"],
"frame", CurrentFrameName,
"grade", outputGrade,
"name", funcName
);
}
TextComposer.AppendAtNewLine(
Templates["selfgp"],
"frame", CurrentFrameName,
"name", BladesLibraryGenerator.GetBinaryFunctionName(OperatorName, inputGrade, inputGrade),
"double", GMacLanguage.ScalarTypeName,
"selfgp_case", gpCaseText
);
}
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(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(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(" ]");
}
private void GenerateMainInvolutionFunction(string macroName, Func <int, bool> useNegative)
{
var caseTemplate1 = Templates["main_negative_case"];
var caseTemplate2 = Templates["main_negative_case2"];
var casesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
if (useNegative(grade))
{
casesText.Add(caseTemplate1,
"frame", CurrentFrameName,
"grade", grade,
"num", CurrentFrame.KvSpaceDimension(grade)
);
}
else
{
casesText.Add(caseTemplate2,
"grade", grade
);
}
}
TextComposer.AppendAtNewLine(
Templates["main_involution"],
"frame", CurrentFrameName,
"name", macroName,
"cases", casesText
);
}
internal void GenerateOutermorphismFileFinishCode()
{
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}")
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
internal DotCodeGenContext Reset(DotGraphType graphType)
{
TextComposer.Clear();
GraphType = graphType;
return(this);
}
public override void Visit(SteComment code)
{
foreach (var commentLine in code.CommentedTextLines)
{
TextComposer.Append("//").AppendLine(commentLine);
}
TextComposer.AppendAtNewLine();
}
internal void GenerateBladeFileStartCode()
{
TextComposer.AppendLine(
Templates["blade_file_start"].GenerateUsing(CurrentFrameName)
);
TextComposer.IncreaseIndentation();
TextComposer.IncreaseIndentation();
}
public override void Generate()
{
TextComposer.Append(
Templates["factored_blade"],
"frame", CurrentFrameName,
"double", GMacLanguage.ScalarTypeName
);
FileComposer.FinalizeText();
}
internal void GenerateIntermediateMethod(string gpCaseText, string name)
{
TextComposer.AppendAtNewLine(
Templates["gp"],
"frame", CurrentFrameName,
"name", name,
"double", GMacLanguage.ScalarTypeName,
"gp_case", gpCaseText
);
}
internal void GenerateOutermorphismFileStartCode()
{
TextComposer.AppendLine(
Templates["om_file_start"],
"frame", CurrentFrameName,
"grade", CurrentFrame.VSpaceDimension
);
TextComposer.IncreaseIndentation();
TextComposer.IncreaseIndentation();
}
internal void GenerateDotCode(KeyValuePair <string, string> attr)
{
TextComposer.Append(attr.Key);
if (attr.Value != "true")
{
TextComposer
.Append(" = ")
.Append(attr.Value);
}
}
