Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
04/17/19 19:43:45 (6 years ago)
Author:
ddorfmei
Message:

#2931: Merged revision(s) 16720-16802 from trunk

Location:
branches/2931_OR-Tools_LP_MIP
Files:
13 edited

Legend:

Unmodified
Added
Removed

  • branches/2931_OR-Tools_LP_MIP

  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic

  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs

    r16720 r16803  
    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(")*(");
    … …  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs

    r16720 r16803  
    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/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

    r16720 r16803  
    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,
     73      return GetSymbolicExpressionTreeInterval(tree, variableRanges);
     74    }
     75
     76    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
    7777      out Dictionary<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, Dictionary<string, Interval> variableRanges) {
    8383      lock (syncRoot) {
    8484        EvaluatedSolutions++;
    … …  
    9696
    9797
    98     public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree,
     98    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
    9999      Dictionary<string, Interval> variableRanges, out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
    100100      lock (syncRoot) {
    … …  
    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)
    … …  
    216216            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
    217217            result = Interval.Tangens(argumentInterval);
     218            break;
     219          }
     220        case OpCodes.Tanh: {
     221            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
     222            result = Interval.HyperbolicTangent(argumentInterval);
    218223            break;
    219224          }

  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

    r16720 r16803  
    2222using System;
    2323using System.Collections.Generic;
     24using System.Linq;
    2425using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
    2526
    2627namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
     28  public enum OpCode : byte {
     29    Add = 1,
     30    Sub = 2,
     31    Mul = 3,
     32    Div = 4,
     33    Sin = 5,
     34    Cos = 6,
     35    Tan = 7,
     36    Log = 8,
     37    Exp = 9,
     38    IfThenElse = 10,
     39    GT = 11,
     40    LT = 12,
     41    AND = 13,
     42    OR = 14,
     43    NOT = 15,
     44    Average = 16,
     45    Call = 17,
     46    Variable = 18,
     47    LagVariable = 19,
     48    Constant = 20,
     49    Arg = 21,
     50    Power = 22,
     51    Root = 23,
     52    TimeLag = 24,
     53    Integral = 25,
     54    Derivative = 26,
     55    VariableCondition = 27,
     56    Square = 28,
     57    SquareRoot = 29,
     58    Gamma = 30,
     59    Psi = 31,
     60    Dawson = 32,
     61    ExponentialIntegralEi = 33,
     62    CosineIntegral = 34,
     63    SineIntegral = 35,
     64    HyperbolicCosineIntegral = 36,
     65    HyperbolicSineIntegral = 37,
     66    FresnelCosineIntegral = 38,
     67    FresnelSineIntegral = 39,
     68    AiryA = 40,
     69    AiryB = 41,
     70    Norm = 42,
     71    Erf = 43,
     72    Bessel = 44,
     73    XOR = 45,
     74    FactorVariable = 46,
     75    BinaryFactorVariable = 47,
     76    Absolute = 48,
     77    AnalyticQuotient = 49,
     78    Cube = 50,
     79    CubeRoot = 51,
     80    Tanh = 52,
     81  };
    2782  public static class OpCodes {
    28     public const byte Add = 1;
    29     public const byte Sub = 2;
    30     public const byte Mul = 3;
    31     public const byte Div = 4;
    32 
    33     public const byte Sin = 5;
    34     public const byte Cos = 6;
    35     public const byte Tan = 7;
    36 
    37     public const byte Log = 8;
    38     public const byte Exp = 9;
    39 
    40     public const byte IfThenElse = 10;
    41 
    42     public const byte GT = 11;
    43     public const byte LT = 12;
    44 
    45     public const byte AND = 13;
    46     public const byte OR = 14;
    47     public const byte NOT = 15;
    48 
    49 
    50     public const byte Average = 16;
    51 
    52     public const byte Call = 17;
    53 
    54     public const byte Variable = 18;
    55     public const byte LagVariable = 19;
    56     public const byte Constant = 20;
    57     public const byte Arg = 21;
    58 
    59     public const byte Power = 22;
    60     public const byte Root = 23;
    61     public const byte TimeLag = 24;
    62     public const byte Integral = 25;
    63     public const byte Derivative = 26;
    64 
    65     public const byte VariableCondition = 27;
    66 
    67     public const byte Square = 28;
    68     public const byte SquareRoot = 29;
    69     public const byte Gamma = 30;
    70     public const byte Psi = 31;
    71     public const byte Dawson = 32;
    72     public const byte ExponentialIntegralEi = 33;
    73     public const byte CosineIntegral = 34;
    74     public const byte SineIntegral = 35;
    75     public const byte HyperbolicCosineIntegral = 36;
    76     public const byte HyperbolicSineIntegral = 37;
    77     public const byte FresnelCosineIntegral = 38;
    78     public const byte FresnelSineIntegral = 39;
    79     public const byte AiryA = 40;
    80     public const byte AiryB = 41;
    81     public const byte Norm = 42;
    82     public const byte Erf = 43;
    83     public const byte Bessel = 44;
    84     public const byte XOR = 45;
    85     public const byte FactorVariable = 46;
    86     public const byte BinaryFactorVariable = 47;
    87     public const byte Absolute = 48;
    88     public const byte AnalyticQuotient = 49;
    89     public const byte Cube = 50;
    90     public const byte CubeRoot = 51;
    91 
    92     public const byte Tanh = 52;
     83    // constants for API compatibility only
     84    public const byte Add = (byte)OpCode.Add;
     85    public const byte Sub =(byte)OpCode.Sub;
     86    public const byte Mul =(byte)OpCode.Mul;
     87    public const byte Div =(byte)OpCode.Div;
     88    public const byte Sin =(byte)OpCode.Sin;
     89    public const byte Cos =(byte)OpCode.Cos;
     90    public const byte Tan =(byte)OpCode.Tan;
     91    public const byte Log =(byte)OpCode.Log;
     92    public const byte Exp = (byte)OpCode.Exp;
     93    public const byte IfThenElse = (byte)OpCode.IfThenElse;
     94    public const byte GT = (byte)OpCode.GT;
     95    public const byte LT = (byte)OpCode.LT;
     96    public const byte AND = (byte)OpCode.AND;
     97    public const byte OR = (byte)OpCode.OR;
     98    public const byte NOT = (byte)OpCode.NOT;
     99    public const byte Average = (byte)OpCode.Average;
     100    public const byte Call = (byte)OpCode.Call;
     101    public const byte Variable = (byte)OpCode.Variable;
     102    public const byte LagVariable = (byte)OpCode.LagVariable;
     103    public const byte Constant = (byte)OpCode.Constant;
     104    public const byte Arg = (byte)OpCode.Arg;
     105    public const byte Power = (byte)OpCode.Power;
     106    public const byte Root = (byte)OpCode.Root;
     107    public const byte TimeLag = (byte)OpCode.TimeLag;
     108    public const byte Integral = (byte)OpCode.Integral;
     109    public const byte Derivative = (byte)OpCode.Derivative;
     110    public const byte VariableCondition = (byte)OpCode.VariableCondition;
     111    public const byte Square = (byte)OpCode.Square;
     112    public const byte SquareRoot = (byte)OpCode.SquareRoot;
     113    public const byte Gamma = (byte)OpCode.Gamma;
     114    public const byte Psi = (byte)OpCode.Psi;
     115    public const byte Dawson = (byte)OpCode.Dawson;
     116    public const byte ExponentialIntegralEi = (byte)OpCode.ExponentialIntegralEi;
     117    public const byte CosineIntegral = (byte)OpCode.CosineIntegral;
     118    public const byte SineIntegral = (byte)OpCode.SineIntegral;
     119    public const byte HyperbolicCosineIntegral = (byte)OpCode.HyperbolicCosineIntegral;
     120    public const byte HyperbolicSineIntegral = (byte)OpCode.HyperbolicSineIntegral;
     121    public const byte FresnelCosineIntegral = (byte)OpCode.FresnelCosineIntegral;
     122    public const byte FresnelSineIntegral = (byte)OpCode.FresnelSineIntegral;
     123    public const byte AiryA = (byte)OpCode.AiryA;
     124    public const byte AiryB = (byte)OpCode.AiryB;
     125    public const byte Norm = (byte)OpCode.Norm;
     126    public const byte Erf = (byte)OpCode.Erf;
     127    public const byte Bessel = (byte)OpCode.Bessel;
     128    public const byte XOR = (byte)OpCode.XOR;
     129    public const byte FactorVariable = (byte)OpCode.FactorVariable;
     130    public const byte BinaryFactorVariable = (byte)OpCode.BinaryFactorVariable;
     131    public const byte Absolute = (byte)OpCode.Absolute;
     132    public const byte AnalyticQuotient = (byte)OpCode.AnalyticQuotient;
     133    public const byte Cube = (byte)OpCode.Cube;
     134    public const byte CubeRoot = (byte)OpCode.CubeRoot;
     135    public const byte Tanh = (byte)OpCode.Tanh;
    93136
    94137
    … …  
    150193
    151194    public static byte MapSymbolToOpCode(ISymbolicExpressionTreeNode treeNode) {
    152       byte opCode;
    153       if (symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out opCode)) return opCode;
     195      if (symbolToOpcode.TryGetValue(treeNode.Symbol.GetType(), out byte opCode)) return opCode;
    154196      else throw new NotSupportedException("Symbol: " + treeNode.Symbol);
    155197    }

  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

    r16720 r16803  
    6363              break;
    6464            }
    65 
     65          case OpCodes.Constant: break; // nothing to do here, don't remove because we want to prevent falling into the default case here.
    6666          case OpCodes.Add: {
    6767              Load(instr.buf, code[c].buf);
    … …  
    173173              break;
    174174            }
     175          default: throw new NotSupportedException($"This interpreter does not support {(OpCode)instr.opcode}");
    175176        }
    176177      }

  • branches/2931_OR-Tools_LP_MIP/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

    r16720 r16803  
    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 = OpCodes.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();
Note: See TracChangeset for help on using the changeset viewer.