Changeset 16899 for branches

Timestamp:

05/06/19 14:20:06 (5 years ago)

Author:

msemenki

Message:

#2988: New version of class structure.

Location:

branches/2988_ModelsOfModels2

Files:

• HeuristicLab.Algorithms.DataAnalysis (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/M5Regression (copied) (copied from trunk/HeuristicLab.Algorithms.DataAnalysis/3.4/M5Regression)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs (modified) (1 diff)
• HeuristicLab.Algorithms.EMM/EMMAlgorithm.cs (modified) (5 diffs)
• HeuristicLab.Algorithms.EMM/EMMBaseAlgorithm.cs (modified) (10 diffs)
• HeuristicLab.Algorithms.EMM/EMMBaseMap.cs (moved) (moved from branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMMapBase.cs) (1 diff)
• HeuristicLab.Algorithms.EMM/EMMClustering.cs (modified) (6 diffs)
• HeuristicLab.Algorithms.EMM/EMMDisatanceMap.cs (added)
• HeuristicLab.Algorithms.EMM/EMMIslandMap.cs (moved) (moved from branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMMapTreeModel.cs) (1 diff)
• HeuristicLab.Algorithms.EMM/EMMMultyPointsMutator.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.EMM/EMMMultyPointsMutatorNodeTypeSaving.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.EMM/EMMMutators.cs (modified) (4 diffs)
• HeuristicLab.Algorithms.EMM/EMMNetworkMap.cs (added)
• HeuristicLab.Algorithms.EMM/HelpFunctions.cs (added)
• HeuristicLab.Algorithms.EMM/HeuristicLab.Algorithms.EvolvmentModelsOfModels.csproj (modified) (5 diffs)
• HeuristicLab.Algorithms.EMM/Plugin.cs (modified) (1 diff)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding (modified) (1 prop)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeGraphvizFormatter.cs (modified) (1 diff)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelClustersFrequencyAnalyzer.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelsFrequencyAnalyzer.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/TerminalNodesFrequencyAnalyzer.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs (modified) (15 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs (modified) (30 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs (modified) (8 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs (modified) (26 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs (modified) (27 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs (modified) (26 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Selectors/DiversitySelector.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ModelTreeNode.cs (modified) (1 diff)

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/RegressionTreeModel.cs

@@ -91 +91 @@
     #region old storable format
     // remove with HL 3.4
-    [Storable(AllowOneWay = true)]
+    [Storable(OldName = "SerializedTree")]
     // to prevent storing the references to data caches in nodes
     // seemingly, it is bad (performance-wise) to persist tuples (tuples are used as keys in a dictionary)

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/NearestNeighbour/NearestNeighbourModel.cs

@@ -294 +294 @@
         return IsProblemDataCompatible(classificationProblemData, out errorMessage);
 
-      throw new ArgumentException("The problem data is not a regression nor a classification problem data. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
+      throw new ArgumentException("The problem data is not compatible with this nearest neighbour model. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkEnsembleModel.cs

@@ -144 +144 @@
         return IsProblemDataCompatible(classificationProblemData, out errorMessage);
 
-      throw new ArgumentException("The problem data is not a regression nor a classification problem data. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
+      throw new ArgumentException("The problem data is not compatible with this neural network ensemble. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
     }
 
@@ -153 +153 @@
       return new NeuralNetworkEnsembleClassificationSolution(this, new ClassificationEnsembleProblemData(problemData));
     }
-   
+
     #region persistence
     [Storable]
@@ -183 +183 @@
       }
     }
-    [Storable(AllowOneWay = true)]
+    [Storable(OldName = "MultiLayerPerceptronEnsembleDfdnet")]
     private double[] MultiLayerPerceptronEnsembleDfdnet {
       set {
@@ -197 +197 @@
       }
     }
-    [Storable(AllowOneWay = true)]
+    [Storable(OldName = "MultiLayerPerceptronEnsembleNeurons")]
     private double[] MultiLayerPerceptronEnsembleNeurons {
       set { mlpEnsemble.innerobj.network.neurons = value; }
     }
-    [Storable(AllowOneWay = true)]
+    [Storable(OldName = "MultiLayerPerceptronEnsembleSerializedMlp")]
     private double[] MultiLayerPerceptronEnsembleSerializedMlp {
       set {
@@ -207 +207 @@
       }
     }
-    [Storable(AllowOneWay = true)]
+    [Storable(OldName = "MultiLayerPerceptronStuctinfo")]
     private int[] MultiLayerPerceptronStuctinfo {
       set {

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/NeuralNetwork/NeuralNetworkModel.cs

@@ -147 +147 @@
         return IsProblemDataCompatible(classificationProblemData, out errorMessage);
 
-      throw new ArgumentException("The problem data is not a regression nor a classification problem data. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
+      throw new ArgumentException("The problem data is not compatible with this neural network. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModel.cs

@@ -300 +300 @@
         return IsProblemDataCompatible(classificationProblemData, out errorMessage);
 
-      throw new ArgumentException("The problem data is not a regression nor a classification problem data. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
+      throw new ArgumentException("The problem data is not compatible with this random forest. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.DataAnalysis/3.4/SupportVectorMachine/SupportVectorMachineModel.cs

@@ -143 +143 @@
         return IsProblemDataCompatible(classificationProblemData, out errorMessage);
 
-      throw new ArgumentException("The problem data is not a regression nor a classification problem data. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
+      throw new ArgumentException("The problem data is not compatible with this SVM. Instead a " + problemData.GetType().GetPrettyName() + " was provided.", "problemData");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMAlgorithm.cs

@@ -28 +28 @@
 using HeuristicLab.Random;
 using HeuristicLab.Selection;
-using System;
 using System.Collections.Generic;
 using System.IO;
@@ -40 +39 @@
   [StorableType("AD23B21F-089A-4C6C-AD2E-1B01E7939CF5")]
   public class EMMAlgorithm : EvolvmentModelsOfModelsAlgorithmBase {
-    public EMMMapTreeModel Map { get; private set; }
-
     public EMMAlgorithm() : base() { }
     protected EMMAlgorithm(EMMAlgorithm original, Cloner cloner) : base(original, cloner) {
-      if (original.Map != null) {
-        Map = cloner.Clone(original.Map);
-      }
+      //if (original.Map != null) {
+      //  Map = cloner.Clone(original.Map);
+      //}
     }
     public override IDeepCloneable Clone(Cloner cloner) {
@@ -58 +55 @@
       InfixExpressionParser parser = new InfixExpressionParser();
       var trees = File.ReadAllLines(InputFileParameter.Value.Value).Select(parser.Parse);
-      // this.Problem.SymbolicExpressionTreeGrammar;
-      /*   Problem.ProblemData.Dataset.ColumnNames.Take(2).ToList();
-         trees.First().Root.Grammar.ContainsSymbol((IVariable)a).
-           = this.Problem.SymbolicExpressionTreeGrammar;*/
-      int neghboorNumber = 10;
-      switch (MapCreationType.Value) { // Configure Map type and it's parameters: IslandMap, FullMap and Percent, Number
-        case "IslandMap": break;
-        case "FullMap":
-          ClusterNumbersParameter.Value.Value = trees.Count();
-          switch (NegbourType.Value) {
-            case "Percent": neghboorNumber = Convert.ToInt32((Convert.ToDouble(ClusterNumbersParameter.Value.Value)) * (Convert.ToDouble(NegbourNumber.Value)) / 100.0); break;
-            case "Number": neghboorNumber = NegbourNumber.Value; break;
-            default: neghboorNumber = NegbourNumber.Value; break;
-          }
-          break;
-        default: MapCreationType.Value = "IslandMap"; break;
-      }
-      switch (AlgorithmImplemetationType.Value) { //Configure type of algorithm application
-        case "OnlyMapCreation": // for case when we want only create map, and do  not want made somting also. OnlyMapCreation, CrateMapAndGo, ReadMapAndGo
-          Map = new EMMMapTreeModel(RandomParameter.Value, trees, ClusterNumbersParameter.Value.Value, neghboorNumber);
-          ClusterNumbersParameter.Value.Value = Map.K;
-          File.WriteAllLines("Map.txt", Map.MapToString());
-          File.WriteAllLines("MapToSee.txt", Map.MapToSee());
-          globalScope = new Scope("Global Scope");
-          executionContext = new ExecutionContext(null, this, globalScope);
-          break;
-        case "ReadMapAndGo": // for case when we want read existed map and work with it;
-          Map = new EMMMapTreeModel(RandomParameter.Value, trees);
-          ClusterNumbersParameter.Value.Value = Map.K;
-          if (previousExecutionState != ExecutionState.Paused) {
-            InitializeAlgorithm(cancellationToken);
-          }
+      if (AlgorithmImplemetationType.Value == "Read") {
+        Map.MapRead(RandomParameter.Value, trees, "Map.txt");
+      } else {
+        Map.MapCreationPrepare(RandomParameter.Value, trees, ClusterNumbersParameter.Value.Value);
+        Map.CreateMap(RandomParameter.Value, ClusterNumbersParameter.Value.Value);
+       // Map.WriteMapToTxtFile(RandomParameter.Value);
+      }
+
+      ClusterNumbersShowParameter.Value.Value = Map.K;
+
+      if (AlgorithmImplemetationType.Value == "OnlyMap") {
+        globalScope = new Scope("Global Scope");
+        executionContext = new ExecutionContext(null, this, globalScope);
+      } else {
+        if (previousExecutionState != ExecutionState.Paused) {
+          InitializeAlgorithm(cancellationToken);
+        }
+        if (!globalScope.Variables.ContainsKey("TreeModelMap"))
           globalScope.Variables.Add(new Variable("TreeModelMap", Map));
-          EMMAlgorithmRun(cancellationToken);
-          break;
-        case "CreateMapAndGo":
-          Map = new EMMMapTreeModel(RandomParameter.Value, trees, ClusterNumbersParameter.Value.Value, neghboorNumber);
-          ClusterNumbersParameter.Value.Value = Map.K;
-          if (previousExecutionState != ExecutionState.Paused) {
-            InitializeAlgorithm(cancellationToken);
-          }
-          globalScope.Variables.Add(new Variable("TreeModelMap", Map));
-          File.WriteAllLines("Map.txt", Map.MapToString());
-          File.WriteAllLines("MapToSee.txt", Map.MapToSee());
-          EMMAlgorithmRun(cancellationToken);
-          break;
-        default: //for case of usial from zero step starting
-          AlgorithmImplemetationType.Value = "CreateMapAndGo";
-          Map = new EMMMapTreeModel(RandomParameter.Value, trees, ClusterNumbersParameter.Value.Value, neghboorNumber);
-          ClusterNumbersParameter.Value.Value = Map.K;
-          File.WriteAllLines("Map.txt", Map.MapToString());
-          File.WriteAllLines("MapToSee.txt", Map.MapToSee());
-          if (previousExecutionState != ExecutionState.Paused) {
-            InitializeAlgorithm(cancellationToken);
-          }
-          globalScope.Variables.Add(new Variable("TreeModelMap", Map));
-          EMMAlgorithmRun(cancellationToken);
-          break;
-      }
-
+        EMMAlgorithmRun(cancellationToken);
+      }
     }
     private void EMMAlgorithmRun(CancellationToken cancellationToken) {
@@ -227 +185 @@
 
       // initialize data structures for map clustering
-      var models = new ItemList<ISymbolicExpressionTree>(Map.ModelSet);
-      var map = new ItemList<ItemList<IntValue>>();
-      foreach (var list in Map.Map) {
-        map.Add(new ItemList<IntValue>(list.Select(x => new IntValue(x))));
-      }
-      var clusterNumber = new ItemList<IntValue>(Map.ClusterNumber.Select(x => new IntValue(x)));
-      globalScope.Variables.Add(new Core.Variable("Models", models));
-      globalScope.Variables.Add(new Core.Variable("Map", map));
-      globalScope.Variables.Add(new Core.Variable("ClusterNumber", clusterNumber));
+      //var models = new ItemList<ISymbolicExpressionTree>(Map.ModelSet);
+      //var map = new ItemList<ItemList<IntValue>>();
+      //foreach (var list in Map.Map) {
+      //  map.Add(new ItemList<IntValue>(list.Select(x => new IntValue(x))));
+      //}
+      //var clusterNumber = new ItemList<IntValue>(Map.ClusterNumber.Select(x => new IntValue(x)));
+      //globalScope.Variables.Add(new Variable("Models", models));
+      //globalScope.Variables.Add(new Variable("Map", map));
+      //globalScope.Variables.Add(new Variable("ClusterNumber", clusterNumber));
 
       EvaluatedSolutions = populationSize;
@@ -274 +232 @@
       }
     }
+    private void LocalDecent(ISymbolicDataAnalysisSingleObjectiveProblem problem, CancellationToken cancellationToken, IScope childScope) {
+      int maxStepNumber = 100;
+      var creator = Problem.SolutionCreator;
+      var name = ((ISymbolicExpressionTreeCreator)creator).SymbolicExpressionTreeParameter.ActualName;
+      var tree = (ISymbolicExpressionTree)childScope.Variables[name].Value;
+      var evaluator = problem.Evaluator;
+      var oldTree = tree.Clone();
+      ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, childScope));
+      var rand = RandomParameter.Value;
+      if (SetSeedRandomly) Seed = RandomSeedGenerator.GetSeed();
+      rand.Reset(Seed);
+      while (maxStepNumber > 0) {
+        maxStepNumber = TreeIterator(tree.Root, rand, cancellationToken, childScope, maxStepNumber);
+      }
+    }
+    int TreeIterator(ISymbolicExpressionTreeNode a, IRandom rand, CancellationToken cancellationToken, IScope childScope, int maxStepNumber) {
+      if (a is TreeModelTreeNode modelNode) {
+        ModelChange(modelNode, rand, cancellationToken, childScope);
+        maxStepNumber--;
+      }
+      if (a.Subtrees != null) {
+        for (int i = 0; i < (a.Subtrees.Count()); i++) {
+          TreeIterator(a.Subtrees.ToList()[i], rand, cancellationToken, childScope, maxStepNumber);
+        }
+      }
+      return maxStepNumber;
+    }
+    void ModelChange(TreeModelTreeNode a, IRandom rand, CancellationToken cancellationToken, IScope childScope) {
+      int treeNumber = a.TreeNumber;
+      var oldSubTree = (ISymbolicExpressionTree)a.Tree.Clone();
+      double oldQuality = ((DoubleValue)childScope.Variables["Quality"].Value).Value;
+      int cluster = Map.ClusterNumber[treeNumber];
+      int newTreeNumber = rand.Next(Map.Map[cluster].Count);
+      a.Tree = (ISymbolicExpressionTree)Map.ModelSet[newTreeNumber].Clone();
+      a.Tree.Root.ShakeLocalParameters(rand, 1);
+      var evaluator = Problem.Evaluator;
+      ExecuteOperation(executionContext, cancellationToken, executionContext.CreateChildOperation(evaluator, childScope));
+      double currentQuality = ((DoubleValue)childScope.Variables["Quality"].Value).Value;
+      if (oldQuality > currentQuality) {
+        a.Tree = (ISymbolicExpressionTree)oldSubTree.Clone();
+        ((DoubleValue)childScope.Variables["Quality"].Value).Value = oldQuality;
+      }
+    }
   }
 
+
 }
 

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMBaseAlgorithm.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Optimization;
 using HeuristicLab.Parameters;
@@ -55 +56 @@
     [Storable]
     protected ExecutionState previousExecutionState;
+
+    [Storable]
+    protected ExecutionState currentExecutionState;
     #endregion
 
@@ -72 +76 @@
     private const string InputFileParameterName = "InputFile";
     private const string ClusterNumbersParameterName = "ClusterNumbers";
+    private const string ClusterNumbersShowParameterName = "ClusterNumbersShow";
     private const string AlgorithmImplementationTypeParameterName = "AlgorithmImplemetationType";
-    private const string MapCreationTypeParameterName = "MapCreationType";
+    private const string MapParameterName = "Map";
     private const string NegbourTypeParameterName = "NegbourType";
     private const string NegbourNumberParameterName = "NegbourNumber";
@@ -85 +90 @@
       get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersParameterName]; }
     }
-    public IFixedValueParameter<StringValue> AlgorithmImplementationTypeParameter {
-      get { return (IFixedValueParameter<StringValue>)Parameters[AlgorithmImplementationTypeParameterName]; }
-    }
-    public IFixedValueParameter<StringValue> MapCreationTypeParameter {
-      get { return (IFixedValueParameter<StringValue>)Parameters[MapCreationTypeParameterName]; }
+    public IValueParameter<IntValue> ClusterNumbersShowParameter {
+      get { return (IValueParameter<IntValue>)Parameters[ClusterNumbersShowParameterName]; }
+    }
+    public IConstrainedValueParameter<StringValue> AlgorithmImplementationTypeParameter {
+      get { return (IConstrainedValueParameter<StringValue>)Parameters[AlgorithmImplementationTypeParameterName]; }
+    }
+    public IConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
+      get { return (IConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
     }
     public IFixedValueParameter<StringValue> NegbourTypeParameter {
@@ -144 +152 @@
       set { ClusterNumbersParameter.Value = value; }
     }
+    public IntValue ClusterNumbersShow {
+      get { return ClusterNumbersShowParameter.Value; }
+      set { ClusterNumbersShowParameter.Value = value; }
+    }
     public StringValue AlgorithmImplemetationType {
       get { return AlgorithmImplementationTypeParameter.Value; }
       set { AlgorithmImplementationTypeParameter.Value.Value = value.Value; }
     }
-    public StringValue MapCreationType {
-      get { return MapCreationTypeParameter.Value; }
-      set { MapCreationTypeParameter.Value.Value = value.Value; }
+    public EMMMapBase<ISymbolicExpressionTree> Map {
+      get { return MapParameter.Value; }
+      set { MapParameter.Value = value; }
     }
     public StringValue NegbourType {
@@ -214 +226 @@
       Parameters.Add(new FixedValueParameter<IntValue>(SeedParameterName, "The random seed used to initialize the new pseudo random number generator.", new IntValue(0)));
       Parameters.Add(new FixedValueParameter<StringValue>(InputFileParameterName, "The file with set of models that will be.", new StringValue("input.txt")));
-      Parameters.Add(new FixedValueParameter<StringValue>(AlgorithmImplementationTypeParameterName, "The Type of possible algorith, implemetation, choose one: OnlyMapCreation, CreateMapAndGo, ReadMapAndGo.", new StringValue("CreateMapAndGo")));
-      Parameters.Add(new FixedValueParameter<StringValue>(MapCreationTypeParameterName, "The type of map crearion algorithm. Use one from: IslandMap, FullMap.", new StringValue("IslandMap")));
+      Parameters.Add(new ConstrainedValueParameter<StringValue>(AlgorithmImplementationTypeParameterName, "The Type of possible algorith, implemetation, choose one: OnlyMap, Full, Read."));
+      Parameters.Add(new ConstrainedValueParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName, "The type of map crearion algorithm. Use one from: IslandMap, NetworkMap."));
       Parameters.Add(new FixedValueParameter<IntValue>(NegbourNumberParameterName, "The parametr for FullMap type of map crearion algorithm. Use one from: 10, 20.", new IntValue(10)));
       Parameters.Add(new FixedValueParameter<StringValue>(NegbourTypeParameterName, "The parametr for FullMap type of map crearion algorithm. Use one from: Percent, Number.", new StringValue("Number")));
@@ -230 +242 @@
       Parameters.Add(new ValueParameter<IRandom>(RandomParameterName, new MersenneTwister()));
       Parameters.Add(new ValueParameter<IntValue>("Elites", "The numer of elite Solutions which are kept in each generation.", new IntValue(1)));
-      Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersParameterName, "The number of clusters for model Map.", new IntValue(100)));
+      Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersParameterName, "The number of clusters for model Map.", new IntValue(10)));
+      Parameters.Add(new ValueParameter<IntValue>(ClusterNumbersShowParameterName, "The number of clusters for model Map.", new IntValue(10)));
       foreach (ISelector selector in ApplicationManager.Manager.GetInstances<ISelector>().Where(x => !(x is IMultiObjectiveSelector)).OrderBy(x => x.Name))
         SelectorParameter.ValidValues.Add(selector);
@@ -238 +251 @@
 
       ProblemChanged += EvolvmentModelsOfModelsAlgorithmBase_ProblemChanged;
-
+      MapParameterUpdate();
     }
 
@@ -245 +258 @@
         Problem.SymbolicExpressionTreeInterpreter = new SymbolicDataAnalysisExpressionTreeBatchInterpreter();
         //Problem.SymbolicExpressionTreeGrammar = new EMMGrammar();
+      }
+    }
+    protected void MapParameterUpdate() {
+      int neghboorNumber = 10;
+
+      switch (NegbourType.Value) {
+        case "Percent": neghboorNumber = Convert.ToInt32((Convert.ToDouble(ClusterNumbersParameter.Value.Value)) * (Convert.ToDouble(NegbourNumber.Value)) / 100.0); break;
+        case "Number": neghboorNumber = NegbourNumber.Value; break;
+        default: neghboorNumber = NegbourNumber.Value; break;
+      }
+      var mapTypes = new EMMMapBase<ISymbolicExpressionTree>[]
+      {
+        new EMMIslandMap(),
+        new EMMNetworkMap(neghboorNumber)
+      };
+      foreach (var t in mapTypes) {
+        MapParameter.ValidValues.Add(t);
+      }
+      var algorithmType = new StringValue[]
+        {
+          new StringValue("Full"),
+          new StringValue("Read"),
+          new StringValue ("OnlyMap")
+        };
+      foreach (var t in algorithmType) {
+        AlgorithmImplementationTypeParameter.ValidValues.Add(t);
       }
     }
@@ -410 +449 @@
 
     protected override void OnExecutionStateChanged() {
-      previousExecutionState = ExecutionState;
+      previousExecutionState = currentExecutionState;
+      currentExecutionState = ExecutionState;
       base.OnExecutionStateChanged();
     }

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMBaseMap.cs

@@ -21 +21 @@
 
 using HEAL.Attic;
+using HeuristicLab.Common;
 using HeuristicLab.Core;
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
+using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using System.Collections.Generic;
+using System.IO;
+using System.Linq;
 
 namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
   [StorableType("83CF9650-98FF-454B-9072-82EA4D39C752")]
   public abstract class EMMMapBase<T> : Item where T : class {
+    [Storable]
     public List<T> ModelSet { get; set; }
+    [Storable]
     public List<int> ClusterNumber { get; set; }
+    [Storable]
     public List<List<int>> Map { get; set; }
+    [Storable]
     public double[,] Distances { get; set; }
-    public int K { get; set; }
+    [Storable]
+    public int K { get; protected set; }
 
-    protected abstract void CalculateDistances();
-    protected abstract void CreateIslandMap(IRandom random, int k);
-    public abstract T NewModelForInizializtion(IRandom random, out int cluster, out int treeNumber);
+    protected void CalculateDistances() {
+      if (ModelSet is List<ISymbolicExpressionTree> set) {
+        Distances = SymbolicExpressionTreeHash.ComputeSimilarityMatrix(set, simplify: false, strict: true);
+      } else { /// for future work
+        for (int i = 0; i < ModelSet.Count - 1; i++) {
+          for (int j = 0; j <= i; j++) {
+            Distances[i, j] = 0;
+          }
+        }
+      }
+      for (int i = 0; i < ModelSet.Count - 1; i++) {
+        for (int j = i + 1; j < ModelSet.Count; j++) {
+          Distances[j, i] = Distances[i, j] = 1 - Distances[i, j];
+        }
+      }
+
+    }
+    public abstract void CreateMap(IRandom random, int k);
+    public abstract T NewModelForInizializtionNotTree(IRandom random, out int cluster, out int treeNumber);
+    public ISymbolicExpressionTree NewModelForInizializtion(IRandom random, out int cluster, out int treeNumber) {
+      treeNumber = random.Next(ModelSet.Count);
+      cluster = ClusterNumber[treeNumber];
+      if (ModelSet[treeNumber] is ISymbolicExpressionTree model)
+        return (ISymbolicExpressionTree)(model.Clone());
+      return new SymbolicExpressionTree();
+    }
 
     [StorableConstructor]
     protected EMMMapBase(StorableConstructorFlag _) : base(_) { }
-    protected EMMMapBase() { }
-
+    protected EMMMapBase() : this(1) { }
+    public EMMMapBase(int k) {
+      K = k;
+      ClusterNumber = new List<int>();
+      Map = new List<List<int>>();
+    }
+    public EMMMapBase(EMMMapBase<T> original, Cloner cloner) {
+      if (original.ModelSet != null) {
+        if (original.ModelSet is List<ISymbolicExpressionTree> originalSet && ModelSet is List<ISymbolicExpressionTree> set)
+          set = originalSet.Select(cloner.Clone).ToList();
+        else ModelSet = original.ModelSet.ToList(); /// check this if you want to use it
+      }
+      if (original.ClusterNumber != null) {
+        ClusterNumber = original.ClusterNumber.ToList();
+      }
+      if (original.Map != null) {
+        Map = original.Map.Select(x => x.ToList()).ToList();
+      }
+      K = original.K;
+    }
+    //public EMMMapBase(IRandom random, IEnumerable<T> trees, int k) : this(k) {
+    //  // constructor that should be used in case of creation of a new map from the start point
+    //  ModelSet = trees.ToList();
+    //  CalculateDistances();
+    //  CreateMap(random, k);
+    //}
+    //public EMMMapBase(IRandom random, IEnumerable<T> trees, string fileName = "Map.txt") : this(1) {
+    //  // constructor that shoud be used in case of using of "old" map, that was previously created and now shoud be readed from file
+    //  ModelSet = trees.ToList();
+    //  MapFromFileRead(fileName);
+    //  K = Map.Count;
+    //  MapPreparation();
+    //}
+    public void MapCreationPrepare(IRandom random, IEnumerable<T> trees, int k) {
+      ModelSet = trees.ToList();
+      CalculateDistances();
+      CreateMap(random, k);
+    }
+    public void MapRead(IRandom random, IEnumerable<T> trees, string fileName = "Map.txt") {
+      ModelSet = trees.ToList();
+      MapFromFileRead(fileName);
+      K = Map.Count;
+      MapPreparation();
+      if (this is EMMNetworkMap one) { one.NeghboorNumber = Map[0].Count; }
+    }
+    public void WriteMapToTxtFile(IRandom random) {
+      string s = random.ToString();
+      string fileName = "Map";
+      fileName += s;
+      fileName += ".txt";
+      File.WriteAllLines(fileName, MapToString());
+      string fileName2 = "MapToSee";
+      fileName2 += s;
+      fileName2 += ".txt";
+      File.WriteAllLines(fileName, MapToSee());
+    }
+    public string[] MapToString() { // Function that preapre Map to printing in .txt File: create a set of strings for future reading by computer
+      string[] s;
+      s = new string[K];
+      for (int i = 0; i < K; i++) {
+        s[i] = "";
+        for (int j = 0; j < Map[i].Count; j++) {
+          s[i] += Map[i][j].ToString();
+          s[i] += " ";
+        }
+      }
+      return s;
+    }
+    public string[] MapToSee() { // Function that prepare Map to printing in .txt File: create a set of strings in human readable view
+      var fmt = new InfixExpressionFormatter();
+      string[] s;
+      s = new string[(ModelSet.Count) + 1];
+      s[0] = "ClusterNumber" + "," + "ModelNumber" + "," + "Model";
+      for (int i = 1; i < ((ModelSet.Count) + 1); i++) {
+        s[i] = ClusterNumber[i - 1].ToString() + "," + (i - 1).ToString() + ",";
+        if (ModelSet[i - 1] is ISymbolicExpressionTree model) {
+          s[i] += fmt.Format(model);
+        } else { s[i] += ModelSet[i - 1].ToString(); }
+      }
+      return s;
+    }
+    public void MapFromFileRead(string fileName) {
+      string input = File.ReadAllText(fileName);
+      int i = 0;
+      foreach (var row in input.Split('\n')) {
+        Map.Add(new List<int>());
+        foreach (var col in row.Trim().Split(' ')) {
+          Map[i].Add(int.Parse(col.Trim()));
+        }
+        i++;
+      }
+    }
+    protected void MapSizeCheck() {
+      if (Map != null) Map.Clear();
+      else Map = new List<List<int>>();
+      if (Map.Count != K) {
+        if (Map.Count != 0) {
+          Map.Clear();
+        }
+        for (int i = 0; i < K; i++) {
+          Map.Add(new List<int>());
+        }
+      }
+    }
+    protected void MapPreparation() {
+      for (int i = 0; i < Map.Count; i++) {
+        for (int j = 0; j < Map[i].Count; j++) {
+          ClusterNumber.Add(0);
+        }
+      }
+      for (int i = 0; i < Map.Count; i++) {
+        for (int j = 0; j < Map[i].Count; j++) {
+          ClusterNumber[Map[i][j]] = i;
+        }
+      }
+    }
   }
 }

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMClustering.cs

@@ -22 +22 @@
 using HeuristicLab.Core;
 using System.Collections.Generic;
-using System.Linq;
 
 namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
@@ -40 +39 @@
       return K;
     }
-    public static void ApplyFullConectedMapCreationAlgorithm(IRandom random, double[,] distances, List<List<int>> map, int k, int neghboorNumber = 10) {
-      int mapSize = distances.GetLength(0);
-      List<double> currentList = new List<double>();
-      for (int i = 0; i < mapSize; i++) {
-        map.Add(new List<int>());
-        for (int j = 0; j < mapSize; j++) {
-          currentList.Add(distances[i, j]);
-        }
-        map[i].Add(ChooseMinElement(currentList));
-        while (map[i].Count < neghboorNumber) {
-          map[i].Add(ChooseMinElement(currentList, i, map[i]));
-        }
-        currentList.Clear();
-      }
-    }
-    private static bool CheckNumberIsInList(int number, List<int> priviousNumber) {
-      foreach (var pNum in priviousNumber) {
-        if (number == pNum)
-          return true;
-      }
-      return false;
-    }
+
     public static int ApplyClusteringAlgorithm(IRandom random, double[,] distances, List<int> numberCluster, int k) {
       int mapSize = distances.GetLength(0);
@@ -82 +60 @@
         }
         for (int i = 0; i < mapSize; i++) {
-          numberCluster[i] = LookCloseCentroid(centroids, mapSize, distances, i, k);
+          numberCluster[i] = LookCloseCentroid(centroids, distances, i, k);
           clusters[numberCluster[i]].Add(numberCluster[i]);
         }
@@ -89 +67 @@
         for (int i = 0; i < k; i++) {
           AverageClusterDistanceCalculation(averageClusterDistance, distances, numberCluster, mapSize, i);
-          var newCentroid = clusters[i][ChooseMinElement(averageClusterDistance)];
+          var newCentroid = clusters[i][HelpFunctions.ChooseMinElementIndex(averageClusterDistance)];
           if (newCentroid != centroids[i]) {
             flag = true;
@@ -104 +82 @@
       }
     }
-    private static int LookCloseCentroid(List<int> centroids, int MapSize, double[,] distances, int currentNumber, int k) {
+    private static int LookCloseCentroid(List<int> centroids, double[,] distances, int currentNumber, int k) {
       double minDistanse = distances[currentNumber, centroids[0]];
       int clusterNum = 0;
@@ -152 +130 @@
       }
     }
-    private static int ChooseMinElement(List<double> averageClusterDistance) {
-      double minValue = averageClusterDistance[0];
-      int minElementNumber = 0;
-      for (int i = 1; i < averageClusterDistance.Count(); i++) {
-        if (averageClusterDistance[i] < minValue) {
-          minValue = averageClusterDistance[i];
-          minElementNumber = i;
-        }
-      }
-      return minElementNumber;
-    }
-    private static int ChooseMinElement(List<double> distances, int currentElement, List<int> previousNumbers) {
-      double minValue = 100;
-      int minElementNumber = 0;
-      int temp = 0, i = 0;
-      while (temp == 0) {
-        if ((currentElement != i) && (!CheckNumberIsInList(i, previousNumbers))) {
-          minValue = distances[i];
-          minElementNumber = i;
-          temp = i;
-        }
-        i++;
-      }
-      for (i = 0; i < distances.Count(); i++) {
-        if ((distances[i] < minValue) && (currentElement != i) && (!CheckNumberIsInList(i, previousNumbers))) {
-          minValue = distances[i];
-          minElementNumber = i;
-        }
-      }
-      return minElementNumber;
-    }
+
+
   }
 }

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMIslandMap.cs

