/// <summary>
/// Bind a macro parameter of multivector type to a set of target language variables or constant values
/// using a generating function acting on each basis blade of the multivector
/// </summary>
/// <param name="valueAccess"></param>
/// <param name="bindingFunction"></param>
/// <param name="ignoreNullPatterns"></param>
/// <returns></returns>
public GMacMacroBinding BindMultivectorUsing(AstDatastoreValueAccess valueAccess, Func <AstFrame, int, GMacScalarBinding> bindingFunction, bool ignoreNullPatterns = true)
{
if (valueAccess.IsNullOrInvalid())
{
throw new ArgumentNullException(nameof(valueAccess));
}
if (valueAccess.AssociatedValueAccess.ExpressionType.IsFrameMultivector() == false)
{
throw new InvalidOperationException("Specified macro parameter is not of multivector type");
}
var frameInfo =
new AstFrame(
((GMacFrameMultivector)valueAccess.AssociatedValueAccess.ExpressionType).ParentFrame
);
var primitiveValueAccessList =
valueAccess.ExpandAll();
foreach (var primitiveValueAccess in primitiveValueAccessList)
{
var id = primitiveValueAccess.GetBasisBladeId();
var scalarPattern = bindingFunction(frameInfo, id);
if (ignoreNullPatterns == false || scalarPattern != null)
{
BindScalarToPattern(primitiveValueAccess, scalarPattern);
}
}
return(this);
}
private void GenerateApplyOutermorphismToVectorMacro(AstFrame frameInfo)
{
var inputsText = ComposeMacroInputs(
"om", DefaultStructure.Outermorphism,
"mv", frameInfo.FrameMultivector.Name
);
var commandsList = GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.AssignToLocalVariable("imageMv", "mv.#E1# * om.ImageV1.@G1@")
);
for (var index = 2; index <= frameInfo.VSpaceDimension; index++)
{
var id = GMacMathUtils.BasisVectorId(index - 1);
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"imageMv",
"imageMv + mv.#E" + id + "# * om.ImageV" + index + ".@G1@"
)
);
}
commandsList.AddEmptyLine();
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.ApplyToVector,
inputsText,
commandsText,
"imageMv"
);
}
private void GenerateFrameCode(AstFrame frameInfo)
{
Progress.Enabled = true;
var progressId = this.ReportStart(
"Generating code files for frame " + frameInfo.AccessName
);
CurrentFrame = frameInfo;
CurrentFrameName = GetSymbolTargetName(CurrentFrame);
CodeFilesComposer.DownFolder(CurrentFrameName);
GenerateBladeFiles();
GenerateVectorFiles();
GenerateFctoredBladeFiles();
GenerateOutermorphismFiles();
CodeFilesComposer.UpFolder();
Progress.Enabled = true;
this.ReportFinish(progressId);
}
private void GenerateComposeOutermorphismsMacro(AstFrame frameInfo)
{
var commandsList = GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.DeclareLocalVariable(DefaultStructure.Outermorphism, "newOm"),
GMacDslSyntaxFactory.EmptyLine()
);
for (var index = 1; index <= frameInfo.VSpaceDimension; index++)
{
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"newOm.ImageV" + index,
DefaultMacro.Outermorphism.ApplyToVector + "(om1, om2.ImageV" + index + ")"
)
);
}
commandsList.AddEmptyLine();
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.Compose,
ComposeMacroInputs(
"om1", DefaultStructure.Outermorphism,
"om2", DefaultStructure.Outermorphism
),
DefaultStructure.Outermorphism,
commandsText,
"newOm"
);
}
private void GenerateDivideByScalarOutermorphismsMacro(AstFrame frameInfo)
{
var commandsList = GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.DeclareLocalVariable(DefaultStructure.Outermorphism, "newOm"),
GMacDslSyntaxFactory.EmptyLine()
);
for (var index = 1; index <= frameInfo.VSpaceDimension; index++)
{
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"newOm.ImageV" + index,
"om.ImageV" + index + ".@G1@ / s"
)
);
}
commandsList.AddEmptyLine();
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.DivideByScalar,
ComposeMacroInputs(
"om", DefaultStructure.Outermorphism,
"s", GMacLanguage.ScalarTypeName
),
DefaultStructure.Outermorphism,
commandsText,
"newOm"
);
}
private void GenerateEuclideanBinaryMacros(AstFrame frameInfo)
{
var inputsText = ComposeMacroInputs(
"mv", frameInfo.FrameMultivector.Name,
"s", GMacLanguage.ScalarTypeName
);
GenerateMacro(frameInfo, DefaultMacro.EuclideanBinary.TimesWithScalar, inputsText, "mv * s");
GenerateMacro(frameInfo, DefaultMacro.EuclideanBinary.DivideByScalar, inputsText, "mv / s");
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.OuterProduct, GMacOpInfo.BinaryOp);
GenerateBinaryScalarMacro(frameInfo, DefaultMacro.EuclideanBinary.ScalarProduct, GMacOpInfo.BinaryESp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.GeometricProduct, GMacOpInfo.BinaryEGp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.LeftContractionProduct, GMacOpInfo.BinaryELcp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.RightContractionProduct, GMacOpInfo.BinaryERcp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.FatDotProduct, GMacOpInfo.BinaryEFdp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.HestenesInnerProduct, GMacOpInfo.BinaryEHip);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.CommutatorProduct, GMacOpInfo.BinaryECp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.AntiCommutatorProduct, GMacOpInfo.BinaryEAcp);
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.GeometricProductDual, DefaultMacro.EuclideanUnary.Dual + "(mv1 egp mv2)");
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.DirectSandwitchProduct, "mv1 egp mv2 egp reverse(mv1)");
GenerateBinaryMacro(frameInfo, DefaultMacro.EuclideanBinary.GradeInvolutionSandwitchProduct, "mv1 egp grade_inv(mv2) egp reverse(mv1)");
}
private void GenerateOutermorphismDeterminantMacros(AstFrame frameInfo)
{
GenerateComment("Compute matric determinant of an outer-morphism");
var pseudoScalar = frameInfo.Name + ".E" + frameInfo.MaxBasisBladeId;
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.MetricDeterminant,
ComposeMacroInputs("om", DefaultStructure.Outermorphism),
GMacLanguage.ScalarTypeName,
"",
String.Format("ApplyOM(om, {0}) sp reverse({0}) / norm2({0})", pseudoScalar)
);
GenerateComment("Compute Euclidean determinant of an outer-morphism");
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.EuclideanDeterminant,
ComposeMacroInputs("om", DefaultStructure.Outermorphism),
GMacLanguage.ScalarTypeName,
"",
String.Format("ApplyOM(om, {0}) esp reverse({0}) / emag2({0})", pseudoScalar)
);
}
private void GenerateFrameCode(AstFrame frameInfo)
{
ActiveFileTextComposer.AppendLine("namespace " + GetSymbolTargetName(frameInfo.ParentNamespace));
ActiveFileTextComposer.AppendLine();
GenerateStructures(frameInfo);
GenerateConstants(frameInfo);
GenerateMetricUnaryMacros(frameInfo);
GenerateEuclideanUnaryMacros(frameInfo);
GenerateMetricBinaryMacros(frameInfo);
GenerateEuclideanBinaryMacros(frameInfo);
GenerateLinearTransformMacros(frameInfo);
GenerateOutermorphismMacros(frameInfo);
GenerateMetricVersorMacros(frameInfo);
GenerateEuclideanVersorMacros(frameInfo);
}
private void GenerateComposeLinearTransformsMacro(AstFrame frameInfo)
{
var commandsList =
GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.DeclareLocalVariable(DefaultStructure.LinearTransform, "newTr"),
GMacDslSyntaxFactory.EmptyLine()
);
for (var id = 0; id <= frameInfo.MaxBasisBladeId; id++)
{
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"newTr.ImageE" + id,
DefaultMacro.LinearTransform.Apply + "(tr1, tr2.ImageE" + id + ")"
)
);
}
commandsList.AddEmptyLine();
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.LinearTransform.Compose,
ComposeMacroInputs(
"tr1", DefaultStructure.LinearTransform,
"tr2", DefaultStructure.LinearTransform
),
DefaultStructure.LinearTransform,
commandsText,
"newTr"
);
}
/// <summary>
/// Convert this binding pattern into a multivector value
/// </summary>
/// <param name="basisBladeToVarName"></param>
/// <returns></returns>
public AstValueMultivector ToValue(Func <AstFrameBasisBlade, string> basisBladeToVarName)
{
var frameInfo = new AstFrame(BaseFrameMultivector.AssociatedFrameMultivector.ParentFrame);
var mv = GaSymMultivector.CreateZero(
BaseFrameMultivector.AssociatedFrameMultivector.ParentFrame.GaSpaceDimension
);
foreach (var pair in _patternDictionary)
{
mv.AddFactor(
pair.Key,
pair.Value.IsConstant
? pair.Value.ConstantSymbolicScalar
: MathematicaScalar.Create(SymbolicUtils.Cas, basisBladeToVarName(frameInfo.BasisBlade(pair.Key)))
);
}
return
(new AstValueMultivector(
GMacValueMultivector.Create(
BaseFrameMultivector.AssociatedFrameMultivector,
mv
)
));
}
private void GenerateApplyLinearTransformMacro(AstFrame frameInfo)
{
var inputsText = ComposeMacroInputs(
"tr", DefaultStructure.LinearTransform,
"mv", frameInfo.FrameMultivector.Name
);
var commandsList =
GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.AssignToLocalVariable("imageMv", "mv.#E0# * tr.ImageE0")
);
for (var id = 1; id <= frameInfo.MaxBasisBladeId; id++)
{
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable("imageMv", "imageMv + mv.#E" + id + "# * tr.ImageE" + id)
);
}
commandsList.AddEmptyLine();
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.LinearTransform.Apply,
inputsText,
commandsText,
"imageMv"
);
}
public string Visit(AstFrame item)
{
var composer = CreateColumnsComposer();
composer
.AppendToColumns("Frame Name:", item.AccessName)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Basis Vectors:",
item
.BasisVectors
.Select(t => t.Name)
.Concatenate(", ")
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Basis Blades:",
BasisBladesInformationTable(item.BasisBladesSortedByGrade())
)
.AppendEmptyStringsToColumns()
.AppendToColumns(
"Subspaces:",
item
.Subspaces
.Select(t => t.Name)
.Concatenate(Environment.NewLine)
);
return composer.GenerateText();
}
private void GenerateFrameCode(AstFrame frameInfo)
{
CodeFilesComposer.InitalizeFile(frameInfo.Name + ".cs", GenerateCodeFileStartCode);
ActiveFileTextComposer.AppendLineAtNewLine(@"public static class " + frameInfo.Name);
ActiveFileTextComposer.AppendLineAtNewLine("{");
ActiveFileTextComposer.IncreaseIndentation();
GenerateFrameMultivectorCode(frameInfo.FrameMultivector);
ActiveFileTextComposer.AppendLineAtNewLine();
foreach (var constantInfo in frameInfo.Constants)
{
GenerateConstantCode(constantInfo);
}
foreach (var macroInfo in frameInfo.Macros)
{
GenerateMacroCode(macroInfo);
}
ActiveFileTextComposer.DecreaseIndentation();
ActiveFileTextComposer.AppendLineAtNewLine("}");
CodeFilesComposer.UnselectActiveFile(GenerateCodeFileEndCode);
}
private void GenerateFrameCode(AstFrame frameInfo)
{
Progress.Enabled = true;
var progressId = this.ReportStart(
"Generating code files for frame " + frameInfo.AccessName
);
CurrentFrame = frameInfo;
CurrentFrameName = GetSymbolTargetName(CurrentFrame);
CodeFilesComposer.DownFolder(CurrentFrameName);
InitializeMultivectorClassesData();
GenerateBaseMvClassFile();
foreach (var classData in MultivectorClassesData.Values)
{
GenerateDerivedMvClassFiles(classData);
}
//GenerateFctoredBladeFiles();
//GenerateOutermorphismFiles();
CodeFilesComposer.UpFolder();
Progress.Enabled = true;
this.ReportFinish(progressId);
}
public TreeNode Visit(AstFrame item)
{
var node = new TreeNode(item.Name)
{
Tag = item,
ImageKey = @"Frame64.png",
SelectedImageKey = @"Frame64.png"
};
node.Nodes.Add(
Visit(item.FrameMultivector)
);
node.Nodes.AddRange(
item.Subspaces.OrderBy(i => i.Name).Select(Visit).ToArray()
);
node.Nodes.AddRange(
item.Constants.OrderBy(i => i.Name).Select(Visit).ToArray()
);
node.Nodes.AddRange(
item.Structures.OrderBy(i => i.Name).Select(Visit).ToArray()
);
node.Nodes.AddRange(
item.Transforms.OrderBy(i => i.Name).Select(Visit).ToArray()
);
node.Nodes.AddRange(
item.Macros.OrderBy(i => i.Name).Select(Visit).ToArray()
);
return(node);
}
public static DotGraph ToGraphViz(this AstFrame frame)
{
var visitor = new FrameToGraphViz();
frame.AcceptVisitor(visitor);
return(visitor.Graph);
}
private DotNode AddBasisBlades(AstFrame frame)
{
var innerTable =
DotUtils.Table()
.SetBorder(0);
innerTable
.AddRow()
.AddCells("Grade", "Index", "ID", "Name", "Indexed Name", "Binary Name", "Grade + Index Name");
foreach (var cell in innerTable.FirstRow)
{
cell
.SetBorder(1)
.SetSides(DotSides.Top, DotSides.Bottom);
}
for (var grade = 0; grade <= frame.VSpaceDimension; grade++)
{
var n = frame.KvSpaceDimension(grade);
for (var index = 0; index < n; index++)
{
var basisBlade = frame.BasisBlade(grade, index);
innerTable
.AddRow()
.AddCells(
basisBlade.Grade.ToString(),
basisBlade.Index.ToString(),
basisBlade.BasisBladeId.ToString(),
basisBlade.Name,
basisBlade.IndexedName,
basisBlade.BinaryIndexedName,
basisBlade.GradeIndexName
);
}
}
var table =
DotUtils.Table()
.SetBorder(0);
table.AddRows(
DotUtils.Cell().SetContents("Basis Blades".Bold()),
DotUtils.Cell().SetContents(innerTable)
);
var node =
Graph
.AddNode("Basis Blades")
.SetLabel(table);
Graph.AddEdge("Inner Product Matrix", "Basis Blades");
return(node);
}
private void GenerateOutermorphismToLinearTransformMacro(AstFrame frameInfo)
{
var commandsList = GMacDslSyntaxFactory.SyntaxElementsList(
GMacDslSyntaxFactory.DeclareLocalVariable(DefaultStructure.LinearTransform, "newTr"),
GMacDslSyntaxFactory.EmptyLine(),
GMacDslSyntaxFactory.FixedCode("let newTr.ImageE0 = Multivector(#E0# = '1')"),
GMacDslSyntaxFactory.EmptyLine()
);
for (var index = 1; index <= frameInfo.VSpaceDimension; index++)
{
var id = GMacMathUtils.BasisVectorId(index - 1);
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"newTr.ImageE" + id,
"om.ImageV" + index + ".@G1@"
)
);
}
commandsList.AddEmptyLine();
for (var grade = 2; grade <= frameInfo.VSpaceDimension; grade++)
{
var kvSpaceDim = frameInfo.KvSpaceDimension(grade);
for (var index = 0; index < kvSpaceDim; index++)
{
int id = GMacMathUtils.BasisBladeId(grade, index);
int id1, id2;
id.SplitBySmallestBasisVectorId(out id1, out id2);
commandsList.Add(
GMacDslSyntaxFactory.AssignToLocalVariable(
"newTr.ImageE" + id,
" newTr.ImageE" + id1 + " op newTr.ImageE" + id2
)
);
}
commandsList.AddEmptyLine();
}
var commandsText = GMacLanguage.CodeGenerator.GenerateCode(commandsList);
GenerateMacro(
frameInfo,
DefaultMacro.Outermorphism.ToLinearTransform,
ComposeMacroInputs("om", DefaultStructure.Outermorphism),
DefaultStructure.LinearTransform,
commandsText,
"newTr"
);
}
private void GenerateUnaryScalarMacro(AstFrame frameInfo, string macroName, string exprText)
{
ActiveFileTextComposer.Append(
Templates["unary_macro"],
"frame", frameInfo.Name,
"name", macroName,
"output_type", TypeNames.Scalar,
"expr", exprText
);
}
private void GenerateBinaryMacro(AstFrame frameInfo, string macroName, string exprText)
{
ActiveFileTextComposer.Append(
Templates["binary_macro"],
"frame", frameInfo.Name,
"name", macroName,
"output_type", frameInfo.FrameMultivector.Name,
"expr", exprText
);
}
private void GenerateMacro(AstFrame frameInfo, string macroName, string inputsText, string resultExprText)
{
ActiveFileTextComposer.Append(
Templates["general_macro"],
"frame", frameInfo.Name,
"name", macroName,
"inputs", inputsText,
"output_type", frameInfo.FrameMultivector.Name,
"expr", resultExprText
);
}
private void GenerateMetricVersorToLinearTransformMacro(AstFrame frameInfo)
{
GenerateMacro(
frameInfo,
DefaultMacro.MetricVersor.ToLinearTransform,
ComposeMacroInputs("v", frameInfo.FrameMultivector.Name),
DefaultStructure.LinearTransform,
"",
DefaultMacro.Outermorphism.ToLinearTransform + "(" + DefaultMacro.MetricVersor.ToOutermorphism + "(v))"
);
}
private void GenerateMacro(AstFrame frameInfo, string macroName, string inputsText, string outputType, object commandsText, string resultExprText)
{
ActiveFileTextComposer.Append(
Templates["macro"],
"frame", frameInfo.Name,
"name", macroName,
"inputs", inputsText,
"output_type", outputType,
"commands", commandsText,
"expr", resultExprText
);
}
private void GenerateConstants(AstFrame frameInfo)
{
for (var id = 0; id <= frameInfo.MaxBasisBladeId; id++)
{
ActiveFileTextComposer.Append(
Templates["constant"],
"frame", frameInfo.Name,
"name", "E" + id,
"value", "Multivector(#E" + id + "# = 1)"
);
}
}
private void GenerateMetricVersorMacros(AstFrame frameInfo)
{
GenerateMetricVersorToOutermorphismMacro(frameInfo);
GenerateMetricVersorToLinearTransformMacro(frameInfo);
GenerateApplyVersorMacro(frameInfo, DefaultMacro.MetricVersor.Apply, "(v gp mv gp reverse(v)) / norm2(v)");
GenerateApplyVersorMacro(frameInfo, DefaultMacro.MetricVersor.ApplyRotor, "v gp mv gp reverse(v)");
GenerateApplyVersorMacro(frameInfo, DefaultMacro.MetricVersor.ApplyReflector, "-v gp mv gp reverse(v)");
}
private void GenerateEuclideanVersorMacros(AstFrame frameInfo)
{
GenerateEuclideanVersorToOutermorphismMacro(frameInfo);
GenerateEuclideanVersorToLinearTransformMacro(frameInfo);
GenerateApplyVersorMacro(frameInfo, DefaultMacro.EuclideanVersor.Apply, "(v egp mv egp reverse(v)) / emag2(v)");
GenerateApplyVersorMacro(frameInfo, DefaultMacro.EuclideanVersor.ApplyRotor, "v egp mv egp reverse(v)");
GenerateApplyVersorMacro(frameInfo, DefaultMacro.EuclideanVersor.ApplyReflector, "-v egp mv egp reverse(v)");
}
/// <summary>
/// Adds the child scope of the given frame to the opened scopes
/// </summary>
/// <param name="symbol"></param>
public void OpenScope(AstFrame symbol)
{
if (symbol.IsNullOrInvalid())
{
this.ReportNormal("Open Scope", ProgressEventArgsResult.Failure);
return;
}
RefResContext.OpenScope(symbol);
this.ReportNormal("Open Scope", symbol.AccessName, ProgressEventArgsResult.Success);
}
private void GenerateApplyVersorMacro(AstFrame frameInfo, string macroName, string exprText)
{
GenerateMacro(
frameInfo,
macroName,
ComposeMacroInputs(
"v", frameInfo.FrameMultivector.Name,
"mv", frameInfo.FrameMultivector.Name
),
frameInfo.FrameMultivector.Name,
"",
exprText
);
}
/// <summary>
/// Generate for a single frame
/// </summary>
/// <param name="frame"></param>
/// <param name="generateMacroCode"></param>
/// <returns></returns>
public static BladesLibrary Generate(AstFrame frame, bool generateMacroCode = true)
{
var libGen = new BladesLibrary(frame.Root)
{
MacroGenDefaults = { AllowGenerateMacroCode = generateMacroCode }
};
libGen.SelectedSymbols.Add(frame);
libGen.Generate();
return(libGen);
}
/// <summary>
/// Close the child scope of the given frame
/// </summary>
/// <param name="symbol"></param>
public void CloseScope(AstFrame symbol)
{
if (symbol.IsNullOrInvalid())
{
this.ReportNormal("Close Scope", ProgressEventArgsResult.Failure);
return;
}
_symbolsCache.Clear();
RefResContext.CloseScope(symbol);
this.ReportNormal("Close Scope", symbol.AccessName, ProgressEventArgsResult.Success);
}
