Changeset 13141

Timestamp:

11/13/15 14:47:00 (9 years ago)

Author:

bburlacu

Message:

#2442: Merged files from trunk and updated project file. Implemented missing operations in the CompiledTreeInterpreter: Integral, Derivative, Lag, TimeLag. Adapted lambda signature to accept an array of List<double> in order to make it easier to work with compiled trees. Changed value parameters to fixed value parameters and adjusted interpreter constructors and after serialization hooks. Removed function symbol.

From the performance point of view, compiling the tree into a lambda accepting a double[][] parameter (an array of arrays for the values of each double variable), accessed with Expression.ArrayIndex is the fastest, but it can be cumbersome to provide the data as a double[][]. Therefore the variant with List<double>[] was chosen. Internally, for each variable node the List's underlying double array is used, result in an overall decent speed compromise.

Location:

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic

Files:

• . (modified) (1 prop)
• 3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs (modified) (2 diffs)
• 3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs (copied) (copied from trunk/sources/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs)
• 3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (3 diffs)
• 3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (2 diffs)
• 3.4/Interpreter/OpCodes.cs (modified) (2 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs (modified) (7 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs (modified) (26 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (30 diffs)
• 3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (7 diffs)
• 3.4/Plugin.cs.frame (modified) (1 diff)
• 3.4/Symbols/FunctionSymbol.cs (deleted)

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

@@ -56 +56 @@
 
     private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      // TODO: adapt to interpreter semantics. The HL interpreter also allows Boolean operations on reals
       if (node.Subtrees.Any()) {
         if (node.Symbol is Addition) {
@@ -83 +84 @@
         } else if (node.Symbol is Or) {
           FormatOperator(node, "||", strBuilder);
+        } else if (node.Symbol is Xor) {
+          FormatOperator(node, "^", strBuilder);
         } else if (node.Symbol is Sine) {
           FormatFunction(node, "Math.Sin", strBuilder);

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -99 +99 @@
   </PropertyGroup>
   <ItemGroup>
-    <Reference Include="ALGLIB-3.9.0">
-      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.9.0.dll</HintPath>
+    <Reference Include="ALGLIB-3.7.0, Version=3.7.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\sources\bin\ALGLIB-3.7.0.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -198 +199 @@
     </Compile>
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionCSharpFormatter.cs" />
+    <Compile Include="Formatters\SymbolicDataAnalysisExpressionMathematicaFormatter.cs" />
     <Compile Include="Importer\SymbolicExpressionImporter.cs" />
     <Compile Include="Importer\Token.cs" />
@@ -257 +259 @@
     <Compile Include="Symbols\AiryB.cs" />
     <Compile Include="Symbols\Bessel.cs" />
-    <Compile Include="Symbols\FunctionSymbol.cs" />
     <Compile Include="Symbols\Xor.cs" />
     <Compile Include="Symbols\Erf.cs" />

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -22 +22 @@
 using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
@@ -28 +27 @@
   public interface ISymbolicDataAnalysisExpressionTreeInterpreter : INamedItem, IStatefulItem {
     IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows);
-    IntValue EvaluatedSolutions { get; set; }
+    int EvaluatedSolutions { get; set; }
   }
 }

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -83 +83 @@
     public const byte Erf = 43;
     public const byte Bessel = 44;
-    public const byte UserDefinedFunction = 46;
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
@@ -132 +131 @@
       { typeof(Erf), OpCodes.Erf},
       { typeof(Bessel), OpCodes.Bessel},
-      { typeof(FunctionSymbol), OpCodes.UserDefinedFunction }
     };
 

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
@@ -61 +62 @@
     #endregion
 
-    private static readonly MethodInfo ListGetValue = typeof(IList<double>).GetProperty("Item", new Type[] { typeof(int) }).GetGetMethod();
+    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>
+    private static readonly Func<List<double>, double[]> ListRetrieveItems = GetField<List<double>, double[]>("_items"); // retrieve underlying field of type double[] from a List<double>
+    private static MethodInfo listGetValue = typeof(IList<double>).GetProperty("Item", new Type[] { typeof(int) }).GetGetMethod();
 
     public override bool CanChangeName { get { return false; } }
@@ -68 +71 @@
 
     #region parameter properties
-    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
-    }
-
-    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     }
     #endregion
 
     #region properties
