Free cookie consent management tool by TermsFeed Policy Generator

Ignore:
Timestamp:
11/18/15 13:50:15 (8 years ago)
Author:
mkommend
Message:

#2442: Reintegrated branch for compiled symbolic expression tree interpreter.

File:
1 edited

Legend:

Unmodified
Added
Removed

  • trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

    r12509 r13248  
    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
    42     public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
    43       get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
    44     }
    45 
    46     public IValueParameter<IntValue> EvaluatedSolutionsParameter {
    47       get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     49    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
     50      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
     51    }
     52
     53    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
     54      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
    4855    }
    4956    #endregion
    5057
    5158    #region properties
    52     public BoolValue CheckExpressionsWithIntervalArithmetic {
    53       get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
    54       set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
    55     }
    56 
    57     public IntValue EvaluatedSolutions {
    58       get { return EvaluatedSolutionsParameter.Value; }
    59       set { EvaluatedSolutionsParameter.Value = value; }
     59    public bool CheckExpressionsWithIntervalArithmetic {
     60      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
     61      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
     62    }
     63
     64    public int EvaluatedSolutions {
     65      get { return EvaluatedSolutionsParameter.Value.Value; }
     66      set { EvaluatedSolutionsParameter.Value.Value = value; }
    6067    }
    6168    #endregion
    … …  
    6370    [StorableConstructor]
    6471    protected SymbolicDataAnalysisExpressionTreeInterpreter(bool deserializing) : base(deserializing) { }
    65     protected SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original, Cloner cloner) : base(original, cloner) { }
     72
     73    protected SymbolicDataAnalysisExpressionTreeInterpreter(SymbolicDataAnalysisExpressionTreeInterpreter original,
     74      Cloner cloner) : base(original, cloner) { }
     75
    6676    public override IDeepCloneable Clone(Cloner cloner) {
    6777      return new SymbolicDataAnalysisExpressionTreeInterpreter(this, cloner);
    … …  
    7080    public SymbolicDataAnalysisExpressionTreeInterpreter()
    7181      : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
    72       Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    73       Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     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)));
     83      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    7484    }
    7585
    7686    protected SymbolicDataAnalysisExpressionTreeInterpreter(string name, string description)
    7787      : base(name, description) {
    78       Parameters.Add(new ValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    79       Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     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)));
     89      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    8090    }
    8191
    8292    [StorableHook(HookType.AfterDeserialization)]
    8393    private void AfterDeserialization() {
    84       if (!Parameters.ContainsKey(EvaluatedSolutionsParameterName))
    85         Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     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));
    86108    }
    87109
    88110    #region IStatefulItem
    89111    public void InitializeState() {
    90       EvaluatedSolutions.Value = 0;
    91     }
    92 
    93     public void ClearState() {
    94     }
     112      EvaluatedSolutions = 0;
     113    }
     114
     115    public void ClearState() { }
    95116    #endregion
    96117
    97     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
    98       if (CheckExpressionsWithIntervalArithmetic.Value)
     118    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset,
     119      IEnumerable<int> rows) {
     120      if (CheckExpressionsWithIntervalArithmetic) {
    99121        throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
    100 
    101       lock (EvaluatedSolutions) {
    102         EvaluatedSolutions.Value++; // increment the evaluated solutions counter
     122      }
     123
     124      lock (EvaluatedSolutionsParameter.Value) {
     125        EvaluatedSolutions++; // increment the evaluated solutions counter
    103126      }
    104127      var state = PrepareInterpreterState(tree, dataset);
    … …  
    131154    }
    132155
    133 
    134156    public virtual double Evaluate(IDataset dataset, ref int row, InterpreterState state) {
    135157      Instruction currentInstr = state.NextInstruction();
    … …  
    147169              s -= Evaluate(dataset, ref row, state);
    148170            }
    149             if (currentInstr.nArguments == 1) s = -s;
     171            if (currentInstr.nArguments == 1) { s = -s; }
    150172            return s;
    151173          }
    … …  
    162184              p /= Evaluate(dataset, ref row, state);
    163185            }
    164             if (currentInstr.nArguments == 1) p = 1.0 / p;
     186            if (currentInstr.nArguments == 1) { p = 1.0 / p; }
    165187            return p;
    166188          }
    … …  
    205227        case OpCodes.Gamma: {
    206228            var x = Evaluate(dataset, ref row, state);
    207             if (double.IsNaN(x)) return double.NaN;
    208             else return alglib.gammafunction(x);
     229            if (double.IsNaN(x)) { return double.NaN; } else { return alglib.gammafunction(x); }
    209230          }
    210231        case OpCodes.Psi: {
    … …  
    216237        case OpCodes.Dawson: {
    217238            var x = Evaluate(dataset, ref row, state);
    218             if (double.IsNaN(x)) return double.NaN;
     239            if (double.IsNaN(x)) { return double.NaN; }
    219240            return alglib.dawsonintegral(x);
    220241          }
    221242        case OpCodes.ExponentialIntegralEi: {
    222243            var x = Evaluate(dataset, ref row, state);
    223             if (double.IsNaN(x)) return double.NaN;
     244            if (double.IsNaN(x)) { return double.NaN; }
    224245            return alglib.exponentialintegralei(x);
    225246          }
    … …  
    349370            int positiveSignals = 0;
    350371            for (int i = 0; i < currentInstr.nArguments; i++) {
    351               if (Evaluate(dataset, ref row, state) > 0.0) positiveSignals++;
     372              if (Evaluate(dataset, ref row, state) > 0.0) { positiveSignals++; }
    352373            }
    353374            return positiveSignals % 2 != 0 ? 1.0 : -1.0;
    … …  
    356377            double x = Evaluate(dataset, ref row, state);
    357378            double y = Evaluate(dataset, ref row, state);
    358             if (x > y) return 1.0;
    359             else return -1.0;
     379            if (x > y) { return 1.0; } else { return -1.0; }
    360380          }
    361381        case OpCodes.LT: {
    362382            double x = Evaluate(dataset, ref row, state);
    363383            double y = Evaluate(dataset, ref row, state);
    364             if (x < y) return 1.0;
    365             else return -1.0;
     384            if (x < y) { return 1.0; } else { return -1.0; }
    366385          }
    367386        case OpCodes.TimeLag: {
    … …  
    437456            var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
    438457            int actualRow = row + laggedVariableTreeNode.Lag;
    439             if (actualRow < 0 || actualRow >= dataset.Rows) return double.NaN;
     458            if (actualRow < 0 || actualRow >= dataset.Rows) { return double.NaN; }
    440459            return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
    441460          }
    … …  
    459478            return trueBranch * p + falseBranch * (1 - p);
    460479          }
    461         default: throw new NotSupportedException();
     480        default:
     481          throw new NotSupportedException();
    462482      }
    463483    }
Note: See TracChangeset for help on using the changeset viewer.