@@ -24 +24 @@
 using HeuristicLab.Core;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
-using HeuristicLab.Problems.DataAnalysis.Symbolic;
 using System.Collections.Generic;
-using System.IO;
-using System.Linq;
 
 namespace HeuristicLab.Algorithms.EvolvmentModelsOfModels {
-  [Item("TreeModelMap", "A map of models of models of models")]
+  [Item("IslandMap", "A map of models of models of models")]
   [StorableType("E4AB04B9-FD5D-47EE-949D-243660754F3A")]
-  public class EMMMapTreeModel : EMMMapBase<ISymbolicExpressionTree> {
+  public class EMMIslandMap : EMMMapBase<ISymbolicExpressionTree> {
     #region conctructors
     [StorableConstructor]
-    protected EMMMapTreeModel(StorableConstructorFlag _) : base(_) { }
-    public EMMMapTreeModel() : this(1) { }
-    public EMMMapTreeModel(int k) {
-      K = k;
-      ModelSet = new List<ISymbolicExpressionTree>();
-      ClusterNumber = new List<int>();
-      Map = new List<List<int>>();
+    protected EMMIslandMap(StorableConstructorFlag _) : base(_) { }
+    public EMMIslandMap() : this(1) { }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      return new EMMIslandMap(this, cloner);
     }
-    public EMMMapTreeModel(EMMMapTreeModel original, Cloner cloner) {
-      //original.ModelSet.ForEach(x => ModelSet.Add((ISymbolicExpressionTree)x.Clone(cloner)));
-      //original.ClusterNumber.ForEach(x => ClusterNumber.Add(x));
-      //original.Map.ForEach(x => Map.Add(x));
-      if (original.ModelSet != null) {
-        ModelSet = original.ModelSet.Select(cloner.Clone).ToList();
-      }
-      if (original.ClusterNumber != null) {
-        ClusterNumber = original.ClusterNumber.ToList();
-      }
-      if (original.Map != null) {
-        Map = original.Map.Select(x => x.ToList()).ToList();
-      }
-      K = original.K;
-    }
-    public EMMMapTreeModel(IRandom random, IEnumerable<ISymbolicExpressionTree> trees, int k, int neghboorNumber) : this(k) {
-      ModelSet = trees.ToList();
-      CalculateDistances();
-      if (k < ModelSet.Count)
-        CreateIslandMap(random, k);
-      else if (k == ModelSet.Count) {
-        CreateFullConnectedMap(random, k, neghboorNumber);
-      } else {
-        k -= ModelSet.Count;
-        CreateIslandMap(random, k);
-      }
-    }
-    public EMMMapTreeModel(IRandom random, IEnumerable<ISymbolicExpressionTree> trees) : this(1) {
-      ModelSet = trees.ToList();
-      string input = File.ReadAllText("Map.txt");
-
-      int i = 0;
-      foreach (var row in input.Split('\n')) {
-        Map.Add(new List<int>());
-        foreach (var col in row.Trim().Split(' ')) {
-          Map[i].Add(int.Parse(col.Trim()));
-        }
-        i++;
-      }
-      K = Map.Count;
-      MapPreparation();
-    }
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new EMMMapTreeModel(this, cloner);
-    }
+    public EMMIslandMap(int k) : base(k) { ModelSet = new List<ISymbolicExpressionTree>(); }
+    public EMMIslandMap(EMMIslandMap original, Cloner cloner) : base(original, cloner) { }
+    // public EMMIslandMap(IRandom random, IEnumerable<ISymbolicExpressionTree> trees, int k, int neghboorNumber) : base(random, trees, k) { }
+    //public EMMIslandMap(IRandom random, IEnumerable<ISymbolicExpressionTree> trees, string fileName = "Map.txt") : base(random, trees, fileName) { }
     #endregion
-    #region MapTransformation
-    override protected void CalculateDistances() {
-      Distances = SymbolicExpressionTreeHash.ComputeSimilarityMatrix(ModelSet, simplify: false, strict: true);
-      for (int i = 0; i < ModelSet.Count - 1; i++) {
-        for (int j = i + 1; j < ModelSet.Count; j++) {
-          Distances[j, i] = Distances[i, j] = 1 - Distances[i, j];
-        }
-      }
-    }
-    protected void CreateFullConnectedMap(IRandom random, int k, int neghboorNumber) {
-      EMModelsClusterizationAlgorithm.ApplyFullConectedMapCreationAlgorithm(random, Distances, Map, k, neghboorNumber);
-      K = k;
-      for (int i = 0; i < Map.Count; i++) {
-        ClusterNumber.Add(i);
-      }
-    }
-    override protected void CreateIslandMap(IRandom random, int k) {
-      //Clusterization
+    #region MapApplayFunctions
+    override public void CreateMap(IRandom random, int k) {
       K = EMModelsClusterizationAlgorithm.ApplyClusteringAlgorithm(random, Distances, ClusterNumber, k);
-      // Cheking a Map size
-      if (Map != null) Map.Clear();
-      else Map = new List<List<int>>();
-      if (Map.Count != K) {
-        if (Map.Count != 0) {
-          Map.Clear();
-        }
-        for (int i = 0; i < K; i++) {
-          Map.Add(new List<int>());
-        }
-      }
-      // Map fulfilment
+      MapSizeCheck();
       for (int i = 0; i < ModelSet.Count; i++) {
         Map[ClusterNumber[i]].Add(i);
       }
     }
-    protected void MapPreparation() {
-      for (int i = 0; i < Map.Count; i++) {
-        for (int j = 0; j < Map[i].Count; j++) {
-          ClusterNumber.Add(0);
-        }
-      }
-      for (int i = 0; i < Map.Count; i++) {
-        for (int j = 0; j < Map[i].Count; j++) {
-          ClusterNumber[Map[i][j]] = i;
-        }
-      }
+    override public ISymbolicExpressionTree NewModelForInizializtionNotTree(IRandom random, out int cluster, out int treeNumber) {
+      return NewModelForInizializtion(random, out cluster, out treeNumber);
     }
     #endregion
-    #region Dialog with surroudings
-    override public ISymbolicExpressionTree NewModelForInizializtion(IRandom random, out int cluster, out int treeNumber) {
-      treeNumber = random.Next(ModelSet.Count);
-      cluster = ClusterNumber[treeNumber];
-      return (ISymbolicExpressionTree)ModelSet[treeNumber].Clone();
-    }
-    public string[] MapToString() {
-      string[] s;
-      s = new string[K];
-      for (int i = 0; i < K; i++) {
-        s[i] = "";
-        for (int j = 0; j < Map[i].Count; j++) {
-          s[i] += Map[i][j].ToString();
-          s[i] += " ";
-        }
-      }
-      return s;
-    }
-    public string[] MapToSee() {
-      var fmt = new InfixExpressionFormatter();
-      string[] s;
-      s = new string[(ModelSet.Count) + 1];
-      s[0] = "ClusterNumber" + "," + "Modfelnumber" + "," + "Model";
-      for (int i = 1; i < ((ModelSet.Count) + 1); i++) {
-        s[i] = ClusterNumber[i - 1].ToString() + "," + (i - 1).ToString() + "," + fmt.Format(ModelSet[i - 1]);
-      }
-      return s;
-    }
 
-    #endregion
   }
 }

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMMultyPointsMutator.cs

@@ -35 +35 @@
   [StorableType("918B5F77-3B9E-4620-94A3-236913C4A3F2")]
   public sealed class EMMMultyPointsMutator : SymbolicExpressionTreeManipulator {
-    private const string ModelSetParameterName = "Models";
-    private const string ClusterNumberParameterName = "ClusterNumber";
     private const string MapParameterName = "Map";
     private const string MutationProbabilityParameterName = "MutationProbability";
-    public ILookupParameter<ItemList<ISymbolicExpressionTree>> ModelSetParameter {
-      get { return (ILookupParameter<ItemList<ISymbolicExpressionTree>>)Parameters[ModelSetParameterName]; }
-    }
-    public ILookupParameter<ItemList<IntValue>> ClusterNumberParameter {
-      get { return (ILookupParameter<ItemList<IntValue>>)Parameters[ClusterNumberParameterName]; }
-    }
-
-    public ILookupParameter<ItemList<ItemList<IntValue>>> MapParameter {
-      get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters[MapParameterName]; }
+    public ILookupParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
+      get { return (ILookupParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
     }
     public ILookupParameter<PercentValue> MutationProbabilityParameter {
       get { return (ILookupParameter<PercentValue>)Parameters[MutationProbabilityParameterName]; }
     }
-    public ItemList<ISymbolicExpressionTree> ModelSet => ModelSetParameter.ActualValue;
-    public ItemList<IntValue> ClusterNumber => ClusterNumberParameter.ActualValue;
-    public ItemList<ItemList<IntValue>> Map => MapParameter.ActualValue;
+    public List<ISymbolicExpressionTree> ModelSet => MapParameter.ActualValue.ModelSet;
+    public List<int> ClusterNumber => MapParameter.ActualValue.ClusterNumber;
+    public List<List<int>> Map => MapParameter.ActualValue.Map;
     public PercentValue MutationProbability => MutationProbabilityParameter.ActualValue;
 
@@ -61 +52 @@
     private EMMMultyPointsMutator(EMMMultyPointsMutator original, Cloner cloner) : base(original, cloner) { }
     public EMMMultyPointsMutator() : base() {
-      Parameters.Add(new LookupParameter<ItemList<ISymbolicExpressionTree>>(ModelSetParameterName));
-      Parameters.Add(new LookupParameter<ItemList<IntValue>>(ClusterNumberParameterName));
-      Parameters.Add(new LookupParameter<ItemList<ItemList<IntValue>>>(MapParameterName));
+      Parameters.Add(new LookupParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName));
       Parameters.Add(new LookupParameter<PercentValue>(MutationProbabilityParameterName));
     }
@@ -81 +70 @@
       return false;
     }
-    public static void EMMOnePointMutatorPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, ItemList<ISymbolicExpressionTree> modelSet, ItemList<IntValue> clusterNumber, ItemList<ItemList<IntValue>> map, PercentValue mutationProbability) {
+    public static void EMMOnePointMutatorPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, List<ISymbolicExpressionTree> modelSet, List<int> clusterNumber, List<List<int>> map, PercentValue mutationProbability) {
 
       List<ISymbol> allowedSymbols = new List<ISymbol>();
@@ -113 +102 @@
 
             if (node is TreeModelTreeNode treeNode2) { // make rigth mutation for tree model
-              treeNode2.TreeNumber = map[pTemp].SampleRandom(random).Value;
+              treeNode2.TreeNumber = map[pTemp].SampleRandom(random);
               treeNode2.Tree = (ISymbolicExpressionTree)modelSet[treeNode2.TreeNumber].Clone();
               treeNode2.ClusterNumer = pTemp;

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMMultyPointsMutatorNodeTypeSaving.cs

@@ -35 +35 @@
   [StorableType("8A24C715-BEFD-4396-9264-31F949330B1A")]
   public sealed class EMMMultyPointsMutatorNodeTypeSaving : SymbolicExpressionTreeManipulator {
-    private const string ModelSetParameterName = "Models";
-    private const string ClusterNumberParameterName = "ClusterNumber";
+
     private const string MapParameterName = "Map";
     private const string MutationProbabilityParameterName = "MutationProbability";
-    public ILookupParameter<ItemList<ISymbolicExpressionTree>> ModelSetParameter {
-      get { return (ILookupParameter<ItemList<ISymbolicExpressionTree>>)Parameters[ModelSetParameterName]; }
+    public ILookupParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
+      get { return (ILookupParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
     }
-    public ILookupParameter<ItemList<IntValue>> ClusterNumberParameter {
-      get { return (ILookupParameter<ItemList<IntValue>>)Parameters[ClusterNumberParameterName]; }
-    }
+    public List<ISymbolicExpressionTree> ModelSet => MapParameter.ActualValue.ModelSet;
+    public List<int> ClusterNumber => MapParameter.ActualValue.ClusterNumber;
+    public List<List<int>> Map => MapParameter.ActualValue.Map;
 
-    public ILookupParameter<ItemList<ItemList<IntValue>>> MapParameter {
-      get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters[MapParameterName]; }
-    }
     public ILookupParameter<PercentValue> MutationProbabilityParameter {
       get { return (ILookupParameter<PercentValue>)Parameters[MutationProbabilityParameterName]; }
     }
-    public ItemList<ISymbolicExpressionTree> ModelSet => ModelSetParameter.ActualValue;
-    public ItemList<IntValue> ClusterNumber => ClusterNumberParameter.ActualValue;
-    public ItemList<ItemList<IntValue>> Map => MapParameter.ActualValue;
+
     public PercentValue MutationProbability => MutationProbabilityParameter.ActualValue;
 
@@ -61 +55 @@
     private EMMMultyPointsMutatorNodeTypeSaving(EMMMultyPointsMutatorNodeTypeSaving original, Cloner cloner) : base(original, cloner) { }
     public EMMMultyPointsMutatorNodeTypeSaving() : base() {
-      Parameters.Add(new LookupParameter<ItemList<ISymbolicExpressionTree>>(ModelSetParameterName));
-      Parameters.Add(new LookupParameter<ItemList<IntValue>>(ClusterNumberParameterName));
-      Parameters.Add(new LookupParameter<ItemList<ItemList<IntValue>>>(MapParameterName));
+      Parameters.Add(new LookupParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName));
       Parameters.Add(new LookupParameter<PercentValue>(MutationProbabilityParameterName));
     }
@@ -81 +73 @@
       return false;
     }
-    public static void EMMOnePointMutatorPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, ItemList<ISymbolicExpressionTree> modelSet, ItemList<IntValue> clusterNumber, ItemList<ItemList<IntValue>> map, PercentValue mutationProbability) {
+    public static void EMMOnePointMutatorPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, List<ISymbolicExpressionTree> modelSet, List<int> clusterNumber, List<List<int>> map, PercentValue mutationProbability) {
 
       List<ISymbol> allowedSymbols = new List<ISymbol>();
@@ -113 +105 @@
 
             if (node is TreeModelTreeNode treeNode2) { // make rigth mutation for tree model
-              treeNode2.TreeNumber = map[pTemp].SampleRandom(random).Value;
+              treeNode2.TreeNumber = map[pTemp].SampleRandom(random);
               treeNode2.Tree = (ISymbolicExpressionTree)modelSet[treeNode2.TreeNumber].Clone();
               treeNode2.ClusterNumer = pTemp;

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/EMMMutators.cs

@@ -36 +36 @@
   public sealed class EMMMutators : SymbolicExpressionTreeManipulator {
     private const int MAX_TRIES = 100;
-
-    private const string ModelSetParameterName = "Models";
-    private const string ClusterNumberParameterName = "ClusterNumber";
     private const string MapParameterName = "Map";
 
-    public ILookupParameter<ItemList<ISymbolicExpressionTree>> ModelSetParameter {
-      get { return (ILookupParameter<ItemList<ISymbolicExpressionTree>>)Parameters[ModelSetParameterName]; }
+    public ILookupParameter<EMMMapBase<ISymbolicExpressionTree>> MapParameter {
+      get { return (ILookupParameter<EMMMapBase<ISymbolicExpressionTree>>)Parameters[MapParameterName]; }
     }
 
-    public ILookupParameter<ItemList<IntValue>> ClusterNumberParameter {
-      get { return (ILookupParameter<ItemList<IntValue>>)Parameters[ClusterNumberParameterName]; }
-    }
-
-    public ILookupParameter<ItemList<ItemList<IntValue>>> MapParameter {
-      get { return (ILookupParameter<ItemList<ItemList<IntValue>>>)Parameters[MapParameterName]; }
-    }
-
-    public ItemList<ISymbolicExpressionTree> ModelSet => ModelSetParameter.ActualValue;
-    public ItemList<IntValue> ClusterNumber => ClusterNumberParameter.ActualValue;
-    public ItemList<ItemList<IntValue>> Map => MapParameter.ActualValue;
+    public List<ISymbolicExpressionTree> ModelSet => MapParameter.ActualValue.ModelSet;
+    public List<int> ClusterNumber => MapParameter.ActualValue.ClusterNumber;
+    public List<List<int>> Map => MapParameter.ActualValue.Map;
 
     [StorableConstructor]
@@ -61 +50 @@
     private EMMMutators(EMMMutators original, Cloner cloner) : base(original, cloner) { }
     public EMMMutators() : base() {
-      Parameters.Add(new LookupParameter<ItemList<ISymbolicExpressionTree>>(ModelSetParameterName));
-      Parameters.Add(new LookupParameter<ItemList<IntValue>>(ClusterNumberParameterName));
-      Parameters.Add(new LookupParameter<ItemList<ItemList<IntValue>>>(MapParameterName));
+      Parameters.Add(new LookupParameter<EMMMapBase<ISymbolicExpressionTree>>(MapParameterName));
     }
 
@@ -73 +60 @@
       EMMMutatorsPart(random, symbolicExpressionTree, ModelSet, ClusterNumber, Map);
     }
-    public static void EMMMutatorsPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, ItemList<ISymbolicExpressionTree> modelSet, ItemList<IntValue> clusterNumber, ItemList<ItemList<IntValue>> map) {
+    public static void EMMMutatorsPart(IRandom random, ISymbolicExpressionTree symbolicExpressionTree, List<ISymbolicExpressionTree> modelSet, List<int> clusterNumber, List<List<int>> map) {
       List<ISymbol> allowedSymbols = new List<ISymbol>();
       ISymbolicExpressionTreeNode parent;
@@ -124 +111 @@
           int p = random.Next(map.Count);
           if (child is TreeModelTreeNode chNode) { p = chNode.ClusterNumer; }
-          treeNode.TreeNumber = map[p].SampleRandom(random).Value;
+          treeNode.TreeNumber = map[p].SampleRandom(random);
           treeNode.Tree = (ISymbolicExpressionTree)modelSet[treeNode.TreeNumber].Clone();
           treeNode.ClusterNumer = p;

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/HeuristicLab.Algorithms.EvolvmentModelsOfModels.csproj

@@ -23 +23 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <PropertyGroup Condition=" '$(Configuration)|$(Platform)' == 'Release|AnyCPU' ">
@@ -31 +32 @@
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
+    <LangVersion>7.1</LangVersion>
   </PropertyGroup>
   <ItemGroup>
@@ -40 +42 @@
     <Reference Include="HeuristicLab.Analysis-3.3">
       <HintPath>..\..\..\trunk\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
+    <Reference Include="HeuristicLab.Attic, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\trunk\bin\HeuristicLab.Attic.dll</HintPath>
       <Private>False</Private>
     </Reference>
@@ -61 +68 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\trunk\bin\HeuristicLab.Operators-3.3.dll</HintPath>
+      <Private>False</Private>
     </Reference>
     <Reference Include="HeuristicLab.Optimization-3.3">
@@ -109 +117 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="EMMDisatanceMap.cs" />
     <Compile Include="EMMMultyPointsMutator.cs" />
     <Compile Include="EMMAlgorithm.cs" />
     <Compile Include="EMMClustering.cs" />
-    <Compile Include="EMMMapBase.cs" />
-    <Compile Include="EMMMapTreeModel.cs" />
+    <Compile Include="EMMBaseMap.cs" />
+    <Compile Include="EMMIslandMap.cs" />
     <Compile Include="EMMMultyPointsMutatorNodeTypeSaving.cs" />
     <Compile Include="EMMMutators.cs" />
     <Compile Include="EMMSolution.cs" />
     <Compile Include="EMMBaseAlgorithm.cs" />
+    <Compile Include="EMMNetworkMap.cs" />
+    <Compile Include="HelpFunctions.cs" />
     <Compile Include="Plugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />

branches/2988_ModelsOfModels2/HeuristicLab.Algorithms.EMM/Plugin.cs

@@ -26 +26 @@
   /// Plugin class for HeuristicLab.Algorithms.EMMAlgorithm plugin.
   /// </summary>
-  [Plugin("HeuristicLab.Algorithms.EMMAlgorithm", "3.3.15.16734")]
+  [Plugin("HeuristicLab.Algorithms.EMMAlgorithm", "3.3.15.16760")]
   [PluginFile("HeuristicLab.Algorithms.EMMAlgorithm-3.3.dll", PluginFileType.Assembly)]
   [PluginDependency("HeuristicLab.Analysis", "3.3")]

branches/2988_ModelsOfModels2/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Formatters/SymbolicExpressionTreeGraphvizFormatter.cs

@@ -33 +33 @@
       // match Koza style
       {"ProgramRootSymbol", "Prog"},
-      {"StartSymbol", "RPB"}, 
+      {"StartSymbol", "RPB"},
+
+      // short form 
+      {"Subtraction", "-" },
+      {"Addition", "+" },
+      {"Multiplication", "*" },
+      {"Division", "/" },
+      {"Absolute", "abs" },
+      {"AnalyticQuotient", "AQ" },
+      {"Sine", "sin" },
+      {"Cosine", "cos" },
+      {"Tanget", "tan" },
+      {"HyperbolicTangent", "tanh" },
+      {"Exponential", "exp" },
+      {"Logarithm", "log" },
+      {"SquareRoot", "sqrt" },
+      {"Square", "sqr" },
+      {"CubeRoot", "cbrt" },
+      {"Cube", "cube" },
+      {"GreaterThan", ">" },
+      {"LessThan", "<" },
     };
 

branches/2988_ModelsOfModels2/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.4.csproj

@@ -100 +100 @@
   </PropertyGroup>
   <ItemGroup>
+    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\bin\HEAL.Attic.dll</HintPath>
+      <Private>False</Private>
+    </Reference>
     <Reference Include="HeuristicLab.Analysis-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Analysis-3.3.dll</HintPath>
+    </Reference>
+    <Reference Include="HeuristicLab.Attic, Version=1.0.0.0, Culture=neutral, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\..\..\trunk\bin\HeuristicLab.Attic.dll</HintPath>
     </Reference>
     <Reference Include="HeuristicLab.Collections-3.3, Version=3.3.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
@@ -279 +288 @@
     </BootstrapperPackage>
   </ItemGroup>
-  <ItemGroup>
-    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\bin\HEAL.Attic.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
-  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelClustersFrequencyAnalyzer.cs

@@ -43 +43 @@
 
     #region parameter properties
+    [Storable]
     public ILookupParameter<DataTable> ModelClustersFrequencyParameter {
       get { return (ILookupParameter<DataTable>)Parameters[ModelClustersFrequencyParameterName]; }
     }
+    [Storable]
     public IValueLookupParameter<BoolValue> AggregateModelClustersParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateModelClustersParameterName]; }
@@ -54 +56 @@
       get { return AggregateModelClustersParameter.ActualValue; }
       set { AggregateModelClustersParameter.Value = value; }
+    }
+    public DataTable ModelClustersFrequency {
+      get { return ModelClustersFrequencyParameter.ActualValue; }
+      set { ModelClustersFrequencyParameter.ActualValue = value; }
     }
     #endregion

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/ModelsFrequencyAnalyzer.cs

@@ -43 +43 @@
 
     #region parameter properties
+    [Storable]
     public ILookupParameter<DataTable> ModelFrequencyParameter {
       get { return (ILookupParameter<DataTable>)Parameters[ModelsFrequencyParameterName]; }
     }
+    [Storable]
     public IValueLookupParameter<BoolValue> AggregateModelParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateModelParameterName]; }