-    public BoolValue CheckExpressionsWithIntervalArithmetic {
-      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
-      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
-    }
-    public IntValue EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value; }
-      set { EvaluatedSolutionsParameter.Value = value; }
+    public bool CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
+    }
+    public int EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value.Value; }
+      set { EvaluatedSolutionsParameter.Value.Value = value; }
     }
     #endregion
@@ -101 +104 @@
     }
 
-    public SymbolicDataAnalysisExpressionCompiledTreeInterpreter() {
-      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)));
-      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    public SymbolicDataAnalysisExpressionCompiledTreeInterpreter() :
+      base("SymbolicDataAnalysisExpressionCompiledTreeInterpreter", "Interpreter which compiles the tree into a lambda") {
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    }
+
+    public SymbolicDataAnalysisExpressionCompiledTreeInterpreter(string name, string description) :
+      base(name, description) {
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    }
+
+    [StorableHook(HookType.AfterDeserialization)]
+    private void AfterDeserialization() {
+      Parameters.Remove(EvaluatedSolutionsParameterName);
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+
+      Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
+      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)));
     }
 
     public void InitializeState() {
-      EvaluatedSolutions.Value = 0;
+      EvaluatedSolutions = 0;
     }
 
     public void ClearState() {
-      EvaluatedSolutions.Value = 0;
     }
 
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      if (CheckExpressionsWithIntervalArithmetic.Value)
+      if (CheckExpressionsWithIntervalArithmetic)
         throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
 
-      lock (EvaluatedSolutions) {
-        EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      lock (EvaluatedSolutionsParameter.Value) {
+        EvaluatedSolutions++; // increment the evaluated solutions counter
       }
-
-      var columns = dataset.DoubleVariables.Select(x => (IList<double>)dataset.GetReadOnlyDoubleValues(x)).ToArray();
+      //      var columns = dataset.DoubleVariables.Select(x => ListRetrieveItems((List<double>)ReadOnlyCollectionRetrieveList(dataset.GetReadOnlyDoubleValues(x)))).ToArray();
+      var columns = dataset.DoubleVariables.Select(x => (List<double>)dataset.GetDoubleValues(x)).ToArray();
       var compiled = CompileTree(tree, dataset);
       return rows.Select(x => compiled(x, columns));
     }
 
