Changeset 5745


Ignore:
Timestamp:
03/18/11 07:27:00 (11 years ago)
Author:
gkronber
Message:

#1418 ported formatters.

Location:
branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4
Files:
2 deleted
1 edited
3 copied

Legend:

Unmodified
Added
Removed
  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r5735 r5745  
    2525using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2626using System.Collections.Generic;
    27 using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
    2827using System;
    29 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    3028using HeuristicLab.Core;
    3129using HeuristicLab.Common;
    3230
    33 namespace HeuristicLab.Problems.DataAnalysis.Symbolic.Formatters {
     31namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    3432  [Item("LaTeX String Formatter", "Formatter for symbolic expression trees for import into LaTeX documents.")]
    3533  [StorableClass]
    36   public sealed class SymbolicExpressionTreeLatexFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
     34  public sealed class SymbolicDataAnalysisExpressionLatexFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
    3735    private List<double> constants;
    3836    private int currentLag;
    3937
    4038    [StorableConstructor]
    41     private SymbolicExpressionTreeLatexFormatter(bool deserializing) : base(deserializing) { }
    42     private SymbolicExpressionTreeLatexFormatter(SymbolicExpressionTreeLatexFormatter original, Cloner cloner)
     39    private SymbolicDataAnalysisExpressionLatexFormatter(bool deserializing) : base(deserializing) { }
     40    private SymbolicDataAnalysisExpressionLatexFormatter(SymbolicDataAnalysisExpressionLatexFormatter original, Cloner cloner)
    4341      : base(original, cloner) {
    4442      constants = new List<double>(original.constants);
    4543    }
    46     public SymbolicExpressionTreeLatexFormatter()
    47       : base("LaTeX String Formatter", "Formatter for symbolic expression trees for import into LaTeX documents.") {
     44    public SymbolicDataAnalysisExpressionLatexFormatter()
     45      : base() {
     46      Name = ItemName;
     47      Description = ItemDescription;
    4848      constants = new List<double>();
    4949    }
    5050
    5151    public override IDeepCloneable Clone(Cloner cloner) {
    52       return new SymbolicExpressionTreeLatexFormatter(this, cloner);
    53     }
    54 
    55     public string Format(SymbolicExpressionTree symbolicExpressionTree) {
     52      return new SymbolicDataAnalysisExpressionLatexFormatter(this, cloner);
     53    }
     54
     55    public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
    5656      try {
    5757        StringBuilder strBuilder = new StringBuilder();
     
    6868    }
    6969
    70     private string FormatRecursively(SymbolicExpressionTreeNode node) {
     70    private string FormatRecursively(ISymbolicExpressionTreeNode node) {
    7171      StringBuilder strBuilder = new StringBuilder();
    7272      currentLag = 0;
    7373      FormatBegin(node, strBuilder);
    7474
    75       if (node.SubTrees.Count > 0) {
    76         strBuilder.Append(FormatRecursively(node.SubTrees[0]));
    77       }
    78       foreach (SymbolicExpressionTreeNode subTree in node.SubTrees.Skip(1)) {
     75      if (node.SubtreesCount > 0) {
     76        strBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     77      }
     78      foreach (SymbolicExpressionTreeNode subTree in node.Subtrees.Skip(1)) {
    7979        FormatSep(node, strBuilder);
    8080        // format the whole subtree
     
    8787    }
    8888
    89     private void FormatBegin(SymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     89    private void FormatBegin(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    9090      if (node.Symbol is Addition) {
    9191        strBuilder.Append(@" \left( ");
    9292      } else if (node.Symbol is Subtraction) {
    93         if (node.SubTrees.Count == 1) {
     93        if (node.SubtreesCount == 1) {
    9494          strBuilder.Append(@"- \left(");
    9595        } else {
     
    9898      } else if (node.Symbol is Multiplication) {
    9999      } else if (node.Symbol is Division) {
    100         if (node.SubTrees.Count == 1) {
     100        if (node.SubtreesCount == 1) {
    101101          strBuilder.Append(@" \cfrac{1}{");
    102102        } else {
     
    105105      } else if (node.Symbol is Average) {
    106106        // skip output of (1/1) if only one subtree
    107         if (node.SubTrees.Count > 1) {
    108           strBuilder.Append(@" \cfrac{1}{" + node.SubTrees.Count + @"}");
     107        if (node.SubtreesCount > 1) {
     108          strBuilder.Append(@" \cfrac{1}{" + node.SubtreesCount + @"}");
    109109        }
    110110        strBuilder.Append(@" \left(");
     
    128128        strBuilder.Append(@" \left( \left( ");
    129129      } else if (node.Symbol is Not) {
    130         strBuilder.Append(@" -1.0 \cdot \left( ");
     130        strBuilder.Append(@" \neg \left( ");
    131131      } else if (node.Symbol is IfThenElse) {
    132132        strBuilder.Append(@"\left( \operatorname{if} \left( 0 < ");
     
    140140        strBuilder.Append(LagToString(currentLag + laggedVarNode.Lag));
    141141        constants.Add(laggedVarNode.Weight);
    142       } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols.Variable) {
     142      } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
    143143        var varNode = node as VariableTreeNode;
    144144        strBuilder.Append("c_{" + constants.Count + "} " + varNode.VariableName);
     
    182182    }
    183183
    184     private void FormatSep(SymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     184    private void FormatSep(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    185185      if (node.Symbol is Addition) {
    186186        strBuilder.Append(" + ");
     
    238238    }
    239239
    240     private void FormatEnd(SymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     240    private void FormatEnd(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
    241241      if (node.Symbol is Addition) {
    242242        strBuilder.Append(@" \right) ");
     
    246246      } else if (node.Symbol is Division) {
    247247        strBuilder.Append("} ");
    248         if (node.SubTrees.Count > 1)
     248        if (node.SubtreesCount > 1)
    249249          strBuilder.Append("{1} ");
    250         for (int i = 1; i < node.SubTrees.Count; i++) {
     250        for (int i = 1; i < node.SubtreesCount; i++) {
    251251          strBuilder.Append(" } ");
    252252        }
     
    277277      } else if (node.Symbol is Constant) {
    278278      } else if (node.Symbol is LaggedVariable) {
    279       } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols.Variable) {
     279      } else if (node.Symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
    280280      } else if (node.Symbol is ProgramRootSymbol) {
    281281        // output all constant values
  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

    r5735 r5745  
    2525using HeuristicLab.Common;
    2626using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
    27 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Symbols;
    28 using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
    2927using HeuristicLab.Problems.DataAnalysis;
    30 using HeuristicLab.Problems.DataAnalysis.Symbolic.Formatters;
    3128using System.Collections.Generic;
    3229using System;
    3330using System.Globalization;
    34 
    35 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Formatters {
    36 
    37   [Item("SymbolicExpressionTreeMATLABFormatter", "String formatter for string representations of symbolic expression trees in MATLAB syntax.")]
     31using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
     32
     33namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
     34
     35  [Item("MATLAB String Formatter", "String formatter for string representations of symbolic data analysis expressions in MATLAB syntax.")]
    3836  [StorableClass]
    39   public sealed class SymbolicExpressionTreeMATLABFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
     37  public sealed class SymbolicDataAnalysisExpressionMATLABFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
    4038    private int currentLag;
    4139
    4240    [StorableConstructor]
    43     private SymbolicExpressionTreeMATLABFormatter(bool deserializing) : base(deserializing) { }
    44     private SymbolicExpressionTreeMATLABFormatter(SymbolicExpressionTreeMATLABFormatter original, Cloner cloner) : base(original, cloner) { }
    45     public SymbolicExpressionTreeMATLABFormatter()
     41    private SymbolicDataAnalysisExpressionMATLABFormatter(bool deserializing) : base(deserializing) { }
     42    private SymbolicDataAnalysisExpressionMATLABFormatter(SymbolicDataAnalysisExpressionMATLABFormatter original, Cloner cloner) : base(original, cloner) { }
     43    public SymbolicDataAnalysisExpressionMATLABFormatter()
    4644      : base() {
    47       Name = "MATLAB String Formatter";
     45      Name = ItemName;
     46      Description = ItemDescription;
    4847    }
    4948    public override IDeepCloneable Clone(Cloner cloner) {
    50       return new SymbolicExpressionTreeMATLABFormatter(this, cloner);
     49      return new SymbolicDataAnalysisExpressionMATLABFormatter(this, cloner);
    5150    }
    5251    private int currentIndexNumber;
     
    6564    }
    6665
    67     public string Format(SymbolicExpressionTree symbolicExpressionTree) {
     66    public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
    6867      currentLag = 0;
    6968      currentIndexNumber = 0;
     
    7170    }
    7271
    73     private string FormatRecursively(SymbolicExpressionTreeNode node) {
    74       Symbol symbol = node.Symbol;
     72    private string FormatRecursively(ISymbolicExpressionTreeNode node) {
     73      ISymbol symbol = node.Symbol;
    7574      StringBuilder stringBuilder = new StringBuilder();
    7675
     
    8483        foreach (string variableName in variableNames)
    8584          stringBuilder.AppendLine("  " + variableName + " = Data(:, ???);");
    86         stringBuilder.AppendLine("  for "+CurrentIndexVariable+" = size(Data,1):-1:1");
    87         stringBuilder.AppendLine("    Target_estimated("+CurrentIndexVariable+") = " + FormatRecursively(node.SubTrees[0]) + ";");
     85        stringBuilder.AppendLine("  for " + CurrentIndexVariable + " = size(Data,1):-1:1");
     86        stringBuilder.AppendLine("    Target_estimated(" + CurrentIndexVariable + ") = " + FormatRecursively(node.GetSubtree(0)) + ";");
    8887        stringBuilder.AppendLine("  end");
    8988        stringBuilder.AppendLine("end");
     
    102101
    103102      if (symbol is StartSymbol)
    104         return FormatRecursively(node.SubTrees[0]);
     103        return FormatRecursively(node.GetSubtree(0));
    105104
    106105      stringBuilder.Append("(");
    107106
    108107      if (symbol is Addition) {
    109         for (int i = 0; i < node.SubTrees.Count; i++) {
     108        for (int i = 0; i < node.SubtreesCount; i++) {
    110109          if (i > 0) stringBuilder.Append("+");
    111           stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     110          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    112111        }
    113112      } else if (symbol is And) {
    114113        stringBuilder.Append("((");
    115         for (int i = 0; i < node.SubTrees.Count; i++) {
     114        for (int i = 0; i < node.SubtreesCount; i++) {
    116115          if (i > 0) stringBuilder.Append("&");
    117116          stringBuilder.Append("((");
    118           stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     117          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    119118          stringBuilder.Append(")>0)");
    120119        }
     
    122121      } else if (symbol is Average) {
    123122        stringBuilder.Append("(1/");
    124         stringBuilder.Append(node.SubTrees.Count);
     123        stringBuilder.Append(node.SubtreesCount);
    125124        stringBuilder.Append(")*(");
    126         for (int i = 0; i < node.SubTrees.Count; i++) {
     125        for (int i = 0; i < node.SubtreesCount; i++) {
    127126          if (i > 0) stringBuilder.Append("+");
    128127          stringBuilder.Append("(");
    129           stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     128          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    130129          stringBuilder.Append(")");
    131130        }
     
    136135      } else if (symbol is Cosine) {
    137136        stringBuilder.Append("cos(");
    138         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     137        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    139138        stringBuilder.Append(")");
    140139      } else if (symbol is Division) {
    141         if (node.SubTrees.Count == 1) {
     140        if (node.SubtreesCount == 1) {
    142141          stringBuilder.Append("1/");
    143           stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     142          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    144143        } else {
    145           stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     144          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    146145          stringBuilder.Append("/(");
    147           for (int i = 1; i < node.SubTrees.Count; i++) {
     146          for (int i = 1; i < node.SubtreesCount; i++) {
    148147            if (i > 1) stringBuilder.Append("*");
    149             stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     148            stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    150149          }
    151150          stringBuilder.Append(")");
     
    153152      } else if (symbol is Exponential) {
    154153        stringBuilder.Append("exp(");
    155         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     154        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    156155        stringBuilder.Append(")");
    157156      } else if (symbol is GreaterThan) {
    158157        stringBuilder.Append("((");
    159         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     158        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    160159        stringBuilder.Append(">");
    161         stringBuilder.Append(FormatRecursively(node.SubTrees[1]));
     160        stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
    162161        stringBuilder.Append(")-0.5)*2"); // MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
    163162      } else if (symbol is IfThenElse) {
    164163        stringBuilder.Append("(");
    165         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     164        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    166165        stringBuilder.Append(">0)*");
    167         stringBuilder.Append(FormatRecursively(node.SubTrees[1]));
     166        stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
    168167        stringBuilder.Append("+");
    169168        stringBuilder.Append("(");
    170         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     169        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    171170        stringBuilder.Append("<=0)*");
    172         stringBuilder.Append(FormatRecursively(node.SubTrees[2]));
     171        stringBuilder.Append(FormatRecursively(node.GetSubtree(2)));
    173172      } else if (symbol is LaggedVariable) {
    174173        // this if must be checked before if(symbol is LaggedVariable)
     
    179178      } else if (symbol is LessThan) {
    180179        stringBuilder.Append("((");
    181         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     180        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    182181        stringBuilder.Append("<");
    183         stringBuilder.Append(FormatRecursively(node.SubTrees[1]));
     182        stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
    184183        stringBuilder.Append(")-0.5)*2"); // MATLAB maps false and true to 0 and 1, resp., we map this result to -1.0 and +1.0, resp.
    185184      } else if (symbol is Logarithm) {
    186185        stringBuilder.Append("log_(");
    187         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     186        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    188187        stringBuilder.Append(")");
    189188      } else if (symbol is Multiplication) {
    190         for (int i = 0; i < node.SubTrees.Count; i++) {
     189        for (int i = 0; i < node.SubtreesCount; i++) {
    191190          if (i > 0) stringBuilder.Append("*");
    192           stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     191          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    193192        }
    194193      } else if (symbol is Not) {
    195         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
    196         stringBuilder.Append("*-1");
     194        stringBuilder.Append("~(");
     195        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     196        stringBuilder.Append(" > 0 )");
    197197      } else if (symbol is Or) {
    198198        stringBuilder.Append("((");
    199         for (int i = 0; i < node.SubTrees.Count; i++) {
     199        for (int i = 0; i < node.SubtreesCount; i++) {
    200200          if (i > 0) stringBuilder.Append("|");
    201201          stringBuilder.Append("((");
    202           stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     202          stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    203203          stringBuilder.Append(")>0)");
    204204        }
     
    206206      } else if (symbol is Sine) {
    207207        stringBuilder.Append("sin(");
    208         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     208        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    209209        stringBuilder.Append(")");
    210210      } else if (symbol is Subtraction) {
    211         if (node.SubTrees.Count == 1) {
     211        if (node.SubtreesCount == 1) {
    212212          stringBuilder.Append("-1*");
    213           stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     213          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    214214        } else {
    215           stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
    216           for (int i = 1; i < node.SubTrees.Count; i++) {
     215          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     216          for (int i = 1; i < node.SubtreesCount; i++) {
    217217            stringBuilder.Append("-");
    218             stringBuilder.Append(FormatRecursively(node.SubTrees[i]));
     218            stringBuilder.Append(FormatRecursively(node.GetSubtree(i)));
    219219          }
    220220        }
    221221      } else if (symbol is Tangent) {
    222222        stringBuilder.Append("tan(");
    223         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
    224         stringBuilder.Append(")");
    225       } else if (symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols.Variable) {
     223        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     224        stringBuilder.Append(")");
     225      } else if (symbol is HeuristicLab.Problems.DataAnalysis.Symbolic.Variable) {
    226226        VariableTreeNode variableTreeNode = node as VariableTreeNode;
    227227        stringBuilder.Append(variableTreeNode.Weight.ToString(CultureInfo.InvariantCulture));
     
    230230      } else if (symbol is Power) {
    231231        stringBuilder.Append("(");
    232         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     232        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    233233        stringBuilder.Append(")^round(");
    234         stringBuilder.Append(FormatRecursively(node.SubTrees[1]));
     234        stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
    235235        stringBuilder.Append(")");
    236236      } else if (symbol is Root) {
    237237        stringBuilder.Append("(");
    238         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     238        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    239239        stringBuilder.Append(")^(1 / round(");
    240         stringBuilder.Append(FormatRecursively(node.SubTrees[1]));
     240        stringBuilder.Append(FormatRecursively(node.GetSubtree(1)));
    241241        stringBuilder.Append("))");
    242242      } else if (symbol is Derivative) {
    243243        stringBuilder.Append("fivePoint(");
    244244        // f0
    245         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     245        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    246246        stringBuilder.Append(", ");
    247247        // f1
    248248        currentLag--;
    249         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     249        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    250250        stringBuilder.Append(", ");
    251251        // f3
    252252        currentLag -= 2;
    253         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     253        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    254254        stringBuilder.Append(", ");
    255255        currentLag--;
    256256        // f4
    257         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     257        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    258258        stringBuilder.Append(")");
    259259        currentLag += 4;
     
    262262        string prevCounterVariable = CurrentIndexVariable;
    263263        string counterVariable = AllocateIndexVariable();
    264         stringBuilder.AppendLine(" sum (map(@(" + counterVariable + ") " + FormatRecursively(node.SubTrees[0]) + ", (" + prevCounterVariable + "+" + laggedNode.Lag + "):" + prevCounterVariable + "))");
     264        stringBuilder.AppendLine(" sum (map(@(" + counterVariable + ") " + FormatRecursively(node.GetSubtree(0)) + ", (" + prevCounterVariable + "+" + laggedNode.Lag + "):" + prevCounterVariable + "))");
    265265        ReleaseIndexVariable();
    266266      } else if (symbol is TimeLag) {
    267267        var laggedNode = node as LaggedTreeNode;
    268268        currentLag += laggedNode.Lag;
    269         stringBuilder.Append(FormatRecursively(node.SubTrees[0]));
     269        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    270270        currentLag -= laggedNode.Lag;
    271271      } else {
  • branches/DataAnalysis Refactoring/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

    r5733 r5745  
    119119    </Compile>
    120120    <Compile Include="Analyzers\SymbolicDataAnalysisVariableFrequencyAnalyzer.cs" />
     121    <Compile Include="Formatters\SymbolicDataAnalysisExpressionLatexFormatter.cs" />
     122    <Compile Include="Formatters\SymbolicDataAnalysisExpressionMATLABFormatter.cs" />
    121123    <Compile Include="Interfaces\ISymbolicDataAnalysisBoundedOperator.cs" />
    122124    <Compile Include="Interfaces\ISymbolicDataAnalysisExpressionTreeInterpreter.cs" />
Note: See TracChangeset for help on using the changeset viewer.