@@ -54 +56 @@
       get { return AggregateModelParameter.ActualValue; }
       set { AggregateModelParameter.Value = value; }
+    }
+    public DataTable ModelFrequency {
+      get { return ModelFrequencyParameter.ActualValue; }
+      set { ModelFrequencyParameter.ActualValue = value; }
     }
     #endregion

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Analyzers/TerminalNodesFrequencyAnalyzer.cs

@@ -43 +43 @@
 
     #region parameter properties
+    [Storable]
     public ILookupParameter<DataTable> TerminalNodesFrequencyParameter {
       get { return (ILookupParameter<DataTable>)Parameters[TerminalNodesFrequencyParameterName]; }
     }
+    [Storable]
     public IValueLookupParameter<BoolValue> AggregateTerminalNodesParameter {
       get { return (IValueLookupParameter<BoolValue>)Parameters[AggregateTerminalNodesParameterName]; }
@@ -55 +57 @@
       set { AggregateTerminalNodesParameter.Value = value; }
     }
+    public DataTable TerminalNodesFrequency {
+      get { return TerminalNodesFrequencyParameter.ActualValue; }
+      set { TerminalNodesFrequencyParameter.ActualValue = value; }
+    }
+
     #endregion
     [StorableConstructor]

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

@@ -83 +83 @@
         if (branch.SubtreeCount >= 2) {
           var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
-          var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(1).Clone();
           var fprime = Derive(f, variableName);
-          var gprime = Derive(g, variableName);
-          var fgPrime = Sum(Product(f, gprime), Product(fprime, g));
-          for (int i = 2; i < branch.SubtreeCount; i++) {
+          for (int i = 1; i < branch.SubtreeCount; i++) {
+            var g = (ISymbolicExpressionTreeNode)branch.GetSubtree(i).Clone();
             var fg = Product((ISymbolicExpressionTreeNode)f.Clone(), (ISymbolicExpressionTreeNode)g.Clone());
-            var h = (ISymbolicExpressionTreeNode)branch.GetSubtree(i).Clone();
-            var hPrime = Derive(h, variableName);
-            fgPrime = Sum(Product(fgPrime, h), Product(fg, hPrime));
+            var gPrime = Derive(g, variableName);
+            var fgPrime = Sum(Product(fprime, g), Product(gPrime, f));
+            // prepare for next iteration
+            f = fg;
+            fprime = fgPrime;
           }
-          return fgPrime;
+          return fprime;
         } else
           // multiplication with only one argument has no effect -> derive the argument

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/LinearModelToTreeConverter.cs

@@ -38 +38 @@
       double @const = 0) {
 
-      if (factorCoefficients.Length == 0 && coefficients.Length == 0) throw new ArgumentException();
+      if (factorCoefficients.Length == 0 && coefficients.Length == 0 && @const==0) throw new ArgumentException();
+
+      // Combine both trees
+      ISymbolicExpressionTreeNode add = (new Addition()).CreateTreeNode();
 
       // Create tree for double variables
-      ISymbolicExpressionTree tree = null;      
       if (coefficients.Length > 0) {
-        tree = CreateTree(variableNames, new int[variableNames.Length], coefficients, @const);
-        if (factorCoefficients.Length == 0) return tree;
+        var varTree = CreateTree(variableNames, new int[variableNames.Length], coefficients);
+        foreach (var varNode in varTree.IterateNodesPrefix().OfType<VariableTreeNode>())
+          add.AddSubtree(varNode);
       }
 
       // Create tree for string variables
-      ISymbolicExpressionTree factorTree = null;      
       if (factorCoefficients.Length > 0) {
-        factorTree = CreateTree(factors, factorCoefficients, @const);
-        if (tree == null) return factorTree;  
+        var factorTree = CreateTree(factors, factorCoefficients);
+        foreach (var binFactorNode in factorTree.IterateNodesPrefix().OfType<BinaryFactorVariableTreeNode>())
+          add.AddSubtree(binFactorNode);
       }
 
-      // Combine both trees
-      ISymbolicExpressionTreeNode add = tree.Root.GetSubtree(0).GetSubtree(0);
-      foreach (var binFactorNode in factorTree.IterateNodesPrefix().OfType<BinaryFactorVariableTreeNode>())
-        add.InsertSubtree(add.SubtreeCount - 1, binFactorNode);
+      if (@const!=0.0) {
+        ConstantTreeNode cNode = (ConstantTreeNode)new Constant().CreateTreeNode();
+        cNode.Value = @const;
+        add.AddSubtree(cNode);
+      }
+
+      ISymbolicExpressionTree tree = new SymbolicExpressionTree(new ProgramRootSymbol().CreateTreeNode());
+      ISymbolicExpressionTreeNode startNode = new StartSymbol().CreateTreeNode();
+      tree.Root.AddSubtree(startNode);
+      startNode.AddSubtree(add);
       return tree;
-
-      throw new ArgumentException();
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionCSharpFormatter.cs

@@ -137 +137 @@
         } else if (node.Symbol is SquareRoot) {
           FormatFunction(node, "Math.Sqrt", strBuilder);
+        } else if (node.Symbol is Cube) {
+          FormatPower(node, strBuilder, "3");
+        } else if (node.Symbol is CubeRoot) {
+          FormatPower(node, strBuilder, "1.0/3");
         } else if (node.Symbol is Power) {
           FormatFunction(node, "Math.Pow", strBuilder);
         } else if (node.Symbol is Root) {
           FormatRoot(node, strBuilder);
+        } else if (node.Symbol is Absolute) {
+          FormatFunction(node, "Math.Abs", strBuilder);
+        } else if (node.Symbol is AnalyticQuotient) {
+          strBuilder.Append("(");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append(" / Math.Sqrt(1 + Math.Pow(");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append(" , 2) )");
         } else {
           throw new NotSupportedException("Formatting of symbol: " + node.Symbol + " not supported for C# symbolic expression tree formatter.");
@@ -173 +185 @@
 
     private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      FormatPower(node, strBuilder, "2");
+    }
+    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
       strBuilder.Append("Math.Pow(");
       FormatRecursively(node.GetSubtree(0), strBuilder);
