Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs	(revision 13141)
@@ -56,4 +56,5 @@
 
     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,4 +84,6 @@
         } 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);
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 13141)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs	(revision 13141)
@@ -0,0 +1,231 @@
+﻿#region License Information
+/* HeuristicLab
+ * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ *
+ * This file is part of HeuristicLab.
+ *
+ * HeuristicLab is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * HeuristicLab is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
+ */
+#endregion
+
+using System;
+using System.Globalization;
+using System.Linq;
+using System.Text;
+using HeuristicLab.Common;
+using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
+
+namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
+  [Item("Mathematica Symbolic Expression Tree Formatter", "A string formatter that converts symbolic expression trees to Mathematica expressions.")]
+  [StorableClass]
+  public sealed class SymbolicDataAnalysisExpressionMathematicaFormatter : NamedItem, ISymbolicExpressionTreeStringFormatter {
+    [StorableConstructor]
+    private SymbolicDataAnalysisExpressionMathematicaFormatter(bool deserializing) : base(deserializing) { }
+    private SymbolicDataAnalysisExpressionMathematicaFormatter(SymbolicDataAnalysisExpressionMathematicaFormatter original, Cloner cloner) : base(original, cloner) { }
+    public SymbolicDataAnalysisExpressionMathematicaFormatter()
+      : base() {
+      Name = ItemName;
+      Description = ItemDescription;
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new SymbolicDataAnalysisExpressionMathematicaFormatter(this, cloner);
+    }
+
+    public string Format(ISymbolicExpressionTree symbolicExpressionTree) {
+      // skip root and start symbols
+      StringBuilder strBuilder = new StringBuilder();
+      FormatRecursively(symbolicExpressionTree.Root.GetSubtree(0).GetSubtree(0), strBuilder);
+      return strBuilder.ToString();
+    }
+
+    private void FormatRecursively(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      if (node.Subtrees.Any()) {
+        if (node.Symbol is Addition) {
+          FormatFunction(node, "Plus", strBuilder);
+        } else if (node.Symbol is Average) {
+          FormatAverage(node, strBuilder);
+        } else if (node.Symbol is Multiplication) {
+          FormatFunction(node, "Times", strBuilder);
+        } else if (node.Symbol is Subtraction) {
+          FormatSubtraction(node, strBuilder);
+        } else if (node.Symbol is Division) {
+          FormatDivision(node, strBuilder);
+        } else if (node.Symbol is Sine) {
+          FormatFunction(node, "Sin", strBuilder);
+        } else if (node.Symbol is Cosine) {
+          FormatFunction(node, "Cos", strBuilder);
+        } else if (node.Symbol is Tangent) {
+          FormatFunction(node, "Tan", strBuilder);
+        } else if (node.Symbol is Exponential) {
+          FormatFunction(node, "Exp", strBuilder);
+        } else if (node.Symbol is Logarithm) {
+          FormatFunction(node, "Log", strBuilder);
+        } else if (node.Symbol is IfThenElse) {
+          FormatIf(node, strBuilder);
+        } else if (node.Symbol is GreaterThan) {
+          strBuilder.Append("If[Greater[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(",");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append("], 1, -1]");
+        } else if (node.Symbol is LessThan) {
+          strBuilder.Append("If[Less[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(",");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append("], 1, -1]");
+        } else if (node.Symbol is And) {
+          FormatAnd(node, strBuilder);
+        } else if (node.Symbol is Not) {
+          strBuilder.Append("If[Greater[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(", 0], -1, 1]");
+        } else if (node.Symbol is Or) {
+          FormatOr(node, strBuilder);
+        } else if (node.Symbol is Xor) {
+          FormatXor(node, strBuilder);
+        } else if (node.Symbol is Square) {
+          FormatSquare(node, strBuilder);
+        } else if (node.Symbol is SquareRoot) {
+          FormatFunction(node, "Sqrt", strBuilder);
+        } else if (node.Symbol is Power) {
+          FormatFunction(node, "Power", strBuilder);
+        } else if (node.Symbol is Root) {
+          FormatRoot(node, strBuilder);
+        } else {
+          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " is not supported.");
+        }
+      } else {
+        if (node is VariableTreeNode) {
+          var varNode = node as VariableTreeNode;
+          strBuilder.AppendFormat("Times[{0}, {1}]", varNode.VariableName, varNode.Weight.ToString("G17", CultureInfo.InvariantCulture));
+        } else if (node is ConstantTreeNode) {
+          var constNode = node as ConstantTreeNode;
+          strBuilder.Append(constNode.Value.ToString("G17", CultureInfo.InvariantCulture));
+        } else {
+          throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " is not supported.");
+        }
+      }
+    }
+
+    private void FormatXor(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("If[Xor[");
+      foreach (var t in node.Subtrees) {
+        strBuilder.Append("Greater[");
+        FormatRecursively(t, strBuilder);
+        strBuilder.Append(", 0]");
+        if (t != node.Subtrees.Last()) strBuilder.Append(",");
+      }
+      strBuilder.Append("], 1, -1]");
+    }
+
+    private void FormatOr(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("If[Or[");
+      foreach (var t in node.Subtrees) {
+        strBuilder.Append("Greater[");
+        FormatRecursively(t, strBuilder);
+        strBuilder.Append(", 0]");
+        if (t != node.Subtrees.Last()) strBuilder.Append(",");
+      }
+      strBuilder.Append("], 1, -1]");
+    }
+
+    private void FormatAnd(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("If[And[");
+      foreach (var t in node.Subtrees) {
+        strBuilder.Append("Greater[");
+        FormatRecursively(t, strBuilder);
+        strBuilder.Append(", 0]");
+        if (t != node.Subtrees.Last()) strBuilder.Append(",");
+      }
+      strBuilder.Append("], 1, -1]");
+    }
+
+    private void FormatIf(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("If[Greater[");
+      FormatRecursively(node.GetSubtree(0), strBuilder);
+      strBuilder.Append(", 0], ");
+      FormatRecursively(node.GetSubtree(1), strBuilder);
+      strBuilder.Append(", ");
+      FormatRecursively(node.GetSubtree(2), strBuilder);
+      strBuilder.Append("]");
+    }
+
+    private void FormatAverage(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      // mean function needs a list of values
+      strBuilder.Append("Mean[{");
+      FormatRecursively(node.GetSubtree(0), strBuilder);
+      for (int i = 1; i < node.SubtreeCount; i++) {
+        strBuilder.Append(",");
+        FormatRecursively(node.GetSubtree(i), strBuilder);
+      }
+      strBuilder.Append("}]");
+    }
+
+    private void FormatSubtraction(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("Subtract[");
+      FormatRecursively(node.GetSubtree(0), strBuilder);
+      strBuilder.Append(", Times[-1");
+      foreach (var t in node.Subtrees) {
+        strBuilder.Append(",");
+        FormatRecursively(t, strBuilder);
+      }
+      strBuilder.Append("]]");
+    }
+
+    private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("Power[");
+      FormatRecursively(node.GetSubtree(0), strBuilder);
+      strBuilder.Append(", 2]");
+    }
+
+    private void FormatRoot(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      strBuilder.Append("Power[");
+      FormatRecursively(node.GetSubtree(0), strBuilder);
+      strBuilder.Append(", Divide[1,");
+      FormatRecursively(node.GetSubtree(1), strBuilder);
+      strBuilder.Append("]]");
+    }
+
+    private void FormatDivision(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      if (node.SubtreeCount == 1) {
+        strBuilder.Append("Divide[1, ");
+        FormatRecursively(node.GetSubtree(0), strBuilder);
+        strBuilder.Append("]");
+      } else {
+        strBuilder.Append("Divide[");
+        FormatRecursively(node.GetSubtree(0), strBuilder);
+        strBuilder.Append(", Times[");
+        FormatRecursively(node.GetSubtree(1), strBuilder);
+        for (int i = 2; i < node.SubtreeCount; i++) {
+          strBuilder.Append(",");
+          FormatRecursively(node.GetSubtree(i), strBuilder);
+        }
+        strBuilder.Append("]]");
+      }
+    }
+
+    private void FormatFunction(ISymbolicExpressionTreeNode node, string function, StringBuilder strBuilder) {
+      strBuilder.Append(function + "[");
+      foreach (var child in node.Subtrees) {
+        FormatRecursively(child, strBuilder);
+        if (child != node.Subtrees.Last())
+          strBuilder.Append(", ");
+      }
+      strBuilder.Append("]");
+    }
+  }
+}
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj	(revision 13141)
@@ -99,6 +99,7 @@
   </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,4 +199,5 @@
     </Compile>
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionCSharpFormatter.cs" />
+    <Compile Include="Formatters\SymbolicDataAnalysisExpressionMathematicaFormatter.cs" />
     <Compile Include="Importer\SymbolicExpressionImporter.cs" />
     <Compile Include="Importer\Token.cs" />