-    public static Func<int, IList<double>[], double> CompileTree(ISymbolicExpressionTree tree, IDataset dataset) {
+    public static Func<int, List<double>[], double> CompileTree(ISymbolicExpressionTree tree, IDataset dataset) {
       var row = Expression.Parameter(typeof(int));
-      var columns = Expression.Parameter(typeof(IList<double>[]));
+      var columns = Expression.Parameter(typeof(List<double>[]));
       var variableIndices = dataset.DoubleVariables.Select((x, i) => new { x, i }).ToDictionary(e => e.x, e => e.i);
       var expr = MakeExpr(tree, variableIndices, row, columns);
-      var lambda = Expression.Lambda<Func<int, IList<double>[], double>>(expr, row, columns);
+      var lambda = Expression.Lambda<Func<int, List<double>[], double>>(expr, row, columns);
       return lambda.Compile();
     }
 
-    private static Expression MakeExpr(ISymbolicExpressionTree tree, Dictionary<string, int> variableIndices, ParameterExpression row, ParameterExpression columns) {
+    private static Expression MakeExpr(ISymbolicExpressionTree tree, Dictionary<string, int> variableIndices, Expression row, Expression columns) {
       var actualRoot = tree.Root.GetSubtree(0).GetSubtree(0);
       return MakeExpr(actualRoot, variableIndices, row, columns);
     }
 
-    private static Expression MakeExpr(ISymbolicExpressionTreeNode node, Dictionary<string, int> variableIndices, ParameterExpression row, ParameterExpression columns) {
+    private static Expression MakeExpr(ISymbolicExpressionTreeNode node, Dictionary<string, int> variableIndices, Expression row, Expression columns) {
       var opcode = OpCodes.MapSymbolToOpCode(node);
+      #region switch opcode
       switch (opcode) {
-        case OpCodes.UserDefinedFunction:
-          {
-            var functionSymbol = (FunctionSymbol)node.Symbol;
-            return Expression.Call(functionSymbol.MethodInfo, node.Subtrees.Select(x => MakeExpr(x, variableIndices, row, columns)));
-          }
         case OpCodes.Constant:
           {
@@ -161 +178 @@
             var indexExpr = Expression.Constant(variableIndices[variableName]);
             var valuesExpr = Expression.ArrayIndex(columns, indexExpr);
-            var variableValue = Expression.Call(valuesExpr, ListGetValue, row);
+            var variableValue = Expression.ArrayIndex(Expression.Field(valuesExpr, "_items"), row);
+            //            var variableValue = Expression.Property(valuesExpr, Indexer, row);
             return Expression.Multiply(variableWeight, variableValue);
           }
@@ -667 +685 @@
             var indexExpr = Expression.Constant(variableIndices[variableName]);
             var valuesExpr = Expression.ArrayIndex(columns, indexExpr);
-            var variableValue = Expression.Call(valuesExpr, ListGetValue, row);
+            var variableValue = Expression.ArrayIndex(valuesExpr, row);
             var variableThreshold = Expression.Constant(variableConditionTreeNode.Threshold);
             var variableSlope = Expression.Constant(variableConditionTreeNode.Slope);
@@ -682 +700 @@
               );
           }
+        case OpCodes.LagVariable:
+          {
+            var laggedVariableTreeNode = (LaggedVariableTreeNode)node;
+            var lag = Expression.Constant(laggedVariableTreeNode.Lag);
+            var variableWeight = Expression.Constant(laggedVariableTreeNode.Weight);
+            var variableName = laggedVariableTreeNode.VariableName;
+            var indexExpr = Expression.Constant(variableIndices[variableName]);
+            var valuesExpr = Expression.ArrayIndex(columns, indexExpr);
+            var variableValue = Expression.ArrayIndex(Expression.Field(valuesExpr, "_items"), Expression.Add(row, lag));
+            return Expression.Multiply(variableWeight, variableValue);
+          }
+        case OpCodes.TimeLag:
+          {
+            var timeLagTreeNode = (LaggedTreeNode)node;
+            var lag = Expression.Constant(timeLagTreeNode.Lag);
+            return MakeExpr(timeLagTreeNode.GetSubtree(0), variableIndices, Expression.Add(row, lag), columns);
+          }
+        case OpCodes.Integral:
+          {
+            var timeLagTreeNode = (LaggedTreeNode)node;
+            var subtree = node.GetSubtree(0);
+            var sum = MakeExpr(subtree, variableIndices, row, columns);
+            var sign = Expression.Constant(Math.Sign(timeLagTreeNode.Lag));
+            var lag = Expression.Add(row, sign);
+            for (int i = 0; i < Math.Abs(timeLagTreeNode.Lag); ++i) {
+              sum = Expression.Add(sum, MakeExpr(subtree, variableIndices, lag, columns));
+              lag = Expression.Add(lag, sign);
+            }
+            return sum;
+          }
+        case OpCodes.Derivative:
+          {
+            var subtree = node.GetSubtree(0);
+            var f0 = MakeExpr(subtree, variableIndices, row, columns);
+            var f1 = MakeExpr(subtree, variableIndices, Expression.Subtract(row, Expression.Constant(1)), columns);
+            var f3 = MakeExpr(subtree, variableIndices, Expression.Subtract(row, Expression.Constant(3)), columns);
+            var f4 = MakeExpr(subtree, variableIndices, Expression.Subtract(row, Expression.Constant(4)), columns);
+
+            var result = f0;
+            result = Expression.Add(result, Expression.Multiply(Expression.Constant(2.0), f1));
+            result = Expression.Subtract(result, Expression.Multiply(Expression.Constant(2.0), f3));
+            result = Expression.Subtract(result, f4);
+            return Expression.Divide(result, Expression.Constant(8.0));
+          }
         default:
           throw new NotSupportedException("Unsupported symbol: " + node.Symbol);
       }
+      #endregion
     }
     // util stuff

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

@@ -80 +80 @@
 
     #region parameter properties
-
-    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
-    }
-
-    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
-    }
-
+    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    }
     #endregion
 
     #region properties