-      strBuilder.Append(", 2)");
+      strBuilder.Append($", {exponent})");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionExcelFormatter.cs

@@ -119 +119 @@
         }
         stringBuilder.Append(")");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"ABS({FormatRecursively(node.GetSubtree(0))})");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / SQRT(1 + POWER({FormatRecursively(node.GetSubtree(1))}, 2))");
       } else if (symbol is Average) {
-        stringBuilder.Append("(1/");
+        stringBuilder.Append("(1/(");
         stringBuilder.Append(node.SubtreeCount);
         stringBuilder.Append(")*(");
@@ -129 +133 @@
           stringBuilder.Append(")");
         }
-        stringBuilder.Append(")");
+        stringBuilder.Append("))");
       } else if (symbol is Constant) {
         ConstantTreeNode constantTreeNode = node as ConstantTreeNode;
@@ -137 +141 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
+      } else if (symbol is Cube) {
+        stringBuilder.Append($"POWER({FormatRecursively(node.GetSubtree(0))}, 3)");
+      } else if (symbol is CubeRoot) {
+        stringBuilder.Append($"POWER({FormatRecursively(node.GetSubtree(0))}, 1/3)");
       } else if (symbol is Division) {
         if (node.SubtreeCount == 1) {
-          stringBuilder.Append("1/");
-          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+          stringBuilder.Append("1/(");
+          stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+          stringBuilder.Append(")");
         } else {
           stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionLatexFormatter.cs

@@ -117 +117 @@
           strBuilder.Append(@" \cfrac{ ");
         }
+      } else if (node.Symbol is Absolute) {
+        strBuilder.Append(@"\operatorname{abs} \left( ");
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@" \frac { ");
       } else if (node.Symbol is Average) {
         // skip output of (1/1) if only one subtree
@@ -131 +135 @@
       } else if (node.Symbol is SquareRoot) {
         strBuilder.Append(@"\sqrt{");
+      } else if (node.Symbol is Cube) {
+        strBuilder.Append(@"\left(");
+      } else if (node.Symbol is CubeRoot) {
+        strBuilder.Append(@"\left(");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@"\sin \left( ");
@@ -289 +297 @@
         else
           strBuilder.Append(@" }{ \cfrac{ ");