@@ -257,5 +259,4 @@
     <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" />
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/ISymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 13141)
@@ -22,5 +22,4 @@
 using System.Collections.Generic;
 using HeuristicLab.Core;
-using HeuristicLab.Data;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
@@ -28,5 +27,5 @@
   public interface ISymbolicDataAnalysisExpressionTreeInterpreter : INamedItem, IStatefulItem {
     IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows);
-    IntValue EvaluatedSolutions { get; set; }
+    int EvaluatedSolutions { get; set; }
   }
 }
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs	(revision 13141)
@@ -83,5 +83,4 @@
     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,5 +131,4 @@
       { typeof(Erf), OpCodes.Erf},
       { typeof(Bessel), OpCodes.Bessel},
-      { typeof(FunctionSymbol), OpCodes.UserDefinedFunction }
     };
 
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs	(revision 13141)
@@ -22,4 +22,5 @@
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
 using System.Linq;
 using System.Linq.Expressions;
@@ -61,5 +62,7 @@
     #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,21 +71,21 @@
 
     #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,52 +104,66 @@
     }
 
-    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,5 +178,6 @@
             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,5 +685,5 @@
             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,7 +700,52 @@
               );
           }
+        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
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs	(revision 13141)
@@ -80,29 +80,23 @@
 
     #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,12 +110,24 @@
     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,9 +135,8 @@
 
     public void InitializeState() {
-      EvaluatedSolutions.Value = 0;
+      EvaluatedSolutions = 0;
     }
 
     public void ClearState() {
-      EvaluatedSolutions.Value = 0;
     }
 