-
-    public BoolValue CheckExpressionsWithIntervalArithmetic {
-      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
-      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
-    }
-
-    public IntValue EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value; }
-      set { EvaluatedSolutionsParameter.Value = value; }
-    }
-
+    public bool CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
+    }
+    public int EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value.Value; }
+      set { EvaluatedSolutionsParameter.Value.Value = value; }
+    }
     #endregion
-
 
     [StorableConstructor]
@@ -116 +110 @@
     public SymbolicDataAnalysisExpressionTreeILEmittingInterpreter()
       : base("SymbolicDataAnalysisExpressionTreeILEmittingInterpreter", "Interpreter for symbolic expression trees.") {
-      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)));
-      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+    }
+
+    public SymbolicDataAnalysisExpressionTreeILEmittingInterpreter(string name, string description)
+      : base(name, description) {
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(EvaluatedSolutionsParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      Parameters.Remove(EvaluatedSolutionsParameterName);
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+
+      Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
+      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)));
     }
 
@@ -129 +135 @@
 
     public void InitializeState() {
-      EvaluatedSolutions.Value = 0;
+      EvaluatedSolutions = 0;
     }
 
     public void ClearState() {
-      EvaluatedSolutions.Value = 0;
     }
 
@@ -139 +144 @@
 
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      if (CheckExpressionsWithIntervalArithmetic.Value)
+      if (CheckExpressionsWithIntervalArithmetic)
         throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
 
-      EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      EvaluatedSolutions++; // increment the evaluated solutions counter
       var state = PrepareInterpreterState(tree, dataset);
 
