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
);
}
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
);
}
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
);
}
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 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("}");
}
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 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("}");
}
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();
}
public override void Visit(SteComment code)
{
foreach (var commentLine in code.CommentedTextLines)
{
TextComposer.Append("//").AppendLine(commentLine);
}
TextComposer.AppendAtNewLine();
}
internal void GenerateIntermediateMethod(string gpCaseText, string name)
{
TextComposer.AppendAtNewLine(
Templates["gp"],
"frame", CurrentFrameName,
"name", name,
"double", GMacLanguage.ScalarTypeName,
"gp_case", gpCaseText
);
}
private void GenerateNormFunction(string opName, int inGrade)
{
_inGrade = inGrade;
SetBaseMacro(CurrentFrame.Macro(opName));
var computationsCode = GenerateComputationsCode();
TextComposer.AppendAtNewLine(
Templates["norm"],
"name", opName,
"grade", inGrade,
"double", GMacLanguage.ScalarTypeName,
"computations", computationsCode
);
}
public void Visit(TccSwitchCaseItem code)
{
TextComposer.AppendAtNewLine("case ");
code.CaseValue.AcceptVisitor(this);
TextComposer.AppendLine(":").IncreaseIndentation();
code.CaseCode.AcceptVisitor(this);
if (code.BreakCase)
{
TextComposer.AppendLineAtNewLine("break;");
}
TextComposer.DecreaseIndentation();
}
private void GenerateMethod(string funcName, int inputGrade, int outputGrade)
{
_inGrade = inputGrade;
_outGrade = outputGrade;
var computationsText = GenerateComputationsCode();
var kvSpaceDim = CurrentFrame.KvSpaceDimension(_outGrade);
TextComposer.AppendAtNewLine(
Templates["self_bilinearproduct"],
"name", funcName,
"num", kvSpaceDim,
"double", GMacLanguage.ScalarTypeName,
"computations", computationsText
);
}
public void Visit(SteIf code)
{
TextComposer.AppendAtNewLine("if (");
code.Condition.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.AppendLine("{")
.IncreaseIndentation();
code.TrueCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
public void Visit(SteIfElseIfElse code)
{
var flag = false;
foreach (var item in code.IfList)
{
if (flag == false)
{
TextComposer.AppendAtNewLine("if (");
flag = true;
}
else
{
TextComposer.AppendAtNewLine("else if (");
}
item.Condition.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.AppendLine("{")
.IncreaseIndentation();
item.TrueCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
if (code.ElseCode == null)
{
return;
}
TextComposer.AppendLine("else")
.AppendLine("{")
.IncreaseIndentation();
code.ElseCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
public override void Generate()
{
GenerateBladeFileStartCode();
var casesText = GetCasesText();
TextComposer.AppendAtNewLine(
Templates["bilinearproduct_main"],
"name", OperatorName,
"frame", CurrentFrameName,
"zerocond", ZeroCondition,
"cases", casesText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
private void GenerateNegativeFunction(int kvSpaceDim)
{
var caseTemplate = Templates["negative_case"];
var casesText = new ListComposer("," + Environment.NewLine);
for (var i = 0; i < kvSpaceDim; i++)
{
casesText.Add(caseTemplate, "num", i);
}
TextComposer.AppendAtNewLine(
Templates["negative"],
"num", kvSpaceDim,
"double", GMacLanguage.ScalarTypeName,
"cases", casesText
);
}
public override void Visit(SteAssign code)
{
if (code.LocalAssignment == false)
{
AddInternalComment("Non-local assignment not implemented: ", code.ToString());
return;
}
TextComposer.Append("let ");
code.LeftHandSide.AcceptVisitor(this);
TextComposer.Append(" = ");
code.RightHandSide.AcceptVisitor(this);
TextComposer.AppendAtNewLine();
}
public void Visit(SteForLoop code)
{
TextComposer.AppendAtNewLine("for (");
code.LoopInitialization.AcceptVisitor(this);
TextComposer.Append("; ");
code.LoopCondition.AcceptVisitor(this);
TextComposer.Append("; ");
code.LoopUpdate.AcceptVisitor(this);
TextComposer.AppendLine(")").Append("{").IncreaseIndentation();
code.LoopCode.AcceptVisitor(this);
TextComposer.DecreaseIndentation().AppendLineAtNewLine("}");
}
private void GenerateMainEqualsFunction()
{
var caseTemplate = Templates["main_equals_case"];
var casesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
casesText.Add(caseTemplate,
"grade", grade,
"num", CurrentFrame.KvSpaceDimension(grade)
);
}
TextComposer.AppendAtNewLine(
Templates["main_equals"],
"frame", CurrentFrameName,
"cases", casesText
);
}
public override void Generate()
{
GenerateBladeFileStartCode();
var computationsText = GenerateComputationsCode();
var kvSpaceDim = CurrentFrame.KvSpaceDimension(OutputGrade);
TextComposer.AppendAtNewLine(
Templates["bilinearproduct"],
"name", MethodName,
"num", kvSpaceDim,
"double", GMacLanguage.ScalarTypeName,
"computations", computationsText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
public void Visit(SteForEachLoop code)
{
TextComposer
.AppendAtNewLine("foreach (")
.Append(code.LoopVariableType)
.Append(code.LoopVariableName)
.Append(" in ");
code.LoopCollection.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.Append("{")
.IncreaseIndentation();
code.LoopCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
public override void Generate()
{
GenerateBladeFileStartCode();
var t2 = Templates["applyversor_main_case"];
var casesText = new ListComposer(Environment.NewLine);
foreach (var inGrade1 in CurrentFrame.Grades())
{
foreach (var inGrade2 in CurrentFrame.Grades())
{
var outGrade = inGrade2;
var id = inGrade1 + inGrade2 * CurrentFrame.GradesCount;
var name = BladesLibraryGenerator.GetBinaryFunctionName(OperatorName, inGrade1, inGrade2, outGrade);
casesText.Add(t2,
"name", name,
"id", id,
"g1", inGrade1,
"g2", inGrade2,
"grade", outGrade,
"frame", CurrentFrameName
);
}
}
TextComposer.AppendAtNewLine(
Templates["applyversor_main"],
"name", OperatorName,
"frame", CurrentFrameName,
"cases", casesText
);
GenerateBladeFileFinishCode();
FileComposer.FinalizeText();
}
private void GenerateMainNormFunction(string opName)
{
var caseTemplate = Templates["main_norm_case"];
var casesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
casesText.Add(
caseTemplate,
"name", opName,
"grade", grade
);
}
TextComposer.AppendAtNewLine(
Templates["main_norm"],
"name", opName,
"double", GMacLanguage.ScalarTypeName,
"main_norm_case", casesText
);
}
internal void GenerateDotCode(DotFixedCode fixedCode)
{
if (fixedCode.CodeType == DotFixedCodeType.MultiLineComment)
{
TextComposer.AppendAtNewLine(@"/*");
TextComposer.AppendAtNewLine(fixedCode.Code);
TextComposer.AppendAtNewLine(@"*/");
return;
}
if (fixedCode.CodeType == DotFixedCodeType.SingleLineComment)
{
TextComposer.IncreaseIndentation("// ");
TextComposer.AppendAtNewLine(fixedCode.Code);
TextComposer.DecreaseIndentation();
return;
}
TextComposer.AppendAtNewLine(fixedCode.Code);
}
private void GenerateMainMethod()
{
var casesTemplate = Templates["selfgp_main_case"];
var casesText = new ListComposer(Environment.NewLine);
foreach (var grade in CurrentFrame.Grades())
{
casesText.Add(
casesTemplate,
"name", BladesLibraryGenerator.GetBinaryFunctionName(OperatorName, grade, grade),
"grade", grade,
"frame", CurrentFrameName
);
}
TextComposer.AppendAtNewLine(
Templates["selfgp_main"],
"name", OperatorName,
"frame", CurrentFrameName,
"cases", casesText
);
}
private void GenerateIsZeroFunction(int kvSpaceDim)
{
var t1 = Templates["iszero"];
var t2 = Templates["iszero_case"];
var t3 = Templates["trimcoefs_case"];
var iszeroCasesText = new ListComposer(" ||" + Environment.NewLine);
var trimCoefsCasesText = new ListComposer("," + Environment.NewLine);
for (var i = 0; i < kvSpaceDim; i++)
{
iszeroCasesText.Add(t2, "num", i);
trimCoefsCasesText.Add(t3, "num", i);
}
TextComposer.AppendAtNewLine(
t1,
"num", kvSpaceDim,
"double", GMacLanguage.ScalarTypeName,
"iszero_case", iszeroCasesText,
"trimcoefs_case", trimCoefsCasesText
);
}
public void Visit(SteWhileLoop code)
{
if (code.DoLoop)
{
TextComposer
.AppendAtNewLine("do")
.AppendLine("{")
.IncreaseIndentation();
code.LoopCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendAtNewLine("} while (");
code.LoopCondition.AcceptVisitor(this);
TextComposer.AppendNewLine(");");
return;
}
TextComposer.AppendAtNewLine("while (");
code.LoopCondition.AcceptVisitor(this);
TextComposer
.AppendLine(")")
.AppendLine("{")
.IncreaseIndentation();
code.LoopCode.AcceptVisitor(this);
TextComposer
.DecreaseIndentation()
.AppendLineAtNewLine("}");
}
