Changeset 13222


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

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

Location:
branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter
Files:
4 edited

Legend:

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

    r13141 r13222  
    2222using System;
    2323using System.Collections.Generic;
    24 using System.Collections.ObjectModel;
    2524using System.Linq;
    2625using System.Linq.Expressions;
     
    3837  public sealed class SymbolicDataAnalysisExpressionCompiledTreeInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
    3938    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
     39    private const string CheckExpressionsWithIntervalArithmeticParameterDescription = "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.";
    4040    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    4141
     
    6262    #endregion
    6363
    64     private static readonly Func<ReadOnlyCollection<double>, IList<double>> ReadOnlyCollectionRetrieveList = GetField<ReadOnlyCollection<double>, IList<double>>("list"); // retrieve underlying field of type IList<double> from a ReadOnlyCollection<double>
    65     private static readonly Func<List<double>, double[]> ListRetrieveItems = GetField<List<double>, double[]>("_items"); // retrieve underlying field of type double[] from a List<double>
    66     private static MethodInfo listGetValue = typeof(IList<double>).GetProperty("Item", new Type[] { typeof(int) }).GetGetMethod();
    67 
    6864    public override bool CanChangeName { get { return false; } }
    69 
    7065    public override bool CanChangeDescription { get { return false; } }
    7166
     
    106101    public SymbolicDataAnalysisExpressionCompiledTreeInterpreter() :
    107102      base("SymbolicDataAnalysisExpressionCompiledTreeInterpreter", "Interpreter which compiles the tree into a lambda") {
    108       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    109         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     103      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, new BoolValue(false)));
    110104      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    111105    }
     
    113107    public SymbolicDataAnalysisExpressionCompiledTreeInterpreter(string name, string description) :
    114108      base(name, description) {
    115       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    116         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     109      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, new BoolValue(false)));
    117110      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    118     }
    119 
    120     [StorableHook(HookType.AfterDeserialization)]
    121     private void AfterDeserialization() {
    122       Parameters.Remove(EvaluatedSolutionsParameterName);
    123       Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    124 
    125       Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
    126       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    127         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
    128111    }
    129112
     
    132115    }
    133116
    134     public void ClearState() {
    135     }
     117    public void ClearState() { }
    136118
    137119    public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
     
    142124        EvaluatedSolutions++; // increment the evaluated solutions counter
    143125      }
    144       //      var columns = dataset.DoubleVariables.Select(x => ListRetrieveItems((List<double>)ReadOnlyCollectionRetrieveList(dataset.GetReadOnlyDoubleValues(x)))).ToArray();
    145       var columns = dataset.DoubleVariables.Select(x => (List<double>)dataset.GetDoubleValues(x)).ToArray();
     126      var columns = dataset.DoubleVariables.Select(x => (IList<double>)dataset.GetReadOnlyDoubleValues(x)).ToArray();
    146127      var compiled = CompileTree(tree, dataset);
    147128      return rows.Select(x => compiled(x, columns));
    148129    }
    149130
    150     public static Func<int, List<double>[], double> CompileTree(ISymbolicExpressionTree tree, IDataset dataset) {
     131    public static Func<int, IList<double>[], double> CompileTree(ISymbolicExpressionTree tree, IDataset dataset) {
    151132      var row = Expression.Parameter(typeof(int));
    152       var columns = Expression.Parameter(typeof(List<double>[]));
     133      var columns = Expression.Parameter(typeof(IList<double>[]));
    153134      var variableIndices = dataset.DoubleVariables.Select((x, i) => new { x, i }).ToDictionary(e => e.x, e => e.i);
    154135      var expr = MakeExpr(tree, variableIndices, row, columns);
    155       var lambda = Expression.Lambda<Func<int, List<double>[], double>>(expr, row, columns);
     136      var lambda = Expression.Lambda<Func<int, IList<double>[], double>>(expr, row, columns);
    156137      return lambda.Compile();
    157138    }
     
    162143    }
    163144
     145    private static readonly PropertyInfo Indexer = typeof(IList<double>).GetProperty("Item");
    164146    private static Expression MakeExpr(ISymbolicExpressionTreeNode node, Dictionary<string, int> variableIndices, Expression row, Expression columns) {
    165147      var opcode = OpCodes.MapSymbolToOpCode(node);
    166148      #region switch opcode
    167149      switch (opcode) {
    168         case OpCodes.Constant:
    169           {
     150        case OpCodes.Constant: {
    170151            var constantTreeNode = (ConstantTreeNode)node;
    171152            return Expression.Constant(constantTreeNode.Value);
    172153          }
    173         case OpCodes.Variable:
    174           {
     154        case OpCodes.Variable: {
    175155            var variableTreeNode = (VariableTreeNode)node;
    176156            var variableWeight = Expression.Constant(variableTreeNode.Weight);
     
    178158            var indexExpr = Expression.Constant(variableIndices[variableName]);
    179159            var valuesExpr = Expression.ArrayIndex(columns, indexExpr);
    180             var variableValue = Expression.ArrayIndex(Expression.Field(valuesExpr, "_items"), row);
    181             //            var variableValue = Expression.Property(valuesExpr, Indexer, row);
     160            var variableValue = Expression.Property(valuesExpr, Indexer, row);
    182161            return Expression.Multiply(variableWeight, variableValue);
    183162          }
    184         case OpCodes.Add:
    185           {
     163        case OpCodes.Add: {
    186164            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    187165            for (int i = 1; i < node.SubtreeCount; ++i) {
     
    190168            return result;
    191169          }
    192         case OpCodes.Sub:
    193           {
     170        case OpCodes.Sub: {
    194171            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    195172            if (node.SubtreeCount == 1)
     
    200177            return result;
    201178          }
    202         case OpCodes.Mul:
    203           {
     179        case OpCodes.Mul: {
    204180            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    205181            for (int i = 1; i < node.SubtreeCount; ++i) {
     
    208184            return result;
    209185          }
    210         case OpCodes.Div:
    211           {
     186        case OpCodes.Div: {
    212187            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    213188            if (node.SubtreeCount == 1)
     
    218193            return result;
    219194          }
    220         case OpCodes.Average:
    221           {
     195        case OpCodes.Average: {
    222196            Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    223197            for (int i = 1; i < node.SubtreeCount; ++i) {
     
    226200            return Expression.Divide(result, Expression.Constant((double)node.SubtreeCount));
    227201          }
    228         case OpCodes.Cos:
    229           {
     202        case OpCodes.Cos: {
    230203            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    231204            return Expression.Call(Cos, arg);
    232205          }
    233         case OpCodes.Sin:
    234           {
     206        case OpCodes.Sin: {
    235207            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    236208            return Expression.Call(Sin, arg);
    237209          }
    238         case OpCodes.Tan:
    239           {
     210        case OpCodes.Tan: {
    240211            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    241212            return Expression.Call(Tan, arg);
    242213          }
    243         case OpCodes.Square:
    244           {
     214        case OpCodes.Square: {
    245215            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    246216            return Expression.Power(arg, Expression.Constant(2));
    247217          }
    248         case OpCodes.Power:
    249           {
     218        case OpCodes.Power: {
    250219            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    251220            var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    252221            return Expression.Power(arg, Expression.Call(Floor, power));
    253222          }
    254         case OpCodes.SquareRoot:
    255           {
     223        case OpCodes.SquareRoot: {
    256224            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    257225            return Expression.Call(Sqrt, arg);
    258226          }
    259         case OpCodes.Root:
    260           {
     227        case OpCodes.Root: {
    261228            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    262229            var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
    263230            return Expression.Power(arg, Expression.Divide(Expression.Constant(1.0), power));
    264231          }
    265         case OpCodes.Exp:
    266           {
     232        case OpCodes.Exp: {
    267233            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    268234            return Expression.Call(Exp, arg);
    269235          }
    270         case OpCodes.Log:
    271           {
     236        case OpCodes.Log: {
    272237            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    273238            return Expression.Call(Log, arg);
    274239          }
    275         case OpCodes.Gamma:
    276           {
     240        case OpCodes.Gamma: {
    277241            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    278242            var isNaN = Expression.Call(IsNaN, arg);
     
    291255            return expr;
    292256          }
    293         case OpCodes.Psi:
    294           {
     257        case OpCodes.Psi: {
    295258            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    296259            var isNaN = Expression.Call(IsNaN, arg);
     
    314277            return expr;
    315278          }
    316         case OpCodes.Dawson:
    317           {
     279        case OpCodes.Dawson: {
    318280            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    319281            var isNaN = Expression.Call(IsNaN, arg);
     
    331293            return expr;
    332294          }
    333         case OpCodes.ExponentialIntegralEi:
    334           {
     295        case OpCodes.ExponentialIntegralEi: {
    335296            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    336297            var isNaN = Expression.Call(IsNaN, arg);
     
    348309            return expr;
    349310          }
    350         case OpCodes.SineIntegral:
    351           {
     311        case OpCodes.SineIntegral: {
    352312            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    353313            var isNaN = Expression.Call(IsNaN, arg);
     
    370330            return expr;
    371331          }
    372         case OpCodes.CosineIntegral:
    373           {
     332        case OpCodes.CosineIntegral: {
    374333            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    375334            var isNaN = Expression.Call(IsNaN, arg);
     
    392351            return expr;
    393352          }
    394         case OpCodes.HyperbolicSineIntegral:
    395           {
     353        case OpCodes.HyperbolicSineIntegral: {
    396354            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    397355            var isNaN = Expression.Call(IsNaN, arg);
     
    414372            return expr;
    415373          }
    416         case OpCodes.HyperbolicCosineIntegral:
    417           {
     374        case OpCodes.HyperbolicCosineIntegral: {
    418375            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    419376            var isNaN = Expression.Call(IsNaN, arg);
     
    436393            return expr;
    437394          }
    438         case OpCodes.FresnelSineIntegral:
    439           {
     395        case OpCodes.FresnelSineIntegral: {
    440396            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    441397            var isNaN = Expression.Call(IsNaN, arg);
     
    454410            return expr;
    455411          }
    456         case OpCodes.FresnelCosineIntegral:
    457           {
     412        case OpCodes.FresnelCosineIntegral: {
    458413            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    459414            var isNaN = Expression.Call(IsNaN, arg);
     
    472427            return expr;
    473428          }
    474         case OpCodes.AiryA:
    475           {
     429        case OpCodes.AiryA: {
    476430            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    477431            var isNaN = Expression.Call(IsNaN, arg);
     
    492446            return expr;
    493447          }
    494         case OpCodes.AiryB:
    495           {
     448        case OpCodes.AiryB: {
    496449            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    497450            var isNaN = Expression.Call(IsNaN, arg);
     
    512465            return expr;
    513466          }
    514         case OpCodes.Norm:
    515           {
     467        case OpCodes.Norm: {
    516468            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    517469            var isNaN = Expression.Call(IsNaN, arg);
     
    525477            return expr;
    526478          }
    527         case OpCodes.Erf:
    528           {
     479        case OpCodes.Erf: {
    529480            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    530481            var isNaN = Expression.Call(IsNaN, arg);
     
    538489            return expr;
    539490          }
    540         case OpCodes.Bessel:
    541           {
     491        case OpCodes.Bessel: {
    542492            var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    543493            var isNaN = Expression.Call(IsNaN, arg);
     
    554504            return expr;
    555505          }
    556         case OpCodes.IfThenElse:
    557           {
     506        case OpCodes.IfThenElse: {
    558507            var test = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    559508            var result = Expression.Variable(typeof(double));
     
    563512            return Expression.Block(new[] { result }, condition, result);
    564513          }
    565         case OpCodes.AND:
    566           {
     514        case OpCodes.AND: {
    567515            var result = Expression.Variable(typeof(double));
    568516            var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     
    589537              );
    590538          }
    591         case OpCodes.OR:
    592           {
     539        case OpCodes.OR: {
    593540            var result = Expression.Variable(typeof(double));
    594541            var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
     
    615562              );
    616563          }
    617         case OpCodes.NOT:
    618           {
     564        case OpCodes.NOT: {
    619565            var value = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    620566            var result = Expression.Variable(typeof(double));
     
    624570            return Expression.Block(new[] { result }, condition, result);
    625571          }
    626         case OpCodes.XOR:
    627           {
     572        case OpCodes.XOR: {
    628573            var ps = Expression.Variable(typeof(int));
    629574            var block = Expression.Block(
     
    656601            return xorExpr;
    657602          }
    658         case OpCodes.GT:
    659           {
     603        case OpCodes.GT: {
    660604            var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    661605            var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
     
    669613              result);
    670614          }
    671         case OpCodes.LT:
    672           {
     615        case OpCodes.LT: {
    673616            var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
    674617            var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
     
    679622            return Expression.Block(new[] { result }, condition, result);
    680623          }
    681         case OpCodes.VariableCondition:
    682           {
     624        case OpCodes.VariableCondition: {
    683625            var variableConditionTreeNode = (VariableConditionTreeNode)node;
    684626            var variableName = variableConditionTreeNode.VariableName;
     
    700642              );
    701643          }
    702         case OpCodes.LagVariable:
    703           {
     644        case OpCodes.LagVariable: {
    704645            var laggedVariableTreeNode = (LaggedVariableTreeNode)node;
    705646            var lag = Expression.Constant(laggedVariableTreeNode.Lag);
     
    708649            var indexExpr = Expression.Constant(variableIndices[variableName]);
    709650            var valuesExpr = Expression.ArrayIndex(columns, indexExpr);
    710             var variableValue = Expression.ArrayIndex(Expression.Field(valuesExpr, "_items"), Expression.Add(row, lag));
     651            var variableValue = Expression.Property(valuesExpr, Indexer, Expression.Add(row, lag));
    711652            return Expression.Multiply(variableWeight, variableValue);
    712653          }
    713         case OpCodes.TimeLag:
    714           {
     654        case OpCodes.TimeLag: {
    715655            var timeLagTreeNode = (LaggedTreeNode)node;
    716656            var lag = Expression.Constant(timeLagTreeNode.Lag);
    717657            return MakeExpr(timeLagTreeNode.GetSubtree(0), variableIndices, Expression.Add(row, lag), columns);
    718658          }
    719         case OpCodes.Integral:
    720           {
     659        case OpCodes.Integral: {
    721660            var timeLagTreeNode = (LaggedTreeNode)node;
    722661            var subtree = node.GetSubtree(0);
     
    730669            return sum;
    731670          }
    732         case OpCodes.Derivative:
    733           {
     671        case OpCodes.Derivative: {
    734672            var subtree = node.GetSubtree(0);
    735673            var f0 = MakeExpr(subtree, variableIndices, row, columns);
  • branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

    r13141 r13222  
    6969
    7070    private const string CheckExpressionsWithIntervalArithmeticParameterName = "CheckExpressionsWithIntervalArithmetic";
     71    private const string CheckExpressionsWithIntervalArithmeticParameterDescription = "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.";
    7172    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    7273
     
    124125    [StorableHook(HookType.AfterDeserialization)]
    125126    private void AfterDeserialization() {
    126       Parameters.Remove(EvaluatedSolutionsParameterName);
    127       Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    128 
    129       Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
    130       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    131         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     127      var evaluatedSolutions = new IntValue(0);
     128      var checkExpressionsWithIntervalArithmetic = new BoolValue(false);
     129      if (Parameters.ContainsKey(EvaluatedSolutionsParameterName)) {
     130        var evaluatedSolutionsParameter = (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
     131        evaluatedSolutions = evaluatedSolutionsParameter.Value;
     132        Parameters.Remove(EvaluatedSolutionsParameterName);
     133      }
     134      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", evaluatedSolutions));
     135      if (Parameters.ContainsKey(CheckExpressionsWithIntervalArithmeticParameterName)) {
     136        var checkExpressionsWithIntervalArithmeticParameter = (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName];
     137        Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
     138        checkExpressionsWithIntervalArithmetic = checkExpressionsWithIntervalArithmeticParameter.Value;
     139      }
     140      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, checkExpressionsWithIntervalArithmetic));
    132141    }
    133142
    134143    #region IStatefulItem
    135 
    136144    public void InitializeState() {
    137145      EvaluatedSolutions = 0;
     
    140148    public void ClearState() {
    141149    }
    142 
    143150    #endregion
    144151
     
    192199
    193200      switch (currentInstr.opCode) {
    194         case OpCodes.Add:
    195           {
     201        case OpCodes.Add: {
    196202            if (nArgs > 0) {
    197203              CompileInstructions(il, state, ds);
     
    203209            return;
    204210          }
    205         case OpCodes.Sub:
    206           {
     211        case OpCodes.Sub: {
    207212            if (nArgs == 1) {
    208213              CompileInstructions(il, state, ds);
     
    219224            return;
    220225          }
    221         case OpCodes.Mul:
    222           {
     226        case OpCodes.Mul: {
    223227            if (nArgs > 0) {
    224228              CompileInstructions(il, state, ds);
     
    230234            return;
    231235          }
    232         case OpCodes.Div:
    233           {
     236        case OpCodes.Div: {
    234237            if (nArgs == 1) {
    235238              il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
     
    247250            return;
    248251          }
    249         case OpCodes.Average:
    250           {
     252        case OpCodes.Average: {
    251253            CompileInstructions(il, state, ds);
    252254            for (int i = 1; i < nArgs; i++) {
     
    258260            return;
    259261          }
    260         case OpCodes.Cos:
    261           {
     262        case OpCodes.Cos: {
    262263            CompileInstructions(il, state, ds);
    263264            il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
    264265            return;
    265266          }
    266         case OpCodes.Sin:
    267           {
     267        case OpCodes.Sin: {
    268268            CompileInstructions(il, state, ds);
    269269            il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
    270270            return;
    271271          }
    272         case OpCodes.Tan:
    273           {
     272        case OpCodes.Tan: {
    274273            CompileInstructions(il, state, ds);
    275274            il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
    276275            return;
    277276          }
    278         case OpCodes.Power:
    279           {
     277        case OpCodes.Power: {
    280278            CompileInstructions(il, state, ds);
    281279            CompileInstructions(il, state, ds);
     
    284282            return;
    285283          }
    286         case OpCodes.Root:
    287           {
     284        case OpCodes.Root: {
    288285            CompileInstructions(il, state, ds);
    289286            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
     
    294291            return;
    295292          }
    296         case OpCodes.Exp:
    297           {
     293        case OpCodes.Exp: {
    298294            CompileInstructions(il, state, ds);
    299295            il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
    300296            return;
    301297          }
    302         case OpCodes.Log:
    303           {
     298        case OpCodes.Log: {
    304299            CompileInstructions(il, state, ds);
    305300            il.Emit(System.Reflection.Emit.OpCodes.Call, log);
    306301            return;
    307302          }
    308         case OpCodes.Square:
    309           {
     303        case OpCodes.Square: {
    310304            CompileInstructions(il, state, ds);
    311305            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
     
    313307            return;
    314308          }
    315         case OpCodes.SquareRoot:
    316           {
     309        case OpCodes.SquareRoot: {
    317310            CompileInstructions(il, state, ds);
    318311            il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
    319312            return;
    320313          }
    321         case OpCodes.AiryA:
    322           {
     314        case OpCodes.AiryA: {
    323315            CompileInstructions(il, state, ds);
    324316            il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
    325317            return;
    326318          }
    327         case OpCodes.AiryB:
    328           {
     319        case OpCodes.AiryB: {
    329320            CompileInstructions(il, state, ds);
    330321            il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
    331322            return;
    332323          }
    333         case OpCodes.Bessel:
    334           {
     324        case OpCodes.Bessel: {
    335325            CompileInstructions(il, state, ds);
    336326            il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
    337327            return;
    338328          }
    339         case OpCodes.CosineIntegral:
    340           {
     329        case OpCodes.CosineIntegral: {
    341330            CompileInstructions(il, state, ds);
    342331            il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
    343332            return;
    344333          }
    345         case OpCodes.Dawson:
    346           {
     334        case OpCodes.Dawson: {
    347335            CompileInstructions(il, state, ds);
    348336            il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
    349337            return;
    350338          }
    351         case OpCodes.Erf:
    352           {
     339        case OpCodes.Erf: {
    353340            CompileInstructions(il, state, ds);
    354341            il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
    355342            return;
    356343          }
    357         case OpCodes.ExponentialIntegralEi:
    358           {
     344        case OpCodes.ExponentialIntegralEi: {
    359345            CompileInstructions(il, state, ds);
    360346            il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
    361347            return;
    362348          }
    363         case OpCodes.FresnelCosineIntegral:
    364           {
     349        case OpCodes.FresnelCosineIntegral: {
    365350            CompileInstructions(il, state, ds);
    366351            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
    367352            return;
    368353          }
    369         case OpCodes.FresnelSineIntegral:
    370           {
     354        case OpCodes.FresnelSineIntegral: {
    371355            CompileInstructions(il, state, ds);
    372356            il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
    373357            return;
    374358          }
    375         case OpCodes.Gamma:
    376           {
     359        case OpCodes.Gamma: {
    377360            CompileInstructions(il, state, ds);
    378361            il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
    379362            return;
    380363          }
    381         case OpCodes.HyperbolicCosineIntegral:
    382           {
     364        case OpCodes.HyperbolicCosineIntegral: {
    383365            CompileInstructions(il, state, ds);
    384366            il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
    385367            return;
    386368          }
    387         case OpCodes.HyperbolicSineIntegral:
    388           {
     369        case OpCodes.HyperbolicSineIntegral: {
    389370            CompileInstructions(il, state, ds);
    390371            il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
    391372            return;
    392373          }
    393         case OpCodes.Norm:
    394           {
     374        case OpCodes.Norm: {
    395375            CompileInstructions(il, state, ds);
    396376            il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
    397377            return;
    398378          }
    399         case OpCodes.Psi:
    400           {
     379        case OpCodes.Psi: {
    401380            CompileInstructions(il, state, ds);
    402381            il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
    403382            return;
    404383          }
    405         case OpCodes.SineIntegral:
    406           {
     384        case OpCodes.SineIntegral: {
    407385            CompileInstructions(il, state, ds);
    408386            il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
    409387            return;
    410388          }
    411         case OpCodes.IfThenElse:
    412           {
     389        case OpCodes.IfThenElse: {
    413390            Label end = il.DefineLabel();
    414391            Label c1 = il.DefineLabel();
     
    424401            return;
    425402          }
    426         case OpCodes.AND:
    427           {
     403        case OpCodes.AND: {
    428404            Label falseBranch = il.DefineLabel();
    429405            Label end = il.DefineLabel();
     
    446422            return;
    447423          }
    448         case OpCodes.OR:
    449           {
     424        case OpCodes.OR: {
    450425            Label trueBranch = il.DefineLabel();
    451426            Label end = il.DefineLabel();
     
    475450            return;
    476451          }
    477         case OpCodes.NOT:
    478           {
     452        case OpCodes.NOT: {
    479453            CompileInstructions(il, state, ds);
    480454            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
     
    487461            return;
    488462          }
    489         case OpCodes.XOR:
    490           {
     463        case OpCodes.XOR: {
    491464            CompileInstructions(il, state, ds);
    492465            il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
     
    505478            return;
    506479          }
    507         case OpCodes.GT:
    508           {
     480        case OpCodes.GT: {
    509481            CompileInstructions(il, state, ds);
    510482            CompileInstructions(il, state, ds);
     
    517489            return;
    518490          }
    519         case OpCodes.LT:
    520           {
     491        case OpCodes.LT: {
    521492            CompileInstructions(il, state, ds);
    522493            CompileInstructions(il, state, ds);
     
    528499            return;
    529500          }
    530         case OpCodes.TimeLag:
    531           {
     501        case OpCodes.TimeLag: {
    532502            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
    533503            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
     
    545515            return;
    546516          }
    547         case OpCodes.Integral:
    548           {
     517        case OpCodes.Integral: {
    549518            int savedPc = state.ProgramCounter;
    550519            LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
     
    573542        //one sided smooth differentiatior, N = 4
    574543        // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
    575         case OpCodes.Derivative:
    576           {
     544        case OpCodes.Derivative: {
    577545            int savedPc = state.ProgramCounter;
    578546            CompileInstructions(il, state, ds);
     
    616584            return;
    617585          }
    618         case OpCodes.Call:
    619           {
     586        case OpCodes.Call: {
    620587            throw new NotSupportedException(
    621588              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
    622589          }
    623         case OpCodes.Arg:
    624           {
     590        case OpCodes.Arg: {
    625591            throw new NotSupportedException(
    626592              "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
    627593          }
    628         case OpCodes.Variable:
    629           {
     594        case OpCodes.Variable: {
    630595            VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
    631596            il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
     
    659624            return;
    660625          }
    661         case OpCodes.LagVariable:
    662           {
     626        case OpCodes.LagVariable: {
    663627            var nanResult = il.DefineLabel();
    664628            var normalResult = il.DefineLabel();
     
    688652            return;
    689653          }
    690         case OpCodes.Constant:
    691           {
     654        case OpCodes.Constant: {
    692655            ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
    693656            il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
     
    697660        //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) )
    698661        //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
    699         case OpCodes.VariableCondition:
    700           {
     662        case OpCodes.VariableCondition: {
    701663            throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
    702664                                            " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");
  • 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    }
  • branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

    r13141 r13222  
    3535  public sealed class SymbolicDataAnalysisExpressionTreeLinearInterpreter : ParameterizedNamedItem, ISymbolicDataAnalysisExpressionTreeInterpreter {
    3636    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.";
    3738    private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
    3839
     
    8485    public SymbolicDataAnalysisExpressionTreeLinearInterpreter()
    8586      : base("SymbolicDataAnalysisExpressionTreeLinearInterpreter", "Linear (non-recursive) interpreter for symbolic expression trees (does not support ADFs).") {
    86       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    87         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     87      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, new BoolValue(false)));
    8888      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    8989      interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
     
    9292    public SymbolicDataAnalysisExpressionTreeLinearInterpreter(string name, string description)
    9393      : base(name, description) {
    94       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    95         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     94      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, new BoolValue(false)));
    9695      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    9796      interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
     
    10099    [StorableHook(HookType.AfterDeserialization)]
    101100    private void AfterDeserialization() {
    102       if (interpreter == null) interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
    103       Parameters.Remove(EvaluatedSolutionsParameterName);
    104       Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
    105 
    106       Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
    107       Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName,
    108         "Switch that determines if the interpreter checks the validity of expressions with interval arithmetic before evaluating the expression.", new BoolValue(false)));
     101      var evaluatedSolutions = new IntValue(0);
     102      var checkExpressionsWithIntervalArithmetic = new BoolValue(false);
     103      if (Parameters.ContainsKey(EvaluatedSolutionsParameterName)) {
     104        var evaluatedSolutionsParameter = (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
     105        evaluatedSolutions = evaluatedSolutionsParameter.Value;
     106        Parameters.Remove(EvaluatedSolutionsParameterName);
     107      }
     108      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", evaluatedSolutions));
     109      if (Parameters.ContainsKey(CheckExpressionsWithIntervalArithmeticParameterName)) {
     110        var checkExpressionsWithIntervalArithmeticParameter = (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName];
     111        Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
     112        checkExpressionsWithIntervalArithmetic = checkExpressionsWithIntervalArithmeticParameter.Value;
     113      }
     114      Parameters.Add(new FixedValueParameter<BoolValue>(CheckExpressionsWithIntervalArithmeticParameterName, CheckExpressionsWithIntervalArithmeticParameterDescription, checkExpressionsWithIntervalArithmetic));
    109115    }
    110116
     
    372378        #region opcode switch
    373379        switch (instr.opCode) {
    374           case OpCodes.Constant:
    375             {
     380          case OpCodes.Constant: {
    376381              var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
    377382              instr.value = constTreeNode.Value;
     
    379384            }
    380385            break;
    381           case OpCodes.Variable:
    382             {
     386          case OpCodes.Variable: {
    383387              var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
    384388              instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
    385389            }
    386390            break;
    387           case OpCodes.LagVariable:
    388             {
     391          case OpCodes.LagVariable: {
    389392              var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
    390393              instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
    391394            }
    392395            break;
    393           case OpCodes.VariableCondition:
    394             {
     396          case OpCodes.VariableCondition: {
    395397              var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
    396398              instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
     
    399401          case OpCodes.TimeLag:
    400402          case OpCodes.Integral:
    401           case OpCodes.Derivative:
    402             {
     403          case OpCodes.Derivative: {
    403404              var seq = GetPrefixSequence(code, i);
    404405              var interpreterState = new InterpreterState(seq, 0);
Note: See TracChangeset for help on using the changeset viewer.