Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
05/06/19 14:20:06 (6 years ago)
Author:
msemenki
Message:

#2988: New version of class structure.

Location:
branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic
Files:
23 edited

Legend:

Unmodified
Added
Removed

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelClustersFrequencyAnalyzer.cs

    r16734 r16899  
    4343
    4444    #region parameter properties
     45    [Storable]
    4546    public ILookupParameter<DataTable> ModelClustersFrequencyParameter {
    4647      get { return (ILookupParameter<DataTable>)Parameters[ModelClustersFrequencyParameterName]; }
    4748    }
     49    [Storable]
    4850    public IValueLookupParameter<BoolValue> AggregateModelClustersParameter {
    4951      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateModelClustersParameterName]; }
    … …  
    5456      get { return AggregateModelClustersParameter.ActualValue; }
    5557      set { AggregateModelClustersParameter.Value = value; }
     58    }
     59    public DataTable ModelClustersFrequency {
     60      get { return ModelClustersFrequencyParameter.ActualValue; }
     61      set { ModelClustersFrequencyParameter.ActualValue = value; }
    5662    }
    5763    #endregion

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelsFrequencyAnalyzer.cs

    r16734 r16899  
    4343
    4444    #region parameter properties
     45    [Storable]
    4546    public ILookupParameter<DataTable> ModelFrequencyParameter {
    4647      get { return (ILookupParameter<DataTable>)Parameters[ModelsFrequencyParameterName]; }
    4748    }
     49    [Storable]
    4850    public IValueLookupParameter<BoolValue> AggregateModelParameter {
    4951      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateModelParameterName]; }
    … …  
    5456      get { return AggregateModelParameter.ActualValue; }
    5557      set { AggregateModelParameter.Value = value; }
     58    }
     59    public DataTable ModelFrequency {
     60      get { return ModelFrequencyParameter.ActualValue; }
     61      set { ModelFrequencyParameter.ActualValue = value; }
    5662    }
    5763    #endregion

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/TerminalNodesFrequencyAnalyzer.cs

    r16760 r16899  
    4343
    4444    #region parameter properties
     45    [Storable]
    4546    public ILookupParameter<DataTable> TerminalNodesFrequencyParameter {
    4647      get { return (ILookupParameter<DataTable>)Parameters[TerminalNodesFrequencyParameterName]; }
    4748    }
     49    [Storable]
    4850    public IValueLookupParameter<BoolValue> AggregateTerminalNodesParameter {
    4951      get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateTerminalNodesParameterName]; }
    … …  
    5557      set { AggregateTerminalNodesParameter.Value = value; }
    5658    }
     59    public DataTable TerminalNodesFrequency {
     60      get { return TerminalNodesFrequencyParameter.ActualValue; }
     61      set { TerminalNodesFrequencyParameter.ActualValue = value; }
     62    }
     63
    5764    #endregion
    5865    [StorableConstructor]

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

    r16565 r16899  
    8383        if (branch.SubtreeCount >= 2) {
    8484          var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
    85           var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();
    8685          var fprime = Derive(f, variableName);
    87           var gprime = Derive(g, variableName);
    88           var fgPrime = Sum(Product(f, gprime), Product(fprime, g));
    89           for (int i = 2; i < branch.SubtreeCount; i++) {
     86          for (int i = 1; i < branch.SubtreeCount; i++) {
     87            var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(i).Clone();
    9088            var fg = Product((ISymbolicExpressionTreeNode)f.Clone(), (ISymbolicExpressionTreeNode)g.Clone());
    91             var h = (ISymbolicExpressionTreeNode)branch.GetSubtree(i).Clone();
    92             var hPrime = Derive(h, variableName);
    93             fgPrime = Sum(Product(fgPrime, h), Product(fg, hPrime));
     89            var gPrime = Derive(g, variableName);
     90            var fgPrime = Sum(Product(fprime, g), Product(gPrime, f));
     91            // prepare for next iteration
     92            f = fg;
     93            fprime = fgPrime;
    9494          }
    95           return fgPrime;
     95          return fprime;
    9696        } else
    9797          // multiplication with only one argument has no effect -> derive the argument

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs

    r16565 r16899  
    3838      double @const = 0) {
    3939
    40       if (factorCoefficients.Length == 0 && coefficients.Length == 0) throw new ArgumentException();
     40      if (factorCoefficients.Length == 0 && coefficients.Length == 0 && @const==0) throw new ArgumentException();
     41
     42      // Combine both trees
     43      ISymbolicExpressionTreeNode add = (new Addition()).CreateTreeNode();
    4144
    4245      // Create tree for double variables
    43       ISymbolicExpressionTree tree = null;     
    4446      if (coefficients.Length > 0) {
    45         tree = CreateTree(variableNames, new int[variableNames.Length], coefficients, @const);
    46         if (factorCoefficients.Length == 0) return tree;
     47        var varTree = CreateTree(variableNames, new int[variableNames.Length], coefficients);
     48        foreach (var varNode in varTree.IterateNodesPrefix().OfType<VariableTreeNode>())
     49          add.AddSubtree(varNode);
    4750      }
    4851
    4952      // Create tree for string variables
    50       ISymbolicExpressionTree factorTree = null;     
    5153      if (factorCoefficients.Length > 0) {
    52         factorTree = CreateTree(factors, factorCoefficients, @const);
    53         if (tree == null) return factorTree; 
     54        var factorTree = CreateTree(factors, factorCoefficients);
     55        foreach (var binFactorNode in factorTree.IterateNodesPrefix().OfType<BinaryFactorVariableTreeNode>())
     56          add.AddSubtree(binFactorNode);
    5457      }
    5558
    56       // Combine both trees
    57       ISymbolicExpressionTreeNode add = tree.Root.GetSubtree(0).GetSubtree(0);
    58       foreach (var binFactorNode in factorTree.IterateNodesPrefix().OfType<BinaryFactorVariableTreeNode>())
    59         add.InsertSubtree(add.SubtreeCount - 1, binFactorNode);
     59      if (@const!=0.0) {
     60        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
     61        cNode.Value = @const;
     62        add.AddSubtree(cNode);
     63      }
     64
     65      ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
     66      ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
     67      tree.Root.AddSubtree(startNode);
     68      startNode.AddSubtree(add);
    6069      return tree;
    61 
    62       throw new ArgumentException();
    6370    }
    6471

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

    r16722 r16899  
    137137        } else if (node.Symbol is SquareRoot) {
    138138          FormatFunction(node, "Math.Sqrt", strBuilder);
     139        } else if (node.Symbol is Cube) {
     140          FormatPower(node, strBuilder, "3");
     141        } else if (node.Symbol is CubeRoot) {
     142          FormatPower(node, strBuilder, "1.0/3");
    139143        } else if (node.Symbol is Power) {
    140144          FormatFunction(node, "Math.Pow", strBuilder);
    141145        } else if (node.Symbol is Root) {
    142146          FormatRoot(node, strBuilder);
     147        } else if (node.Symbol is Absolute) {
     148          FormatFunction(node, "Math.Abs", strBuilder);
     149        } else if (node.Symbol is AnalyticQuotient) {
     150          strBuilder.Append("(");
     151          FormatRecursively(node.GetSubtree(0), strBuilder);
     152          strBuilder.Append(" / Math.Sqrt(1 + Math.Pow(");
     153          FormatRecursively(node.GetSubtree(1), strBuilder);
     154          strBuilder.Append(" , 2) )");
    143155        } else {
    144156          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");
    … …  
    173185
    174186    private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     187      FormatPower(node, strBuilder, "2");
     188    }
     189    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
    175190      strBuilder.Append("Math.Pow(");
    176191      FormatRecursively(node.GetSubtree(0), strBuilder);
    177       strBuilder.Append(", 2)");
     192      strBuilder.Append($", {exponent})");
    178193    }
    179194

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs

    r16722 r16899  
    119119        }
    120120        stringBuilder.Append(")");
     121      } else if (symbol is Absolute) {
     122        stringBuilder.Append($"ABS({FormatRecursively(node.GetSubtree(0))})");
     123      } else if (symbol is AnalyticQuotient) {
     124        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / SQRT(1 + POWER({FormatRecursively(node.GetSubtree(1))}, 2))");
    121125      } else if (symbol is Average) {
    122         stringBuilder.Append("(1/");
     126        stringBuilder.Append("(1/(");
    123127        stringBuilder.Append(node.SubtreeCount);
    124128        stringBuilder.Append(")*(");
    … …  
    129133          stringBuilder.Append(")");
    130134        }
    131         stringBuilder.Append(")");
     135        stringBuilder.Append("))");
    132136      } else if (symbol is Constant) {
    133137        ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
    … …  
    137141        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    138142        stringBuilder.Append(")");
     143      } else if (symbol is Cube) {
     144        stringBuilder.Append($"POWER({FormatRecursively(node.GetSubtree(0))}, 3)");
     145      } else if (symbol is CubeRoot) {
     146        stringBuilder.Append($"POWER({FormatRecursively(node.GetSubtree(0))}, 1/3)");
    139147      } else if (symbol is Division) {
    140148        if (node.SubtreeCount == 1) {
    141           stringBuilder.Append("1/");
    142           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     149          stringBuilder.Append("1/(");
     150          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     151          stringBuilder.Append(")");
    143152        } else {
    144153          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r16722 r16899  
    117117          strBuilder.Append(@" \cfrac{ ");
    118118        }
     119      } else if (node.Symbol is Absolute) {
     120        strBuilder.Append(@"\operatorname{abs} \left( ");
     121      } else if (node.Symbol is AnalyticQuotient) {
     122        strBuilder.Append(@" \frac { ");
    119123      } else if (node.Symbol is Average) {
    120124        // skip output of (1/1) if only one subtree
    … …  
    131135      } else if (node.Symbol is SquareRoot) {
    132136        strBuilder.Append(@"\sqrt{");
     137      } else if (node.Symbol is Cube) {
     138        strBuilder.Append(@"\left(");
     139      } else if (node.Symbol is CubeRoot) {
     140        strBuilder.Append(@"\left(");
    133141      } else if (node.Symbol is Sine) {
    134142        strBuilder.Append(@"\sin \left( ");
    … …  
    289297        else
    290298          strBuilder.Append(@" }{ \cfrac{ ");
     299      } else if (node.Symbol is Absolute) {
     300        throw new InvalidOperationException();
     301      } else if (node.Symbol is AnalyticQuotient) {
     302        strBuilder.Append(@"}{\sqrt{1 + \left( ");
    291303      } else if (node.Symbol is Average) {
    292304        strBuilder.Append(@" + ");
    … …  
    298310        throw new InvalidOperationException();
    299311      } else if (node.Symbol is SquareRoot) {
     312        throw new InvalidOperationException();
     313      } else if (node.Symbol is Cube) {
     314        throw new InvalidOperationException();
     315      } else if (node.Symbol is CubeRoot) {
    300316        throw new InvalidOperationException();
    301317      } else if (node.Symbol is Sine) {
    … …  
    387403        for (int i = 2; i < node.SubtreeCount; i++)
    388404          strBuilder.Append(" } ");
     405      } else if (node.Symbol is Absolute) {
     406        strBuilder.Append(@" \right)");
     407      } else if (node.Symbol is AnalyticQuotient) {
     408        strBuilder.Append(@" \right)^2}}");
    389409      } else if (node.Symbol is Average) {
    390410        strBuilder.Append(@" \right) ");
    … …  
    397417      } else if (node.Symbol is SquareRoot) {
    398418        strBuilder.Append(@"}");
     419      } else if (node.Symbol is Cube) {
     420        strBuilder.Append(@"\right)^3");
     421      } else if (node.Symbol is CubeRoot) {
     422        strBuilder.Append(@"\right)^\frac{1}{3}");
    399423      } else if (node.Symbol is Sine) {
    400424        strBuilder.Append(@" \right) ");

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

    r16722 r16899  
    126126        }
    127127        stringBuilder.Append(")");
     128      } else if (symbol is Absolute) {
     129        stringBuilder.Append($"abs({FormatRecursively(node.GetSubtree(0))})");
     130      } else if (symbol is AnalyticQuotient) {
     131        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / sqrt(1 + ({FormatRecursively(node.GetSubtree(1))}).^2)");
    128132      } else if (symbol is And) {
    129133        stringBuilder.Append("((");
    … …  
    179183        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    180184        stringBuilder.Append(")");
     185      } else if (symbol is Cube) {
     186        stringBuilder.Append("(");
     187        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     188        stringBuilder.Append(").^3");
     189      } else if (symbol is CubeRoot) {
     190        stringBuilder.Append("(");
     191        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
     192        stringBuilder.Append(").^(1/3)");
    181193      } else if (symbol is GreaterThan) {
    182194        stringBuilder.Append("((");

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs

    r16722 r16899  
    5656        if (node.Symbol is Addition) {
    5757          FormatFunction(node, "Plus", strBuilder);
     58        } else if (node.Symbol is Absolute) {
     59          FormatFunction(node, "Abs", strBuilder);
     60        } else if (node.Symbol is AnalyticQuotient) {
     61          strBuilder.Append("[");
     62          FormatRecursively(node.GetSubtree(0), strBuilder);
     63          strBuilder.Append("]/Sqrt[ 1 + Power[");
     64          FormatRecursively(node.GetSubtree(1), strBuilder);
     65          strBuilder.Append(", 2]]");
    5866        } else if (node.Symbol is Average) {
    5967          FormatAverage(node, strBuilder);
    … …  
    104112        } else if (node.Symbol is SquareRoot) {
    105113          FormatFunction(node, "Sqrt", strBuilder);
     114        } else if (node.Symbol is Cube) {
     115          FormatPower(node, strBuilder, "3");
     116        } else if (node.Symbol is CubeRoot) {
     117          FormatPower(node, strBuilder, "1/3");
    106118        } else if (node.Symbol is Power) {
    107119          FormatFunction(node, "Power", strBuilder);
    … …  
    205217
    206218    private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
     219      FormatPower(node, strBuilder, "2");
     220    }
     221
     222    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
    207223      strBuilder.Append("Power[");
    208224      FormatRecursively(node.GetSubtree(0), strBuilder);
    209       strBuilder.Append(", 2]");
     225      strBuilder.Append($", {exponent}]");
    210226    }
    211227

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs

    r16722 r16899  
    2020#endregion
    2121
     22using System;
    2223using System.Globalization;
    2324using System.Text;
    … …  
    6970        }
    7071        stringBuilder.Append(") ifTrue:[1] ifFalse:[-1]");
     72      } else if (symbol is Absolute) {
     73        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) abs");
     74      } else if (symbol is AnalyticQuotient) {
     75        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / (1 + ({FormatPower(node.GetSubtree(1), "2")})) sqrt");
    7176      } else if (symbol is Average) {
    7277        stringBuilder.Append("(1/");
    … …  
    8489        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    8590        stringBuilder.Append(" cos");
     91      } else if (symbol is Cube) {
     92        stringBuilder.Append(FormatPower(node.GetSubtree(0), "3"));
     93      } else if (symbol is CubeRoot) {
     94        stringBuilder.Append(FormatPower(node.GetSubtree(0), "(1/3)"));
    8695      } else if (symbol is Division) {
    8796        if (node.SubtreeCount == 1) {
    … …  
    146155        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
    147156        stringBuilder.Append(" sin");
     157      } else if (symbol is Square) {
     158        stringBuilder.Append(FormatPower(node.GetSubtree(0), "2"));
     159      } else if (symbol is SquareRoot) {
     160        stringBuilder.Append(FormatPower(node.GetSubtree(0), "(1/2)"));
    148161      } else if (symbol is Subtraction) {
    149162        if (node.SubtreeCount == 1) {
    … …  
    184197    }
    185198
     199    private string FormatPower(ISymbolicExpressionTreeNode node, string exponent) {
     200      return $"(({FormatRecursively(node)}) log * {exponent}) exp ";
     201    }
     202
    186203    public override IDeepCloneable Clone(Cloner cloner) {
    187204      return new SymbolicDataAnalysisExpressionSmalltalkFormatter(this, cloner);

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

    r16722 r16899  
    6969    #endregion
    7070
    71     public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
     71    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
    7272      var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
    73       return GetSymbolicExressionTreeInterval(tree, variableRanges);
    74     }
    75 
    76     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
    77       out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
     73      return GetSymbolicExpressionTreeInterval(tree, variableRanges);
     74    }
     75
     76    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
     77      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
    7878      var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
    79       return GetSymbolicExressionTreeIntervals(tree, variableRanges, out nodeIntervals);
    80     }
    81 
    82     public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
     79      return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
     80    }
     81
     82    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
    8383      lock (syncRoot) {
    8484        EvaluatedSolutions++;
    … …  
    9696
    9797
    98     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree,
    99       Dictionary<string, Interval> variableRanges, out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
     98    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
     99      IDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
    100100      lock (syncRoot) {
    101101        EvaluatedSolutions++;
    … …  
    108108      // fix incorrect intervals if necessary (could occur because of numerical errors)
    109109      nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
    110       foreach(var kvp in intervals) {
     110      foreach (var kvp in intervals) {
    111111        var interval = kvp.Value;
    112112        if (interval.IsInfiniteOrUndefined || interval.LowerBound <= interval.UpperBound)
    … …  
    124124
    125125
    126     private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
     126    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
    127127      if (variableRanges == null)
    128128        throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
    … …  
    133133      }
    134134
    135       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
    136       foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
     135      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
     136      foreach (Instruction instr in code.Where(i => i.opCode == OpCode.Variable)) {
    137137        var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
    138138        instr.data = variableRanges[variableTreeNode.VariableName];
    … …  
    141141    }
    142142
    143     private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
     143    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
    144144      Instruction currentInstr = instructions[instructionCounter];
    145145      //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
    … …  
    150150      switch (currentInstr.opCode) {
    151151        //Variables, Constants, ...
    152         case OpCodes.Variable: {
     152        case OpCode.Variable: {
    153153            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
    154154            var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
    … …  
    158158            break;
    159159          }
    160         case OpCodes.Constant: {
     160        case OpCode.Constant: {
    161161            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
    162162            result = new Interval(constTreeNode.Value, constTreeNode.Value);
    … …  
    164164          }
    165165        //Elementary arithmetic rules
    166         case OpCodes.Add: {
     166        case OpCode.Add: {
    167167            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    168168            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    172172            break;
    173173          }
    174         case OpCodes.Sub: {
     174        case OpCode.Sub: {
    175175            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    176176            if (currentInstr.nArguments == 1)
    … …  
    183183            break;
    184184          }
    185         case OpCodes.Mul: {
     185        case OpCode.Mul: {
    186186            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    187187            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    191191            break;
    192192          }
    193         case OpCodes.Div: {
     193        case OpCode.Div: {
    194194            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    195195            if (currentInstr.nArguments == 1)
    … …  
    203203          }
    204204        //Trigonometric functions
    205         case OpCodes.Sin: {
     205        case OpCode.Sin: {
    206206            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    207207            result = Interval.Sine(argumentInterval);
    208208            break;
    209209          }
    210         case OpCodes.Cos: {
     210        case OpCode.Cos: {
    211211            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    212212            result = Interval.Cosine(argumentInterval);
    213213            break;
    214214          }
    215         case OpCodes.Tan: {
     215        case OpCode.Tan: {
    216216            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    217217            result = Interval.Tangens(argumentInterval);
    218218            break;
    219219          }
     220        case OpCode.Tanh: {
     221            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
     222            result = Interval.HyperbolicTangent(argumentInterval);
     223            break;
     224          }
    220225        //Exponential functions
    221         case OpCodes.Log: {
     226        case OpCode.Log: {
    222227            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    223228            result = Interval.Logarithm(argumentInterval);
    224229            break;
    225230          }
    226         case OpCodes.Exp: {
     231        case OpCode.Exp: {
    227232            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    228233            result = Interval.Exponential(argumentInterval);
    229234            break;
    230235          }
    231         case OpCodes.Power: {
     236        case OpCode.Power: {
    232237            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    233238            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    237242            break;
    238243          }
    239         case OpCodes.Square: {
     244        case OpCode.Square: {
    240245            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    241246            result = Interval.Square(argumentInterval);
    242247            break;
    243248          }
    244         case OpCodes.Root: {
     249        case OpCode.Root: {
    245250            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    246251            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    250255            break;
    251256          }
    252         case OpCodes.SquareRoot: {
     257        case OpCode.SquareRoot: {
    253258            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    254259            result = Interval.SquareRoot(argumentInterval);

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

    r16722 r16899  
    2020#endregion
    2121
     22using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2223using System;
    2324using System.Collections.Generic;
    24 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2525
    2626namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    27   public static class OpCodes {
     27  public static class OpCode {
    2828    public const byte Add = 1;
    2929    public const byte Sub = 2;
    … …  
    9595
    9696    private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
    97        { typeof(Addition), OpCodes.Add },
    98       { typeof(Subtraction), OpCodes.Sub },
    99       { typeof(Multiplication), OpCodes.Mul },
    100       { typeof(Division), OpCodes.Div },
    101       { typeof(Sine), OpCodes.Sin },
    102       { typeof(Cosine), OpCodes.Cos },
    103       { typeof(Tangent), OpCodes.Tan },
    104       { typeof (HyperbolicTangent), OpCodes.Tanh},
    105       { typeof(Logarithm), OpCodes.Log },
    106       { typeof(Exponential), OpCodes.Exp },
    107       { typeof(IfThenElse), OpCodes.IfThenElse },
    108       { typeof(GreaterThan), OpCodes.GT },
    109       { typeof(LessThan), OpCodes.LT },
    110       { typeof(And), OpCodes.AND },
    111       { typeof(Or), OpCodes.OR },
    112       { typeof(Not), OpCodes.NOT},
    113       { typeof(Xor),OpCodes.XOR},
    114       { typeof(Average), OpCodes.Average},
    115       { typeof(InvokeFunction), OpCodes.Call },
    116       { typeof(Variable), OpCodes.Variable },
    117       { typeof(LaggedVariable), OpCodes.LagVariable },
    118       { typeof(AutoregressiveTargetVariable),OpCodes.LagVariable},
    119       { typeof(Constant), OpCodes.Constant },
    120       { typeof(TreeModel), OpCodes.TreeModel },
    121       { typeof(Argument), OpCodes.Arg },
    122       { typeof(Power),OpCodes.Power},
    123       { typeof(Root),OpCodes.Root},
    124       { typeof(TimeLag), OpCodes.TimeLag},
    125       { typeof(Integral), OpCodes.Integral},
    126       { typeof(Derivative), OpCodes.Derivative},
    127       { typeof(VariableCondition),OpCodes.VariableCondition},
    128       { typeof(Square),OpCodes.Square},
    129       { typeof(SquareRoot),OpCodes.SquareRoot},
    130       { typeof(Gamma), OpCodes.Gamma },
    131       { typeof(Psi), OpCodes.Psi },
    132       { typeof(Dawson), OpCodes.Dawson},
    133       { typeof(ExponentialIntegralEi), OpCodes.ExponentialIntegralEi },
    134       { typeof(CosineIntegral), OpCodes.CosineIntegral },
    135       { typeof(SineIntegral), OpCodes.SineIntegral },
    136       { typeof(HyperbolicCosineIntegral), OpCodes.HyperbolicCosineIntegral },
    137       { typeof(HyperbolicSineIntegral), OpCodes.HyperbolicSineIntegral },
    138       { typeof(FresnelCosineIntegral), OpCodes.FresnelCosineIntegral },
    139       { typeof(FresnelSineIntegral), OpCodes.FresnelSineIntegral },
    140       { typeof(AiryA), OpCodes.AiryA },
    141       { typeof(AiryB), OpCodes.AiryB },
    142       { typeof(Norm), OpCodes.Norm},
    143       { typeof(Erf), OpCodes.Erf},
    144       { typeof(Bessel), OpCodes.Bessel},
    145       { typeof(FactorVariable), OpCodes.FactorVariable },
    146       { typeof(BinaryFactorVariable), OpCodes.BinaryFactorVariable },
    147       { typeof(Absolute), OpCodes.Absolute },
    148       { typeof(AnalyticQuotient), OpCodes.AnalyticQuotient },
    149       { typeof(Cube), OpCodes.Cube },
    150       { typeof(CubeRoot), OpCodes.CubeRoot }
     97       { typeof(Addition), OpCode.Add },
     98      { typeof(Subtraction), OpCode.Sub },
     99      { typeof(Multiplication), OpCode.Mul },
     100      { typeof(Division), OpCode.Div },
     101      { typeof(Sine), OpCode.Sin },
     102      { typeof(Cosine), OpCode.Cos },
     103      { typeof(Tangent), OpCode.Tan },
     104      { typeof (HyperbolicTangent), OpCode.Tanh},
     105      { typeof(Logarithm), OpCode.Log },
     106      { typeof(Exponential), OpCode.Exp },
     107      { typeof(IfThenElse), OpCode.IfThenElse },
     108      { typeof(GreaterThan), OpCode.GT },
     109      { typeof(LessThan), OpCode.LT },
     110      { typeof(And), OpCode.AND },
     111      { typeof(Or), OpCode.OR },
     112      { typeof(Not), OpCode.NOT},
     113      { typeof(Xor),OpCode.XOR},
     114      { typeof(Average), OpCode.Average},
     115      { typeof(InvokeFunction), OpCode.Call },
     116      { typeof(Variable), OpCode.Variable },
     117      { typeof(LaggedVariable), OpCode.LagVariable },
     118      { typeof(AutoregressiveTargetVariable),OpCode.LagVariable},
     119      { typeof(Constant), OpCode.Constant },
     120      { typeof(TreeModel), OpCode.TreeModel },
     121      { typeof(Argument), OpCode.Arg },
     122      { typeof(Power),OpCode.Power},
     123      { typeof(Root),OpCode.Root},
     124      { typeof(TimeLag), OpCode.TimeLag},
     125      { typeof(Integral), OpCode.Integral},
     126      { typeof(Derivative), OpCode.Derivative},
     127      { typeof(VariableCondition),OpCode.VariableCondition},
     128      { typeof(Square),OpCode.Square},
     129      { typeof(SquareRoot),OpCode.SquareRoot},
     130      { typeof(Gamma), OpCode.Gamma },
     131      { typeof(Psi), OpCode.Psi },
     132      { typeof(Dawson), OpCode.Dawson},
     133      { typeof(ExponentialIntegralEi), OpCode.ExponentialIntegralEi },
     134      { typeof(CosineIntegral), OpCode.CosineIntegral },
     135      { typeof(SineIntegral), OpCode.SineIntegral },
     136      { typeof(HyperbolicCosineIntegral), OpCode.HyperbolicCosineIntegral },
     137      { typeof(HyperbolicSineIntegral), OpCode.HyperbolicSineIntegral },
     138      { typeof(FresnelCosineIntegral), OpCode.FresnelCosineIntegral },
     139      { typeof(FresnelSineIntegral), OpCode.FresnelSineIntegral },
     140      { typeof(AiryA), OpCode.AiryA },
     141      { typeof(AiryB), OpCode.AiryB },
     142      { typeof(Norm), OpCode.Norm},
     143      { typeof(Erf), OpCode.Erf},
     144      { typeof(Bessel), OpCode.Bessel},
     145      { typeof(FactorVariable), OpCode.FactorVariable },
     146      { typeof(BinaryFactorVariable), OpCode.BinaryFactorVariable },
     147      { typeof(Absolute), OpCode.Absolute },
     148      { typeof(AnalyticQuotient), OpCode.AnalyticQuotient },
     149      { typeof(Cube), OpCode.Cube },
     150      { typeof(CubeRoot), OpCode.CubeRoot }
    151151    };
    152152

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs

    r16722 r16899  
    154154    private static readonly PropertyInfo Indexer = typeof(IList<double>).GetProperty("Item");
    155155    private static Expression MakeExpr(ISymbolicExpressionTreeNode node, Dictionary<string, int> variableIndices, Expression row, Expression columns) {
    156       var opcode = OpCodes.MapSymbolToOpCode(node);
     156      var opcode = OpCode.MapSymbolToOpCode(node);
    157157      #region switch opcode
    158158      switch (opcode) {
    159         case OpCodes.Constant: {
     159        case OpCode.Constant: {
    160160            var constantTreeNode = (ConstantTreeNode)node;
    161161            return Expression.Constant(constantTreeNode.Value);
    162162          }
    163         case OpCodes.Variable: {
     163        case OpCode.Variable: {
    164164            var variableTreeNode = (VariableTreeNode)node;
    165165            var variableWeight = Expression.Constant(variableTreeNode.Weight);
    … …  
    169169            return Expression.Multiply(variableWeight, Expression.Property(valuesExpr, Indexer, row));
    170170          }
    171         case OpCodes.Add: {
     171        case OpCode.Add: {
    172172            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    173173            for (int i = 1; i < node.SubtreeCount; ++i) {
    … …  
    176176            return result;
    177177          }
    178         case OpCodes.Sub: {
     178        case OpCode.Sub: {
    179179            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    180180            if (node.SubtreeCount == 1)
    … …  
    185185            return result;
    186186          }
    187         case OpCodes.Mul: {
     187        case OpCode.Mul: {
    188188            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    189189            for (int i = 1; i < node.SubtreeCount; ++i) {
    … …  
    192192            return result;
    193193          }
    194         case OpCodes.Div: {
     194        case OpCode.Div: {
    195195            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    196196            if (node.SubtreeCount == 1)
    … …  
    201201            return result;
    202202          }
    203         case OpCodes.Average: {
     203        case OpCode.Average: {
    204204            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    205205            for (int i = 1; i < node.SubtreeCount; ++i) {
    … …  
    208208            return Expression.Divide(result, Expression.Constant((double)node.SubtreeCount));
    209209          }
    210         case OpCodes.Absolute: {
     210        case OpCode.Absolute: {
    211211            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    212212            return Expression.Call(Abs, arg);
    213213          }
    214         case OpCodes.Cos: {
     214        case OpCode.Cos: {
    215215            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    216216            return Expression.Call(Cos, arg);
    217217          }
    218         case OpCodes.Sin: {
     218        case OpCode.Sin: {
    219219            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    220220            return Expression.Call(Sin, arg);
    221221          }
    222         case OpCodes.Tan: {
     222        case OpCode.Tan: {
    223223            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    224224            return Expression.Call(Tan, arg);
    225225          }
    226         case OpCodes.Tanh: {
     226        case OpCode.Tanh: {
    227227            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    228228            return Expression.Call(Tanh, arg);
    229229          }
    230         case OpCodes.Square: {
     230        case OpCode.Square: {
    231231            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    232232            return Expression.Power(arg, Expression.Constant(2.0));
    233233          }
    234         case OpCodes.Cube: {
     234        case OpCode.Cube: {
    235235            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    236236            return Expression.Power(arg, Expression.Constant(3.0));
    237237          }
    238         case OpCodes.Power: {
     238        case OpCode.Power: {
    239239            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    240240            var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    241241            return Expression.Power(arg, Expression.Call(Round, power));
    242242          }
    243         case OpCodes.SquareRoot: {
     243        case OpCode.SquareRoot: {
    244244            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    245245            return Expression.Call(Sqrt, arg);
    246246          }
    247         case OpCodes.CubeRoot: {
     247        case OpCode.CubeRoot: {
    248248            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    249249            return Expression.Power(arg, Expression.Constant(1.0 / 3.0));
    250250          }
    251         case OpCodes.Root: {
     251        case OpCode.Root: {
    252252            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    253253            var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    254254            return Expression.Power(arg, Expression.Divide(Expression.Constant(1.0), Expression.Call(Round, power)));
    255255          }
    256         case OpCodes.Exp: {
     256        case OpCode.Exp: {
    257257            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    258258            return Expression.Call(Exp, arg);
    259259          }
    260         case OpCodes.Log: {
     260        case OpCode.Log: {
    261261            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    262262            return Expression.Call(Log, arg);
    263263          }
    264         case OpCodes.Gamma: {
     264        case OpCode.Gamma: {
    265265            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    266266            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    278278            return expr;
    279279          }
    280         case OpCodes.Psi: {
     280        case OpCode.Psi: {
    281281            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    282282            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    300300            return expr;
    301301          }
    302         case OpCodes.Dawson: {
     302        case OpCode.Dawson: {
    303303            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    304304            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    314314            return expr;
    315315          }
    316         case OpCodes.ExponentialIntegralEi: {
     316        case OpCode.ExponentialIntegralEi: {
    317317            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    318318            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    328328            return expr;
    329329          }
    330         case OpCodes.SineIntegral: {
     330        case OpCode.SineIntegral: {
    331331            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    332332            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    348348            return expr;
    349349          }
    350         case OpCodes.CosineIntegral: {
     350        case OpCode.CosineIntegral: {
    351351            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    352352            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    368368            return expr;
    369369          }
    370         case OpCodes.HyperbolicSineIntegral: {
     370        case OpCode.HyperbolicSineIntegral: {
    371371            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    372372            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    388388            return expr;
    389389          }
    390         case OpCodes.HyperbolicCosineIntegral: {
     390        case OpCode.HyperbolicCosineIntegral: {
    391391            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    392392            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    408408            return expr;
    409409          }
    410         case OpCodes.FresnelSineIntegral: {
     410        case OpCode.FresnelSineIntegral: {
    411411            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    412412            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    424424            return expr;
    425425          }
    426         case OpCodes.FresnelCosineIntegral: {
     426        case OpCode.FresnelCosineIntegral: {
    427427            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    428428            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    440440            return expr;
    441441          }
    442         case OpCodes.AiryA: {
     442        case OpCode.AiryA: {
    443443            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    444444            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    458458            return expr;
    459459          }
    460         case OpCodes.AiryB: {
     460        case OpCode.AiryB: {
    461461            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    462462            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    476476            return expr;
    477477          }
    478         case OpCodes.Norm: {
     478        case OpCode.Norm: {
    479479            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    480480            var result = Expression.Variable(typeof(double));
    … …  
    487487              result);
    488488          }
    489         case OpCodes.Erf: {
     489        case OpCode.Erf: {
    490490            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    491491            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    499499              result);
    500500          }
    501         case OpCodes.Bessel: {
     501        case OpCode.Bessel: {
    502502            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    503503            var isNaN = Expression.Call(IsNaN, arg);
    … …  
    511511              result);
    512512          }
    513         case OpCodes.AnalyticQuotient: {
     513        case OpCode.AnalyticQuotient: {
    514514            var x1 = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    515515            var x2 = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    … …  
    520520                Expression.Multiply(x2, x2))));
    521521          }
    522         case OpCodes.IfThenElse: {
     522        case OpCode.IfThenElse: {
    523523            var test = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    524524            var result = Expression.Variable(typeof(double));
    … …  
    528528            return Expression.Block(new[] { result }, condition, result);
    529529          }
    530         case OpCodes.AND: {
     530        case OpCode.AND: {
    531531            var result = Expression.Variable(typeof(double));
    532532            var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    … …  
    553553              );
    554554          }
    555         case OpCodes.OR: {
     555        case OpCode.OR: {
    556556            var result = Expression.Variable(typeof(double));
    557557            var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    … …  
    578578              );
    579579          }
    580         case OpCodes.NOT: {
     580        case OpCode.NOT: {
    581581            var value = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    582582            var result = Expression.Variable(typeof(double));
    … …  
    586586            return Expression.Block(new[] { result }, condition, result);
    587587          }
    588         case OpCodes.XOR: {
     588        case OpCode.XOR: {
    589589            var ps = Expression.Variable(typeof(int));
    590590            var block = Expression.Block(
    … …  
    617617            return xorExpr;
    618618          }
    619         case OpCodes.GT: {
     619        case OpCode.GT: {
    620620            var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    621621            var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    … …  
    629629              result);
    630630          }
    631         case OpCodes.LT: {
     631        case OpCode.LT: {
    632632            var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    633633            var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    … …  
    638638            return Expression.Block(new[] { result }, condition, result);
    639639          }
    640         case OpCodes.VariableCondition: {
     640        case OpCode.VariableCondition: {
    641641            var variableConditionTreeNode = (VariableConditionTreeNode)node;
    642642            if (variableConditionTreeNode.Symbol.IgnoreSlope) throw new NotSupportedException("Strict variable conditionals are not supported");

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

    r16722 r16899  
    6464
    6565        switch (instr.opcode) {
    66           case OpCodes.Variable: {
     66          case OpCode.Variable: {
    6767              LoadData(instr, rows, rowIndex, batchSize);
    6868              break;
    6969            }
    70           case OpCodes.TreeModel: {
     70          case OpCode.TreeModel: {
    7171              SubTreeEvoluate(instr, rows, rowIndex, batchSize);
    7272              break;
    7373            }
    7474
    75           case OpCodes.Add: {
     75          case OpCode.Add: {
    7676              Load(instr.buf, code[c].buf);
    7777              for (int j = 1; j < n; ++j) {
    … …  
    8181            }
    8282
    83           case OpCodes.Sub: {
     83          case OpCode.Sub: {
    8484              if (n == 1) {
    8585                Neg(instr.buf, code[c].buf);
    … …  
    9393            }
    9494
    95           case OpCodes.Mul: {
     95          case OpCode.Mul: {
    9696              Load(instr.buf, code[c].buf);
    9797              for (int j = 1; j < n; ++j) {
    … …  
    101101            }
    102102
    103           case OpCodes.Div: {
     103          case OpCode.Div: {
    104104              if (n == 1) {
    105105                Inv(instr.buf, code[c].buf);
    … …  
    113113            }
    114114
    115           case OpCodes.Square: {
     115          case OpCode.Square: {
    116116              Square(instr.buf, code[c].buf);
    117117              break;
    118118            }
    119119
    120           case OpCodes.Root: {
     120          case OpCode.Root: {
    121121              Load(instr.buf, code[c].buf);
    122122              Root(instr.buf, code[c + 1].buf);
    … …  
    124124            }
    125125
    126           case OpCodes.SquareRoot: {
     126          case OpCode.SquareRoot: {
    127127              Sqrt(instr.buf, code[c].buf);
    128128              break;
    129129            }
    130130
    131           case OpCodes.Cube: {
     131          case OpCode.Cube: {
    132132              Cube(instr.buf, code[c].buf);
    133133              break;
    134134            }
    135           case OpCodes.CubeRoot: {
     135          case OpCode.CubeRoot: {
    136136              CubeRoot(instr.buf, code[c].buf);
    137137              break;
    138138            }
    139139
    140           case OpCodes.Power: {
     140          case OpCode.Power: {
    141141              Load(instr.buf, code[c].buf);
    142142              Pow(instr.buf, code[c + 1].buf);
    … …  
    144144            }
    145145
    146           case OpCodes.Exp: {
     146          case OpCode.Exp: {
    147147              Exp(instr.buf, code[c].buf);
    148148              break;
    149149            }
    150150
    151           case OpCodes.Log: {
     151          case OpCode.Log: {
    152152              Log(instr.buf, code[c].buf);
    153153              break;
    154154            }
    155155
    156           case OpCodes.Sin: {
     156          case OpCode.Sin: {
    157157              Sin(instr.buf, code[c].buf);
    158158              break;
    159159            }
    160160
    161           case OpCodes.Cos: {
     161          case OpCode.Cos: {
    162162              Cos(instr.buf, code[c].buf);
    163163              break;
    164164            }
    165165
    166           case OpCodes.Tan: {
     166          case OpCode.Tan: {
    167167              Tan(instr.buf, code[c].buf);
    168168              break;
    169169            }
    170           case OpCodes.Tanh: {
     170          case OpCode.Tanh: {
    171171              Tanh(instr.buf, code[c].buf);
    172172              break;
    173173            }
    174           case OpCodes.Absolute: {
     174          case OpCode.Absolute: {
    175175              Absolute(instr.buf, code[c].buf);
    176176              break;
    177177            }
    178178
    179           case OpCodes.AnalyticQuotient: {
     179          case OpCode.AnalyticQuotient: {
    180180              Load(instr.buf, code[c].buf);
    181181              AnalyticQuotient(instr.buf, code[c + 1].buf);
    … …  
    213213      }
    214214
    215       var code = Compile(tree, dataset, OpCodes.MapSymbolToOpCode, rows);
     215      var code = Compile(tree, dataset, OpCode.MapSymbolToOpCode, rows);
    216216      var remainingRows = rows.Length % BATCHSIZE;
    217217      var roundedTotal = rows.Length - remainingRows;

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r16722 r16899  
    180180
    181181    private InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset) {
    182       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
     182      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
    183183      Dictionary<string, int> doubleVariableNames = dataset.DoubleVariables.Select((x, i) => new { x, i }).ToDictionary(e => e.x, e => e.i);
    184184      int necessaryArgStackSize = 0;
    185185      foreach (Instruction instr in code) {
    186         if (instr.opCode == OpCodes.Variable) {
     186        if (instr.opCode == OpCode.Variable) {
    187187          var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
    188188          instr.data = doubleVariableNames[variableTreeNode.VariableName];
    189         } else if (instr.opCode == OpCodes.LagVariable) {
     189        } else if (instr.opCode == OpCode.LagVariable) {
    190190          var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    191191          instr.data = doubleVariableNames[laggedVariableTreeNode.VariableName];
    192         } else if (instr.opCode == OpCodes.VariableCondition) {
     192        } else if (instr.opCode == OpCode.VariableCondition) {
    193193          var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    194194          instr.data = doubleVariableNames[variableConditionTreeNode.VariableName];
    195         } else if (instr.opCode == OpCodes.Call) {
     195        } else if (instr.opCode == OpCode.Call) {
    196196          necessaryArgStackSize += instr.nArguments + 1;
    197197        }
    … …  
    205205
    206206      switch (currentInstr.opCode) {
    207         case OpCodes.Add: {
     207        case OpCode.Add: {
    208208            if (nArgs > 0) {
    209209              CompileInstructions(il, state, ds);
    … …  
    215215            return;
    216216          }
    217         case OpCodes.Sub: {
     217        case OpCode.Sub: {
    218218            if (nArgs == 1) {
    219219              CompileInstructions(il, state, ds);
    … …  
    230230            return;
    231231          }
    232         case OpCodes.Mul: {
     232        case OpCode.Mul: {
    233233            if (nArgs > 0) {
    234234              CompileInstructions(il, state, ds);
    … …  
    240240            return;
    241241          }
    242         case OpCodes.Div: {
     242        case OpCode.Div: {
    243243            if (nArgs == 1) {
    244244              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
    … …  
    256256            return;
    257257          }
    258         case OpCodes.Average: {
     258        case OpCode.Average: {
    259259            CompileInstructions(il, state, ds);
    260260            for (int i = 1; i < nArgs; i++) {
    … …  
    266266            return;
    267267          }
    268         case OpCodes.Absolute: {
     268        case OpCode.Absolute: {
    269269            CompileInstructions(il, state, ds);
    270270            il.Emit(System.Reflection.Emit.OpCodes.Call, abs);
    271271            return;
    272272          }
    273         case OpCodes.Cos: {
     273        case OpCode.Cos: {
    274274            CompileInstructions(il, state, ds);
    275275            il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
    276276            return;
    277277          }
    278         case OpCodes.Sin: {
     278        case OpCode.Sin: {
    279279            CompileInstructions(il, state, ds);
    280280            il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
    281281            return;
    282282          }
    283         case OpCodes.Tan: {
     283        case OpCode.Tan: {
    284284            CompileInstructions(il, state, ds);
    285285            il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
    286286            return;
    287287          }
    288         case OpCodes.Tanh: {
     288        case OpCode.Tanh: {
    289289            CompileInstructions(il, state, ds);
    290290            il.Emit(System.Reflection.Emit.OpCodes.Call, tanh);
    291291            return;
    292292          }
    293         case OpCodes.Power: {
     293        case OpCode.Power: {
    294294            CompileInstructions(il, state, ds);
    295295            CompileInstructions(il, state, ds);
    … …  
    298298            return;
    299299          }
    300         case OpCodes.Root: {
     300        case OpCode.Root: {
    301301            CompileInstructions(il, state, ds);
    302302            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
    … …  
    307307            return;
    308308          }
    309         case OpCodes.Exp: {
     309        case OpCode.Exp: {
    310310            CompileInstructions(il, state, ds);
    311311            il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
    312312            return;
    313313          }
    314         case OpCodes.Log: {
     314        case OpCode.Log: {
    315315            CompileInstructions(il, state, ds);
    316316            il.Emit(System.Reflection.Emit.OpCodes.Call, log);
    317317            return;
    318318          }
    319         case OpCodes.Square: {
     319        case OpCode.Square: {
    320320            CompileInstructions(il, state, ds);
    321321            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
    … …  
    323323            return;
    324324          }
    325         case OpCodes.Cube: {
     325        case OpCode.Cube: {
    326326            CompileInstructions(il, state, ds);
    327327            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 3.0);
    … …  
    329329            return;
    330330          }
    331         case OpCodes.SquareRoot: {
     331        case OpCode.SquareRoot: {
    332332            CompileInstructions(il, state, ds);
    333333            il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
    334334            return;
    335335          }
    336         case OpCodes.CubeRoot: {
     336        case OpCode.CubeRoot: {
    337337            CompileInstructions(il, state, ds);
    338338            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
    … …  
    340340            return;
    341341          }
    342         case OpCodes.AiryA: {
     342        case OpCode.AiryA: {
    343343            CompileInstructions(il, state, ds);
    344344            il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
    345345            return;
    346346          }
    347         case OpCodes.AiryB: {
     347        case OpCode.AiryB: {
    348348            CompileInstructions(il, state, ds);
    349349            il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
    350350            return;
    351351          }
    352         case OpCodes.Bessel: {
     352        case OpCode.Bessel: {
    353353            CompileInstructions(il, state, ds);
    354354            il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
    355355            return;
    356356          }
    357         case OpCodes.CosineIntegral: {
     357        case OpCode.CosineIntegral: {
    358358            CompileInstructions(il, state, ds);
    359359            il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
    360360            return;
    361361          }
    362         case OpCodes.Dawson: {
     362        case OpCode.Dawson: {
    363363            CompileInstructions(il, state, ds);
    364364            il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
    365365            return;
    366366          }
    367         case OpCodes.Erf: {
     367        case OpCode.Erf: {
    368368            CompileInstructions(il, state, ds);
    369369            il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
    370370            return;
    371371          }
    372         case OpCodes.ExponentialIntegralEi: {
     372        case OpCode.ExponentialIntegralEi: {
    373373            CompileInstructions(il, state, ds);
    374374            il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
    375375            return;
    376376          }
    377         case OpCodes.FresnelCosineIntegral: {
     377        case OpCode.FresnelCosineIntegral: {
    378378            CompileInstructions(il, state, ds);
    379379            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
    380380            return;
    381381          }
    382         case OpCodes.FresnelSineIntegral: {
     382        case OpCode.FresnelSineIntegral: {
    383383            CompileInstructions(il, state, ds);
    384384            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
    385385            return;
    386386          }
    387         case OpCodes.Gamma: {
     387        case OpCode.Gamma: {
    388388            CompileInstructions(il, state, ds);
    389389            il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
    390390            return;
    391391          }
    392         case OpCodes.HyperbolicCosineIntegral: {
     392        case OpCode.HyperbolicCosineIntegral: {
    393393            CompileInstructions(il, state, ds);
    394394            il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
    395395            return;
    396396          }
    397         case OpCodes.HyperbolicSineIntegral: {
     397        case OpCode.HyperbolicSineIntegral: {
    398398            CompileInstructions(il, state, ds);
    399399            il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
    400400            return;
    401401          }
    402         case OpCodes.Norm: {
     402        case OpCode.Norm: {
    403403            CompileInstructions(il, state, ds);
    404404            il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
    405405            return;
    406406          }
    407         case OpCodes.Psi: {
     407        case OpCode.Psi: {
    408408            CompileInstructions(il, state, ds);
    409409            il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
    410410            return;
    411411          }
    412         case OpCodes.SineIntegral: {
     412        case OpCode.SineIntegral: {
    413413            CompileInstructions(il, state, ds);
    414414            il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
    415415            return;
    416416          }
    417         case OpCodes.AnalyticQuotient: {
     417        case OpCode.AnalyticQuotient: {
    418418            CompileInstructions(il, state, ds); // x1
    419419            CompileInstructions(il, state, ds); // x2
    … …  
    427427            return;
    428428          }
    429         case OpCodes.IfThenElse: {
     429        case OpCode.IfThenElse: {
    430430            Label end = il.DefineLabel();
    431431            Label c1 = il.DefineLabel();
    … …  
    441441            return;
    442442          }
    443         case OpCodes.AND: {
     443        case OpCode.AND: {
    444444            Label falseBranch = il.DefineLabel();
    445445            Label end = il.DefineLabel();
    … …  
    462462            return;
    463463          }
    464         case OpCodes.OR: {
     464        case OpCode.OR: {
    465465            Label trueBranch = il.DefineLabel();
    466466            Label end = il.DefineLabel();
    … …  
    490490            return;
    491491          }
    492         case OpCodes.NOT: {
     492        case OpCode.NOT: {
    493493            CompileInstructions(il, state, ds);
    494494            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0); // > 0
    … …  
    502502            return;
    503503          }
    504         case OpCodes.XOR: {
     504        case OpCode.XOR: {
    505505            CompileInstructions(il, state, ds);
    506506            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0);
    … …  
    521521            return;
    522522          }
    523         case OpCodes.GT: {
     523        case OpCode.GT: {
    524524            CompileInstructions(il, state, ds);
    525525            CompileInstructions(il, state, ds);
    … …  
    533533            return;
    534534          }
    535         case OpCodes.LT: {
     535        case OpCode.LT: {
    536536            CompileInstructions(il, state, ds);
    537537            CompileInstructions(il, state, ds);
    … …  
    544544            return;
    545545          }
    546         case OpCodes.TimeLag: {
     546        case OpCode.TimeLag: {
    547547            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    548548            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
    … …  
    560560            return;
    561561          }
    562         case OpCodes.Integral: {
     562        case OpCode.Integral: {
    563563            int savedPc = state.ProgramCounter;
    564564            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    … …  
    587587        //one sided smooth differentiatior, N = 4
    588588        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
    589         case OpCodes.Derivative: {
     589        case OpCode.Derivative: {
    590590            int savedPc = state.ProgramCounter;
    591591            CompileInstructions(il, state, ds);
    … …  
    629629            return;
    630630          }
    631         case OpCodes.Call: {
     631        case OpCode.Call: {
    632632            throw new NotSupportedException(
    633633              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
    634634          }
    635         case OpCodes.Arg: {
     635        case OpCode.Arg: {
    636636            throw new NotSupportedException(
    637637              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
    638638          }
    639         case OpCodes.Variable: {
     639        case OpCode.Variable: {
    640640            VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
    641641            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
    … …  
    669669            return;
    670670          }
    671         case OpCodes.LagVariable: {
     671        case OpCode.LagVariable: {
    672672            var nanResult = il.DefineLabel();
    673673            var normalResult = il.DefineLabel();
    … …  
    697697            return;
    698698          }
    699         case OpCodes.Constant: {
     699        case OpCode.Constant: {
    700700            ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
    701701            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
    … …  
    705705        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
    706706        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
    707         case OpCodes.VariableCondition: {
     707        case OpCode.VariableCondition: {
    708708            throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
    709709                                            " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r16722 r16899  
    137137
    138138    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset) {
    139       Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
     139      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
    140140      int necessaryArgStackSize = 0;
    141141      foreach (Instruction instr in code) {
    142         if (instr.opCode == OpCodes.Variable) {
     142        if (instr.opCode == OpCode.Variable) {
    143143          var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
    144144          instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
    145         } else if (instr.opCode == OpCodes.FactorVariable) {
     145        } else if (instr.opCode == OpCode.FactorVariable) {
    146146          var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
    147147          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
    148         } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
     148        } else if (instr.opCode == OpCode.BinaryFactorVariable) {
    149149          var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
    150150          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
    151         } else if (instr.opCode == OpCodes.LagVariable) {
     151        } else if (instr.opCode == OpCode.LagVariable) {
    152152          var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    153153          instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
    154         } else if (instr.opCode == OpCodes.VariableCondition) {
     154        } else if (instr.opCode == OpCode.VariableCondition) {
    155155          var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    156156          instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
    157         } else if (instr.opCode == OpCodes.Call) {
     157        } else if (instr.opCode == OpCode.Call) {
    158158          necessaryArgStackSize += instr.nArguments + 1;
    159159        }
    … …  
    165165      Instruction currentInstr = state.NextInstruction();
    166166      switch (currentInstr.opCode) {
    167         case OpCodes.Add: {
     167        case OpCode.Add: {
    168168            double s = Evaluate(dataset, ref row, state);
    169169            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    172172            return s;
    173173          }
    174         case OpCodes.Sub: {
     174        case OpCode.Sub: {
    175175            double s = Evaluate(dataset, ref row, state);
    176176            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    180180            return s;
    181181          }
    182         case OpCodes.Mul: {
     182        case OpCode.Mul: {
    183183            double p = Evaluate(dataset, ref row, state);
    184184            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    187187            return p;
    188188          }
    189         case OpCodes.Div: {
     189        case OpCode.Div: {
    190190            double p = Evaluate(dataset, ref row, state);
    191191            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    195195            return p;
    196196          }
    197         case OpCodes.Average: {
     197        case OpCode.Average: {
    198198            double sum = Evaluate(dataset, ref row, state);
    199199            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    202202            return sum / currentInstr.nArguments;
    203203          }
    204         case OpCodes.Absolute: {
     204        case OpCode.Absolute: {
    205205            return Math.Abs(Evaluate(dataset, ref row, state));
    206206          }
    207         case OpCodes.Tanh: {
     207        case OpCode.Tanh: {
    208208            return Math.Tanh(Evaluate(dataset, ref row, state));
    209209          }
    210         case OpCodes.Cos: {
     210        case OpCode.Cos: {
    211211            return Math.Cos(Evaluate(dataset, ref row, state));
    212212          }
    213         case OpCodes.Sin: {
     213        case OpCode.Sin: {
    214214            return Math.Sin(Evaluate(dataset, ref row, state));
    215215          }
    216         case OpCodes.Tan: {
     216        case OpCode.Tan: {
    217217            return Math.Tan(Evaluate(dataset, ref row, state));
    218218          }
    219         case OpCodes.Square: {
     219        case OpCode.Square: {
    220220            return Math.Pow(Evaluate(dataset, ref row, state), 2);
    221221          }
    222         case OpCodes.Cube: {
     222        case OpCode.Cube: {
    223223            return Math.Pow(Evaluate(dataset, ref row, state), 3);
    224224          }
    225         case OpCodes.Power: {
     225        case OpCode.Power: {
    226226            double x = Evaluate(dataset, ref row, state);
    227227            double y = Math.Round(Evaluate(dataset, ref row, state));
    228228            return Math.Pow(x, y);
    229229          }
    230         case OpCodes.SquareRoot: {
     230        case OpCode.SquareRoot: {
    231231            return Math.Sqrt(Evaluate(dataset, ref row, state));
    232232          }
    233         case OpCodes.CubeRoot: {
     233        case OpCode.CubeRoot: {
    234234            return Math.Pow(Evaluate(dataset, ref row, state), 1.0 / 3.0);
    235235          }
    236         case OpCodes.Root: {
     236        case OpCode.Root: {
    237237            double x = Evaluate(dataset, ref row, state);
    238238            double y = Math.Round(Evaluate(dataset, ref row, state));
    239239            return Math.Pow(x, 1 / y);
    240240          }
    241         case OpCodes.Exp: {
     241        case OpCode.Exp: {
    242242            return Math.Exp(Evaluate(dataset, ref row, state));
    243243          }
    244         case OpCodes.Log: {
     244        case OpCode.Log: {
    245245            return Math.Log(Evaluate(dataset, ref row, state));
    246246          }
    247         case OpCodes.Gamma: {
     247        case OpCode.Gamma: {
    248248            var x = Evaluate(dataset, ref row, state);
    249249            if (double.IsNaN(x)) { return double.NaN; } else { return alglib.gammafunction(x); }
    250250          }
    251         case OpCodes.Psi: {
     251        case OpCode.Psi: {
    252252            var x = Evaluate(dataset, ref row, state);
    253253            if (double.IsNaN(x)) return double.NaN;
    … …  
    255255            return alglib.psi(x);
    256256          }
    257         case OpCodes.Dawson: {
     257        case OpCode.Dawson: {
    258258            var x = Evaluate(dataset, ref row, state);
    259259            if (double.IsNaN(x)) { return double.NaN; }
    260260            return alglib.dawsonintegral(x);
    261261          }
    262         case OpCodes.ExponentialIntegralEi: {
     262        case OpCode.ExponentialIntegralEi: {
    263263            var x = Evaluate(dataset, ref row, state);
    264264            if (double.IsNaN(x)) { return double.NaN; }
    265265            return alglib.exponentialintegralei(x);
    266266          }
    267         case OpCodes.SineIntegral: {
     267        case OpCode.SineIntegral: {
    268268            double si, ci;
    269269            var x = Evaluate(dataset, ref row, state);
    … …  
    274274            }
    275275          }
    276         case OpCodes.CosineIntegral: {
     276        case OpCode.CosineIntegral: {
    277277            double si, ci;
    278278            var x = Evaluate(dataset, ref row, state);
    … …  
    283283            }
    284284          }
    285         case OpCodes.HyperbolicSineIntegral: {
     285        case OpCode.HyperbolicSineIntegral: {
    286286            double shi, chi;
    287287            var x = Evaluate(dataset, ref row, state);
    … …  
    292292            }
    293293          }
    294         case OpCodes.HyperbolicCosineIntegral: {
     294        case OpCode.HyperbolicCosineIntegral: {
    295295            double shi, chi;
    296296            var x = Evaluate(dataset, ref row, state);
    … …  
    301301            }
    302302          }
    303         case OpCodes.FresnelCosineIntegral: {
     303        case OpCode.FresnelCosineIntegral: {
    304304            double c = 0, s = 0;
    305305            var x = Evaluate(dataset, ref row, state);
    … …  
    310310            }
    311311          }
    312         case OpCodes.FresnelSineIntegral: {
     312        case OpCode.FresnelSineIntegral: {
    313313            double c = 0, s = 0;
    314314            var x = Evaluate(dataset, ref row, state);
    … …  
    319319            }
    320320          }
    321         case OpCodes.AiryA: {
     321        case OpCode.AiryA: {
    322322            double ai, aip, bi, bip;
    323323            var x = Evaluate(dataset, ref row, state);
    … …  
    328328            }
    329329          }
    330         case OpCodes.AiryB: {
     330        case OpCode.AiryB: {
    331331            double ai, aip, bi, bip;
    332332            var x = Evaluate(dataset, ref row, state);
    … …  
    337337            }
    338338          }
    339         case OpCodes.Norm: {
     339        case OpCode.Norm: {
    340340            var x = Evaluate(dataset, ref row, state);
    341341            if (double.IsNaN(x)) return double.NaN;
    342342            else return alglib.normaldistribution(x);
    343343          }
    344         case OpCodes.Erf: {
     344        case OpCode.Erf: {
    345345            var x = Evaluate(dataset, ref row, state);
    346346            if (double.IsNaN(x)) return double.NaN;
    347347            else return alglib.errorfunction(x);
    348348          }
    349         case OpCodes.Bessel: {
     349        case OpCode.Bessel: {
    350350            var x = Evaluate(dataset, ref row, state);
    351351            if (double.IsNaN(x)) return double.NaN;
    … …  
    353353          }
    354354
    355         case OpCodes.AnalyticQuotient: {
     355        case OpCode.AnalyticQuotient: {
    356356            var x1 = Evaluate(dataset, ref row, state);
    357357            var x2 = Evaluate(dataset, ref row, state);
    358358            return x1 / Math.Pow(1 + x2 * x2, 0.5);
    359359          }
    360         case OpCodes.IfThenElse: {
     360        case OpCode.IfThenElse: {
    361361            double condition = Evaluate(dataset, ref row, state);
    362362            double result;
    … …  
    368368            return result;
    369369          }
    370         case OpCodes.AND: {
     370        case OpCode.AND: {
    371371            double result = Evaluate(dataset, ref row, state);
    372372            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    378378            return result > 0.0 ? 1.0 : -1.0;
    379379          }
    380         case OpCodes.OR: {
     380        case OpCode.OR: {
    381381            double result = Evaluate(dataset, ref row, state);
    382382            for (int i = 1; i < currentInstr.nArguments; i++) {
    … …  
    388388            return result > 0.0 ? 1.0 : -1.0;
    389389          }
    390         case OpCodes.NOT: {
     390        case OpCode.NOT: {
    391391            return Evaluate(dataset, ref row, state) > 0.0 ? -1.0 : 1.0;
    392392          }
    393         case OpCodes.XOR: {
     393        case OpCode.XOR: {
    394394            //mkommend: XOR on multiple inputs is defined as true if the number of positive signals is odd
    395395            // this is equal to a consecutive execution of binary XOR operations.
    … …  
    400400            return positiveSignals % 2 != 0 ? 1.0 : -1.0;
    401401          }
    402         case OpCodes.GT: {
     402        case OpCode.GT: {
    403403            double x = Evaluate(dataset, ref row, state);
    404404            double y = Evaluate(dataset, ref row, state);
    405405            if (x > y) { return 1.0; } else { return -1.0; }
    406406          }
    407         case OpCodes.LT: {
     407        case OpCode.LT: {
    408408            double x = Evaluate(dataset, ref row, state);
    409409            double y = Evaluate(dataset, ref row, state);
    410410            if (x < y) { return 1.0; } else { return -1.0; }
    411411          }
    412         case OpCodes.TimeLag: {
     412        case OpCode.TimeLag: {
    413413            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    414414            row += timeLagTreeNode.Lag;
    … …  
    417417            return result;
    418418          }
    419         case OpCodes.Integral: {
     419        case OpCode.Integral: {
    420420            int savedPc = state.ProgramCounter;
    421421            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    … …  
    435435        //one sided smooth differentiatior, N = 4
    436436        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
    437         case OpCodes.Derivative: {
     437        case OpCode.Derivative: {
    438438            int savedPc = state.ProgramCounter;
    439439            double f_0 = Evaluate(dataset, ref row, state); row--;
    … …  
    448448            return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
    449449          }
    450         case OpCodes.Call: {
     450        case OpCode.Call: {
    451451            // evaluate sub-trees
    452452            double[] argValues = new double[currentInstr.nArguments];
    … …  
    471471            return v;
    472472          }
    473         case OpCodes.Arg: {
     473        case OpCode.Arg: {
    474474            return state.GetStackFrameValue((ushort)currentInstr.data);
    475475          }
    476         case OpCodes.Variable: {
     476        case OpCode.Variable: {
    477477            if (row < 0 || row >= dataset.Rows) return double.NaN;
    478478            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
    479479            return ((IList<double>)currentInstr.data)[row] * variableTreeNode.Weight;
    480480          }
    481         case OpCodes.BinaryFactorVariable: {
     481        case OpCode.BinaryFactorVariable: {
    482482            if (row < 0 || row >= dataset.Rows) return double.NaN;
    483483            var factorVarTreeNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
    484484            return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0;
    485485          }
    486         case OpCodes.FactorVariable: {
     486        case OpCode.FactorVariable: {
    487487            if (row < 0 || row >= dataset.Rows) return double.NaN;
    488488            var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
    489489            return factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]);
    490490          }
    491         case OpCodes.LagVariable: {
     491        case OpCode.LagVariable: {
    492492            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
    493493            int actualRow = row + laggedVariableTreeNode.Lag;
    … …  
    495495            return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
    496496          }
    497         case OpCodes.Constant: {
     497        case OpCode.Constant: {
    498498            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
    499499            return constTreeNode.Value;
    … …  
    502502        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
    503503        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
    504         case OpCodes.VariableCondition: {
     504        case OpCode.VariableCondition: {
    505505            if (row < 0 || row >= dataset.Rows) return double.NaN;
    506506            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

    r16722 r16899  
    133133      }
    134134
    135       var code = SymbolicExpressionTreeLinearCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
     135      var code = SymbolicExpressionTreeLinearCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
    136136      PrepareInstructions(code, dataset);
    137137      return rows.Select(row => Evaluate(dataset, row, code));
    … …  
    143143        #region opcode if
    144144        var instr = code[i];
    145         if (instr.opCode == OpCodes.Variable) {
     145        if (instr.opCode == OpCode.Variable) {
    146146          if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
    147147          else {
    … …  
    149149            instr.value = ((IList<double>)instr.data)[row] * variableTreeNode.Weight;
    150150          }
    151         } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
     151        } else if (instr.opCode == OpCode.BinaryFactorVariable) {
    152152          if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
    153153          else {
    … …  
    155155            instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? factorTreeNode.Weight : 0;
    156156          }
    157         } else if (instr.opCode == OpCodes.FactorVariable) {
     157        } else if (instr.opCode == OpCode.FactorVariable) {
    158158          if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
    159159          else {
    … …  
    161161            instr.value = factorTreeNode.GetValue(((IList<string>)instr.data)[row]);
    162162          }
    163         } else if (instr.opCode == OpCodes.LagVariable) {
     163        } else if (instr.opCode == OpCode.LagVariable) {
    164164          var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    165165          int actualRow = row + laggedVariableTreeNode.Lag;
    … …  
    168168          else
    169169            instr.value = ((IList<double>)instr.data)[actualRow] * laggedVariableTreeNode.Weight;
    170         } else if (instr.opCode == OpCodes.VariableCondition) {
     170        } else if (instr.opCode == OpCode.VariableCondition) {
    171171          if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
    172172          var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    … …  
    188188            }
    189189          }
    190         } else if (instr.opCode == OpCodes.Add) {
     190        } else if (instr.opCode == OpCode.Add) {
    191191          double s = code[instr.childIndex].value;
    192192          for (int j = 1; j != instr.nArguments; ++j) {
    … …  
    194194          }
    195195          instr.value = s;
    196         } else if (instr.opCode == OpCodes.Sub) {
     196        } else if (instr.opCode == OpCode.Sub) {
    197197          double s = code[instr.childIndex].value;
    198198          for (int j = 1; j != instr.nArguments; ++j) {
    … …  
    201201          if (instr.nArguments == 1) s = -s;
    202202          instr.value = s;
    203         } else if (instr.opCode == OpCodes.Mul) {
     203        } else if (instr.opCode == OpCode.Mul) {
    204204          double p = code[instr.childIndex].value;
    205205          for (int j = 1; j != instr.nArguments; ++j) {
    … …  
    207207          }
    208208          instr.value = p;
    209         } else if (instr.opCode == OpCodes.Div) {
     209        } else if (instr.opCode == OpCode.Div) {
    210210          double p = code[instr.childIndex].value;
    211211          for (int j = 1; j != instr.nArguments; ++j) {
    … …  
    214214          if (instr.nArguments == 1) p = 1.0 / p;
    215215          instr.value = p;
    216         } else if (instr.opCode == OpCodes.AnalyticQuotient) {
     216        } else if (instr.opCode == OpCode.AnalyticQuotient) {
    217217          var x1 = code[instr.childIndex].value;
    218218          var x2 = code[instr.childIndex + 1].value;
    219219          instr.value = x1 / Math.Sqrt(1 + x2 * x2);
    220         } else if (instr.opCode == OpCodes.Average) {
     220        } else if (instr.opCode == OpCode.Average) {
    221221          double s = code[instr.childIndex].value;
    222222          for (int j = 1; j != instr.nArguments; ++j) {
    … …  
    224224          }
    225225          instr.value = s / instr.nArguments;
    226         } else if (instr.opCode == OpCodes.Absolute) {
     226        } else if (instr.opCode == OpCode.Absolute) {
    227227          instr.value = Math.Abs(code[instr.childIndex].value);
    228         } else if (instr.opCode == OpCodes.Tanh) {
     228        } else if (instr.opCode == OpCode.Tanh) {
    229229          instr.value = Math.Tanh(code[instr.childIndex].value);
    230         } else if (instr.opCode == OpCodes.Cos) {
     230        } else if (instr.opCode == OpCode.Cos) {
    231231          instr.value = Math.Cos(code[instr.childIndex].value);
    232         } else if (instr.opCode == OpCodes.Sin) {
     232        } else if (instr.opCode == OpCode.Sin) {
    233233          instr.value = Math.Sin(code[instr.childIndex].value);
    234         } else if (instr.opCode == OpCodes.Tan) {
     234        } else if (instr.opCode == OpCode.Tan) {
    235235          instr.value = Math.Tan(code[instr.childIndex].value);
    236         } else if (instr.opCode == OpCodes.Square) {
     236        } else if (instr.opCode == OpCode.Square) {
    237237          instr.value = Math.Pow(code[instr.childIndex].value, 2);
    238         } else if (instr.opCode == OpCodes.Cube) {
     238        } else if (instr.opCode == OpCode.Cube) {
    239239          instr.value = Math.Pow(code[instr.childIndex].value, 3);
    240         } else if (instr.opCode == OpCodes.Power) {
     240        } else if (instr.opCode == OpCode.Power) {
    241241          double x = code[instr.childIndex].value;
    242242          double y = Math.Round(code[instr.childIndex + 1].value);
    243243          instr.value = Math.Pow(x, y);
    244         } else if (instr.opCode == OpCodes.SquareRoot) {
     244        } else if (instr.opCode == OpCode.SquareRoot) {
    245245          instr.value = Math.Sqrt(code[instr.childIndex].value);
    246         } else if (instr.opCode == OpCodes.CubeRoot) {
     246        } else if (instr.opCode == OpCode.CubeRoot) {
    247247          instr.value = Math.Pow(code[instr.childIndex].value, 1.0 / 3.0);
    248         } else if (instr.opCode == OpCodes.Root) {
     248        } else if (instr.opCode == OpCode.Root) {
    249249          double x = code[instr.childIndex].value;
    250250          double y = Math.Round(code[instr.childIndex + 1].value);
    251251          instr.value = Math.Pow(x, 1 / y);
    252         } else if (instr.opCode == OpCodes.Exp) {
     252        } else if (instr.opCode == OpCode.Exp) {
    253253          instr.value = Math.Exp(code[instr.childIndex].value);
    254         } else if (instr.opCode == OpCodes.Log) {
     254        } else if (instr.opCode == OpCode.Log) {
    255255          instr.value = Math.Log(code[instr.childIndex].value);
    256         } else if (instr.opCode == OpCodes.Gamma) {
     256        } else if (instr.opCode == OpCode.Gamma) {
    257257          var x = code[instr.childIndex].value;
    258258          instr.value = double.IsNaN(x) ? double.NaN : alglib.gammafunction(x);
    259         } else if (instr.opCode == OpCodes.Psi) {
     259        } else if (instr.opCode == OpCode.Psi) {
    260260          var x = code[instr.childIndex].value;
    261261          if (double.IsNaN(x)) instr.value = double.NaN;
    262262          else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) instr.value = double.NaN;
    263263          else instr.value = alglib.psi(x);
    264         } else if (instr.opCode == OpCodes.Dawson) {
     264        } else if (instr.opCode == OpCode.Dawson) {
    265265          var x = code[instr.childIndex].value;
    266266          instr.value = double.IsNaN(x) ? double.NaN : alglib.dawsonintegral(x);
    267         } else if (instr.opCode == OpCodes.ExponentialIntegralEi) {
     267        } else if (instr.opCode == OpCode.ExponentialIntegralEi) {
    268268          var x = code[instr.childIndex].value;
    269269          instr.value = double.IsNaN(x) ? double.NaN : alglib.exponentialintegralei(x);
    270         } else if (instr.opCode == OpCodes.SineIntegral) {
     270        } else if (instr.opCode == OpCode.SineIntegral) {
    271271          double si, ci;
    272272          var x = code[instr.childIndex].value;
    … …  
    276276            instr.value = si;
    277277          }
    278         } else if (instr.opCode == OpCodes.CosineIntegral) {
     278        } else if (instr.opCode == OpCode.CosineIntegral) {
    279279          double si, ci;
    280280          var x = code[instr.childIndex].value;
    … …  
    284284            instr.value = ci;
    285285          }
    286         } else if (instr.opCode == OpCodes.HyperbolicSineIntegral) {
     286        } else if (instr.opCode == OpCode.HyperbolicSineIntegral) {
    287287          double shi, chi;
    288288          var x = code[instr.childIndex].value;
    … …  
    292292            instr.value = shi;
    293293          }
    294         } else if (instr.opCode == OpCodes.HyperbolicCosineIntegral) {
     294        } else if (instr.opCode == OpCode.HyperbolicCosineIntegral) {
    295295          double shi, chi;
    296296          var x = code[instr.childIndex].value;
    … …  
    300300            instr.value = chi;
    301301          }
    302         } else if (instr.opCode == OpCodes.FresnelCosineIntegral) {
     302        } else if (instr.opCode == OpCode.FresnelCosineIntegral) {
    303303          double c = 0, s = 0;
    304304          var x = code[instr.childIndex].value;
    … …  
    308308            instr.value = c;
    309309          }
    310         } else if (instr.opCode == OpCodes.FresnelSineIntegral) {
     310        } else if (instr.opCode == OpCode.FresnelSineIntegral) {
    311311          double c = 0, s = 0;
    312312          var x = code[instr.childIndex].value;
    … …  
    316316            instr.value = s;
    317317          }
    318         } else if (instr.opCode == OpCodes.AiryA) {
     318        } else if (instr.opCode == OpCode.AiryA) {
    319319          double ai, aip, bi, bip;
    320320          var x = code[instr.childIndex].value;
    … …  
    324324            instr.value = ai;
    325325          }
    326         } else if (instr.opCode == OpCodes.AiryB) {
     326        } else if (instr.opCode == OpCode.AiryB) {
    327327          double ai, aip, bi, bip;
    328328          var x = code[instr.childIndex].value;
    … …  
    332332            instr.value = bi;
    333333          }
    334         } else if (instr.opCode == OpCodes.Norm) {
     334        } else if (instr.opCode == OpCode.Norm) {
    335335          var x = code[instr.childIndex].value;
    336336          if (double.IsNaN(x)) instr.value = double.NaN;
    337337          else instr.value = alglib.normaldistribution(x);
    338         } else if (instr.opCode == OpCodes.Erf) {
     338        } else if (instr.opCode == OpCode.Erf) {
    339339          var x = code[instr.childIndex].value;
    340340          if (double.IsNaN(x)) instr.value = double.NaN;
    341341          else instr.value = alglib.errorfunction(x);
    342         } else if (instr.opCode == OpCodes.Bessel) {
     342        } else if (instr.opCode == OpCode.Bessel) {
    343343          var x = code[instr.childIndex].value;
    344344          if (double.IsNaN(x)) instr.value = double.NaN;
    345345          else instr.value = alglib.besseli0(x);
    346         } else if (instr.opCode == OpCodes.IfThenElse) {
     346        } else if (instr.opCode == OpCode.IfThenElse) {
    347347          double condition = code[instr.childIndex].value;
    348348          double result;
    … …  
    353353          }
    354354          instr.value = result;
    355         } else if (instr.opCode == OpCodes.AND) {
     355        } else if (instr.opCode == OpCode.AND) {
    356356          double result = code[instr.childIndex].value;
    357357          for (int j = 1; j < instr.nArguments; j++) {
    … …  
    360360          }
    361361          instr.value = result > 0.0 ? 1.0 : -1.0;
    362         } else if (instr.opCode == OpCodes.OR) {
     362        } else if (instr.opCode == OpCode.OR) {
    363363          double result = code[instr.childIndex].value;
    364364          for (int j = 1; j < instr.nArguments; j++) {
    … …  
    367367          }
    368368          instr.value = result > 0.0 ? 1.0 : -1.0;
    369         } else if (instr.opCode == OpCodes.NOT) {
     369        } else if (instr.opCode == OpCode.NOT) {
    370370          instr.value = code[instr.childIndex].value > 0.0 ? -1.0 : 1.0;
    371         } else if (instr.opCode == OpCodes.XOR) {
     371        } else if (instr.opCode == OpCode.XOR) {
    372372          int positiveSignals = 0;
    373373          for (int j = 0; j < instr.nArguments; j++) {
    … …  
    375375          }
    376376          instr.value = positiveSignals % 2 != 0 ? 1.0 : -1.0;
    377         } else if (instr.opCode == OpCodes.GT) {
     377        } else if (instr.opCode == OpCode.GT) {
    378378          double x = code[instr.childIndex].value;
    379379          double y = code[instr.childIndex + 1].value;
    380380          instr.value = x > y ? 1.0 : -1.0;
    381         } else if (instr.opCode == OpCodes.LT) {
     381        } else if (instr.opCode == OpCode.LT) {
    382382          double x = code[instr.childIndex].value;
    383383          double y = code[instr.childIndex + 1].value;
    384384          instr.value = x < y ? 1.0 : -1.0;
    385         } else if (instr.opCode == OpCodes.TimeLag || instr.opCode == OpCodes.Derivative || instr.opCode == OpCodes.Integral) {
     385        } else if (instr.opCode == OpCode.TimeLag || instr.opCode == OpCode.Derivative || instr.opCode == OpCode.Integral) {
    386386          var state = (InterpreterState)instr.data;
    387387          state.Reset();
    … …  
    415415        #region opcode switch
    416416        switch (instr.opCode) {
    417           case OpCodes.Constant: {
     417          case OpCode.Constant: {
    418418              var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
    419419              instr.value = constTreeNode.Value;
    … …  
    421421            }
    422422            break;
    423           case OpCodes.Variable: {
     423          case OpCode.Variable: {
    424424              var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
    425425              instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
    426426            }
    427427            break;
    428           case OpCodes.BinaryFactorVariable: {
     428          case OpCode.BinaryFactorVariable: {
    429429              var factorVariableTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
    430430              instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
    431431            }
    432432            break;
    433           case OpCodes.FactorVariable: {
     433          case OpCode.FactorVariable: {
    434434              var factorVariableTreeNode = instr.dynamicNode as FactorVariableTreeNode;
    435435              instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
    436436            }
    437437            break;
    438           case OpCodes.LagVariable: {
     438          case OpCode.LagVariable: {
    439439              var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    440440              instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
    441441            }
    442442            break;
    443           case OpCodes.VariableCondition: {
     443          case OpCode.VariableCondition: {
    444444              var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    445445              instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
    446446            }
    447447            break;
    448           case OpCodes.TimeLag:
    449           case OpCodes.Integral:
    450           case OpCodes.Derivative: {
     448          case OpCode.TimeLag:
     449          case OpCode.Integral:
     450          case OpCode.Derivative: {
    451451              var seq = GetPrefixSequence(code, i);
    452452              var interpreterState = new InterpreterState(seq, 0);

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

    r16565 r16899  
    2020#endregion
    2121
    22 using System;
    23 using System.Collections.Generic;
    24 using System.Linq;
    25 using System.Runtime.InteropServices;
     22using HEAL.Attic;
    2623using HeuristicLab.Common;
    2724using HeuristicLab.Core;
    … …  
    2926using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    3027using HeuristicLab.Parameters;
    31 using HEAL.Attic;
     28using System;
     29using System.Collections.Generic;
     30using System.Linq;
     31using System.Runtime.InteropServices;
    3232
    3333namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
    … …  
    101101    private IDataset dataset;
    102102
     103    private static readonly HashSet<byte> supportedOpCodes = new HashSet<byte>() {
     104      (byte)OpCode.Constant,
     105      (byte)OpCode.Variable,
     106      (byte)OpCode.Add,
     107      (byte)OpCode.Sub,
     108      (byte)OpCode.Mul,
     109      (byte)OpCode.Div,
     110      (byte)OpCode.Exp,
     111      (byte)OpCode.Log,
     112      (byte)OpCode.Sin,
     113      (byte)OpCode.Cos,
     114      (byte)OpCode.Tan,
     115      (byte)OpCode.Tanh,
     116      (byte)OpCode.Power,
     117      (byte)OpCode.Root,
     118      (byte)OpCode.SquareRoot,
     119      (byte)OpCode.Square,
     120      (byte)OpCode.CubeRoot,
     121      (byte)OpCode.Cube,
     122      (byte)OpCode.Absolute,
     123      (byte)OpCode.AnalyticQuotient
     124    };
     125
    103126    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
    104127      if (!rows.Any()) return Enumerable.Empty<double>();
    … …  
    108131      }
    109132
    110       var code = Compile(tree, OpCodes.MapSymbolToOpCode);
     133      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {
     134        var opCode = OpCode.MapSymbolToOpCode(node);
     135        if (supportedOpCodes.Contains(opCode)) return opCode;
     136        else throw new NotSupportedException($"The native interpreter does not support {node.Symbol.Name}");
     137      };
     138      var code = Compile(tree, mapSupportedSymbols);
    111139
    112140      var rowsArray = rows.ToArray();

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Selectors/DiversitySelector.cs

    r16722 r16899  
    100100    #region Events
    101101    private void RegisterParameterEventHandlers() {
    102       SelectorParameter.ValueChanged += new EventHandler(SelectorParameter_ValueChanged);
    103       CopySelected.ValueChanged += new EventHandler(CopySelected_ValueChanged);
     102      SelectorParameter.ValueChanged += SelectorParameter_ValueChanged;
     103      CopySelectedParameter.ValueChanged += CopySelectedParameter_ValueChanged;
     104      CopySelected.ValueChanged += CopySelected_ValueChanged;
     105    }
     106
     107    private void CopySelectedParameter_ValueChanged(object sender, EventArgs e) {
     108      if (CopySelected.Value != true) {
     109        CopySelected.Value = true;
     110      }
     111      CopySelected.ValueChanged += CopySelected_ValueChanged;
    104112    }
    105113

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs

    r16565 r16899  
    3535      if (node.Symbol is StartSymbol) node = node.GetSubtree(0);
    3636
    37       switch (OpCodes.MapSymbolToOpCode(node)) {
    38         case OpCodes.Constant: {
     37      switch (OpCode.MapSymbolToOpCode(node)) {
     38        case OpCode.Constant: {
    3939            return 1;
    4040          }
    41         case OpCodes.Variable:
    42         case OpCodes.BinaryFactorVariable:
    43         case OpCodes.FactorVariable: {
     41        case OpCode.Variable:
     42        case OpCode.BinaryFactorVariable:
     43        case OpCode.FactorVariable: {
    4444            return 2;
    4545          }
    46         case OpCodes.Add:
    47         case OpCodes.Sub: {
     46        case OpCode.Add:
     47        case OpCode.Sub: {
    4848            double complexity = 0;
    4949            for (int i = 0; i < node.SubtreeCount; i++) {
    … …  
    5252            return complexity;
    5353          }
    54         case OpCodes.Mul:
    55         case OpCodes.Div: {
     54        case OpCode.Mul:
     55        case OpCode.Div: {
    5656            double complexity = 1;
    5757            for (int i = 0; i < node.SubtreeCount; i++) {
    … …  
    6161            return complexity;
    6262          }
    63         case OpCodes.Sin:
    64         case OpCodes.Cos:
    65         case OpCodes.Tan:
    66         case OpCodes.Exp:
    67         case OpCodes.Log: {
     63        case OpCode.Sin:
     64        case OpCode.Cos:
     65        case OpCode.Tan:
     66        case OpCode.Exp:
     67        case OpCode.Log: {
    6868            double complexity = CalculateComplexity(node.GetSubtree(0));
    6969            return Math.Pow(2.0, complexity);
    7070          }
    71         case OpCodes.Square: {
     71        case OpCode.Square: {
    7272            double complexity = CalculateComplexity(node.GetSubtree(0));
    7373            return complexity * complexity;
    7474          }
    75         case OpCodes.SquareRoot: {
     75        case OpCode.SquareRoot: {
    7676            double complexity = CalculateComplexity(node.GetSubtree(0));
    7777            return complexity * complexity * complexity;
    7878          }
    79         case OpCodes.Power:
    80         case OpCodes.Root: {
     79        case OpCode.Power:
     80        case OpCode.Root: {
    8181            double complexity = CalculateComplexity(node.GetSubtree(0));
    8282            var exponent = node.GetSubtree(1) as ConstantTreeNode;

  • branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ModelTreeNode.cs

    r16734 r16899  
    5757    private TreeModelTreeNode(TreeModelTreeNode original, Cloner cloner)
    5858      : base(original, cloner) {
    59       tree = original.tree;
     59      tree = (ISymbolicExpressionTree)original.tree.Clone(cloner);
    6060      ClusterNumer = original.ClusterNumer;
    6161      TreeNumber = original.TreeNumber;
Note: See TracChangeset for help on using the changeset viewer.