Free cookie consent management tool by TermsFeed Policy Generator

source: trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs @ 14826

Last change on this file since 14826 was 14826, checked in by gkronber, 7 years ago

#2650: merged the factors branch into trunk

File size: 23.1 KB
RevLine 
[5571]1#region License Information
2/* HeuristicLab
[14185]3 * Copyright (C) 2002-2016 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
[5571]4 *
5 * This file is part of HeuristicLab.
6 *
7 * HeuristicLab is free software: you can redistribute it and/or modify
8 * it under the terms of the GNU General Public License as published by
9 * the Free Software Foundation, either version 3 of the License, or
10 * (at your option) any later version.
11 *
12 * HeuristicLab is distributed in the hope that it will be useful,
13 * but WITHOUT ANY WARRANTY; without even the implied warranty of
14 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 * GNU General Public License for more details.
16 *
17 * You should have received a copy of the GNU General Public License
18 * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
19 */
20#endregion
21
22using System;
23using System.Collections.Generic;
[14826]24using System.Linq;
[5571]25using HeuristicLab.Common;
26using HeuristicLab.Core;
[6740]27using HeuristicLab.Data;
[5571]28using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
[6740]29using HeuristicLab.Parameters;
[5571]30using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
31
32namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
33  [StorableClass]
34  [Item("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.")]
[13248]35  public class SymbolicDataAnalysisExpressionTreeInterpreter : ParameterizedNamedItem,
36    ISymbolicDataAnalysisExpressionTreeInterpreter {
[5749]37    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
[13248]38    private const string CheckExpressionsWithIntervalArithmeticParameterDescription = "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.";
[7615]39    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
[5571]40
[13248]41    public override bool CanChangeName {
42      get { return false; }
43    }
[5571]44
[13248]45    public override bool CanChangeDescription {
46      get { return false; }
47    }
48
[5749]49    #region parameter properties
[13248]50    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
51      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
[5749]52    }
[7615]53
[13248]54    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
55      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
[7615]56    }
[5749]57    #endregion
58
59    #region properties
[13248]60    public bool CheckExpressionsWithIntervalArithmetic {
61      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
62      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
[5749]63    }
[7615]64
[13248]65    public int EvaluatedSolutions {
66      get { return EvaluatedSolutionsParameter.Value.Value; }
67      set { EvaluatedSolutionsParameter.Value.Value = value; }
[7615]68    }
[5749]69    #endregion
70
[5571]71    [StorableConstructor]
[8436]72    protected SymbolicDataAnalysisExpressionTreeInterpreter(bool deserializing) : base(deserializing) { }
[13248]73
74    protected SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original,
[13251]75      Cloner cloner)
76      : base(original, cloner) { }
[13248]77
[5571]78    public override IDeepCloneable Clone(Cloner cloner) {
79      return new SymbolicDataAnalysisExpressionTreeInterpreter(this, cloner);
80    }
81
82    public SymbolicDataAnalysisExpressionTreeInterpreter()
[5749]83      : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
[13248]84      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)));
85      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
[5571]86    }
87
[8436]88    protected SymbolicDataAnalysisExpressionTreeInterpreter(string name, string description)
89      : base(name, description) {
[13248]90      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)));
91      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
[8436]92    }
93
[7615]94    [StorableHook(HookType.AfterDeserialization)]
95    private void AfterDeserialization() {
[13248]96      var evaluatedSolutions = new IntValue(0);
97      var checkExpressionsWithIntervalArithmetic = new BoolValue(false);
98      if (Parameters.ContainsKey(EvaluatedSolutionsParameterName)) {
99        var evaluatedSolutionsParameter = (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
100        evaluatedSolutions = evaluatedSolutionsParameter.Value;
101        Parameters.Remove(EvaluatedSolutionsParameterName);
102      }
103      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", evaluatedSolutions));
104      if (Parameters.ContainsKey(CheckExpressionsWithIntervalArithmeticParameterName)) {
105        var checkExpressionsWithIntervalArithmeticParameter = (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName];
106        Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
107        checkExpressionsWithIntervalArithmetic = checkExpressionsWithIntervalArithmeticParameter.Value;
108      }
109      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, checkExpressionsWithIntervalArithmetic));
[7615]110    }
111
112    #region IStatefulItem
113    public void InitializeState() {
[13248]114      EvaluatedSolutions = 0;
[7615]115    }
116
[13248]117    public void ClearState() { }
[7615]118    #endregion
119
[13251]120    private readonly object syncRoot = new object();
[13248]121    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset,
122      IEnumerable<int> rows) {
123      if (CheckExpressionsWithIntervalArithmetic) {
[8436]124        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
[13248]125      }
[7120]126
[13251]127      lock (syncRoot) {
[13248]128        EvaluatedSolutions++; // increment the evaluated solutions counter
[9004]129      }
[8436]130      var state = PrepareInterpreterState(tree, dataset);
131
132      foreach (var rowEnum in rows) {
133        int row = rowEnum;
134        yield return Evaluate(dataset, ref row, state);
135        state.Reset();
136      }
[7154]137    }
138
[12509]139    private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset) {
[8436]140      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
[5987]141      int necessaryArgStackSize = 0;
[8436]142      foreach (Instruction instr in code) {
[6860]143        if (instr.opCode == OpCodes.Variable) {
[8436]144          var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
[9828]145          instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
[14826]146        } else if (instr.opCode == OpCodes.FactorVariable) {
147          var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
148          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
149        } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
150          var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
151          instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
[5571]152        } else if (instr.opCode == OpCodes.LagVariable) {
[8436]153          var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
[9828]154          instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
[6860]155        } else if (instr.opCode == OpCodes.VariableCondition) {
[8436]156          var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
[9828]157          instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
[5987]158        } else if (instr.opCode == OpCodes.Call) {
159          necessaryArgStackSize += instr.nArguments + 1;
[5571]160        }
161      }
[8436]162      return new InterpreterState(code, necessaryArgStackSize);
163    }
[5571]164
[12509]165    public virtual double Evaluate(IDataset dataset, ref int row, InterpreterState state) {
[5571]166      Instruction currentInstr = state.NextInstruction();
167      switch (currentInstr.opCode) {
168        case OpCodes.Add: {
[8436]169            double s = Evaluate(dataset, ref row, state);
[5571]170            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]171              s += Evaluate(dataset, ref row, state);
[5571]172            }
173            return s;
174          }
175        case OpCodes.Sub: {
[8436]176            double s = Evaluate(dataset, ref row, state);
[5571]177            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]178              s -= Evaluate(dataset, ref row, state);
[5571]179            }
[13248]180            if (currentInstr.nArguments == 1) { s = -s; }
[5571]181            return s;
182          }
183        case OpCodes.Mul: {
[8436]184            double p = Evaluate(dataset, ref row, state);
[5571]185            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]186              p *= Evaluate(dataset, ref row, state);
[5571]187            }
188            return p;
189          }
190        case OpCodes.Div: {
[8436]191            double p = Evaluate(dataset, ref row, state);
[5571]192            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]193              p /= Evaluate(dataset, ref row, state);
[5571]194            }
[13248]195            if (currentInstr.nArguments == 1) { p = 1.0 / p; }
[5571]196            return p;
197          }
198        case OpCodes.Average: {
[8436]199            double sum = Evaluate(dataset, ref row, state);
[5571]200            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]201              sum += Evaluate(dataset, ref row, state);
[5571]202            }
203            return sum / currentInstr.nArguments;
204          }
205        case OpCodes.Cos: {
[8436]206            return Math.Cos(Evaluate(dataset, ref row, state));
[5571]207          }
208        case OpCodes.Sin: {
[8436]209            return Math.Sin(Evaluate(dataset, ref row, state));
[5571]210          }
211        case OpCodes.Tan: {
[8436]212            return Math.Tan(Evaluate(dataset, ref row, state));
[5571]213          }
[7842]214        case OpCodes.Square: {
[8436]215            return Math.Pow(Evaluate(dataset, ref row, state), 2);
[7842]216          }
[5571]217        case OpCodes.Power: {
[8436]218            double x = Evaluate(dataset, ref row, state);
219            double y = Math.Round(Evaluate(dataset, ref row, state));
[5571]220            return Math.Pow(x, y);
221          }
[7842]222        case OpCodes.SquareRoot: {
[8436]223            return Math.Sqrt(Evaluate(dataset, ref row, state));
[7842]224          }
[5571]225        case OpCodes.Root: {
[8436]226            double x = Evaluate(dataset, ref row, state);
227            double y = Math.Round(Evaluate(dataset, ref row, state));
[5571]228            return Math.Pow(x, 1 / y);
229          }
230        case OpCodes.Exp: {
[8436]231            return Math.Exp(Evaluate(dataset, ref row, state));
[5571]232          }
233        case OpCodes.Log: {
[8436]234            return Math.Log(Evaluate(dataset, ref row, state));
[5571]235          }
[7842]236        case OpCodes.Gamma: {
[8436]237            var x = Evaluate(dataset, ref row, state);
[13248]238            if (double.IsNaN(x)) { return double.NaN; } else { return alglib.gammafunction(x); }
[7842]239          }
240        case OpCodes.Psi: {
[8436]241            var x = Evaluate(dataset, ref row, state);
[7842]242            if (double.IsNaN(x)) return double.NaN;
[8430]243            else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) return double.NaN;
[7842]244            return alglib.psi(x);
245          }
246        case OpCodes.Dawson: {
[8436]247            var x = Evaluate(dataset, ref row, state);
[13248]248            if (double.IsNaN(x)) { return double.NaN; }
[7842]249            return alglib.dawsonintegral(x);
250          }
251        case OpCodes.ExponentialIntegralEi: {
[8436]252            var x = Evaluate(dataset, ref row, state);
[13248]253            if (double.IsNaN(x)) { return double.NaN; }
[7842]254            return alglib.exponentialintegralei(x);
255          }
256        case OpCodes.SineIntegral: {
257            double si, ci;
[8436]258            var x = Evaluate(dataset, ref row, state);
[7842]259            if (double.IsNaN(x)) return double.NaN;
260            else {
261              alglib.sinecosineintegrals(x, out si, out ci);
262              return si;
263            }
264          }
265        case OpCodes.CosineIntegral: {
266            double si, ci;
[8436]267            var x = Evaluate(dataset, ref row, state);
[7842]268            if (double.IsNaN(x)) return double.NaN;
269            else {
270              alglib.sinecosineintegrals(x, out si, out ci);
271              return ci;
272            }
273          }
274        case OpCodes.HyperbolicSineIntegral: {
275            double shi, chi;
[8436]276            var x = Evaluate(dataset, ref row, state);
[7842]277            if (double.IsNaN(x)) return double.NaN;
278            else {
279              alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
280              return shi;
281            }
282          }
283        case OpCodes.HyperbolicCosineIntegral: {
284            double shi, chi;
[8436]285            var x = Evaluate(dataset, ref row, state);
[7842]286            if (double.IsNaN(x)) return double.NaN;
287            else {
288              alglib.hyperbolicsinecosineintegrals(x, out shi, out chi);
289              return chi;
290            }
291          }
292        case OpCodes.FresnelCosineIntegral: {
293            double c = 0, s = 0;
[8436]294            var x = Evaluate(dataset, ref row, state);
[7842]295            if (double.IsNaN(x)) return double.NaN;
296            else {
297              alglib.fresnelintegral(x, ref c, ref s);
298              return c;
299            }
300          }
301        case OpCodes.FresnelSineIntegral: {
302            double c = 0, s = 0;
[8436]303            var x = Evaluate(dataset, ref row, state);
[7842]304            if (double.IsNaN(x)) return double.NaN;
305            else {
306              alglib.fresnelintegral(x, ref c, ref s);
307              return s;
308            }
309          }
310        case OpCodes.AiryA: {
311            double ai, aip, bi, bip;
[8436]312            var x = Evaluate(dataset, ref row, state);
[7842]313            if (double.IsNaN(x)) return double.NaN;
314            else {
315              alglib.airy(x, out ai, out aip, out bi, out bip);
316              return ai;
317            }
318          }
319        case OpCodes.AiryB: {
320            double ai, aip, bi, bip;
[8436]321            var x = Evaluate(dataset, ref row, state);
[7842]322            if (double.IsNaN(x)) return double.NaN;
323            else {
324              alglib.airy(x, out ai, out aip, out bi, out bip);
325              return bi;
326            }
327          }
328        case OpCodes.Norm: {
[8436]329            var x = Evaluate(dataset, ref row, state);
[7842]330            if (double.IsNaN(x)) return double.NaN;
331            else return alglib.normaldistribution(x);
332          }
333        case OpCodes.Erf: {
[8436]334            var x = Evaluate(dataset, ref row, state);
[7842]335            if (double.IsNaN(x)) return double.NaN;
336            else return alglib.errorfunction(x);
337          }
338        case OpCodes.Bessel: {
[8436]339            var x = Evaluate(dataset, ref row, state);
[7842]340            if (double.IsNaN(x)) return double.NaN;
341            else return alglib.besseli0(x);
342          }
[5571]343        case OpCodes.IfThenElse: {
[8436]344            double condition = Evaluate(dataset, ref row, state);
[5571]345            double result;
346            if (condition > 0.0) {
[8436]347              result = Evaluate(dataset, ref row, state); state.SkipInstructions();
[5571]348            } else {
[8436]349              state.SkipInstructions(); result = Evaluate(dataset, ref row, state);
[5571]350            }
351            return result;
352          }
353        case OpCodes.AND: {
[8436]354            double result = Evaluate(dataset, ref row, state);
[5571]355            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]356              if (result > 0.0) result = Evaluate(dataset, ref row, state);
[5571]357              else {
[8436]358                state.SkipInstructions();
[5571]359              }
360            }
[6732]361            return result > 0.0 ? 1.0 : -1.0;
[5571]362          }
363        case OpCodes.OR: {
[8436]364            double result = Evaluate(dataset, ref row, state);
[5571]365            for (int i = 1; i < currentInstr.nArguments; i++) {
[8436]366              if (result <= 0.0) result = Evaluate(dataset, ref row, state);
[5571]367              else {
[8436]368                state.SkipInstructions();
[5571]369              }
370            }
371            return result > 0.0 ? 1.0 : -1.0;
372          }
373        case OpCodes.NOT: {
[8436]374            return Evaluate(dataset, ref row, state) > 0.0 ? -1.0 : 1.0;
[5571]375          }
[10774]376        case OpCodes.XOR: {
[10788]377            //mkommend: XOR on multiple inputs is defined as true if the number of positive signals is odd
378            // this is equal to a consecutive execution of binary XOR operations.
379            int positiveSignals = 0;
380            for (int i = 0; i < currentInstr.nArguments; i++) {
[13248]381              if (Evaluate(dataset, ref row, state) > 0.0) { positiveSignals++; }
[10774]382            }
[10788]383            return positiveSignals % 2 != 0 ? 1.0 : -1.0;
[10774]384          }
[5571]385        case OpCodes.GT: {
[8436]386            double x = Evaluate(dataset, ref row, state);
387            double y = Evaluate(dataset, ref row, state);
[13248]388            if (x > y) { return 1.0; } else { return -1.0; }
[5571]389          }
390        case OpCodes.LT: {
[8436]391            double x = Evaluate(dataset, ref row, state);
392            double y = Evaluate(dataset, ref row, state);
[13248]393            if (x < y) { return 1.0; } else { return -1.0; }
[5571]394          }
395        case OpCodes.TimeLag: {
396            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
397            row += timeLagTreeNode.Lag;
[8436]398            double result = Evaluate(dataset, ref row, state);
[5571]399            row -= timeLagTreeNode.Lag;
400            return result;
401          }
402        case OpCodes.Integral: {
403            int savedPc = state.ProgramCounter;
404            var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
405            double sum = 0.0;
406            for (int i = 0; i < Math.Abs(timeLagTreeNode.Lag); i++) {
407              row += Math.Sign(timeLagTreeNode.Lag);
[8436]408              sum += Evaluate(dataset, ref row, state);
[5571]409              state.ProgramCounter = savedPc;
410            }
411            row -= timeLagTreeNode.Lag;
[8436]412            sum += Evaluate(dataset, ref row, state);
[5571]413            return sum;
414          }
415
416        //mkommend: derivate calculation taken from:
417        //http://www.holoborodko.com/pavel/numerical-methods/numerical-derivative/smooth-low-noise-differentiators/
418        //one sided smooth differentiatior, N = 4
419        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
420        case OpCodes.Derivative: {
421            int savedPc = state.ProgramCounter;
[8436]422            double f_0 = Evaluate(dataset, ref row, state); row--;
[5571]423            state.ProgramCounter = savedPc;
[8436]424            double f_1 = Evaluate(dataset, ref row, state); row -= 2;
[5571]425            state.ProgramCounter = savedPc;
[8436]426            double f_3 = Evaluate(dataset, ref row, state); row--;
[5571]427            state.ProgramCounter = savedPc;
[8436]428            double f_4 = Evaluate(dataset, ref row, state);
[5571]429            row += 4;
430
431            return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
432          }
433        case OpCodes.Call: {
434            // evaluate sub-trees
435            double[] argValues = new double[currentInstr.nArguments];
436            for (int i = 0; i < currentInstr.nArguments; i++) {
[8436]437              argValues[i] = Evaluate(dataset, ref row, state);
[5571]438            }
439            // push on argument values on stack
440            state.CreateStackFrame(argValues);
441
442            // save the pc
443            int savedPc = state.ProgramCounter;
444            // set pc to start of function 
[9828]445            state.ProgramCounter = (ushort)currentInstr.data;
[5571]446            // evaluate the function
[8436]447            double v = Evaluate(dataset, ref row, state);
[5571]448
449            // delete the stack frame
450            state.RemoveStackFrame();
451
452            // restore the pc => evaluation will continue at point after my subtrees 
453            state.ProgramCounter = savedPc;
454            return v;
455          }
456        case OpCodes.Arg: {
[9828]457            return state.GetStackFrameValue((ushort)currentInstr.data);
[5571]458          }
459        case OpCodes.Variable: {
[8486]460            if (row < 0 || row >= dataset.Rows) return double.NaN;
[6740]461            var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
[9828]462            return ((IList<double>)currentInstr.data)[row] * variableTreeNode.Weight;
[5571]463          }
[14826]464        case OpCodes.BinaryFactorVariable: {
465            if (row < 0 || row >= dataset.Rows) return double.NaN;
466            var factorVarTreeNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
467            return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0;
468          }
469        case OpCodes.FactorVariable: {
470            if (row < 0 || row >= dataset.Rows) return double.NaN;
471            var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
472            return factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]);
473          }
[5571]474        case OpCodes.LagVariable: {
[6740]475            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
[5571]476            int actualRow = row + laggedVariableTreeNode.Lag;
[13248]477            if (actualRow < 0 || actualRow >= dataset.Rows) { return double.NaN; }
[9828]478            return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
[5571]479          }
480        case OpCodes.Constant: {
[8436]481            var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
[5897]482            return constTreeNode.Value;
[5571]483          }
484
485        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
486        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
487        case OpCodes.VariableCondition: {
[8486]488            if (row < 0 || row >= dataset.Rows) return double.NaN;
[5571]489            var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;
[14345]490            if (!variableConditionTreeNode.Symbol.IgnoreSlope) {
491              double variableValue = ((IList<double>)currentInstr.data)[row];
492              double x = variableValue - variableConditionTreeNode.Threshold;
493              double p = 1 / (1 + Math.Exp(-variableConditionTreeNode.Slope * x));
[5571]494
[14345]495              double trueBranch = Evaluate(dataset, ref row, state);
496              double falseBranch = Evaluate(dataset, ref row, state);
[5571]497
[14345]498              return trueBranch * p + falseBranch * (1 - p);
499            } else {
500              // strict threshold
501              double variableValue = ((IList<double>)currentInstr.data)[row];
502              if (variableValue <= variableConditionTreeNode.Threshold) {
503                var left = Evaluate(dataset, ref row, state);
504                state.SkipInstructions();
505                return left;
506              } else {
507                state.SkipInstructions();
508                return Evaluate(dataset, ref row, state);
509              }
510            }
[5571]511          }
[13248]512        default:
513          throw new NotSupportedException();
[5571]514      }
515    }
516  }
[13248]517}
Note: See TracBrowser for help on using the repository browser.