Free cookie consent management tool by TermsFeed Policy Generator

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

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

File:
1 edited

Legend:

Unmodified
Added
Removed

  • branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/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);
Note: See TracChangeset for help on using the changeset viewer.