/// <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); }