@@ -139,8 +144,8 @@
 
     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,5 +192,6 @@
 
       switch (currentInstr.opCode) {
-        case OpCodes.Add: {
+        case OpCodes.Add:
+          {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -197,5 +203,6 @@
             return;
           }
-        case OpCodes.Sub: {
+        case OpCodes.Sub:
+          {
             if (nArgs == 1) {
               CompileInstructions(il, state, ds);
@@ -212,5 +219,6 @@
             return;
           }
-        case OpCodes.Mul: {
+        case OpCodes.Mul:
+          {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -222,5 +230,6 @@
             return;
           }
-        case OpCodes.Div: {
+        case OpCodes.Div:
+          {
             if (nArgs == 1) {
               il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
@@ -238,5 +247,6 @@
             return;
           }
-        case OpCodes.Average: {
+        case OpCodes.Average:
+          {
             CompileInstructions(il, state, ds);
             for (int i = 1; i < nArgs; i++) {
@@ -248,20 +258,24 @@
             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,5 +284,6 @@
             return;
           }
-        case OpCodes.Root: {
+        case OpCodes.Root:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
@@ -279,15 +294,18 @@
             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,85 +313,102 @@
             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,5 +424,6 @@
             return;
           }
-        case OpCodes.AND: {
+        case OpCodes.AND:
+          {
             Label falseBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -410,5 +446,6 @@
             return;
           }
-        case OpCodes.OR: {
+        case OpCodes.OR:
+          {
             Label trueBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -438,5 +475,6 @@
             return;
           }
-        case OpCodes.NOT: {
+        case OpCodes.NOT:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0); // > 0
@@ -449,5 +487,6 @@
             return;
           }
-        case OpCodes.XOR: {
+        case OpCodes.XOR:
+          {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_I4_0);
@@ -466,5 +505,6 @@
             return;
           }
-        case OpCodes.GT: {
+        case OpCodes.GT:
+          {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -477,5 +517,6 @@
             return;
           }
-        case OpCodes.LT: {
+        case OpCodes.LT:
+          {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -487,5 +528,6 @@
             return;
           }
-        case OpCodes.TimeLag: {
+        case OpCodes.TimeLag:
+          {
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
@@ -503,5 +545,6 @@
             return;
           }
-        case OpCodes.Integral: {
+        case OpCodes.Integral:
+          {
             int savedPc = state.ProgramCounter;
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -530,5 +573,6 @@
         //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,13 +616,16 @@
             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,5 +659,6 @@
             return;
           }
-        case OpCodes.LagVariable: {
+        case OpCodes.LagVariable:
+          {
             var nanResult = il.DefineLabel();
             var normalResult = il.DefineLabel();
@@ -640,5 +688,6 @@
             return;
           }
-        case OpCodes.Constant: {
+        case OpCodes.Constant:
+          {
             ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
@@ -648,5 +697,6 @@
         //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");
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs	(revision 13141)
@@ -40,22 +40,21 @@
 
     #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,23 +69,29 @@
     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,9 +101,9 @@
 
     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,5 +140,6 @@
       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,5 +148,6 @@
             return s;
           }
-        case OpCodes.Sub: {
+        case OpCodes.Sub:
+          {
             double s = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -150,5 +157,6 @@
             return s;
           }
-        case OpCodes.Mul: {
+        case OpCodes.Mul:
+          {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -157,5 +165,6 @@
             return p;
           }
-        case OpCodes.Div: {
+        case OpCodes.Div:
+          {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -165,5 +174,6 @@
             return p;
           }
-        case OpCodes.Average: {
+        case OpCodes.Average:
+          {
             double sum = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172,41 +182,52 @@
             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,15 +235,18 @@
             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,5 +257,6 @@
             }
           }
-        case OpCodes.CosineIntegral: {
+        case OpCodes.CosineIntegral:
+          {
             double si, ci;
             var x = Evaluate(dataset, ref row, state);
@@ -242,5 +267,6 @@
             }
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCodes.HyperbolicSineIntegral:
+          {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -251,5 +277,6 @@
             }
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCodes.HyperbolicCosineIntegral:
+          {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -260,5 +287,6 @@
             }
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCodes.FresnelCosineIntegral:
+          {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -269,5 +297,6 @@
             }
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCodes.FresnelSineIntegral:
+          {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -278,5 +307,6 @@
             }
           }
-        case OpCodes.AiryA: {
+        case OpCodes.AiryA:
+          {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -287,5 +317,6 @@
             }
           }
-        case OpCodes.AiryB: {
+        case OpCodes.AiryB:
+          {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -296,20 +327,24 @@
             }
           }
-        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,5 +356,6 @@
             return result;
           }
-        case OpCodes.AND: {
+        case OpCodes.AND:
+          {
             double result = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -331,5 +367,6 @@
             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,8 +378,10 @@
             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,5 +392,6 @@
             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,5 +399,6 @@
             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,5 +406,6 @@
             else return -1.0;
           }
-        case OpCodes.TimeLag: {
+        case OpCodes.TimeLag:
+          {
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             row += timeLagTreeNode.Lag;
@@ -372,5 +414,6 @@
             return result;
           }
-        case OpCodes.Integral: {
+        case OpCodes.Integral:
+          {
             int savedPc = state.ProgramCounter;
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -390,5 +433,6 @@
         //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,5 +447,6 @@
             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,13 +471,16 @@
             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,5 +488,6 @@
             return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
           }
-        case OpCodes.Constant: {
+        case OpCodes.Constant:
+          {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             return constTreeNode.Value;
@@ -447,5 +496,6 @@
         //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;
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs	(revision 13141)
@@ -48,21 +48,21 @@
 
     #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,6 +84,15 @@
     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,9 +101,15 @@
     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,9 +118,9 @@
 
     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,5 +372,6 @@
         #region opcode switch
         switch (instr.opCode) {
-          case OpCodes.Constant: {
+          case OpCodes.Constant:
+            {
               var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
               instr.value = constTreeNode.Value;
@@ -363,15 +379,18 @@
             }
             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,5 +399,6 @@
           case OpCodes.TimeLag:
           case OpCodes.Integral:
-          case OpCodes.Derivative: {
+          case OpCodes.Derivative:
+            {
               var seq = GetPrefixSequence(code, i);
               var interpreterState = new InterpreterState(seq, 0);
Index: /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame	(revision 13140)
+++ /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Plugin.cs.frame	(revision 13141)
@@ -28,5 +28,5 @@
   [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")]
Index: anches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/FunctionSymbol.cs
===================================================================
--- /branches/HeuristicLab.LinqExpressionTreeInterpreter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/FunctionSymbol.cs	(revision 13140)
+++ 	(revision )
@@ -1,80 +1,0 @@
-#region License Information
-/* HeuristicLab
- * Copyright (C) 2002-2015 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
- *
- * This file is part of HeuristicLab.
- *
- * HeuristicLab is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * HeuristicLab is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
- */
-#endregion
-
-using System;
-using System.Reflection;
-using HeuristicLab.Common;
-using HeuristicLab.Core;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Persistence.Default.CompositeSerializers.Storable;
-
-namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  [StorableClass]
-  [Item("FunctionSymbol", "Symbol that wraps a user-defined function.")]
-  public sealed class FunctionSymbol : Symbol {
-    private readonly int minimumArity;
-    private readonly int maximumArity;
-
-    public override int MinimumArity {
-      get { return minimumArity; }
-    }
-    public override int MaximumArity {
-      get { return maximumArity; }
-    }
-
-    //[Storable]
-    private MethodInfo methodInfo;
-    public MethodInfo MethodInfo {
-      get { return methodInfo; }
-      private set { methodInfo = value; }
-    }
-
-    [StorableConstructor]
-    private FunctionSymbol(bool deserializing) : base(deserializing) { }
-
-    private FunctionSymbol(FunctionSymbol original, Cloner cloner) : base(original, cloner) {
-      this.MethodInfo = original.MethodInfo; // symbols are cached so we also cache the MethodInfo in order to optimize the performance of the interpreter
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new FunctionSymbol(this, cloner);
-    }
-
-    public FunctionSymbol(string name, Func<double, double> f) : base(name, "Symbol that wraps a user-defined unary function.") {
-      MethodInfo = f.GetMethodInfo();
-      minimumArity = maximumArity = 1;
-    }
-
-    public FunctionSymbol(string name, Func<double, double, double> f) : base(name, "Symbol that wraps a user-defined binary function.") {
-      MethodInfo = f.GetMethodInfo();
-      minimumArity = maximumArity = 2;
-    }
-
-    public FunctionSymbol(string name, Func<double, double, double, double> f) : base(name, "Symbol that wraps a user-defined tertiary function.") {
-      MethodInfo = f.GetMethodInfo();
-      minimumArity = maximumArity = 3;
-    }
-
-    public FunctionSymbol(string name, Func<double, double, double, double, double> f) : base(name, "Symbol that wraps a user-defined quaternary function.") {
-      MethodInfo = f.GetMethodInfo();
-      minimumArity = maximumArity = 4;
-    }
-  }
-}