@@ -187 +192 @@
 
       switch (currentInstr.opCode) {
-        case OpCodes.Add: {
+        case OpCodes.Add:
+          {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -197 +203 @@
             return;
           }
-        case OpCodes.Sub: {
+        case OpCodes.Sub:
+          {
             if (nArgs == 1) {
               CompileInstructions(il, state, ds);
@@ -212 +219 @@
             return;
           }
-        case OpCodes.Mul: {
+        case OpCodes.Mul:
+          {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -222 +230 @@
             return;
           }
-        case OpCodes.Div: {
+        case OpCodes.Div:
+          {
             if (nArgs == 1) {
               il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
@@ -238 +247 @@
             return;
           }
-        case OpCodes.Average: {
+        case OpCodes.Average:
+          {
             CompileInstructions(il, state, ds);
             for (int i = 1; i < nArgs; i++) {
@@ -248 +258 @@
             return;
           }
-        case OpCodes.Cos: {
+        case OpCodes.Cos:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
             return;
           }
-        case OpCodes.Sin: {
+        case OpCodes.Sin:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
             return;
           }
-        case OpCodes.Tan: {
+        case OpCodes.Tan:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
             return;
           }
-        case OpCodes.Power: {
+        case OpCodes.Power:
+          {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -270 +284 @@
             return;
           }
-        case OpCodes.Root: {
+        case OpCodes.Root:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
@@ -279 +294 @@
             return;
           }
-        case OpCodes.Exp: {
+        case OpCodes.Exp:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
             return;
           }
-        case OpCodes.Log: {
+        case OpCodes.Log:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, log);
             return;
           }
-        case OpCodes.Square: {
+        case OpCodes.Square:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
@@ -295 +313 @@
             return;
           }
-        case OpCodes.SquareRoot: {
+        case OpCodes.SquareRoot:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
             return;
           }
-        case OpCodes.AiryA: {
+        case OpCodes.AiryA:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
             return;
           }
-        case OpCodes.AiryB: {
+        case OpCodes.AiryB:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
             return;
           }
-        case OpCodes.Bessel: {
+        case OpCodes.Bessel:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
             return;
           }
-        case OpCodes.CosineIntegral: {
+        case OpCodes.CosineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
             return;
           }
-        case OpCodes.Dawson: {
+        case OpCodes.Dawson:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
             return;
           }
-        case OpCodes.Erf: {
+        case OpCodes.Erf:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
             return;
           }
-        case OpCodes.ExponentialIntegralEi: {
+        case OpCodes.ExponentialIntegralEi:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
             return;
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCodes.FresnelCosineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
             return;
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCodes.FresnelSineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
             return;
           }
-        case OpCodes.Gamma: {
+        case OpCodes.Gamma:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
             return;
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCodes.HyperbolicCosineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
             return;
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCodes.HyperbolicSineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
             return;
           }
-        case OpCodes.Norm: {
+        case OpCodes.Norm:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
             return;
           }
-        case OpCodes.Psi: {
+        case OpCodes.Psi:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
             return;
           }
-        case OpCodes.SineIntegral: {
+        case OpCodes.SineIntegral:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
             return;
           }
-        case OpCodes.IfThenElse: {
+        case OpCodes.IfThenElse:
+          {
             Label end = il.DefineLabel();
             Label c1 = il.DefineLabel();
@@ -389 +424 @@
             return;
           }
-        case OpCodes.AND: {
+        case OpCodes.AND:
+          {
             Label falseBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -410 +446 @@
             return;
           }
-        case OpCodes.OR: {
+        case OpCodes.OR:
+          {
             Label trueBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -438 +475 @@
             return;
           }
-        case OpCodes.NOT: {
+        case OpCodes.NOT:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
@@ -449 +487 @@
             return;
           }
-        case OpCodes.XOR: {
+        case OpCodes.XOR:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
@@ -466 +505 @@
             return;
           }
-        case OpCodes.GT: {
+        case OpCodes.GT:
+          {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -477 +517 @@
             return;
           }
-        case OpCodes.LT: {
+        case OpCodes.LT:
+          {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -487 +528 @@
             return;
           }
-        case OpCodes.TimeLag: {
+        case OpCodes.TimeLag:
+          {
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
@@ -503 +545 @@
             return;
           }
-        case OpCodes.Integral: {
+        case OpCodes.Integral:
+          {
             int savedPc = state.ProgramCounter;
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -530 +573 @@
         //one sided smooth differentiatior, N = 4
         // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
-        case OpCodes.Derivative: {
+        case OpCodes.Derivative:
+          {
             int savedPc = state.ProgramCounter;
             CompileInstructions(il, state, ds);
@@ -572 +616 @@
             return;
           }
-        case OpCodes.Call: {
+        case OpCodes.Call:
+          {
             throw new NotSupportedException(
               "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
           }
-        case OpCodes.Arg: {
+        case OpCodes.Arg:
+          {
             throw new NotSupportedException(
               "Automatically defined functions are not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter. Either turn of ADFs or change the interpeter.");
           }
-        case OpCodes.Variable: {
+        case OpCodes.Variable:
+          {
             VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
@@ -612 +659 @@
             return;
           }
-        case OpCodes.LagVariable: {
+        case OpCodes.LagVariable:
+          {
             var nanResult = il.DefineLabel();
             var normalResult = il.DefineLabel();
@@ -640 +688 @@
             return;
           }
-        case OpCodes.Constant: {
+        case OpCodes.Constant:
+          {
             ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
@@ -648 +697 @@
         //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
         //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
-        case OpCodes.VariableCondition: {
+        case OpCodes.VariableCondition:
+          {
             throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
                                             " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -40 +40 @@
 
     #region parameter properties
-    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
-    }
-
-    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     }
     #endregion
 
     #region properties
-    public BoolValue CheckExpressionsWithIntervalArithmetic {
-      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
-      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
-    }
-
-    public IntValue EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value; }
-      set { EvaluatedSolutionsParameter.Value = value; }
+    public bool CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
+    }
+    public int EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value.Value; }
+      set { EvaluatedSolutionsParameter.Value.Value = value; }
     }
     #endregion
@@ -70 +69 @@
     public SymbolicDataAnalysisExpressionTreeInterpreter()
       : base("SymbolicDataAnalysisExpressionTreeInterpreter", "Interpreter for symbolic expression trees including automatically defined functions.") {
-      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)));
-      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     }
 
     protected SymbolicDataAnalysisExpressionTreeInterpreter(string name, string description)
       : base(name, description) {
-      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)));
-      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
-      if (!Parameters.ContainsKey(EvaluatedSolutionsParameterName))
-        Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      Parameters.Remove(EvaluatedSolutionsParameterName);
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+
+      Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
+      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)));
     }
 
     #region IStatefulItem
     public void InitializeState() {
-      EvaluatedSolutions.Value = 0;
+      EvaluatedSolutions = 0;
     }
 
@@ -96 +101 @@
 
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      if (CheckExpressionsWithIntervalArithmetic.Value)
+      if (CheckExpressionsWithIntervalArithmetic)
         throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
 
-      lock (EvaluatedSolutions) {
-        EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      lock (EvaluatedSolutionsParameter.Value) {
+        EvaluatedSolutions++; // increment the evaluated solutions counter
       }
       var state = PrepareInterpreterState(tree, dataset);
@@ -135 +140 @@
       Instruction currentInstr = state.NextInstruction();
       switch (currentInstr.opCode) {
-        case OpCodes.Add: {
+        case OpCodes.Add:
+          {
             double s = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -142 +148 @@
             return s;
           }
-        case OpCodes.Sub: {
+        case OpCodes.Sub:
+          {
             double s = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -150 +157 @@
             return s;
           }
-        case OpCodes.Mul: {
+        case OpCodes.Mul:
+          {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -157 +165 @@
             return p;
           }
-        case OpCodes.Div: {
+        case OpCodes.Div:
+          {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -165 +174 @@
             return p;
           }
-        case OpCodes.Average: {
+        case OpCodes.Average:
+          {
             double sum = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172 +182 @@
             return sum / currentInstr.nArguments;
           }
-        case OpCodes.Cos: {
+        case OpCodes.Cos:
+          {
             return Math.Cos(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Sin: {
+        case OpCodes.Sin:
+          {
             return Math.Sin(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Tan: {
+        case OpCodes.Tan:
+          {
             return Math.Tan(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Square: {
+        case OpCodes.Square:
+          {
             return Math.Pow(Evaluate(dataset, ref row, state), 2);
           }
-        case OpCodes.Power: {
+        case OpCodes.Power:
+          {
             double x = Evaluate(dataset, ref row, state);
             double y = Math.Round(Evaluate(dataset, ref row, state));
             return Math.Pow(x, y);
           }
-        case OpCodes.SquareRoot: {
+        case OpCodes.SquareRoot:
+          {
             return Math.Sqrt(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Root: {
+        case OpCodes.Root:
+          {
             double x = Evaluate(dataset, ref row, state);
             double y = Math.Round(Evaluate(dataset, ref row, state));
             return Math.Pow(x, 1 / y);
           }
-        case OpCodes.Exp: {
+        case OpCodes.Exp:
+          {
             return Math.Exp(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Log: {
+        case OpCodes.Log:
+          {
             return Math.Log(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Gamma: {
+        case OpCodes.Gamma:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.gammafunction(x);
           }
-        case OpCodes.Psi: {
+        case OpCodes.Psi:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
@@ -214 +235 @@
             return alglib.psi(x);
           }
-        case OpCodes.Dawson: {
+        case OpCodes.Dawson:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             return alglib.dawsonintegral(x);
           }
-        case OpCodes.ExponentialIntegralEi: {
+        case OpCodes.ExponentialIntegralEi:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             return alglib.exponentialintegralei(x);
           }
-        case OpCodes.SineIntegral: {
+        case OpCodes.SineIntegral:
+          {
             double si, ci;
             var x = Evaluate(dataset, ref row, state);
@@ -233 +257 @@
             }
           }
-        case OpCodes.CosineIntegral: {
+        case OpCodes.CosineIntegral:
+          {
             double si, ci;
             var x = Evaluate(dataset, ref row, state);
@@ -242 +267 @@
             }
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCodes.HyperbolicSineIntegral:
+          {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -251 +277 @@
             }
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCodes.HyperbolicCosineIntegral:
+          {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -260 +287 @@
             }
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCodes.FresnelCosineIntegral:
+          {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -269 +297 @@
             }
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCodes.FresnelSineIntegral:
+          {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -278 +307 @@
             }
           }
-        case OpCodes.AiryA: {
+        case OpCodes.AiryA:
+          {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -287 +317 @@
             }
           }
-        case OpCodes.AiryB: {
+        case OpCodes.AiryB:
+          {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -296 +327 @@
             }
           }
-        case OpCodes.Norm: {
+        case OpCodes.Norm:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.normaldistribution(x);
           }
-        case OpCodes.Erf: {
+        case OpCodes.Erf:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.errorfunction(x);
           }
-        case OpCodes.Bessel: {
+        case OpCodes.Bessel:
+          {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.besseli0(x);
           }
-        case OpCodes.IfThenElse: {
+        case OpCodes.IfThenElse:
+          {
             double condition = Evaluate(dataset, ref row, state);
             double result;
@@ -321 +356 @@
             return result;
           }
-        case OpCodes.AND: {
+        case OpCodes.AND:
+          {
             double result = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -331 +367 @@
             return result > 0.0 ? 1.0 : -1.0;
           }
-        case OpCodes.OR: {
+        case OpCodes.OR:
+          {
             double result = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -341 +378 @@
             return result > 0.0 ? 1.0 : -1.0;
           }
-        case OpCodes.NOT: {
+        case OpCodes.NOT:
+          {
             return Evaluate(dataset, ref row, state) > 0.0 ? -1.0 : 1.0;
           }
-        case OpCodes.XOR: {
+        case OpCodes.XOR:
+          {
             //mkommend: XOR on multiple inputs is defined as true if the number of positive signals is odd
             // this is equal to a consecutive execution of binary XOR operations.
@@ -353 +392 @@
             return positiveSignals % 2 != 0 ? 1.0 : -1.0;
           }
-        case OpCodes.GT: {
+        case OpCodes.GT:
+          {
             double x = Evaluate(dataset, ref row, state);
             double y = Evaluate(dataset, ref row, state);
@@ -359 +399 @@
             else return -1.0;
           }
-        case OpCodes.LT: {
+        case OpCodes.LT:
+          {
             double x = Evaluate(dataset, ref row, state);
             double y = Evaluate(dataset, ref row, state);
@@ -365 +406 @@
             else return -1.0;
           }
-        case OpCodes.TimeLag: {
+        case OpCodes.TimeLag:
+          {
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             row += timeLagTreeNode.Lag;
@@ -372 +414 @@
             return result;
           }
-        case OpCodes.Integral: {
+        case OpCodes.Integral:
+          {
             int savedPc = state.ProgramCounter;
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -390 +433 @@
         //one sided smooth differentiatior, N = 4
         // y' = 1/8h (f_i + 2f_i-1, -2 f_i-3 - f_i-4)
-        case OpCodes.Derivative: {
+        case OpCodes.Derivative:
+          {
             int savedPc = state.ProgramCounter;
             double f_0 = Evaluate(dataset, ref row, state); row--;
@@ -403 +447 @@
             return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
           }
-        case OpCodes.Call: {
+        case OpCodes.Call:
+          {
             // evaluate sub-trees
             double[] argValues = new double[currentInstr.nArguments];
@@ -426 +471 @@
             return v;
           }
-        case OpCodes.Arg: {
+        case OpCodes.Arg:
+          {
             return state.GetStackFrameValue((ushort)currentInstr.data);
           }
-        case OpCodes.Variable: {
+        case OpCodes.Variable:
+          {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             return ((IList<double>)currentInstr.data)[row] * variableTreeNode.Weight;
           }
-        case OpCodes.LagVariable: {
+        case OpCodes.LagVariable:
+          {
             var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
             int actualRow = row + laggedVariableTreeNode.Lag;
@@ -440 +488 @@
             return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
           }
-        case OpCodes.Constant: {
+        case OpCodes.Constant:
+          {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             return constTreeNode.Value;
@@ -447 +496 @@
         //mkommend: this symbol uses the logistic function f(x) = 1 / (1 + e^(-alpha * x) ) 
         //to determine the relative amounts of the true and false branch see http://en.wikipedia.org/wiki/Logistic_function
-        case OpCodes.VariableCondition: {
+        case OpCodes.VariableCondition:
+          {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

@@ -48 +48 @@
 
     #region parameter properties
-    public IValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
-      get { return (IValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
-    }
-
-    public IValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
+    public IFixedValueParameter<BoolValue> CheckExpressionsWithIntervalArithmeticParameter {
+      get { return (IFixedValueParameter<BoolValue>)Parameters[CheckExpressionsWithIntervalArithmeticParameterName]; }
+    }
+
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
+      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
     }
     #endregion
 
     #region properties
-    public BoolValue CheckExpressionsWithIntervalArithmetic {
-      get { return CheckExpressionsWithIntervalArithmeticParameter.Value; }
-      set { CheckExpressionsWithIntervalArithmeticParameter.Value = value; }
-    }
-    public IntValue EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value; }
-      set { EvaluatedSolutionsParameter.Value = value; }
+    public bool CheckExpressionsWithIntervalArithmetic {
+      get { return CheckExpressionsWithIntervalArithmeticParameter.Value.Value; }
+      set { CheckExpressionsWithIntervalArithmeticParameter.Value.Value = value; }
+    }
+    public int EvaluatedSolutions {
+      get { return EvaluatedSolutionsParameter.Value.Value; }
+      set { EvaluatedSolutionsParameter.Value.Value = value; }
     }
     #endregion
@@ -84 +84 @@
     public SymbolicDataAnalysisExpressionTreeLinearInterpreter()
       : base("SymbolicDataAnalysisExpressionTreeLinearInterpreter", "Linear (non-recursive) interpreter for symbolic expression trees (does not support ADFs).") {
-      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)));
-      Parameters.Add(new ValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
+    }
+
+    public SymbolicDataAnalysisExpressionTreeLinearInterpreter(string name, string description)
+      : base(name, description) {
+      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)));
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
       interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
     }
@@ -92 +101 @@
     private void AfterDeserialization() {
       if (interpreter == null) interpreter = new SymbolicDataAnalysisExpressionTreeInterpreter();
+      Parameters.Remove(EvaluatedSolutionsParameterName);
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+
+      Parameters.Remove(CheckExpressionsWithIntervalArithmeticParameterName);
+      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)));
     }
 
     #region IStatefulItem
     public void InitializeState() {
-      EvaluatedSolutions.Value = 0;
+      EvaluatedSolutions = 0;
     }
 
@@ -103 +118 @@
 
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
-      if (CheckExpressionsWithIntervalArithmetic.Value)
+      if (CheckExpressionsWithIntervalArithmetic)
         throw new NotSupportedException("Interval arithmetic is not yet supported in the symbolic data analysis interpreter.");
 
-      lock (EvaluatedSolutions) {
-        EvaluatedSolutions.Value++; // increment the evaluated solutions counter
+      lock (EvaluatedSolutionsParameter.Value) {
+        EvaluatedSolutions++; // increment the evaluated solutions counter
       }
 
@@ -357 +372 @@
         #region opcode switch
         switch (instr.opCode) {
-          case OpCodes.Constant: {
+          case OpCodes.Constant:
+            {
               var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
               instr.value = constTreeNode.Value;
@@ -363 +379 @@
             }
             break;
-          case OpCodes.Variable: {
+          case OpCodes.Variable:
+            {
               var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
             }
             break;
-          case OpCodes.LagVariable: {
+          case OpCodes.LagVariable:
+            {
               var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
             }
             break;
-          case OpCodes.VariableCondition: {
+          case OpCodes.VariableCondition:
+            {
               var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
@@ -380 +399 @@
           case OpCodes.TimeLag:
           case OpCodes.Integral:
-          case OpCodes.Derivative: {
+          case OpCodes.Derivative:
+            {
               var seq = GetPrefixSequence(code, i);
               var interpreterState = new InterpreterState(seq, 0);

branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame

@@ -28 +28 @@
   [Plugin("HeuristicLab.Problems.DataAnalysis.Symbolic","Provides base classes for symbolic data analysis tasks.", "3.4.8.$WCREV$")]
   [PluginFile("HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.dll", PluginFileType.Assembly)]
-  [PluginDependency("HeuristicLab.ALGLIB", "3.9")]
+  [PluginDependency("HeuristicLab.ALGLIB", "3.7.0")]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]
   [PluginDependency("HeuristicLab.Collections", "3.3")]