+      } else if (node.Symbol is Absolute) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@"}{\sqrt{1 + \left( ");
       } else if (node.Symbol is Average) {
         strBuilder.Append(@" + ");
@@ -298 +310 @@
         throw new InvalidOperationException();
       } else if (node.Symbol is SquareRoot) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is Cube) {
+        throw new InvalidOperationException();
+      } else if (node.Symbol is CubeRoot) {
         throw new InvalidOperationException();
       } else if (node.Symbol is Sine) {
@@ -387 +403 @@
         for (int i = 2; i < node.SubtreeCount; i++)
           strBuilder.Append(" } ");
+      } else if (node.Symbol is Absolute) {
+        strBuilder.Append(@" \right)");
+      } else if (node.Symbol is AnalyticQuotient) {
+        strBuilder.Append(@" \right)^2}}");
       } else if (node.Symbol is Average) {
         strBuilder.Append(@" \right) ");
@@ -397 +417 @@
       } else if (node.Symbol is SquareRoot) {
         strBuilder.Append(@"}");
+      } else if (node.Symbol is Cube) {
+        strBuilder.Append(@"\right)^3");
+      } else if (node.Symbol is CubeRoot) {
+        strBuilder.Append(@"\right)^\frac{1}{3}");
       } else if (node.Symbol is Sine) {
         strBuilder.Append(@" \right) ");

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMATLABFormatter.cs

@@ -126 +126 @@
         }
         stringBuilder.Append(")");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"abs({FormatRecursively(node.GetSubtree(0))})");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / sqrt(1 + ({FormatRecursively(node.GetSubtree(1))}).^2)");
       } else if (symbol is And) {
         stringBuilder.Append("((");
@@ -179 +183 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(")");
+      } else if (symbol is Cube) {
+        stringBuilder.Append("(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(").^3");
+      } else if (symbol is CubeRoot) {
+        stringBuilder.Append("(");
+        stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
+        stringBuilder.Append(").^(1/3)");
       } else if (symbol is GreaterThan) {
         stringBuilder.Append("((");

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionMathematicaFormatter.cs

@@ -56 +56 @@
         if (node.Symbol is Addition) {
           FormatFunction(node, "Plus", strBuilder);
+        } else if (node.Symbol is Absolute) {
+          FormatFunction(node, "Abs", strBuilder);
+        } else if (node.Symbol is AnalyticQuotient) {
+          strBuilder.Append("[");
+          FormatRecursively(node.GetSubtree(0), strBuilder);
+          strBuilder.Append("]/Sqrt[ 1 + Power[");
+          FormatRecursively(node.GetSubtree(1), strBuilder);
+          strBuilder.Append(", 2]]");
         } else if (node.Symbol is Average) {
           FormatAverage(node, strBuilder);
@@ -104 +112 @@
         } else if (node.Symbol is SquareRoot) {
           FormatFunction(node, "Sqrt", strBuilder);
+        } else if (node.Symbol is Cube) {
+          FormatPower(node, strBuilder, "3");
+        } else if (node.Symbol is CubeRoot) {
+          FormatPower(node, strBuilder, "1/3");
         } else if (node.Symbol is Power) {
           FormatFunction(node, "Power", strBuilder);
@@ -205 +217 @@
 
     private void FormatSquare(ISymbolicExpressionTreeNode node, StringBuilder strBuilder) {
+      FormatPower(node, strBuilder, "2");
+    }
+
+    private void FormatPower(ISymbolicExpressionTreeNode node, StringBuilder strBuilder, string exponent) {
       strBuilder.Append("Power[");
       FormatRecursively(node.GetSubtree(0), strBuilder);
-      strBuilder.Append(", 2]");
+      strBuilder.Append($", {exponent}]");
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Formatters/SymbolicDataAnalysisExpressionSmalltalkFormatter.cs

@@ -20 +20 @@
 #endregion
 
+using System;
 using System.Globalization;
 using System.Text;
@@ -69 +70 @@
         }
         stringBuilder.Append(") ifTrue:[1] ifFalse:[-1]");
+      } else if (symbol is Absolute) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) abs");
+      } else if (symbol is AnalyticQuotient) {
+        stringBuilder.Append($"({FormatRecursively(node.GetSubtree(0))}) / (1 + ({FormatPower(node.GetSubtree(1), "2")})) sqrt");
       } else if (symbol is Average) {
         stringBuilder.Append("(1/");
@@ -84 +89 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(" cos");
+      } else if (symbol is Cube) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "3"));
+      } else if (symbol is CubeRoot) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "(1/3)"));
       } else if (symbol is Division) {
         if (node.SubtreeCount == 1) {
@@ -146 +155 @@
         stringBuilder.Append(FormatRecursively(node.GetSubtree(0)));
         stringBuilder.Append(" sin");
+      } else if (symbol is Square) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "2"));
+      } else if (symbol is SquareRoot) {
+        stringBuilder.Append(FormatPower(node.GetSubtree(0), "(1/2)"));
       } else if (symbol is Subtraction) {
         if (node.SubtreeCount == 1) {
@@ -184 +197 @@
     }
 
+    private string FormatPower(ISymbolicExpressionTreeNode node, string exponent) {
+      return $"(({FormatRecursively(node)}) log * {exponent}) exp ";
+    }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       return new SymbolicDataAnalysisExpressionSmalltalkFormatter(this, cloner);

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs

@@ -69 +69 @@
     #endregion
 
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeInterval(tree, variableRanges);
-    }
-
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
-      out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
+      return GetSymbolicExpressionTreeInterval(tree, variableRanges);
+    }
+
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
-      return GetSymbolicExressionTreeIntervals(tree, variableRanges, out nodeIntervals);
-    }
-
-    public Interval GetSymbolicExressionTreeInterval(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+      return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
+    }
+
+    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -96 +96 @@
 
 
-    public Interval GetSymbolicExressionTreeIntervals(ISymbolicExpressionTree tree,
-      Dictionary<string, Interval> variableRanges, out Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
+      IDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
@@ -108 +108 @@
       // fix incorrect intervals if necessary (could occur because of numerical errors)
       nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
-      foreach(var kvp in intervals) {
+      foreach (var kvp in intervals) {
         var interval = kvp.Value;
         if (interval.IsInfiniteOrUndefined || interval.LowerBound <= interval.UpperBound)
@@ -124 +124 @@
 
 
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, Dictionary<string, Interval> variableRanges) {
+    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
@@ -133 +133 @@
       }
 
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
+      foreach (Instruction instr in code.Where(i => i.opCode == OpCode.Variable)) {
         var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
         instr.data = variableRanges[variableTreeNode.VariableName];
@@ -141 +141 @@
     }
 
-    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, Dictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
+    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
       Instruction currentInstr = instructions[instructionCounter];
       //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
@@ -150 +150 @@
       switch (currentInstr.opCode) {
         //Variables, Constants, ...
-        case OpCodes.Variable: {
+        case OpCode.Variable: {
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
@@ -158 +158 @@
             break;
           }
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             result = new Interval(constTreeNode.Value, constTreeNode.Value);
@@ -164 +164 @@
           }
         //Elementary arithmetic rules
-        case OpCodes.Add: {
+        case OpCode.Add: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172 +172 @@
             break;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -183 +183 @@
             break;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -191 +191 @@
             break;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             if (currentInstr.nArguments == 1)
@@ -203 +203 @@
           }
         //Trigonometric functions
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Sine(argumentInterval);
             break;
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Cosine(argumentInterval);
             break;
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Tangens(argumentInterval);
             break;
           }
+        case OpCode.Tanh: {
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Interval.HyperbolicTangent(argumentInterval);
+            break;
+          }
         //Exponential functions
-        case OpCodes.Log: {
+        case OpCode.Log: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Logarithm(argumentInterval);
             break;
           }
-        case OpCodes.Exp: {
+        case OpCode.Exp: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Exponential(argumentInterval);
             break;
           }
-        case OpCodes.Power: {
+        case OpCode.Power: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -237 +242 @@
             break;
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.Square(argumentInterval);
             break;
           }
-        case OpCodes.Root: {
+        case OpCode.Root: {
             result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -250 +255 @@
             break;
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
             result = Interval.SquareRoot(argumentInterval);

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/OpCodes.cs

@@ -20 +20 @@
 #endregion
 
+using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using System;
 using System.Collections.Generic;
-using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
-  public static class OpCodes {
+  public static class OpCode {
     public const byte Add = 1;
     public const byte Sub = 2;
@@ -95 +95 @@
 
     private static Dictionary<Type, byte> symbolToOpcode = new Dictionary<Type, byte>() {
-       { typeof(Addition), OpCodes.Add },
-      { typeof(Subtraction), OpCodes.Sub },
-      { typeof(Multiplication), OpCodes.Mul },
-      { typeof(Division), OpCodes.Div },
-      { typeof(Sine), OpCodes.Sin },
-      { typeof(Cosine), OpCodes.Cos },
-      { typeof(Tangent), OpCodes.Tan },
-      { typeof (HyperbolicTangent), OpCodes.Tanh},
-      { typeof(Logarithm), OpCodes.Log },
-      { typeof(Exponential), OpCodes.Exp },
-      { typeof(IfThenElse), OpCodes.IfThenElse },
-      { typeof(GreaterThan), OpCodes.GT },
-      { typeof(LessThan), OpCodes.LT },
-      { typeof(And), OpCodes.AND },
-      { typeof(Or), OpCodes.OR },
-      { typeof(Not), OpCodes.NOT},
-      { typeof(Xor),OpCodes.XOR},
-      { typeof(Average), OpCodes.Average},
-      { typeof(InvokeFunction), OpCodes.Call },
-      { typeof(Variable), OpCodes.Variable },
-      { typeof(LaggedVariable), OpCodes.LagVariable },
-      { typeof(AutoregressiveTargetVariable),OpCodes.LagVariable},
-      { typeof(Constant), OpCodes.Constant },
-      { typeof(TreeModel), OpCodes.TreeModel },
-      { typeof(Argument), OpCodes.Arg },
-      { typeof(Power),OpCodes.Power},
-      { typeof(Root),OpCodes.Root},
-      { typeof(TimeLag), OpCodes.TimeLag},
-      { typeof(Integral), OpCodes.Integral},
-      { typeof(Derivative), OpCodes.Derivative},
-      { typeof(VariableCondition),OpCodes.VariableCondition},
-      { typeof(Square),OpCodes.Square},
-      { typeof(SquareRoot),OpCodes.SquareRoot},
-      { typeof(Gamma), OpCodes.Gamma },
-      { typeof(Psi), OpCodes.Psi },
-      { typeof(Dawson), OpCodes.Dawson},
-      { typeof(ExponentialIntegralEi), OpCodes.ExponentialIntegralEi },
-      { typeof(CosineIntegral), OpCodes.CosineIntegral },
-      { typeof(SineIntegral), OpCodes.SineIntegral },
-      { typeof(HyperbolicCosineIntegral), OpCodes.HyperbolicCosineIntegral },
-      { typeof(HyperbolicSineIntegral), OpCodes.HyperbolicSineIntegral },
-      { typeof(FresnelCosineIntegral), OpCodes.FresnelCosineIntegral },
-      { typeof(FresnelSineIntegral), OpCodes.FresnelSineIntegral },
-      { typeof(AiryA), OpCodes.AiryA },
-      { typeof(AiryB), OpCodes.AiryB },
-      { typeof(Norm), OpCodes.Norm},
-      { typeof(Erf), OpCodes.Erf},
-      { typeof(Bessel), OpCodes.Bessel},
-      { typeof(FactorVariable), OpCodes.FactorVariable },
-      { typeof(BinaryFactorVariable), OpCodes.BinaryFactorVariable },
-      { typeof(Absolute), OpCodes.Absolute },
-      { typeof(AnalyticQuotient), OpCodes.AnalyticQuotient },
-      { typeof(Cube), OpCodes.Cube },
-      { typeof(CubeRoot), OpCodes.CubeRoot }
+       { typeof(Addition), OpCode.Add },
+      { typeof(Subtraction), OpCode.Sub },
+      { typeof(Multiplication), OpCode.Mul },
+      { typeof(Division), OpCode.Div },
+      { typeof(Sine), OpCode.Sin },
+      { typeof(Cosine), OpCode.Cos },
+      { typeof(Tangent), OpCode.Tan },
+      { typeof (HyperbolicTangent), OpCode.Tanh},
+      { typeof(Logarithm), OpCode.Log },
+      { typeof(Exponential), OpCode.Exp },
+      { typeof(IfThenElse), OpCode.IfThenElse },
+      { typeof(GreaterThan), OpCode.GT },
+      { typeof(LessThan), OpCode.LT },
+      { typeof(And), OpCode.AND },
+      { typeof(Or), OpCode.OR },
+      { typeof(Not), OpCode.NOT},
+      { typeof(Xor),OpCode.XOR},
+      { typeof(Average), OpCode.Average},
+      { typeof(InvokeFunction), OpCode.Call },
+      { typeof(Variable), OpCode.Variable },
+      { typeof(LaggedVariable), OpCode.LagVariable },
+      { typeof(AutoregressiveTargetVariable),OpCode.LagVariable},
+      { typeof(Constant), OpCode.Constant },
+      { typeof(TreeModel), OpCode.TreeModel },
+      { typeof(Argument), OpCode.Arg },
+      { typeof(Power),OpCode.Power},
+      { typeof(Root),OpCode.Root},
+      { typeof(TimeLag), OpCode.TimeLag},
+      { typeof(Integral), OpCode.Integral},
+      { typeof(Derivative), OpCode.Derivative},
+      { typeof(VariableCondition),OpCode.VariableCondition},
+      { typeof(Square),OpCode.Square},
+      { typeof(SquareRoot),OpCode.SquareRoot},
+      { typeof(Gamma), OpCode.Gamma },
+      { typeof(Psi), OpCode.Psi },
+      { typeof(Dawson), OpCode.Dawson},
+      { typeof(ExponentialIntegralEi), OpCode.ExponentialIntegralEi },
+      { typeof(CosineIntegral), OpCode.CosineIntegral },
+      { typeof(SineIntegral), OpCode.SineIntegral },
+      { typeof(HyperbolicCosineIntegral), OpCode.HyperbolicCosineIntegral },
+      { typeof(HyperbolicSineIntegral), OpCode.HyperbolicSineIntegral },
+      { typeof(FresnelCosineIntegral), OpCode.FresnelCosineIntegral },
+      { typeof(FresnelSineIntegral), OpCode.FresnelSineIntegral },
+      { typeof(AiryA), OpCode.AiryA },
+      { typeof(AiryB), OpCode.AiryB },
+      { typeof(Norm), OpCode.Norm},
+      { typeof(Erf), OpCode.Erf},
+      { typeof(Bessel), OpCode.Bessel},
+      { typeof(FactorVariable), OpCode.FactorVariable },
+      { typeof(BinaryFactorVariable), OpCode.BinaryFactorVariable },
+      { typeof(Absolute), OpCode.Absolute },
+      { typeof(AnalyticQuotient), OpCode.AnalyticQuotient },
+      { typeof(Cube), OpCode.Cube },
+      { typeof(CubeRoot), OpCode.CubeRoot }
     };
 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs

@@ -154 +154 @@
     private static readonly PropertyInfo Indexer = typeof(IList<double>).GetProperty("Item");
     private static Expression MakeExpr(ISymbolicExpressionTreeNode node, Dictionary<string, int> variableIndices, Expression row, Expression columns) {
-      var opcode = OpCodes.MapSymbolToOpCode(node);
+      var opcode = OpCode.MapSymbolToOpCode(node);
       #region switch opcode
       switch (opcode) {
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             var constantTreeNode = (ConstantTreeNode)node;
             return Expression.Constant(constantTreeNode.Value);
           }
-        case OpCodes.Variable: {
+        case OpCode.Variable: {
             var variableTreeNode = (VariableTreeNode)node;
             var variableWeight = Expression.Constant(variableTreeNode.Weight);
@@ -169 +169 @@
             return Expression.Multiply(variableWeight, Expression.Property(valuesExpr, Indexer, row));
           }
-        case OpCodes.Add: {
+        case OpCode.Add: {
             Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             for (int i = 1; i < node.SubtreeCount; ++i) {
@@ -176 +176 @@
             return result;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             if (node.SubtreeCount == 1)
@@ -185 +185 @@
             return result;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             for (int i = 1; i < node.SubtreeCount; ++i) {
@@ -192 +192 @@
             return result;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             if (node.SubtreeCount == 1)
@@ -201 +201 @@
             return result;
           }
-        case OpCodes.Average: {
+        case OpCode.Average: {
             Expression result = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             for (int i = 1; i < node.SubtreeCount; ++i) {
@@ -208 +208 @@
             return Expression.Divide(result, Expression.Constant((double)node.SubtreeCount));
           }
-        case OpCodes.Absolute: {
+        case OpCode.Absolute: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Abs, arg);
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Cos, arg);
           }
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Sin, arg);
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Tan, arg);
           }
-        case OpCodes.Tanh: {
+        case OpCode.Tanh: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Tanh, arg);
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Power(arg, Expression.Constant(2.0));
           }
-        case OpCodes.Cube: {
+        case OpCode.Cube: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Power(arg, Expression.Constant(3.0));
           }
-        case OpCodes.Power: {
+        case OpCode.Power: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
             return Expression.Power(arg, Expression.Call(Round, power));
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Sqrt, arg);
           }
-        case OpCodes.CubeRoot: {
+        case OpCode.CubeRoot: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Power(arg, Expression.Constant(1.0 / 3.0));
           }
-        case OpCodes.Root: {
+        case OpCode.Root: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var power = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
             return Expression.Power(arg, Expression.Divide(Expression.Constant(1.0), Expression.Call(Round, power)));
           }
-        case OpCodes.Exp: {
+        case OpCode.Exp: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Exp, arg);
           }
-        case OpCodes.Log: {
+        case OpCode.Log: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             return Expression.Call(Log, arg);
           }
-        case OpCodes.Gamma: {
+        case OpCode.Gamma: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -278 +278 @@
             return expr;
           }
-        case OpCodes.Psi: {
+        case OpCode.Psi: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -300 +300 @@
             return expr;
           }
-        case OpCodes.Dawson: {
+        case OpCode.Dawson: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -314 +314 @@
             return expr;
           }
-        case OpCodes.ExponentialIntegralEi: {
+        case OpCode.ExponentialIntegralEi: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -328 +328 @@
             return expr;
           }
-        case OpCodes.SineIntegral: {
+        case OpCode.SineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -348 +348 @@
             return expr;
           }
-        case OpCodes.CosineIntegral: {
+        case OpCode.CosineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -368 +368 @@
             return expr;
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCode.HyperbolicSineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -388 +388 @@
             return expr;
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCode.HyperbolicCosineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -408 +408 @@
             return expr;
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCode.FresnelSineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -424 +424 @@
             return expr;
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCode.FresnelCosineIntegral: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -440 +440 @@
             return expr;
           }
-        case OpCodes.AiryA: {
+        case OpCode.AiryA: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -458 +458 @@
             return expr;
           }
-        case OpCodes.AiryB: {
+        case OpCode.AiryB: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -476 +476 @@
             return expr;
           }
-        case OpCodes.Norm: {
+        case OpCode.Norm: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var result = Expression.Variable(typeof(double));
@@ -487 +487 @@
               result);
           }
-        case OpCodes.Erf: {
+        case OpCode.Erf: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -499 +499 @@
               result);
           }
-        case OpCodes.Bessel: {
+        case OpCode.Bessel: {
             var arg = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var isNaN = Expression.Call(IsNaN, arg);
@@ -511 +511 @@
               result);
           }
-        case OpCodes.AnalyticQuotient: {
+        case OpCode.AnalyticQuotient: {
             var x1 = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var x2 = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
@@ -520 +520 @@
                 Expression.Multiply(x2, x2))));
           }
-        case OpCodes.IfThenElse: {
+        case OpCode.IfThenElse: {
             var test = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var result = Expression.Variable(typeof(double));
@@ -528 +528 @@
             return Expression.Block(new[] { result }, condition, result);
           }
-        case OpCodes.AND: {
+        case OpCode.AND: {
             var result = Expression.Variable(typeof(double));
             var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
@@ -553 +553 @@
               );
           }
-        case OpCodes.OR: {
+        case OpCode.OR: {
             var result = Expression.Variable(typeof(double));
             var expr = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
@@ -578 +578 @@
               );
           }
-        case OpCodes.NOT: {
+        case OpCode.NOT: {
             var value = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var result = Expression.Variable(typeof(double));
@@ -586 +586 @@
             return Expression.Block(new[] { result }, condition, result);
           }
-        case OpCodes.XOR: {
+        case OpCode.XOR: {
             var ps = Expression.Variable(typeof(int));
             var block = Expression.Block(
@@ -617 +617 @@
             return xorExpr;
           }
-        case OpCodes.GT: {
+        case OpCode.GT: {
             var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
@@ -629 +629 @@
               result);
           }
-        case OpCodes.LT: {
+        case OpCode.LT: {
             var left = MakeExpr(node.GetSubtree(0), variableIndices, row, columns);
             var right = MakeExpr(node.GetSubtree(1), variableIndices, row, columns);
@@ -638 +638 @@
             return Expression.Block(new[] { result }, condition, result);
           }
-        case OpCodes.VariableCondition: {
+        case OpCode.VariableCondition: {
             var variableConditionTreeNode = (VariableConditionTreeNode)node;
             if (variableConditionTreeNode.Symbol.IgnoreSlope) throw new NotSupportedException("Strict variable conditionals are not supported");

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs

@@ -64 +64 @@
 
         switch (instr.opcode) {
-          case OpCodes.Variable: {
+          case OpCode.Variable: {
               LoadData(instr, rows, rowIndex, batchSize);
               break;
             }
-          case OpCodes.TreeModel: {
+          case OpCode.TreeModel: {
               SubTreeEvoluate(instr, rows, rowIndex, batchSize);
               break;
             }
 
-          case OpCodes.Add: {
+          case OpCode.Add: {
               Load(instr.buf, code[c].buf);
               for (int j = 1; j < n; ++j) {
@@ -81 +81 @@
             }
 
-          case OpCodes.Sub: {
+          case OpCode.Sub: {
               if (n == 1) {
                 Neg(instr.buf, code[c].buf);
@@ -93 +93 @@
             }
 
-          case OpCodes.Mul: {
+          case OpCode.Mul: {
               Load(instr.buf, code[c].buf);
               for (int j = 1; j < n; ++j) {
@@ -101 +101 @@
             }
 
-          case OpCodes.Div: {
+          case OpCode.Div: {
               if (n == 1) {
                 Inv(instr.buf, code[c].buf);
@@ -113 +113 @@
             }
 
-          case OpCodes.Square: {
+          case OpCode.Square: {
               Square(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Root: {
+          case OpCode.Root: {
               Load(instr.buf, code[c].buf);
               Root(instr.buf, code[c + 1].buf);
@@ -124 +124 @@
             }
 
-          case OpCodes.SquareRoot: {
+          case OpCode.SquareRoot: {
               Sqrt(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Cube: {
+          case OpCode.Cube: {
               Cube(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.CubeRoot: {
+          case OpCode.CubeRoot: {
               CubeRoot(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Power: {
+          case OpCode.Power: {
               Load(instr.buf, code[c].buf);
               Pow(instr.buf, code[c + 1].buf);
@@ -144 +144 @@
             }
 
-          case OpCodes.Exp: {
+          case OpCode.Exp: {
               Exp(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Log: {
+          case OpCode.Log: {
               Log(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Sin: {
+          case OpCode.Sin: {
               Sin(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Cos: {
+          case OpCode.Cos: {
               Cos(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.Tan: {
+          case OpCode.Tan: {
               Tan(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.Tanh: {
+          case OpCode.Tanh: {
               Tanh(instr.buf, code[c].buf);
               break;
             }
-          case OpCodes.Absolute: {
+          case OpCode.Absolute: {
               Absolute(instr.buf, code[c].buf);
               break;
             }
 
-          case OpCodes.AnalyticQuotient: {
+          case OpCode.AnalyticQuotient: {
               Load(instr.buf, code[c].buf);
               AnalyticQuotient(instr.buf, code[c + 1].buf);
@@ -213 +213 @@
       }
 
-      var code = Compile(tree, dataset, OpCodes.MapSymbolToOpCode, rows);
+      var code = Compile(tree, dataset, OpCode.MapSymbolToOpCode, rows);
       var remainingRows = rows.Length % BATCHSIZE;
       var roundedTotal = rows.Length - remainingRows;

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeILEmittingInterpreter.cs

@@ -180 +180 @@
 
     private InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset) {
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
       Dictionary<string, int> doubleVariableNames = dataset.DoubleVariables.Select((x, i) => new { x, i }).ToDictionary(e => e.x, e => e.i);
       int necessaryArgStackSize = 0;
       foreach (Instruction instr in code) {
-        if (instr.opCode == OpCodes.Variable) {
+        if (instr.opCode == OpCode.Variable) {
           var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
           instr.data = doubleVariableNames[variableTreeNode.VariableName];
-        } else if (instr.opCode == OpCodes.LagVariable) {
+        } else if (instr.opCode == OpCode.LagVariable) {
           var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
           instr.data = doubleVariableNames[laggedVariableTreeNode.VariableName];
-        } else if (instr.opCode == OpCodes.VariableCondition) {
+        } else if (instr.opCode == OpCode.VariableCondition) {
           var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
           instr.data = doubleVariableNames[variableConditionTreeNode.VariableName];
-        } else if (instr.opCode == OpCodes.Call) {
+        } else if (instr.opCode == OpCode.Call) {
           necessaryArgStackSize += instr.nArguments + 1;
         }
@@ -205 +205 @@
 
       switch (currentInstr.opCode) {
-        case OpCodes.Add: {
+        case OpCode.Add: {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -215 +215 @@
             return;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             if (nArgs == 1) {
               CompileInstructions(il, state, ds);
@@ -230 +230 @@
             return;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             if (nArgs > 0) {
               CompileInstructions(il, state, ds);
@@ -240 +240 @@
             return;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             if (nArgs == 1) {
               il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0);
@@ -256 +256 @@
             return;
           }
-        case OpCodes.Average: {
+        case OpCode.Average: {
             CompileInstructions(il, state, ds);
             for (int i = 1; i < nArgs; i++) {
@@ -266 +266 @@
             return;
           }
-        case OpCodes.Absolute: {
+        case OpCode.Absolute: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, abs);
             return;
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, cos);
             return;
           }
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sin);
             return;
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, tan);
             return;
           }
-        case OpCodes.Tanh: {
+        case OpCode.Tanh: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, tanh);
             return;
           }
-        case OpCodes.Power: {
+        case OpCode.Power: {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -298 +298 @@
             return;
           }
-        case OpCodes.Root: {
+        case OpCode.Root: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0); // 1 / round(...)
@@ -307 +307 @@
             return;
           }
-        case OpCodes.Exp: {
+        case OpCode.Exp: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, exp);
             return;
           }
-        case OpCodes.Log: {
+        case OpCode.Log: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, log);
             return;
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 2.0);
@@ -323 +323 @@
             return;
           }
-        case OpCodes.Cube: {
+        case OpCode.Cube: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 3.0);
@@ -329 +329 @@
             return;
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sqrt);
             return;
           }
-        case OpCodes.CubeRoot: {
+        case OpCode.CubeRoot: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 1.0 / 3.0);
@@ -340 +340 @@
             return;
           }
-        case OpCodes.AiryA: {
+        case OpCode.AiryA: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, airyA);
             return;
           }
-        case OpCodes.AiryB: {
+        case OpCode.AiryB: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, airyB);
             return;
           }
-        case OpCodes.Bessel: {
+        case OpCode.Bessel: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, bessel);
             return;
           }
-        case OpCodes.CosineIntegral: {
+        case OpCode.CosineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, cosIntegral);
             return;
           }
-        case OpCodes.Dawson: {
+        case OpCode.Dawson: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, dawson);
             return;
           }
-        case OpCodes.Erf: {
+        case OpCode.Erf: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, erf);
             return;
           }
-        case OpCodes.ExponentialIntegralEi: {
+        case OpCode.ExponentialIntegralEi: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, expIntegralEi);
             return;
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCode.FresnelCosineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelCosIntegral);
             return;
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCode.FresnelSineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, fresnelSinIntegral);
             return;
           }
-        case OpCodes.Gamma: {
+        case OpCode.Gamma: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, gamma);
             return;
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCode.HyperbolicCosineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, hypCosIntegral);
             return;
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCode.HyperbolicSineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, hypSinIntegral);
             return;
           }
-        case OpCodes.Norm: {
+        case OpCode.Norm: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, norm);
             return;
           }
-        case OpCodes.Psi: {
+        case OpCode.Psi: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, psi);
             return;
           }
-        case OpCodes.SineIntegral: {
+        case OpCode.SineIntegral: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Call, sinIntegral);
             return;
           }
-        case OpCodes.AnalyticQuotient: {
+        case OpCode.AnalyticQuotient: {
             CompileInstructions(il, state, ds); // x1
             CompileInstructions(il, state, ds); // x2
@@ -427 +427 @@
             return;
           }
-        case OpCodes.IfThenElse: {
+        case OpCode.IfThenElse: {
             Label end = il.DefineLabel();
             Label c1 = il.DefineLabel();
@@ -441 +441 @@
             return;
           }
-        case OpCodes.AND: {
+        case OpCode.AND: {
             Label falseBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -462 +462 @@
             return;
           }
-        case OpCodes.OR: {
+        case OpCode.OR: {
             Label trueBranch = il.DefineLabel();
             Label end = il.DefineLabel();
@@ -490 +490 @@
             return;
           }
-        case OpCodes.NOT: {
+        case OpCode.NOT: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0); // > 0
@@ -502 +502 @@
             return;
           }
-        case OpCodes.XOR: {
+        case OpCode.XOR: {
             CompileInstructions(il, state, ds);
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, 0.0);
@@ -521 +521 @@
             return;
           }
-        case OpCodes.GT: {
+        case OpCode.GT: {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -533 +533 @@
             return;
           }
-        case OpCodes.LT: {
+        case OpCode.LT: {
             CompileInstructions(il, state, ds);
             CompileInstructions(il, state, ds);
@@ -544 +544 @@
             return;
           }
-        case OpCodes.TimeLag: {
+        case OpCode.TimeLag: {
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_0); // row -= lag
@@ -560 +560 @@
             return;
           }
-        case OpCodes.Integral: {
+        case OpCode.Integral: {
             int savedPc = state.ProgramCounter;
             LaggedTreeNode laggedTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -587 +587 @@
         //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 OpCode.Derivative: {
             int savedPc = state.ProgramCounter;
             CompileInstructions(il, state, ds);
@@ -629 +629 @@
             return;
           }
-        case OpCodes.Call: {
+        case OpCode.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 OpCode.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 OpCode.Variable: {
             VariableTreeNode varNode = (VariableTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldarg_1); // load columns array
@@ -669 +669 @@
             return;
           }
-        case OpCodes.LagVariable: {
+        case OpCode.LagVariable: {
             var nanResult = il.DefineLabel();
             var normalResult = il.DefineLabel();
@@ -697 +697 @@
             return;
           }
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             ConstantTreeNode constNode = (ConstantTreeNode)currentInstr.dynamicNode;
             il.Emit(System.Reflection.Emit.OpCodes.Ldc_R8, constNode.Value);
@@ -705 +705 @@
         //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 OpCode.VariableCondition: {
             throw new NotSupportedException("Interpretation of symbol " + currentInstr.dynamicNode.Symbol.Name +
                                             " is not supported by the SymbolicDataAnalysisTreeILEmittingInterpreter");

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeInterpreter.cs

@@ -137 +137 @@
 
     private static InterpreterState PrepareInterpreterState(ISymbolicExpressionTree tree, IDataset dataset) {
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
       int necessaryArgStackSize = 0;
       foreach (Instruction instr in code) {
-        if (instr.opCode == OpCodes.Variable) {
+        if (instr.opCode == OpCode.Variable) {
           var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
           instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.FactorVariable) {
+        } else if (instr.opCode == OpCode.FactorVariable) {
           var factorTreeNode = instr.dynamicNode as FactorVariableTreeNode;
           instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
+        } else if (instr.opCode == OpCode.BinaryFactorVariable) {
           var factorTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
           instr.data = dataset.GetReadOnlyStringValues(factorTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.LagVariable) {
+        } else if (instr.opCode == OpCode.LagVariable) {
           var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
           instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.VariableCondition) {
+        } else if (instr.opCode == OpCode.VariableCondition) {
           var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
           instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
-        } else if (instr.opCode == OpCodes.Call) {
+        } else if (instr.opCode == OpCode.Call) {
           necessaryArgStackSize += instr.nArguments + 1;
         }
@@ -165 +165 @@
       Instruction currentInstr = state.NextInstruction();
       switch (currentInstr.opCode) {
-        case OpCodes.Add: {
+        case OpCode.Add: {
             double s = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -172 +172 @@
             return s;
           }
-        case OpCodes.Sub: {
+        case OpCode.Sub: {
             double s = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -180 +180 @@
             return s;
           }
-        case OpCodes.Mul: {
+        case OpCode.Mul: {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -187 +187 @@
             return p;
           }
-        case OpCodes.Div: {
+        case OpCode.Div: {
             double p = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -195 +195 @@
             return p;
           }
-        case OpCodes.Average: {
+        case OpCode.Average: {
             double sum = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -202 +202 @@
             return sum / currentInstr.nArguments;
           }
-        case OpCodes.Absolute: {
+        case OpCode.Absolute: {
             return Math.Abs(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Tanh: {
+        case OpCode.Tanh: {
             return Math.Tanh(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Cos: {
+        case OpCode.Cos: {
             return Math.Cos(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Sin: {
+        case OpCode.Sin: {
             return Math.Sin(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Tan: {
+        case OpCode.Tan: {
             return Math.Tan(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             return Math.Pow(Evaluate(dataset, ref row, state), 2);
           }
-        case OpCodes.Cube: {
+        case OpCode.Cube: {
             return Math.Pow(Evaluate(dataset, ref row, state), 3);
           }
-        case OpCodes.Power: {
+        case OpCode.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 OpCode.SquareRoot: {
             return Math.Sqrt(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.CubeRoot: {
+        case OpCode.CubeRoot: {
             return Math.Pow(Evaluate(dataset, ref row, state), 1.0 / 3.0);
           }
-        case OpCodes.Root: {
+        case OpCode.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 OpCode.Exp: {
             return Math.Exp(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Log: {
+        case OpCode.Log: {
             return Math.Log(Evaluate(dataset, ref row, state));
           }
-        case OpCodes.Gamma: {
+        case OpCode.Gamma: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) { return double.NaN; } else { return alglib.gammafunction(x); }
           }
-        case OpCodes.Psi: {
+        case OpCode.Psi: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
@@ -255 +255 @@
             return alglib.psi(x);
           }
-        case OpCodes.Dawson: {
+        case OpCode.Dawson: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) { return double.NaN; }
             return alglib.dawsonintegral(x);
           }
-        case OpCodes.ExponentialIntegralEi: {
+        case OpCode.ExponentialIntegralEi: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) { return double.NaN; }
             return alglib.exponentialintegralei(x);
           }
-        case OpCodes.SineIntegral: {
+        case OpCode.SineIntegral: {
             double si, ci;
             var x = Evaluate(dataset, ref row, state);
@@ -274 +274 @@
             }
           }
-        case OpCodes.CosineIntegral: {
+        case OpCode.CosineIntegral: {
             double si, ci;
             var x = Evaluate(dataset, ref row, state);
@@ -283 +283 @@
             }
           }
-        case OpCodes.HyperbolicSineIntegral: {
+        case OpCode.HyperbolicSineIntegral: {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -292 +292 @@
             }
           }
-        case OpCodes.HyperbolicCosineIntegral: {
+        case OpCode.HyperbolicCosineIntegral: {
             double shi, chi;
             var x = Evaluate(dataset, ref row, state);
@@ -301 +301 @@
             }
           }
-        case OpCodes.FresnelCosineIntegral: {
+        case OpCode.FresnelCosineIntegral: {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -310 +310 @@
             }
           }
-        case OpCodes.FresnelSineIntegral: {
+        case OpCode.FresnelSineIntegral: {
             double c = 0, s = 0;
             var x = Evaluate(dataset, ref row, state);
@@ -319 +319 @@
             }
           }
-        case OpCodes.AiryA: {
+        case OpCode.AiryA: {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -328 +328 @@
             }
           }
-        case OpCodes.AiryB: {
+        case OpCode.AiryB: {
             double ai, aip, bi, bip;
             var x = Evaluate(dataset, ref row, state);
@@ -337 +337 @@
             }
           }
-        case OpCodes.Norm: {
+        case OpCode.Norm: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.normaldistribution(x);
           }
-        case OpCodes.Erf: {
+        case OpCode.Erf: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
             else return alglib.errorfunction(x);
           }
-        case OpCodes.Bessel: {
+        case OpCode.Bessel: {
             var x = Evaluate(dataset, ref row, state);
             if (double.IsNaN(x)) return double.NaN;
@@ -353 +353 @@
           }
 
-        case OpCodes.AnalyticQuotient: {
+        case OpCode.AnalyticQuotient: {
             var x1 = Evaluate(dataset, ref row, state);
             var x2 = Evaluate(dataset, ref row, state);
             return x1 / Math.Pow(1 + x2 * x2, 0.5);
           }
-        case OpCodes.IfThenElse: {
+        case OpCode.IfThenElse: {
             double condition = Evaluate(dataset, ref row, state);
             double result;
@@ -368 +368 @@
             return result;
           }
-        case OpCodes.AND: {
+        case OpCode.AND: {
             double result = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -378 +378 @@
             return result > 0.0 ? 1.0 : -1.0;
           }
-        case OpCodes.OR: {
+        case OpCode.OR: {
             double result = Evaluate(dataset, ref row, state);
             for (int i = 1; i < currentInstr.nArguments; i++) {
@@ -388 +388 @@
             return result > 0.0 ? 1.0 : -1.0;
           }
-        case OpCodes.NOT: {
+        case OpCode.NOT: {
             return Evaluate(dataset, ref row, state) > 0.0 ? -1.0 : 1.0;
           }
-        case OpCodes.XOR: {
+        case OpCode.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.
@@ -400 +400 @@
             return positiveSignals % 2 != 0 ? 1.0 : -1.0;
           }
-        case OpCodes.GT: {
+        case OpCode.GT: {
             double x = Evaluate(dataset, ref row, state);
             double y = Evaluate(dataset, ref row, state);
             if (x > y) { return 1.0; } else { return -1.0; }
           }
-        case OpCodes.LT: {
+        case OpCode.LT: {
             double x = Evaluate(dataset, ref row, state);
             double y = Evaluate(dataset, ref row, state);
             if (x < y) { return 1.0; } else { return -1.0; }
           }
-        case OpCodes.TimeLag: {
+        case OpCode.TimeLag: {
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
             row += timeLagTreeNode.Lag;
@@ -417 +417 @@
             return result;
           }
-        case OpCodes.Integral: {
+        case OpCode.Integral: {
             int savedPc = state.ProgramCounter;
             var timeLagTreeNode = (LaggedTreeNode)currentInstr.dynamicNode;
@@ -435 +435 @@
         //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 OpCode.Derivative: {
             int savedPc = state.ProgramCounter;
             double f_0 = Evaluate(dataset, ref row, state); row--;
@@ -448 +448 @@
             return (f_0 + 2 * f_1 - 2 * f_3 - f_4) / 8; // h = 1
           }
-        case OpCodes.Call: {
+        case OpCode.Call: {
             // evaluate sub-trees
             double[] argValues = new double[currentInstr.nArguments];
@@ -471 +471 @@
             return v;
           }
-        case OpCodes.Arg: {
+        case OpCode.Arg: {
             return state.GetStackFrameValue((ushort)currentInstr.data);
           }
-        case OpCodes.Variable: {
+        case OpCode.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.BinaryFactorVariable: {
+        case OpCode.BinaryFactorVariable: {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as BinaryFactorVariableTreeNode;
             return ((IList<string>)currentInstr.data)[row] == factorVarTreeNode.VariableValue ? factorVarTreeNode.Weight : 0;
           }
-        case OpCodes.FactorVariable: {
+        case OpCode.FactorVariable: {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var factorVarTreeNode = currentInstr.dynamicNode as FactorVariableTreeNode;
             return factorVarTreeNode.GetValue(((IList<string>)currentInstr.data)[row]);
           }
-        case OpCodes.LagVariable: {
+        case OpCode.LagVariable: {
             var laggedVariableTreeNode = (LaggedVariableTreeNode)currentInstr.dynamicNode;
             int actualRow = row + laggedVariableTreeNode.Lag;
@@ -495 +495 @@
             return ((IList<double>)currentInstr.data)[actualRow] * laggedVariableTreeNode.Weight;
           }
-        case OpCodes.Constant: {
+        case OpCode.Constant: {
             var constTreeNode = (ConstantTreeNode)currentInstr.dynamicNode;
             return constTreeNode.Value;
@@ -502 +502 @@
         //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 OpCode.VariableCondition: {
             if (row < 0 || row >= dataset.Rows) return double.NaN;
             var variableConditionTreeNode = (VariableConditionTreeNode)currentInstr.dynamicNode;

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeLinearInterpreter.cs

@@ -133 +133 @@
       }
 
-      var code = SymbolicExpressionTreeLinearCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      var code = SymbolicExpressionTreeLinearCompiler.Compile(tree, OpCode.MapSymbolToOpCode);
       PrepareInstructions(code, dataset);
       return rows.Select(row => Evaluate(dataset, row, code));
@@ -143 +143 @@
         #region opcode if
         var instr = code[i];
-        if (instr.opCode == OpCodes.Variable) {
+        if (instr.opCode == OpCode.Variable) {
           if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
           else {
@@ -149 +149 @@
             instr.value = ((IList<double>)instr.data)[row] * variableTreeNode.Weight;
           }
-        } else if (instr.opCode == OpCodes.BinaryFactorVariable) {
+        } else if (instr.opCode == OpCode.BinaryFactorVariable) {
           if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
           else {
@@ -155 +155 @@
             instr.value = ((IList<string>)instr.data)[row] == factorTreeNode.VariableValue ? factorTreeNode.Weight : 0;
           }
-        } else if (instr.opCode == OpCodes.FactorVariable) {
+        } else if (instr.opCode == OpCode.FactorVariable) {
           if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
           else {
@@ -161 +161 @@
             instr.value = factorTreeNode.GetValue(((IList<string>)instr.data)[row]);
           }
-        } else if (instr.opCode == OpCodes.LagVariable) {
+        } else if (instr.opCode == OpCode.LagVariable) {
           var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
           int actualRow = row + laggedVariableTreeNode.Lag;
@@ -168 +168 @@
           else
             instr.value = ((IList<double>)instr.data)[actualRow] * laggedVariableTreeNode.Weight;
-        } else if (instr.opCode == OpCodes.VariableCondition) {
+        } else if (instr.opCode == OpCode.VariableCondition) {
           if (row < 0 || row >= dataset.Rows) instr.value = double.NaN;
           var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
@@ -188 +188 @@
             }
           }
-        } else if (instr.opCode == OpCodes.Add) {
+        } else if (instr.opCode == OpCode.Add) {
           double s = code[instr.childIndex].value;
           for (int j = 1; j != instr.nArguments; ++j) {
@@ -194 +194 @@
           }
           instr.value = s;
-        } else if (instr.opCode == OpCodes.Sub) {
+        } else if (instr.opCode == OpCode.Sub) {
           double s = code[instr.childIndex].value;
           for (int j = 1; j != instr.nArguments; ++j) {
@@ -201 +201 @@
           if (instr.nArguments == 1) s = -s;
           instr.value = s;
-        } else if (instr.opCode == OpCodes.Mul) {
+        } else if (instr.opCode == OpCode.Mul) {
           double p = code[instr.childIndex].value;
           for (int j = 1; j != instr.nArguments; ++j) {
@@ -207 +207 @@
           }
           instr.value = p;
-        } else if (instr.opCode == OpCodes.Div) {
+        } else if (instr.opCode == OpCode.Div) {
           double p = code[instr.childIndex].value;
           for (int j = 1; j != instr.nArguments; ++j) {
@@ -214 +214 @@
           if (instr.nArguments == 1) p = 1.0 / p;
           instr.value = p;
-        } else if (instr.opCode == OpCodes.AnalyticQuotient) {
+        } else if (instr.opCode == OpCode.AnalyticQuotient) {
           var x1 = code[instr.childIndex].value;
           var x2 = code[instr.childIndex + 1].value;
           instr.value = x1 / Math.Sqrt(1 + x2 * x2);
-        } else if (instr.opCode == OpCodes.Average) {
+        } else if (instr.opCode == OpCode.Average) {
           double s = code[instr.childIndex].value;
           for (int j = 1; j != instr.nArguments; ++j) {
@@ -224 +224 @@
           }
           instr.value = s / instr.nArguments;
-        } else if (instr.opCode == OpCodes.Absolute) {
+        } else if (instr.opCode == OpCode.Absolute) {
           instr.value = Math.Abs(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Tanh) {
+        } else if (instr.opCode == OpCode.Tanh) {
           instr.value = Math.Tanh(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Cos) {
+        } else if (instr.opCode == OpCode.Cos) {
           instr.value = Math.Cos(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Sin) {
+        } else if (instr.opCode == OpCode.Sin) {
           instr.value = Math.Sin(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Tan) {
+        } else if (instr.opCode == OpCode.Tan) {
           instr.value = Math.Tan(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Square) {
+        } else if (instr.opCode == OpCode.Square) {
           instr.value = Math.Pow(code[instr.childIndex].value, 2);
-        } else if (instr.opCode == OpCodes.Cube) {
+        } else if (instr.opCode == OpCode.Cube) {
           instr.value = Math.Pow(code[instr.childIndex].value, 3);
-        } else if (instr.opCode == OpCodes.Power) {
+        } else if (instr.opCode == OpCode.Power) {
           double x = code[instr.childIndex].value;
           double y = Math.Round(code[instr.childIndex + 1].value);
           instr.value = Math.Pow(x, y);
-        } else if (instr.opCode == OpCodes.SquareRoot) {
+        } else if (instr.opCode == OpCode.SquareRoot) {
           instr.value = Math.Sqrt(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.CubeRoot) {
+        } else if (instr.opCode == OpCode.CubeRoot) {
           instr.value = Math.Pow(code[instr.childIndex].value, 1.0 / 3.0);
-        } else if (instr.opCode == OpCodes.Root) {
+        } else if (instr.opCode == OpCode.Root) {
           double x = code[instr.childIndex].value;
           double y = Math.Round(code[instr.childIndex + 1].value);
           instr.value = Math.Pow(x, 1 / y);
-        } else if (instr.opCode == OpCodes.Exp) {
+        } else if (instr.opCode == OpCode.Exp) {
           instr.value = Math.Exp(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Log) {
+        } else if (instr.opCode == OpCode.Log) {
           instr.value = Math.Log(code[instr.childIndex].value);
-        } else if (instr.opCode == OpCodes.Gamma) {
+        } else if (instr.opCode == OpCode.Gamma) {
           var x = code[instr.childIndex].value;
           instr.value = double.IsNaN(x) ? double.NaN : alglib.gammafunction(x);
-        } else if (instr.opCode == OpCodes.Psi) {
+        } else if (instr.opCode == OpCode.Psi) {
           var x = code[instr.childIndex].value;
           if (double.IsNaN(x)) instr.value = double.NaN;
           else if (x <= 0 && (Math.Floor(x) - x).IsAlmost(0)) instr.value = double.NaN;
           else instr.value = alglib.psi(x);
-        } else if (instr.opCode == OpCodes.Dawson) {
+        } else if (instr.opCode == OpCode.Dawson) {
           var x = code[instr.childIndex].value;
           instr.value = double.IsNaN(x) ? double.NaN : alglib.dawsonintegral(x);
-        } else if (instr.opCode == OpCodes.ExponentialIntegralEi) {
+        } else if (instr.opCode == OpCode.ExponentialIntegralEi) {
           var x = code[instr.childIndex].value;
           instr.value = double.IsNaN(x) ? double.NaN : alglib.exponentialintegralei(x);
-        } else if (instr.opCode == OpCodes.SineIntegral) {
+        } else if (instr.opCode == OpCode.SineIntegral) {
           double si, ci;
           var x = code[instr.childIndex].value;
@@ -276 +276 @@
             instr.value = si;
           }
-        } else if (instr.opCode == OpCodes.CosineIntegral) {
+        } else if (instr.opCode == OpCode.CosineIntegral) {
           double si, ci;
           var x = code[instr.childIndex].value;
@@ -284 +284 @@
             instr.value = ci;
           }
-        } else if (instr.opCode == OpCodes.HyperbolicSineIntegral) {
+        } else if (instr.opCode == OpCode.HyperbolicSineIntegral) {
           double shi, chi;
           var x = code[instr.childIndex].value;
@@ -292 +292 @@
             instr.value = shi;
           }
-        } else if (instr.opCode == OpCodes.HyperbolicCosineIntegral) {
+        } else if (instr.opCode == OpCode.HyperbolicCosineIntegral) {
           double shi, chi;
           var x = code[instr.childIndex].value;
@@ -300 +300 @@
             instr.value = chi;
           }
-        } else if (instr.opCode == OpCodes.FresnelCosineIntegral) {
+        } else if (instr.opCode == OpCode.FresnelCosineIntegral) {
           double c = 0, s = 0;
           var x = code[instr.childIndex].value;
@@ -308 +308 @@
             instr.value = c;
           }
-        } else if (instr.opCode == OpCodes.FresnelSineIntegral) {
+        } else if (instr.opCode == OpCode.FresnelSineIntegral) {
           double c = 0, s = 0;
           var x = code[instr.childIndex].value;
@@ -316 +316 @@
             instr.value = s;
           }
-        } else if (instr.opCode == OpCodes.AiryA) {
+        } else if (instr.opCode == OpCode.AiryA) {
           double ai, aip, bi, bip;
           var x = code[instr.childIndex].value;
@@ -324 +324 @@
             instr.value = ai;
           }
-        } else if (instr.opCode == OpCodes.AiryB) {
+        } else if (instr.opCode == OpCode.AiryB) {
           double ai, aip, bi, bip;
           var x = code[instr.childIndex].value;
@@ -332 +332 @@
             instr.value = bi;
           }
-        } else if (instr.opCode == OpCodes.Norm) {
+        } else if (instr.opCode == OpCode.Norm) {
           var x = code[instr.childIndex].value;
           if (double.IsNaN(x)) instr.value = double.NaN;
           else instr.value = alglib.normaldistribution(x);
-        } else if (instr.opCode == OpCodes.Erf) {
+        } else if (instr.opCode == OpCode.Erf) {
           var x = code[instr.childIndex].value;
           if (double.IsNaN(x)) instr.value = double.NaN;
           else instr.value = alglib.errorfunction(x);
-        } else if (instr.opCode == OpCodes.Bessel) {
+        } else if (instr.opCode == OpCode.Bessel) {
           var x = code[instr.childIndex].value;
           if (double.IsNaN(x)) instr.value = double.NaN;
           else instr.value = alglib.besseli0(x);
-        } else if (instr.opCode == OpCodes.IfThenElse) {
+        } else if (instr.opCode == OpCode.IfThenElse) {
           double condition = code[instr.childIndex].value;
           double result;
@@ -353 +353 @@
           }
           instr.value = result;
-        } else if (instr.opCode == OpCodes.AND) {
+        } else if (instr.opCode == OpCode.AND) {
           double result = code[instr.childIndex].value;
           for (int j = 1; j < instr.nArguments; j++) {
@@ -360 +360 @@
           }
           instr.value = result > 0.0 ? 1.0 : -1.0;
-        } else if (instr.opCode == OpCodes.OR) {
+        } else if (instr.opCode == OpCode.OR) {
           double result = code[instr.childIndex].value;
           for (int j = 1; j < instr.nArguments; j++) {
@@ -367 +367 @@
           }
           instr.value = result > 0.0 ? 1.0 : -1.0;
-        } else if (instr.opCode == OpCodes.NOT) {
+        } else if (instr.opCode == OpCode.NOT) {
           instr.value = code[instr.childIndex].value > 0.0 ? -1.0 : 1.0;
-        } else if (instr.opCode == OpCodes.XOR) {
+        } else if (instr.opCode == OpCode.XOR) {
           int positiveSignals = 0;
           for (int j = 0; j < instr.nArguments; j++) {
@@ -375 +375 @@
           }
           instr.value = positiveSignals % 2 != 0 ? 1.0 : -1.0;
-        } else if (instr.opCode == OpCodes.GT) {
+        } else if (instr.opCode == OpCode.GT) {
           double x = code[instr.childIndex].value;
           double y = code[instr.childIndex + 1].value;
           instr.value = x > y ? 1.0 : -1.0;
-        } else if (instr.opCode == OpCodes.LT) {
+        } else if (instr.opCode == OpCode.LT) {
           double x = code[instr.childIndex].value;
           double y = code[instr.childIndex + 1].value;
           instr.value = x < y ? 1.0 : -1.0;
-        } else if (instr.opCode == OpCodes.TimeLag || instr.opCode == OpCodes.Derivative || instr.opCode == OpCodes.Integral) {
+        } else if (instr.opCode == OpCode.TimeLag || instr.opCode == OpCode.Derivative || instr.opCode == OpCode.Integral) {
           var state = (InterpreterState)instr.data;
           state.Reset();
@@ -415 +415 @@
         #region opcode switch
         switch (instr.opCode) {
-          case OpCodes.Constant: {
+          case OpCode.Constant: {
               var constTreeNode = (ConstantTreeNode)instr.dynamicNode;
               instr.value = constTreeNode.Value;
@@ -421 +421 @@
             }
             break;
-          case OpCodes.Variable: {
+          case OpCode.Variable: {
               var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(variableTreeNode.VariableName);
             }
             break;
-          case OpCodes.BinaryFactorVariable: {
+          case OpCode.BinaryFactorVariable: {
               var factorVariableTreeNode = instr.dynamicNode as BinaryFactorVariableTreeNode;
               instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
             }
             break;
-          case OpCodes.FactorVariable: {
+          case OpCode.FactorVariable: {
               var factorVariableTreeNode = instr.dynamicNode as FactorVariableTreeNode;
               instr.data = dataset.GetReadOnlyStringValues(factorVariableTreeNode.VariableName);
             }
             break;
-          case OpCodes.LagVariable: {
+          case OpCode.LagVariable: {
               var laggedVariableTreeNode = (LaggedVariableTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(laggedVariableTreeNode.VariableName);
             }
             break;
-          case OpCodes.VariableCondition: {
+          case OpCode.VariableCondition: {
               var variableConditionTreeNode = (VariableConditionTreeNode)instr.dynamicNode;
               instr.data = dataset.GetReadOnlyDoubleValues(variableConditionTreeNode.VariableName);
             }
             break;
-          case OpCodes.TimeLag:
-          case OpCodes.Integral:
-          case OpCodes.Derivative: {
+          case OpCode.TimeLag:
+          case OpCode.Integral:
+          case OpCode.Derivative: {
               var seq = GetPrefixSequence(code, i);
               var interpreterState = new InterpreterState(seq, 0);

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs

@@ -20 +20 @@
 #endregion
 
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using System.Runtime.InteropServices;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
@@ -29 +26 @@
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Runtime.InteropServices;
 
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
@@ -101 +101 @@
     private IDataset dataset;
 
+    private static readonly HashSet<byte> supportedOpCodes = new HashSet<byte>() {
+      (byte)OpCode.Constant,
+      (byte)OpCode.Variable,
+      (byte)OpCode.Add,
+      (byte)OpCode.Sub,
+      (byte)OpCode.Mul,
+      (byte)OpCode.Div,
+      (byte)OpCode.Exp,
+      (byte)OpCode.Log,
+      (byte)OpCode.Sin,
+      (byte)OpCode.Cos,
+      (byte)OpCode.Tan,
+      (byte)OpCode.Tanh,
+      (byte)OpCode.Power,
+      (byte)OpCode.Root,
+      (byte)OpCode.SquareRoot,
+      (byte)OpCode.Square,
+      (byte)OpCode.CubeRoot,
+      (byte)OpCode.Cube,
+      (byte)OpCode.Absolute,
+      (byte)OpCode.AnalyticQuotient
+    };
+
     public IEnumerable<double> GetSymbolicExpressionTreeValues(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows) {
       if (!rows.Any()) return Enumerable.Empty<double>();
@@ -108 +131 @@
       }
 
-      var code = Compile(tree, OpCodes.MapSymbolToOpCode);
+      byte mapSupportedSymbols(ISymbolicExpressionTreeNode node) {
+        var opCode = OpCode.MapSymbolToOpCode(node);
+        if (supportedOpCodes.Contains(opCode)) return opCode;
+        else throw new NotSupportedException($"The native interpreter does not support {node.Symbol.Name}");
+      };
+      var code = Compile(tree, mapSupportedSymbols);
 
       var rowsArray = rows.ToArray();

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Selectors/DiversitySelector.cs

@@ -100 +100 @@
     #region Events
     private void RegisterParameterEventHandlers() {
-      SelectorParameter.ValueChanged += new EventHandler(SelectorParameter_ValueChanged);
-      CopySelected.ValueChanged += new EventHandler(CopySelected_ValueChanged);
+      SelectorParameter.ValueChanged += SelectorParameter_ValueChanged;
+      CopySelectedParameter.ValueChanged += CopySelectedParameter_ValueChanged;
+      CopySelected.ValueChanged += CopySelected_ValueChanged;
+    }
+
+    private void CopySelectedParameter_ValueChanged(object sender, EventArgs e) {
+      if (CopySelected.Value != true) {
+        CopySelected.Value = true;
+      }
+      CopySelected.ValueChanged += CopySelected_ValueChanged;
     }
 

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/SymbolicDataAnalysisModelComplexityCalculator.cs

@@ -35 +35 @@
       if (node.Symbol is StartSymbol) node = node.GetSubtree(0);
 
-      switch (OpCodes.MapSymbolToOpCode(node)) {
-        case OpCodes.Constant: {
+      switch (OpCode.MapSymbolToOpCode(node)) {
+        case OpCode.Constant: {
             return 1;
           }
-        case OpCodes.Variable:
-        case OpCodes.BinaryFactorVariable:
-        case OpCodes.FactorVariable: {
+        case OpCode.Variable:
+        case OpCode.BinaryFactorVariable:
+        case OpCode.FactorVariable: {
             return 2;
           }
-        case OpCodes.Add:
-        case OpCodes.Sub: {
+        case OpCode.Add:
+        case OpCode.Sub: {
             double complexity = 0;
             for (int i = 0; i < node.SubtreeCount; i++) {
@@ -52 +52 @@
             return complexity;
           }
-        case OpCodes.Mul:
-        case OpCodes.Div: {
+        case OpCode.Mul:
+        case OpCode.Div: {
             double complexity = 1;
             for (int i = 0; i < node.SubtreeCount; i++) {
@@ -61 +61 @@
             return complexity;
           }
-        case OpCodes.Sin:
-        case OpCodes.Cos:
-        case OpCodes.Tan:
-        case OpCodes.Exp:
-        case OpCodes.Log: {
+        case OpCode.Sin:
+        case OpCode.Cos:
+        case OpCode.Tan:
+        case OpCode.Exp:
+        case OpCode.Log: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
             return Math.Pow(2.0, complexity);
           }
-        case OpCodes.Square: {
+        case OpCode.Square: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
             return complexity * complexity;
           }
-        case OpCodes.SquareRoot: {
+        case OpCode.SquareRoot: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
             return complexity * complexity * complexity;
           }
-        case OpCodes.Power:
-        case OpCodes.Root: {
+        case OpCode.Power:
+        case OpCode.Root: {
             double complexity = CalculateComplexity(node.GetSubtree(0));
             var exponent = node.GetSubtree(1) as ConstantTreeNode;

branches/2988_ModelsOfModels2/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Symbols/ModelTreeNode.cs

@@ -57 +57 @@
     private TreeModelTreeNode(TreeModelTreeNode original, Cloner cloner)
       : base(original, cloner) {
-      tree = original.tree;
+      tree = (ISymbolicExpressionTree)original.tree.Clone(cloner);
       ClusterNumer = original.ClusterNumer;
       TreeNumber = original.TreeNumber;