Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/17/15 16:21:29 (8 years ago)
Author:
bburlacu
Message:

#2442: Removed unused code, fixed formatting, fixed bug in AfterDeserializationHook.

File:
1 edited

Legend:

Unmodified
Added
Removed
  • branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r13141 r13222  
    3232  [StorableClass]
    3333  [Item("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.")]
    34   public class SymbolicDataAnalysisExpressionTreeInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
     34  public class SymbolicDataAnalysisExpressionTreeInterpreter : ParameterizedNamedItem,
     35    ISymbolicDataAnalysisExpressionTreeInterpreter {
    3536    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
     37    private const string CheckExpressionsWithIntervalArithmeticParameterDescription = "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.";
    3638    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    3739
    38     public override bool CanChangeName { get { return false; } }
    39     public override bool CanChangeDescription { get { return false; } }
     40    public override bool CanChangeName {
     41      get { return false; }
     42    }
     43
     44    public override bool CanChangeDescription {
     45      get { return false; }
     46    }
    4047
    4148    #region parameter properties
     
    5461      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
    5562    }
     63
    5664    public int EvaluatedSolutions {
    5765      get { return EvaluatedSolutionsParameter.Value.Value; }
     
    6270    [StorableConstructor]
    6371    protected SymbolicDataAnalysisExpressionTreeInterpreter(bool deserializing) : base(deserializing) { }
    64     protected SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original, Cloner cloner) : base(original, cloner) { }
     72
     73    protected SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original,
     74      Cloner cloner) : base(original, cloner) { }
     75
    6576    public override IDeepCloneable Clone(Cloner cloner) {
    6677      return new SymbolicDataAnalysisExpressionTreeInterpreter(this, cloner);
     
    6980    public SymbolicDataAnalysisExpressionTreeInterpreter()
    7081      : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
    71       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    72         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     82      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    7383      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    7484    }
     
    7686    protected SymbolicDataAnalysisExpressionTreeInterpreter(string name, string description)
    7787      : base(name, description) {
    78       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    79         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     88      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    8089      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    8190    }
     
    8392    [StorableHook(HookType.AfterDeserialization)]
    8493    private void AfterDeserialization() {
    85       Parameters.Remove(EvaluatedSolutionsParameterName);
    86       Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    87 
    88       Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
    89       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    90         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     94      var evaluatedSolutions = new IntValue(0);
     95      var checkExpressionsWithIntervalArithmetic = new BoolValue(false);
     96      if (Parameters.ContainsKey(EvaluatedSolutionsParameterName)) {
     97        var evaluatedSolutionsParameter = (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
     98        evaluatedSolutions = evaluatedSolutionsParameter.Value;
     99        Parameters.Remove(EvaluatedSolutionsParameterName);
     100      }
     101      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", evaluatedSolutions));
     102      if (Parameters.ContainsKey(CheckExpressionsWithIntervalArithmeticParameterName)) {
     103        var checkExpressionsWithIntervalArithmeticParameter = (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName];
     104        Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
     105        checkExpressionsWithIntervalArithmetic = checkExpressionsWithIntervalArithmeticParameter.Value;
     106      }
     107      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, checkExpressionsWithIntervalArithmetic));
    91108    }
    92109
     
    96113    }
    97114
    98     public void ClearState() {
    99     }
     115    public void ClearState() { }
    100116    #endregion
    101117
    102     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
    103       if (CheckExpressionsWithIntervalArithmetic)
     118    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset,
     119      IEnumerable<int> rows) {
     120      if (CheckExpressionsWithIntervalArithmetic) {
    104121        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
     122      }
    105123
    106124      lock (EvaluatedSolutionsParameter.Value) {
     
    136154    }
    137155
    138 
    139156    public virtual double Evaluate(IDataset dataset, ref int row, InterpreterState state) {
    140157      Instruction currentInstr = state.NextInstruction();
    141158      switch (currentInstr.opCode) {
    142         case OpCodes.Add:
    143           {
     159        case OpCodes.Add: {
    144160            double s = Evaluate(dataset, ref row, state);
    145161            for (int i = 1; i < currentInstr.nArguments; i++) {
     
    148164            return s;
    149165          }
    150         case OpCodes.Sub:
    151           {
     166        case OpCodes.Sub: {
    152167            double s = Evaluate(dataset, ref row, state);
    153168            for (int i = 1; i < currentInstr.nArguments; i++) {
    154169              s -= Evaluate(dataset, ref row, state);
    155170            }
    156             if (currentInstr.nArguments == 1) s = -s;
     171            if (currentInstr.nArguments == 1) { s = -s; }
    157172            return s;
    158173          }
    159         case OpCodes.Mul:
    160           {
     174        case OpCodes.Mul: {
    161175            double p = Evaluate(dataset, ref row, state);
    162176            for (int i = 1; i < currentInstr.nArguments; i++) {
     
    165179            return p;
    166180          }
    167         case OpCodes.Div:
    168           {
     181        case OpCodes.Div: {
    169182            double p = Evaluate(dataset, ref row, state);
    170183            for (int i = 1; i < currentInstr.nArguments; i++) {
    171184              p /= Evaluate(dataset, ref row, state);
    172185            }
    173             if (currentInstr.nArguments == 1) p = 1.0 / p;
     186            if (currentInstr.nArguments == 1) { p = 1.0 / p; }
    174187            return p;
    175188          }
    176         case OpCodes.Average:
    177           {
     189        case OpCodes.Average: {
    178190            double sum = Evaluate(dataset, ref row, state);
    179191            for (int i = 1; i < currentInstr.nArguments; i++) {
     
    182194            return sum / currentInstr.nArguments;
    183195          }
    184         case OpCodes.Cos:
    185           {
     196        case OpCodes.Cos: {
    186197            return Math.Cos(Evaluate(dataset, ref row, state));
    187198          }
    188         case OpCodes.Sin:
    189           {
     199        case OpCodes.Sin: {
    190200            return Math.Sin(Evaluate(dataset, ref row, state));
    191201          }
    192         case OpCodes.Tan:
    193           {
     202        case OpCodes.Tan: {
    194203            return Math.Tan(Evaluate(dataset, ref row, state));
    195204          }
    196         case OpCodes.Square:
    197           {
     205        case OpCodes.Square: {
    198206            return Math.Pow(Evaluate(dataset, ref row, state), 2);
    199207          }
    200         case OpCodes.Power:
    201           {
     208        case OpCodes.Power: {
    202209            double x = Evaluate(dataset, ref row, state);
    203210            double y = Math.Round(Evaluate(dataset, ref row, state));
    204211            return Math.Pow(x, y);
    205212          }
    206         case OpCodes.SquareRoot:
    207           {
     213        case OpCodes.SquareRoot: {
    208214            return Math.Sqrt(Evaluate(dataset, ref row, state));
    209215          }
    210         case OpCodes.Root:
    211           {
     216        case OpCodes.Root: {
    212217            double x = Evaluate(dataset, ref row, state);
    213218            double y = Math.Round(Evaluate(dataset, ref row, state));
    214219            return Math.Pow(x, 1 / y);
    215220          }
    216         case OpCodes.Exp:
    217           {
     221        case OpCodes.Exp: {
    218222            return Math.Exp(Evaluate(dataset, ref row, state));
    219223          }
    220         case OpCodes.Log:
    221           {
     224        case OpCodes.Log: {
    222225            return Math.Log(Evaluate(dataset, ref row, state));
    223226          }
    224         case OpCodes.Gamma:
    225           {
    226             var x = Evaluate(dataset, ref row, state);
    227             if (double.IsNaN(x)) return double.NaN;
    228             else return alglib.gammafunction(x);
    229           }
    230         case OpCodes.Psi:
    231           {
     227        case OpCodes.Gamma: {
     228            var x = Evaluate(dataset, ref row, state);
     229            if (double.IsNaN(x)) { return double.NaN; } else { return alglib.gammafunction(x); }
     230          }
     231        case OpCodes.Psi: {
    232232            var x = Evaluate(dataset, ref row, state);
    233233            if (double.IsNaN(x)) return double.NaN;
     
    235235            return alglib.psi(x);
    236236          }
    237         case OpCodes.Dawson:
    238           {
    239             var x = Evaluate(dataset, ref row, state);
    240             if (double.IsNaN(x)) return double.NaN;
     237        case OpCodes.Dawson: {
     238            var x = Evaluate(dataset, ref row, state);
     239            if (double.IsNaN(x)) { return double.NaN; }
    241240            return alglib.dawsonintegral(x);
    242241          }
    243         case OpCodes.ExponentialIntegralEi:
    244           {
    245             var x = Evaluate(dataset, ref row, state);
    246             if (double.IsNaN(x)) return double.NaN;
     242        case OpCodes.ExponentialIntegralEi: {
     243            var x = Evaluate(dataset, ref row, state);
     244            if (double.IsNaN(x)) { return double.NaN; }
    247245            return alglib.exponentialintegralei(x);
    248246          }
    249         case OpCodes.SineIntegral:
    250           {
     247        case OpCodes.SineIntegral: {
    251248            double si, ci;
    252249            var x = Evaluate(dataset, ref row, state);
     
    257254            }
    258255          }
    259         case OpCodes.CosineIntegral:
    260           {
     256        case OpCodes.CosineIntegral: {
    261257            double si, ci;
    262258            var x = Evaluate(dataset, ref row, state);
     
    267263            }
    268264          }
    269         case OpCodes.HyperbolicSineIntegral:
    270           {
     265        case OpCodes.HyperbolicSineIntegral: {
    271266            double shi, chi;
    272267            var x = Evaluate(dataset, ref row, state);
     
    277272            }
    278273          }
    279         case OpCodes.HyperbolicCosineIntegral:
    280           {
     274        case OpCodes.HyperbolicCosineIntegral: {
    281275            double shi, chi;
    282276            var x = Evaluate(dataset, ref row, state);
     
    287281            }
    288282          }
    289         case OpCodes.FresnelCosineIntegral:
    290           {
     283        case OpCodes.FresnelCosineIntegral: {
    291284            double c = 0, s = 0;
    292285            var x = Evaluate(dataset, ref row, state);
     
    297290            }
    298291          }
    299         case OpCodes.FresnelSineIntegral:
    300           {
     292        case OpCodes.FresnelSineIntegral: {
    301293            double c = 0, s = 0;
    302294            var x = Evaluate(dataset, ref row, state);
     
    307299            }
    308300          }
    309         case OpCodes.AiryA:
    310           {
     301        case OpCodes.AiryA: {
    311302            double ai, aip, bi, bip;
    312303            var x = Evaluate(dataset, ref row, state);
     
    317308            }
    318309          }
    319         case OpCodes.AiryB:
    320           {
     310        case OpCodes.AiryB: {
    321311            double ai, aip, bi, bip;
    322312            var x = Evaluate(dataset, ref row, state);
     
    327317            }
    328318          }
    329         case OpCodes.Norm:
    330           {
     319        case OpCodes.Norm: {
    331320            var x = Evaluate(dataset, ref row, state);
    332321            if (double.IsNaN(x)) return double.NaN;
    333322            else return alglib.normaldistribution(x);
    334323          }
    335         case OpCodes.Erf:
    336           {
     324        case OpCodes.Erf: {
    337325            var x = Evaluate(dataset, ref row, state);
    338326            if (double.IsNaN(x)) return double.NaN;
    339327            else return alglib.errorfunction(x);
    340328          }
    341         case OpCodes.Bessel:
    342           {
     329        case OpCodes.Bessel: {
    343330            var x = Evaluate(dataset, ref row, state);
    344331            if (double.IsNaN(x)) return double.NaN;
    345332            else return alglib.besseli0(x);
    346333          }
    347         case OpCodes.IfThenElse:
    348           {
     334        case OpCodes.IfThenElse: {
    349335            double condition = Evaluate(dataset, ref row, state);
    350336            double result;
     
    356342            return result;
    357343          }
    358         case OpCodes.AND:
    359           {
     344        case OpCodes.AND: {
    360345            double result = Evaluate(dataset, ref row, state);
    361346            for (int i = 1; i < currentInstr.nArguments; i++) {
     
    367352            return result > 0.0 ? 1.0 : -1.0;
    368353          }
    369         case OpCodes.OR:
    370           {
     354        case OpCodes.OR: {
    371355            double result = Evaluate(dataset, ref row, state);
    372356            for (int i = 1; i < currentInstr.nArguments; i++) {
     
    378362            return result > 0.0 ? 1.0 : -1.0;
    379363          }
    380         case OpCodes.NOT:
    381           {
     364        case OpCodes.NOT: {
    382365            return Evaluate(dataset, ref row, state) > 0.0 ? -1.0 : 1.0;
    383366          }
    384         case OpCodes.XOR:
    385           {
     367        case OpCodes.XOR: {
    386368            //mkommend: XOR on multiple inputs is defined as true if the number of positive signals is odd
    387369            // this is equal to a consecutive execution of binary XOR operations.
    388370            int positiveSignals = 0;
    389371            for (int i = 0; i < currentInstr.nArguments; i++) {
    390               if (Evaluate(dataset, ref row, state) > 0.0) positiveSignals++;
     372              if (Evaluate(dataset, ref row, state) > 0.0) { positiveSignals++; }
    391373            }
    392374            return positiveSignals % 2 != 0 ? 1.0 : -1.0;
    393375          }
    394         case OpCodes.GT:
    395           {
     376        case OpCodes.GT: {
    396377            double x = Evaluate(dataset, ref row, state);
    397378            double y = Evaluate(dataset, ref row, state);
    398             if (x > y) return 1.0;
    399             else return -1.0;
    400           }
    401         case OpCodes.LT:
    402           {
     379            if (x > y) { return 1.0; } else { return -1.0; }
     380          }
     381        case OpCodes.LT: {
    403382            double x = Evaluate(dataset, ref row, state);
    404383            double y = Evaluate(dataset, ref row, state);
    405             if (x < y) return 1.0;
    406             else return -1.0;
    407           }
    408         case OpCodes.TimeLag:
    409           {
     384            if (x < y) { return 1.0; } else { return -1.0; }
     385          }
     386        case OpCodes.TimeLag: {
    410387            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    411388            row += timeLagTreeNode.Lag;
     
    414391            return result;
    415392          }
    416         case OpCodes.Integral:
    417           {
     393        case OpCodes.Integral: {
    418394            int savedPc = state.ProgramCounter;
    419395            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
     
    433409        //one sided smooth differentiatior, N = 4
    434410        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
    435         case OpCodes.Derivative:
    436           {
     411        case OpCodes.Derivative: {
    437412            int savedPc = state.ProgramCounter;
    438413            double f_0 = Evaluate(dataset, ref row, state); row--;
     
    447422            return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
    448423          }
    449         case OpCodes.Call:
    450           {
     424        case OpCodes.Call: {
    451425            // evaluate sub-trees
    452426            double[] argValues = new double[currentInstr.nArguments];
     
    471445            return v;
    472446          }
    473         case OpCodes.Arg:
    474           {
     447        case OpCodes.Arg: {
    475448            return state.GetStackFrameValue((ushort)currentInstr.data);
    476449          }
    477         case OpCodes.Variable:
    478           {
     450        case OpCodes.Variable: {
    479451            if (row < 0 || row >= dataset.Rows) return double.NaN;
    480452            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
    481453            return ((IList<double>)currentInstr.data)[row] * variableTreeNode.Weight;
    482454          }
    483         case OpCodes.LagVariable:
    484           {
     455        case OpCodes.LagVariable: {
    485456            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
    486457            int actualRow = row + laggedVariableTreeNode.Lag;
    487             if (actualRow < 0 || actualRow >= dataset.Rows) return double.NaN;
     458            if (actualRow < 0 || actualRow >= dataset.Rows) { return double.NaN; }
    488459            return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
    489460          }
    490         case OpCodes.Constant:
    491           {
     461        case OpCodes.Constant: {
    492462            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
    493463            return constTreeNode.Value;
     
    496466        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
    497467        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
    498         case OpCodes.VariableCondition:
    499           {
     468        case OpCodes.VariableCondition: {
    500469            if (row < 0 || row >= dataset.Rows) return double.NaN;
    501470            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
     
    509478            return trueBranch * p + falseBranch * (1 - p);
    510479          }
    511         default: throw new NotSupportedException();
     480        default:
     481          throw new NotSupportedException();
    512482      }
    513483    }
Note: See TracChangeset for help on using the changeset viewer.