public override void ToTextTree(LinearComposer log) { log.AppendLine("{"); log.IncreaseIndentation(); var flag = false; foreach (var pair in _chidNodesDictionary) { if (flag) { log.Append(", "); } else { flag = true; } log.Append(Key + " : "); pair.Value.ToTextTree(log); } log.DecreaseIndentation(); log.AppendAtNewLine("}"); }
/// <summary> /// Generate a string containing some statistics about the final text inside /// the files of this composer /// </summary> /// <returns></returns> public string GenerateStatistics() { var composer = new LinearComposer(); composer .AppendLineAtNewLine("Composer Log:") .AppendLineAtNewLine(_log.ToString()) .AppendLine(); var totalLines = 0; var totalCharacters = 0; foreach (var pair in _fileComposersDictionary) { int linesCount, charsCount; composer.AppendAtNewLine( pair.Value.GenerateStatistics(RootFolder, FilesEncoding, out linesCount, out charsCount) ); totalLines += linesCount; totalCharacters += charsCount; } composer .AppendLine() .AppendAtNewLine("Total Files: ") .AppendLine(_fileComposersDictionary.Count.ToString("###,###,###,###")) .AppendAtNewLine("Total Lines: ") .AppendLine(totalLines.ToString("###,###,###,###")) .AppendAtNewLine("Total Characters: ") .AppendLine(totalCharacters.ToString("###,###,###,###")); return(composer.ToString()); }
protected IronyAstDescription() { Log = new LinearComposer() { ClearOnRead = true }; }
private string GenerateClassCode() { var composer = new LinearComposer(); composer.AppendLineAtNewLine(GenerateDeclareCoefsText()); composer.AppendLineAtNewLine(GenerateAbstractCoefsText()); composer.AppendAtNewLine( MainCodeTemplate, "mv_class_name", ClassData.ClassName, "mv_class_id", ClassData.ClassId, "frame", CurrentFrameName, "double", GMacLanguage.ScalarTypeName, "iszero_code", GenerateIsZeroCode(), "norm2_code", GenerateNorm2Code(), "isequal_cases", GenerateAbstractMethodCases("IsEqual"), "op_cases", GenerateAbstractMethodCases("OP"), "gp_cases", GenerateAbstractMethodCases("GP"), "lcp_cases", GenerateAbstractMethodCases("LCP"), "rcp_cases", GenerateAbstractMethodCases("RCP"), "sp_cases", GenerateAbstractMethodCases("SP"), "add_cases", GenerateAbstractMethodCases("Add"), "subtract_cases", GenerateAbstractMethodCases("Subtract") ); return(composer.ToString()); }
private void SectionsTreeToText(LinearComposer log) { log.Append(SectionName); if (IsLeaf) { return; } log.AppendLine(" {"); log.IncreaseIndentation(); var flag = true; foreach (var lowerSection in ChildSections) { if (flag) { flag = false; } else { log.AppendLine(","); } lowerSection.SectionsTreeToText(log); } log.DecreaseIndentation(); log.AppendLine("}"); }
public override void ToString(LinearComposer textBuilder) { textBuilder.AppendLine("{"); textBuilder.IncreaseIndentation(); var flag = false; foreach (var pair in _nodes) { if (flag) { textBuilder.AppendLine(","); } else { flag = true; } textBuilder.Append(pair.Key.ToString()); pair.Value.ToString(textBuilder); } textBuilder.DecreaseIndentation(); textBuilder.AppendAtNewLine("}"); }
public string ToTextTree() { var log = new LinearComposer(); ToTextTree(log); return(log.ToString()); }
public string SectionsTreeToText() { var log = new LinearComposer(); SectionsTreeToText(log); return(log.ToString()); }
public override string ToString() { var textBuilder = new LinearComposer(); ToString(textBuilder); return(textBuilder.ToString()); }
private string GenerateProductMethodCode(string macroName, out string resultClassName) { SetBaseMacro(CurrentFrame.Macro(macroName)); var computationsText = GenerateComputationsCode(); //The result is zero if (MacroCodeGenerator.CodeBlock.NonZeroOutputVariables.Any() == false) { //The result is the zero multivector if (BaseMacro.OutputType.IsValidMultivectorType) { resultClassName = MvLibraryGenerator.MultivectorClassesData[0].ClassName; return("return Zero;"); } //The result is the scalar zero resultClassName = GMacLanguage.ScalarTypeName; return("return " + GMacLanguage.ScalarZero + ";"); } //The result is not zero string resultDeclarationText; if (BaseMacro.OutputType.IsValidMultivectorType) { var grades = MacroCodeGenerator .CodeBlock .NonZeroOutputVariables .Select(v => v.ValueAccess.GetBasisBlade().Grade) .Distinct(); var id = grades.Sum(grade => 1 << grade); resultClassName = MvLibraryGenerator.MultivectorClassesData[id].ClassName; resultDeclarationText = "var result = new " + resultClassName + "();"; } else { resultClassName = GMacLanguage.ScalarTypeName; resultDeclarationText = "var result = " + GMacLanguage.ScalarZero + ";"; } var composer = new LinearComposer(); composer .AppendLineAtNewLine(resultDeclarationText) .AppendLine() .AppendLineAtNewLine(computationsText) .AppendAtNewLine("return result;"); return(composer.ToString()); }
/// <summary> /// Clear the final text and the linear text composer /// </summary> /// <returns></returns> public TextFileComposer Clear() { _textComposer = null; FinalText = string.Empty; IsFinalized = false; IsSavedToDisk = false; return(this); }
public override void ToString(LinearComposer textBuilder) { textBuilder.Append("{"); textBuilder.IncreaseIndentation(); foreach (var item in _branches) { item.ToString(textBuilder); } textBuilder.DecreaseIndentation(); textBuilder.AppendAtNewLine("}"); }
public string Execute() { var composer = new LinearComposer(); foreach (var test in this) { composer .AppendLineAtNewLine(test.Execute()) .AppendLine(); } return(composer.ToString()); }
public static string InitializeGMac() { var log = new LinearComposer(); try { log.Append("Initializing GA Data..."); GMacLookupTables.Choose(1, 1); log.AppendLine("Done").AppendLine(); log.Append("Initializing GMac Resources..."); if (Directory.Exists(IconsPath) == false) { Directory.CreateDirectory(IconsPath); } SaveIcon(Resources.BasisVector64, "BasisVector64"); SaveIcon(Resources.Compile64, "Compile64"); SaveIcon(Resources.Constant64, "Constant64"); SaveIcon(Resources.Filter64, "Filter64"); SaveIcon(Resources.Frame64, "Frame64"); SaveIcon(Resources.GMacAST64, "GMacAST64"); SaveIcon(Resources.GMac_Icon64, "GMac_Icon64"); SaveIcon(Resources.Idea64, "Idea64"); SaveIcon(Resources.Input64, "Input64"); SaveIcon(Resources.Macro64, "Macro64"); SaveIcon(Resources.Namespace64, "Namespace64"); SaveIcon(Resources.Output64, "Output64"); SaveIcon(Resources.Scalar64, "Scalar64"); SaveIcon(Resources.Structure64, "Structure64"); SaveIcon(Resources.Subspace64, "Subspace64"); SaveIcon(Resources.Transform64, "Transform64"); log.AppendLine("Done").AppendLine(); log.Append("Initializing Symbolic Engine..."); MathematicaScalar.Create(SymbolicUtils.Cas, "0"); log.AppendLine("Done").AppendLine(); } catch (Exception e) { log.AppendLine("Failed").AppendLine(e.Message).AppendLine(); } return(log.ToString()); }
/// <summary> /// Set final text to the text generated from the linear composer and clear the linear composer /// </summary> /// <returns></returns> public TextFileComposer FinalizeText() { if (IsFinalized) { return(this); } FinalText = _textComposer.ToString(); _textComposer = null; IsFinalized = true; return(this); }
public void SaveScript(string filePath) { var composer = new LinearComposer(); composer .AppendLine("[shortcuts]") .AppendLine(Ipr.Shortcuts) .AppendLine("[namespaces]") .AppendLine(OpenedNamespaces.Concatenate(Environment.NewLine)) .AppendLine() .AppendLine("[members]") .AppendLine(ScriptClassMembersText) .AppendLine("[script]") .AppendLine(ScriptText); File.WriteAllText(filePath, composer.ToString()); }
//private void ComputeTableSize() //{ //} public override string ToString() { var rowHeadersWidth = RowsInfo.Max(r => r.Header.Length); var colHeadersWidth = ColumnsInfo.Max(c => c.Header.Length); var maxItemWidth = Math.Max(rowHeadersWidth, colHeadersWidth); for (var c = 0; c < Columns; c++) { for (var r = 0; r < Rows; r++) { if (maxItemWidth < Items[r, c].Length) { maxItemWidth = Items[r, c].Length; } } } var composer = new LinearComposer(); //Add column headers composer.Append(FormatItem("", maxItemWidth)); for (var c = 0; c < Columns; c++) { composer.Append(FormatItem(ColumnsInfo[c].Header, maxItemWidth)); } composer.AppendLine(); //Add rows for (var r = 0; r < Rows; r++) { composer.Append(FormatItem(RowsInfo[r].Header, maxItemWidth)); for (var c = 0; c < Columns; c++) { composer.Append(FormatItem(Items[r, c], maxItemWidth)); } composer.AppendLine(); } return(composer.ToString()); }
/// <summary> /// This method generates a full report regarding any errors in the structure /// of this AST /// </summary> /// <returns></returns> public string VerifyAst() { var composer = new LinearComposer(); //Chack for macros without a command body foreach (var macro in this.Macros()) { if (macro.SymbolBody == null) { composer .AppendAtNewLine("Macro <") .Append(macro.SymbolAccessName) .AppendLine("> Has null Command Body!"); } } return(composer.ToString()); }
private string GenerateIsEqualMethod() { var codeText = GenerateIsEqualMethodCode(); var template = new ParametricComposer("#", "#", BilinearTemplateText); var composer = new LinearComposer(); composer.Append( template, "result_type", "bool", "op_name", "IsEqual", "mv_class_name", CalcClassData.ClassName, "code", codeText ); return(composer.ToString()); }
public override string ToString() { var composer = new LinearComposer(); composer .AppendLineAtNewLine(@"<TR>") .IncreaseIndentation(); foreach (var cell in _cells) { composer.AppendLineAtNewLine(cell.ToString()); } composer .DecreaseIndentation() .AppendAtNewLine(@"</TR>"); return(composer.ToString()); }
public override string ToString() { var s = new LinearComposer(); s.Append(ProgressId.ToString("D6")).Append(": ").Append(FullTimingText); s.AppendLineAtNewLine(FullTitle); if (String.IsNullOrEmpty(Details) == false) { s.AppendLineAtNewLine() .AppendLineAtNewLine("Begin Details") .IncreaseIndentation() .AppendAtNewLine(Details) .DecreaseIndentation() .AppendLineAtNewLine("End Details"); } return(s.ToString()); }
private string GenerateProductMethod(string macroName) { string resultClassName; var codeText = GenerateProductMethodCode(macroName, out resultClassName); var template = new ParametricComposer("#", "#", BilinearTemplateText); var composer = new LinearComposer(); composer.Append( template, "result_type", resultClassName, "op_name", BaseMacro.Name, "mv_class_name", CalcClassData.ClassName, "code", codeText ); return(composer.ToString()); }
private string GenerateSubtractMethod() { var resultId = ClassData.ClassId | CalcClassData.ClassId; var resultClassData = MvLibraryGenerator.MultivectorClassesData[resultId]; var codeText = GenerateSubtractMethodCode(resultClassData); var template = new ParametricComposer("#", "#", BilinearTemplateText); var composer = new LinearComposer(); composer.Append( template, "result_type", resultClassData.ClassName, "op_name", "Subtract", "mv_class_name", CalcClassData.ClassName, "code", codeText ); return(composer.ToString()); }
private string GenerateClassCode() { var macroNames = new[] { DefaultMacro.EuclideanBinary.OuterProduct, DefaultMacro.MetricBinary.GeometricProduct, DefaultMacro.MetricBinary.LeftContractionProduct, DefaultMacro.MetricBinary.RightContractionProduct, DefaultMacro.MetricBinary.ScalarProduct }; var composer = new LinearComposer(); if (MvLibraryGenerator.MacroGenDefaults.AllowGenerateMacroCode) { foreach (var macroName in macroNames) { composer.AppendAtNewLine( GenerateProductMethod(macroName) ); } } composer.AppendAtNewLine( GenerateAddMethod() ); composer.AppendAtNewLine( GenerateSubtractMethod() ); composer.AppendAtNewLine( GenerateIsEqualMethod() ); return(composer.ToString()); }
public abstract void ToString(LinearComposer textBuilder);
public override string ToString() { var textComposer = new LinearComposer(); var idStack = new Stack <ulong>(); var nodeStack = new Stack <IGMacBinaryTreeNode <T> >(); idStack.Push(0ul); nodeStack.Push(this); while (nodeStack.Count > 0) { var id = idStack.Pop(); var node = nodeStack.Pop(); var level = TreeDepth - node.TreeDepth; if (node.IsLeafNode) { textComposer .AppendAtNewLine("<") .Append(id.PatternToString(level)) .Append("> ") .Append("".PadRight(level * 2, ' ')) .Append("Leaf { ") .Append(node.Value.ToString()) .AppendLine(" }"); continue; } if (node.TreeDepth == TreeDepth) { textComposer .AppendAtNewLine("<") .Append("".PadRight(TreeDepth, '-')) .Append("> ") .AppendLine("Root"); } else { textComposer .AppendAtNewLine("<") .Append( id .PatternToString(TreeDepth) .Substring(0, level) .PadRight(TreeDepth, '-') ) .Append("> ") .Append("".PadRight(level * 2, ' ')) .AppendLine("Node"); } if (node.HasChildNode1) { idStack.Push(id | node.ChildNode1.BitMask); nodeStack.Push(node.ChildNode1); } if (node.HasChildNode0) { idStack.Push(id); nodeStack.Push(node.ChildNode0); } } return(textComposer.ToString()); }
public override void ToString(LinearComposer textBuilder) { textBuilder.Append(Value.ToString()); }
public LcLineCount(LinearComposer parentComposer, string formatString) { ParentComposer = parentComposer; FormatString = formatString; }
public LcLineCount(LinearComposer parentComposer) { ParentComposer = parentComposer; }
internal DotCodeGenContext(DotGraphType graphType) { TextComposer = new LinearComposer(); GraphType = graphType; }