Changeset 3681

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Analyzers/MinAvgMaxSymbolicExpressionTreeSizeAnalyzer.cs

-                      r3665
+                      r3681
 using HeuristicLab.Analysis;
 using HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Interfaces;
+using System;
 namespace HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Analyzers {
   /// <summary>
   /// An operator that tracks the min avgerage and max tree size in the population.
+  /// An operator that tracks the min avgerage and max tree size.
   /// </summary>
   [Item("PopulationMinAvgMaxTreeSizeAnalyzer", "An operator that tracks the min avgerage and max tree size in the population.")]
+  [Item("MinAvgMaxSymbolicExpressionTreeSizeAnalyzer", "An operator that tracks the min avgerage and max tree size.")]
   [StorableClass]
   public sealed class PopulationMinAvgMaxTreeSizeAnalyzer : AlgorithmOperator, ISymbolicExpressionTreePopulationAnalyzer {
+  public sealed class MinAvgMaxSymbolicExpressionTreeSizeAnalyzer : AlgorithmOperator, ISymbolicExpressionTreeAnalyzer {
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string SymbolicExpressionTreeSizeParameterName = "SymbolicExpressionTreeSize";
 …
     private const string ResultsParameterName = "Results";
     #region parameter properties
     public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
     public ILookupParameter<ItemArray<DoubleValue>> SymbolicExpressionTreeSizeParameter {
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters[SymbolicExpressionTreeSizeParameterName]; }
+    public ScopeTreeLookupParameter<DoubleValue> SymbolicExpressionTreeSizeParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[SymbolicExpressionTreeSizeParameterName]; }
+    }
     public ValueLookupParameter<DataTable> SymbolicExpressionTreeSizesParameter {
 …
       get { return (ValueLookupParameter<VariableCollection>)Parameters[ResultsParameterName]; }
+    }
+    [Storable]
+    private MinAverageMaxValueAnalyzer valueAnalyzer;
     #endregion
     public PopulationMinAvgMaxTreeSizeAnalyzer()
+    public MinAvgMaxSymbolicExpressionTreeSizeAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree whose size should be calculated."));
 …
       UniformSubScopesProcessor subScopesProcessor = new UniformSubScopesProcessor();
       SymbolicExpressionTreeSizeCalculator sizeCalculator = new SymbolicExpressionTreeSizeCalculator();
       MinAverageMaxValueAnalyzer valuesAnalyzer = new MinAverageMaxValueAnalyzer();
+      valueAnalyzer = new MinAverageMaxValueAnalyzer();
       sizeCalculator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
       sizeCalculator.SymbolicExpressionTreeSizeParameter.ActualName = SymbolicExpressionTreeSizeParameter.Name;
+      valuesAnalyzer.ValueParameter.ActualName = sizeCalculator.SymbolicExpressionTreeSizeParameter.Name;
+      valuesAnalyzer.ValuesParameter.ActualName = SymbolicExpressionTreeSizesParameter.Name;
+      valuesAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      valuesAnalyzer.AverageValueParameter.ActualName = "Avg. Tree Size";
+      valuesAnalyzer.MaxValueParameter.ActualName = "Max Tree Size";
+      valuesAnalyzer.MinValueParameter.ActualName = "Min Tree Size";
+      valueAnalyzer.ValueParameter.ActualName = sizeCalculator.SymbolicExpressionTreeSizeParameter.Name;
+      valueAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeSizeParameter.Depth;
+      valueAnalyzer.ValuesParameter.ActualName = SymbolicExpressionTreeSizesParameter.Name;
+      valueAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      valueAnalyzer.AverageValueParameter.ActualName = "Avg. Tree Size";
+      valueAnalyzer.MaxValueParameter.ActualName = "Max Tree Size";
+      valueAnalyzer.MinValueParameter.ActualName = "Min Tree Size";
       OperatorGraph.InitialOperator = subScopesProcessor;
       subScopesProcessor.Operator = sizeCalculator;
+      subScopesProcessor.Successor = valuesAnalyzer;
+      valuesAnalyzer.Successor = null;
+      subScopesProcessor.Successor = valueAnalyzer;
+      valueAnalyzer.Successor = null;
+      Initialize();
+    }
+    [StorableConstructor]
+    private MinAvgMaxSymbolicExpressionTreeSizeAnalyzer(bool deserializing) : base() { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      SymbolicExpressionTreeParameter.DepthChanged += new EventHandler(SymbolicExpressionTreeParameter_DepthChanged);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      MinAvgMaxSymbolicExpressionTreeSizeAnalyzer clone = (MinAvgMaxSymbolicExpressionTreeSizeAnalyzer)base.Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+    private void SymbolicExpressionTreeParameter_DepthChanged(object sender, EventArgs e) {
+      valueAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+    }
+  }

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj

-                      r3651
+                      r3681
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="Analyzers\PopulationMinAvgMaxTreeSizeAnalyzer.cs" />
+    <Compile Include="Analyzers\SymbolicExpressionTreeSizeAnalyzer.cs" />
+    <Compile Include="Analyzers\MinAvgMaxSymbolicExpressionTreeSizeAnalyzer.cs" />
     <Compile Include="Analyzers\SymbolicExpressionTreeSizeCalculator.cs" />
     <Compile Include="ArchitectureManipulators\ArgumentCreater.cs" />
 …
     <Compile Include="Interfaces\ISymbolicExpressionTreeCreator.cs" />
     <Compile Include="Interfaces\ISymbolicExpressionTreeCrossover.cs" />
-    <Compile Include="Interfaces\ISymbolicExpressionTreeMultiPopulationAnalyzer.cs" />
-    <Compile Include="Interfaces\ISymbolicExpressionTreePopulationAnalyzer.cs" />
     <Compile Include="Manipulators\ChangeNodeTypeManipulation.cs" />
     <Compile Include="Interfaces\ISymbolicExpressionTreeManipulator.cs" />

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Interfaces/ISymbolicExpressionTreeAnalyzer.cs

r3658	r3681
35	35	/// </summary>
36	36	public interface ISymbolicExpressionTreeAnalyzer : IAnalyzer {
37		ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
	37	ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
38	38	}
39	39	}

trunk/sources/HeuristicLab.Problems.ArtificialAnt.Views/3.3/HeuristicLab.Problems.ArtificialAnt.Views-3.3.csproj

-                      r3437
+                      r3681
       <DependentUpon>AntTrailView.cs</DependentUpon>
     </Compile>
+    <Compile Include="AntTrailSymbolicExpressionTreeView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="AntTrailSymbolicExpressionTreeView.Designer.cs">
+      <DependentUpon>AntTrailSymbolicExpressionTreeView.cs</DependentUpon>
+    </Compile>
     <Compile Include="HeuristicLabProblemsArtificialAntViewsPlugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
 …
       <Project>{BBAB9DF5-5EF3-4BA8-ADE9-B36E82114937}</Project>
       <Name>HeuristicLab.Data-3.3</Name>
+    </ProjectReference>
+    <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views\3.3\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views-3.3.csproj">
+      <Project>{6F42C5F8-16CD-43EE-8208-FD4573A69D85}</Project>
+      <Name>HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views-3.3</Name>
     </ProjectReference>
     <ProjectReference Include="..\..\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding\3.3\HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj">
 …
     </ProjectReference>
   </ItemGroup>
+  <ItemGroup>
+    <EmbeddedResource Include="AntTrailSymbolicExpressionTreeView.resx">
+      <DependentUpon>AntTrailSymbolicExpressionTreeView.cs</DependentUpon>
+    </EmbeddedResource>
+  </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it.

trunk/sources/HeuristicLab.Problems.ArtificialAnt.Views/3.3/HeuristicLabProblemsArtificialAntViewsPlugin.cs.frame

r3437	r3681
33	33	[PluginDependency("HeuristicLab.Data", "3.3.0.0")]
34	34	[PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding","3.3.0.0")]
	35	[PluginDependency("HeuristicLab.Encodings.SymbolicExpressionTreeEncoding.Views","3.3.0.0")]
35	36	[PluginDependency("HeuristicLab.MainForm", "3.3.0.0")]
36	37	[PluginDependency("HeuristicLab.MainForm.WindowsForms", "3.3.0.0")]

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Analyzers/BestAntTrailAnalyzer.cs

-                      r3665
+                      r3681
 namespace HeuristicLab.Problems.ArtificialAnt.Analyzers {
   /// <summary>
   /// An operator for visualizing the best ant trail of an artificial ant problem.
+  /// An operator for analyzing the best ant trail of an artificial ant problem.
   /// </summary>
   [Item("PopulationBestAntTrailAnalyzer", "An operator for visualizing the best ant trail of an artificial ant problem.")]
+  [Item("BestAntTrailAnalyzer", "An operator for analyzing the best ant trail of an artificial ant problem.")]
   [StorableClass]
   public sealed class PopulationBestAntTrailAnalyzer : SingleSuccessorOperator, IAntTrailPopulationAnalyzer {
+  public sealed class BestAntTrailAnalyzer : SingleSuccessorOperator, IAntTrailAnalyzer {
     public ILookupParameter<BoolMatrix> WorldParameter {
       get { return (ILookupParameter<BoolMatrix>)Parameters["World"]; }
+    }
     public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters["SymbolicExpressionTree"]; }
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters["SymbolicExpressionTree"]; }
+    }
     public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters["Quality"]; }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters["Quality"]; }
+    }
     public ILookupParameter<IntValue> MaxTimeStepsParameter {
 …
+    }
     public PopulationBestAntTrailAnalyzer()
+    public BestAntTrailAnalyzer()
       : base() {
       Parameters.Add(new LookupParameter<BoolMatrix>("World", "The world with food items for the artificial ant."));

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Analyzers/IAntTrailAnalyzer.cs

-                      r3665
+                      r3681
 using HeuristicLab.Core;
 using HeuristicLab.Data;
+using HeuristicLab.Parameters;
 namespace HeuristicLab.Problems.ArtificialAnt.Analyzers {
   public interface IAntTrailPopulationAnalyzer : IAnalyzer {
     ILookupParameter<ItemArray<DoubleValue>> QualityParameter { get; }
     ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter { get; }
+  public interface IAntTrailAnalyzer : IAnalyzer {
+    ScopeTreeLookupParameter<DoubleValue> QualityParameter { get; }
+    ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
     ILookupParameter<BoolMatrix> WorldParameter { get; }
     ILookupParameter<IntValue> MaxTimeStepsParameter { get; }

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/ArtificialAntProblem.cs

-                      r3651
+                      r3681
+    }
     public IEnumerable<IAntTrailPopulationAnalyzer> AntTrailAnalyzers {
       get { return operators.OfType<IAntTrailPopulationAnalyzer>(); }
+    public IEnumerable<IAntTrailAnalyzer> AntTrailAnalyzers {
+      get { return operators.OfType<IAntTrailAnalyzer>(); }
+    }
     #endregion
 …
       operators = new List<IOperator>();
       operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>().OfType<IOperator>());
       operators.Add(new PopulationBestAntTrailAnalyzer());
       operators.Add(new PopulationMinAvgMaxTreeSizeAnalyzer());
+      operators.Add(new BestAntTrailAnalyzer());
+      operators.Add(new MinAvgMaxSymbolicExpressionTreeSizeAnalyzer());
       ParameterizeAnalyzers();
       ParameterizeOperators();
 …
+    }
     private void ParameterizeAnalyzers() {
       foreach (IAntTrailPopulationAnalyzer analyzer in AntTrailAnalyzers) {
+      foreach (IAntTrailAnalyzer analyzer in AntTrailAnalyzers) {
         analyzer.QualityParameter.ActualName = Evaluator.QualityParameter.ActualName;
         analyzer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
 …
         analyzer.MaxTimeStepsParameter.ActualName = MaxTimeStepsParameter.Name;
+      }
       foreach (ISymbolicExpressionTreePopulationAnalyzer analyzer in Operators.OfType<ISymbolicExpressionTreePopulationAnalyzer>()) {
+      foreach (ISymbolicExpressionTreeAnalyzer analyzer in Operators.OfType<ISymbolicExpressionTreeAnalyzer>()) {
         analyzer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/HeuristicLab.Problems.ArtificialAnt-3.3.csproj

-                      r3631
+                      r3681
   </ItemGroup>
   <ItemGroup>
     <Compile Include="Analyzers\IAntTrailPopulationAnalyzer.cs" />
     <Compile Include="Analyzers\PopulationBestAntTrailAnalyzer.cs" />
+    <Compile Include="Analyzers\BestAntTrailAnalyzer.cs" />
+    <Compile Include="Analyzers\IAntTrailAnalyzer.cs" />
     <Compile Include="AntInterpreter.cs" />
     <Compile Include="HeuristicLabProblemsArtificialAntPlugin.cs" />

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj

-                      r3666
+                      r3681
     <Compile Include="HeuristicLabProblemsDataAnalysisRegressionPlugin.cs" />
     <Compile Include="Properties\AssemblyInfo.cs" />
+    <Compile Include="Symbolic\Analyzers\BestSymbolicRegressionSolutionAnalyzer.cs" />
+    <Compile Include="Symbolic\Analyzers\ISymbolicRegressionAnalyzer.cs" />
+    <Compile Include="Symbolic\Analyzers\SymbolicRegressionModelQualityAnalyzer.cs" />
     <Compile Include="Symbolic\Analyzers\SymbolicRegressionModelQualityCalculator.cs" />
-    <Compile Include="Symbolic\Analyzers\PopulationSymbolicRegressionModelQualityAnalyzer.cs" />
-    <Compile Include="Symbolic\Analyzers\PopulationSymbolicRegressionVariableFrequencyAnalyzer.cs" />
-    <Compile Include="Symbolic\Analyzers\PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs" />
     <Compile Include="Symbolic\Analyzers\SymbolicRegressionSolutionLinearScaler.cs" />
     <Compile Include="Symbolic\Analyzers\ISymbolicRegressionSolutionPopulationAnalyzer.cs" />
     <Compile Include="Symbolic\Analyzers\PopulationBestSymbolicRegressionSolutionAnalyzer.cs" />
+    <Compile Include="Symbolic\Analyzers\SymbolicRegressionVariableFrequencyAnalyzer.cs" />
+    <Compile Include="Symbolic\Analyzers\ValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs" />
     <Compile Include="Symbolic\SimpleSymbolicRegressionEvaluator.cs" />
     <Compile Include="Symbolic\SymbolicRegressionScaledMeanSquaredErrorEvaluator.cs" />

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs

-                      r3665
+                      r3681
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
   [Item("PopulationBestSymbolicRegressionSolutionAnalyzer", "An operator for analyzing the best solution of symbolic regression problems given in symbolic expression tree encoding.")]
+  [Item("BestSymbolicRegressionSolutionAnalyzer", "An operator for analyzing the best solution of symbolic regression problems given in symbolic expression tree encoding.")]
   [StorableClass]
   public sealed class PopulationBestSymbolicRegressionSolutionAnalyzer : SingleSuccessorOperator, ISymbolicRegressionSolutionPopulationAnalyzer {
+  public sealed class BestSymbolicRegressionSolutionAnalyzer : SingleSuccessorOperator, ISymbolicRegressionAnalyzer {
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
 …
     private const string ResultsParameterName = "Results";
+    public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    private const string BestSolutionResultName = "Best Solution (on validiation set)";
+    private const string BestSolutionInputvariableCountResultName = "Variables Used by Best Solution";
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
     public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
       get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    public IValueLookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
     public ILookupParameter<DataAnalysisProblemData> ProblemDataParameter {
       get { return (ILookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
     public ILookupParameter<ItemArray<DoubleValue>> QualityParameter {
       get { return (ILookupParameter<ItemArray<DoubleValue>>)Parameters[QualityParameterName]; }
+    public ScopeTreeLookupParameter<DoubleValue> QualityParameter {
+      get { return (ScopeTreeLookupParameter<DoubleValue>)Parameters[QualityParameterName]; }
+    }
     public ILookupParameter<DoubleValue> UpperEstimationLimitParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
     public ILookupParameter<DoubleValue> LowerEstimationLimitParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
     public ILookupParameter<SymbolicRegressionSolution> BestSolutionParameter {
 …
+    }
     public PopulationBestSymbolicRegressionSolutionAnalyzer()
+    public BestSymbolicRegressionSolutionAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
       Parameters.Add(new LookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new LookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new ScopeTreeLookupParameter<DoubleValue>(QualityParameterName, "The qualities of the symbolic regression trees which should be analyzed."));
       Parameters.Add(new LookupParameter<SymbolicRegressionSolution>(BestSolutionParameterName, "The best symbolic regression solution."));
 …
       SymbolicRegressionSolution solution = BestSolutionParameter.ActualValue;
       if (solution == null) {
         var model = new SymbolicRegressionModel(interpreter, expressions[i], GetInputVariables(expressions[i]));
+        var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)interpreter.Clone(), expressions[i], GetInputVariables(expressions[i]));
         solution = new SymbolicRegressionSolution(problemData, model, lowerEstimationLimit.Value, upperEstimationLimit.Value);
         BestSolutionParameter.ActualValue = solution;
         BestSolutionQualityParameter.ActualValue = qualities[i];
+        results.Add(new Result("Best Symbolic Regression Solution", solution));
+        results.Add(new Result(BestSolutionResultName, solution));
+        results.Add(new Result(BestSolutionInputvariableCountResultName, new IntValue(model.InputVariables.Count())));
       } else {
         if (BestSolutionQualityParameter.ActualValue.Value > qualities[i].Value) {
           var model = new SymbolicRegressionModel(interpreter, expressions[i], GetInputVariables(expressions[i]));
+          var model = new SymbolicRegressionModel((ISymbolicExpressionTreeInterpreter)interpreter.Clone(), expressions[i], GetInputVariables(expressions[i]));
           solution = new SymbolicRegressionSolution(problemData, model, lowerEstimationLimit.Value, upperEstimationLimit.Value);
           BestSolutionParameter.ActualValue = solution;
           BestSolutionQualityParameter.ActualValue = qualities[i];
+          results["Best Symbolic Regression Solution"].Value = solution;
+          results[BestSolutionResultName].Value = solution;
+          results[BestSolutionInputvariableCountResultName].Value = new IntValue(model.InputVariables.Count());
+        }
+      }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/ISymbolicRegressionAnalyzer.cs

-                      r3665
+                      r3681
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
   public interface ISymbolicRegressionSolutionPopulationAnalyzer : IAnalyzer {
     ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter { get; }
+  public interface ISymbolicRegressionAnalyzer : IAnalyzer {
+    ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter { get; }
     ILookupParameter<ResultCollection> ResultsParameter { get; }
+  }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionModelQualityAnalyzer.cs

-                      r3666
+                      r3681
 using HeuristicLab.Problems.DataAnalysis.Evaluators;
 using HeuristicLab.Optimization.Operators;
+using System;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
 …
   /// "An operator for analyzing the quality of symbolic regression solutions symbolic expression tree encoding."
   /// </summary>
   [Item("PopulationSymbolicRegressionModelQualityAnalyzer", "An operator for analyzing the quality of symbolic regression solutions symbolic expression tree encoding.")]
+  [Item("SymbolicRegressionModelQualityAnalyzer", "An operator for analyzing the quality of symbolic regression solutions symbolic expression tree encoding.")]
   [StorableClass]
   public sealed class PopulationSymbolicRegressionModelQualityAnalyzer : AlgorithmOperator, ISymbolicRegressionSolutionPopulationAnalyzer {
+  public sealed class SymbolicRegressionModelQualityAnalyzer : AlgorithmOperator, ISymbolicRegressionAnalyzer {
     private const string SymbolicExpressionTreeInterpreterParameterName = "SymbolicExpressionTreeInterpreter";
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
 …
     private const string MaxTrainingMeanSquaredErrorQualityParameterName = "MaxTrainingMeanSquaredError";
     private const string AverageTrainingMeanSquaredErrorQualityParameterName = "AverageTrainingMeanSquaredError";
+    private const string BestTrainingMeanSquaredErrorQualityParameterName = "BestTrainingMeanSquaredError";
     private const string TrainingAverageRelativeErrorQualityParameterName = "TrainingAverageRelativeError";
 …
     private const string MaxTrainingAverageRelativeErrorQualityParameterName = "MaxTrainingAverageRelativeError";
     private const string AverageTrainingAverageRelativeErrorQualityParameterName = "AverageTrainingAverageRelativeError";
+    private const string BestTrainingAverageRelativeErrorQualityParameterName = "BestTrainingAverageRelativeError";
     private const string TrainingRSquaredQualityParameterName = "TrainingRSquared";
 …
     private const string MaxTrainingRSquaredQualityParameterName = "MaxTrainingRSquared";
     private const string AverageTrainingRSquaredQualityParameterName = "AverageTrainingRSquared";
+    private const string BestTrainingRSquaredQualityParameterName = "BestTrainingRSquared";
     private const string TestMeanSquaredErrorQualityParameterName = "TestMeanSquaredError";
 …
     private const string MaxTestMeanSquaredErrorQualityParameterName = "MaxTestMeanSquaredError";
     private const string AverageTestMeanSquaredErrorQualityParameterName = "AverageTestMeanSquaredError";
+    private const string BestTestMeanSquaredErrorQualityParameterName = "BestTestMeanSquaredError";
     private const string TestAverageRelativeErrorQualityParameterName = "TestAverageRelativeError";
 …
     private const string MaxTestAverageRelativeErrorQualityParameterName = "MaxTestAverageRelativeError";
     private const string AverageTestAverageRelativeErrorQualityParameterName = "AverageTestAverageRelativeError";
+    private const string BestTestAverageRelativeErrorQualityParameterName = "BestTestAverageRelativeError";
     private const string TestRSquaredQualityParameterName = "TestRSquared";
 …
     private const string MaxTestRSquaredQualityParameterName = "MaxTestRSquared";
     private const string AverageTestRSquaredQualityParameterName = "AverageTestRSquared";
+    private const string BestTestRSquaredQualityParameterName = "BestTestRSquared";
     private const string RSquaredValuesParameterName = "R-squared Values";
 …
     #region parameter properties
+    public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
+    public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public ILookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (ILookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IValueLookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
+    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> TrainingSamplesStartParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[TrainingSamplesStartParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> TrainingSamplesEndParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[TrainingSamplesEndParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> TestSamplesStartParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[TestSamplesStartParameterName]; }
+    }
+    public IValueLookupParameter<IntValue> TestSamplesEndParameter {
+      get { return (IValueLookupParameter<IntValue>)Parameters[TestSamplesEndParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
     public ILookupParameter<ResultCollection> ResultsParameter {
       get { return (ILookupParameter<ResultCollection>)Parameters[ResultsParameterName]; }
+    }
-    public IValueLookupParameter<IntValue> TrainingSamplesStartParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[TrainingSamplesStartParameterName]; }
+    }
-    public IValueLookupParameter<IntValue> TrainingSamplesEndParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[TrainingSamplesEndParameterName]; }
+    }
-    public IValueLookupParameter<IntValue> TestSamplesStartParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[TestSamplesStartParameterName]; }
+    }
-    public IValueLookupParameter<IntValue> TestSamplesEndParameter {
-      get { return (IValueLookupParameter<IntValue>)Parameters[TestSamplesEndParameterName]; }
+    }
-    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
-    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
-      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
     #endregion
+    public PopulationSymbolicRegressionModelQualityAnalyzer()
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTrainingMseAnalyzer;
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTestMseAnalyzer;
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTrainingRSquaredAnalyzer;
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTestRSquaredAnalyzer;
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTrainingRelErrorAnalyzer;
+    [Storable]
+    private MinAverageMaxValueAnalyzer minAvgMaxTestRelErrorAnalyzer;
+    public SymbolicRegressionModelQualityAnalyzer()
       : base() {
-      Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic expression tree."));
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data containing the input varaibles for the symbolic regression problem."));
       Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best symbolic regression solution should be stored."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic expression tree."));
+      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data containing the input varaibles for the symbolic regression problem."));
       Parameters.Add(new ValueLookupParameter<IntValue>(TrainingSamplesStartParameterName, "The first index of the training data set partition on which the model quality values should be calculated."));
       Parameters.Add(new ValueLookupParameter<IntValue>(TrainingSamplesEndParameterName, "The last index of the training data set partition on which the model quality values should be calculated."));
 …
       Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper limit that should be used as cut off value for the output values of symbolic expression trees."));
       Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower limit that should be used as cut off value for the output values of symbolic expression trees."));
+      Parameters.Add(new LookupParameter<DataTable>(MeanSquaredErrorValuesParameterName, "The data table to collect mean squared error values."));
+      Parameters.Add(new LookupParameter<DataTable>(RSquaredValuesParameterName, "The data table to collect R² correlation coefficient values."));
+      Parameters.Add(new LookupParameter<DataTable>(RelativeErrorValuesParameterName, "The data table to collect relative error values."));
+      Parameters.Add(new ValueLookupParameter<DataTable>(MeanSquaredErrorValuesParameterName, "The data table to collect mean squared error values."));
+      Parameters.Add(new ValueLookupParameter<DataTable>(RSquaredValuesParameterName, "The data table to collect R² correlation coefficient values."));
+      Parameters.Add(new ValueLookupParameter<DataTable>(RelativeErrorValuesParameterName, "The data table to collect relative error values."));
+      Parameters.Add(new LookupParameter<ResultCollection>(ResultsParameterName, "The result collection where the best symbolic regression solution should be stored."));
       #region operator initialization
 …
       SymbolicRegressionModelQualityCalculator trainingQualityCalculator = new SymbolicRegressionModelQualityCalculator();
       SymbolicRegressionModelQualityCalculator testQualityCalculator = new SymbolicRegressionModelQualityCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTrainingMseCalculator = new MinAverageMaxValueCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTestMseCalculator = new MinAverageMaxValueCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTrainingR2Calculator = new MinAverageMaxValueCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTestR2Calculator = new MinAverageMaxValueCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTrainingRelErrorCalculator = new MinAverageMaxValueCalculator();
+      MinAverageMaxValueCalculator minAvgMaxTestRelErrorCalculator = new MinAverageMaxValueCalculator();
+      DataTableValuesCollector mseDataTableValuesCollector = new DataTableValuesCollector();
+      DataTableValuesCollector r2DataTableValuesCollector = new DataTableValuesCollector();
+      DataTableValuesCollector relErrorDataTableValuesCollector = new DataTableValuesCollector();
+      ResultsCollector resultsCollector = new ResultsCollector();
+      minAvgMaxTrainingMseAnalyzer = new MinAverageMaxValueAnalyzer();
+      minAvgMaxTestMseAnalyzer = new MinAverageMaxValueAnalyzer();
+      minAvgMaxTrainingRSquaredAnalyzer = new MinAverageMaxValueAnalyzer();
+      minAvgMaxTestRSquaredAnalyzer = new MinAverageMaxValueAnalyzer();
+      minAvgMaxTrainingRelErrorAnalyzer = new MinAverageMaxValueAnalyzer();
+      minAvgMaxTestRelErrorAnalyzer = new MinAverageMaxValueAnalyzer();
       #endregion
       #region parameter wiring
       trainingQualityCalculator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.ActualName;
       trainingQualityCalculator.ProblemDataParameter.ActualName = ProblemDataParameter.ActualName;
       trainingQualityCalculator.SamplesStartParameter.ActualName = TrainingSamplesStartParameter.ActualName;
       trainingQualityCalculator.SamplesEndParameter.ActualName = TrainingSamplesEndParameter.ActualName;
       trainingQualityCalculator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.ActualName;
       trainingQualityCalculator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.ActualName;
       trainingQualityCalculator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.ActualName;
+      trainingQualityCalculator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+      trainingQualityCalculator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+      trainingQualityCalculator.SamplesStartParameter.ActualName = TrainingSamplesStartParameter.Name;
+      trainingQualityCalculator.SamplesEndParameter.ActualName = TrainingSamplesEndParameter.Name;
+      trainingQualityCalculator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
+      trainingQualityCalculator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
+      trainingQualityCalculator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
       trainingQualityCalculator.AverageRelativeErrorQualityParameter.ActualName = TrainingAverageRelativeErrorQualityParameterName;
       trainingQualityCalculator.MeanSquaredErrorQualityParameter.ActualName = TrainingMeanSquaredErrorQualityParameterName;
       trainingQualityCalculator.RSquaredQualityParameter.ActualName = TrainingRSquaredQualityParameterName;
       testQualityCalculator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.ActualName;
       testQualityCalculator.ProblemDataParameter.ActualName = ProblemDataParameter.ActualName;
       testQualityCalculator.SamplesStartParameter.ActualName = TestSamplesStartParameter.ActualName;
       testQualityCalculator.SamplesEndParameter.ActualName = TestSamplesEndParameter.ActualName;
       testQualityCalculator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.ActualName;
       testQualityCalculator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.ActualName;
       testQualityCalculator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.ActualName;
+      testQualityCalculator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+      testQualityCalculator.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
+      testQualityCalculator.SamplesStartParameter.ActualName = TestSamplesStartParameter.Name;
+      testQualityCalculator.SamplesEndParameter.ActualName = TestSamplesEndParameter.Name;
+      testQualityCalculator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
+      testQualityCalculator.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
+      testQualityCalculator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
       testQualityCalculator.AverageRelativeErrorQualityParameter.ActualName = TestAverageRelativeErrorQualityParameterName;
       testQualityCalculator.MeanSquaredErrorQualityParameter.ActualName = TestMeanSquaredErrorQualityParameterName;
       testQualityCalculator.RSquaredQualityParameter.ActualName = TestRSquaredQualityParameterName;
+      #region training min/avg/max
+      minAvgMaxTrainingMseCalculator.AverageValueParameter.ActualName = AverageTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseCalculator.MaxValueParameter.ActualName = MaxTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseCalculator.MinValueParameter.ActualName = MinTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseCalculator.ValueParameter.ActualName = TrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingR2Calculator.AverageValueParameter.ActualName = AverageTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingR2Calculator.MaxValueParameter.ActualName = MaxTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingR2Calculator.MinValueParameter.ActualName = MinTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingR2Calculator.ValueParameter.ActualName = TrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingRelErrorCalculator.AverageValueParameter.ActualName = AverageTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorCalculator.MaxValueParameter.ActualName = MaxTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorCalculator.MinValueParameter.ActualName = MinTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorCalculator.ValueParameter.ActualName = TrainingAverageRelativeErrorQualityParameterName;
+      #endregion
+      #region test min/avg/max
+      minAvgMaxTestMseCalculator.AverageValueParameter.ActualName = AverageTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseCalculator.MaxValueParameter.ActualName = MaxTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseCalculator.MinValueParameter.ActualName = MinTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseCalculator.ValueParameter.ActualName = TestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestR2Calculator.AverageValueParameter.ActualName = AverageTestRSquaredQualityParameterName;
+      minAvgMaxTestR2Calculator.MaxValueParameter.ActualName = MaxTestRSquaredQualityParameterName;
+      minAvgMaxTestR2Calculator.MinValueParameter.ActualName = MinTestRSquaredQualityParameterName;
+      minAvgMaxTestR2Calculator.ValueParameter.ActualName = TestRSquaredQualityParameterName;
+      minAvgMaxTestRelErrorCalculator.AverageValueParameter.ActualName = AverageTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorCalculator.MaxValueParameter.ActualName = MaxTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorCalculator.MinValueParameter.ActualName = MinTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorCalculator.ValueParameter.ActualName = TestAverageRelativeErrorQualityParameterName;
+      #endregion
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTrainingMeanSquaredErrorQualityParameterName, null, AverageTrainingMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTrainingMeanSquaredErrorQualityParameterName, null, MaxTrainingMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTrainingMeanSquaredErrorQualityParameterName, null, MinTrainingMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTestMeanSquaredErrorQualityParameterName, null, AverageTestMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTestMeanSquaredErrorQualityParameterName, null, MaxTestMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTestMeanSquaredErrorQualityParameterName, null, MinTestMeanSquaredErrorQualityParameterName));
+      mseDataTableValuesCollector.DataTableParameter.ActualName = MeanSquaredErrorValuesParameterName;
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTrainingRSquaredQualityParameterName, null, AverageTrainingRSquaredQualityParameterName));
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTrainingRSquaredQualityParameterName, null, MaxTrainingRSquaredQualityParameterName));
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTrainingRSquaredQualityParameterName, null, MinTrainingRSquaredQualityParameterName));
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTestRSquaredQualityParameterName, null, AverageTestRSquaredQualityParameterName));
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTestRSquaredQualityParameterName, null, MaxTestRSquaredQualityParameterName));
+      r2DataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTestRSquaredQualityParameterName, null, MinTestRSquaredQualityParameterName));
+      r2DataTableValuesCollector.DataTableParameter.ActualName = RSquaredValuesParameterName;
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTrainingAverageRelativeErrorQualityParameterName, null, AverageTrainingAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTrainingAverageRelativeErrorQualityParameterName, null, MaxTrainingAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTrainingAverageRelativeErrorQualityParameterName, null, MinTrainingAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(AverageTestAverageRelativeErrorQualityParameterName, null, AverageTestAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MaxTestAverageRelativeErrorQualityParameterName, null, MaxTestAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>(MinTestAverageRelativeErrorQualityParameterName, null, MinTestAverageRelativeErrorQualityParameterName));
+      relErrorDataTableValuesCollector.DataTableParameter.ActualName = RelativeErrorValuesParameterName;
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(MeanSquaredErrorValuesParameterName));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(RSquaredValuesParameterName));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>(RelativeErrorValuesParameterName));
+      resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
+      #region training/test MSE
+      minAvgMaxTrainingMseAnalyzer.ValueParameter.ActualName = TrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTrainingMseAnalyzer.AverageValueParameter.ActualName = AverageTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseAnalyzer.MaxValueParameter.ActualName = MaxTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseAnalyzer.MinValueParameter.ActualName = MinTrainingMeanSquaredErrorQualityParameterName;
+      minAvgMaxTrainingMseAnalyzer.ValuesParameter.ActualName = MeanSquaredErrorValuesParameterName;
+      minAvgMaxTrainingMseAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      minAvgMaxTestMseAnalyzer.ValueParameter.ActualName = TestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestMseAnalyzer.AverageValueParameter.ActualName = AverageTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseAnalyzer.MaxValueParameter.ActualName = MaxTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseAnalyzer.MinValueParameter.ActualName = MinTestMeanSquaredErrorQualityParameterName;
+      minAvgMaxTestMseAnalyzer.ValuesParameter.ActualName = MeanSquaredErrorValuesParameterName;
+      minAvgMaxTestMseAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      #endregion
+      #region training/test R²
+      minAvgMaxTrainingRSquaredAnalyzer.ValueParameter.ActualName = TrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingRSquaredAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTrainingRSquaredAnalyzer.AverageValueParameter.ActualName = AverageTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingRSquaredAnalyzer.MaxValueParameter.ActualName = MaxTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingRSquaredAnalyzer.MinValueParameter.ActualName = MinTrainingRSquaredQualityParameterName;
+      minAvgMaxTrainingRSquaredAnalyzer.ValuesParameter.ActualName = RSquaredValuesParameterName;
+      minAvgMaxTrainingRSquaredAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      minAvgMaxTestRSquaredAnalyzer.ValueParameter.ActualName = TestRSquaredQualityParameterName;
+      minAvgMaxTestRSquaredAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestRSquaredAnalyzer.AverageValueParameter.ActualName = AverageTestRSquaredQualityParameterName;
+      minAvgMaxTestRSquaredAnalyzer.MaxValueParameter.ActualName = MaxTestRSquaredQualityParameterName;
+      minAvgMaxTestRSquaredAnalyzer.MinValueParameter.ActualName = MinTestRSquaredQualityParameterName;
+      minAvgMaxTestRSquaredAnalyzer.ValuesParameter.ActualName = RSquaredValuesParameterName;
+      minAvgMaxTestRSquaredAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      #endregion
+      #region training/test avg. rel. error
+      minAvgMaxTrainingRelErrorAnalyzer.ValueParameter.ActualName = TrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTrainingRelErrorAnalyzer.AverageValueParameter.ActualName = AverageTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorAnalyzer.MaxValueParameter.ActualName = MaxTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorAnalyzer.MinValueParameter.ActualName = MinTrainingAverageRelativeErrorQualityParameterName;
+      minAvgMaxTrainingRelErrorAnalyzer.ValuesParameter.ActualName = RelativeErrorValuesParameterName;
+      minAvgMaxTrainingRelErrorAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      minAvgMaxTestRelErrorAnalyzer.ValueParameter.ActualName = TestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestRelErrorAnalyzer.AverageValueParameter.ActualName = AverageTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorAnalyzer.MaxValueParameter.ActualName = MaxTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorAnalyzer.MinValueParameter.ActualName = MinTestAverageRelativeErrorQualityParameterName;
+      minAvgMaxTestRelErrorAnalyzer.ValuesParameter.ActualName = RelativeErrorValuesParameterName;
+      minAvgMaxTestRelErrorAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      #endregion
       #endregion
 …
       trainingQualityCalculator.Successor = testQualityCalculator;
       testQualityCalculator.Successor = null;
+      subScopesProcessor.Successor = minAvgMaxTrainingMseCalculator;
+      minAvgMaxTrainingMseCalculator.Successor = minAvgMaxTestMseCalculator;
+      minAvgMaxTestMseCalculator.Successor = minAvgMaxTrainingR2Calculator;
+      minAvgMaxTrainingR2Calculator.Successor = minAvgMaxTestR2Calculator;
+      minAvgMaxTestR2Calculator.Successor = minAvgMaxTrainingRelErrorCalculator;
+      minAvgMaxTrainingRelErrorCalculator.Successor = minAvgMaxTestRelErrorCalculator;
+      minAvgMaxTestRelErrorCalculator.Successor = mseDataTableValuesCollector;
+      mseDataTableValuesCollector.Successor = r2DataTableValuesCollector;
+      r2DataTableValuesCollector.Successor = relErrorDataTableValuesCollector;
+      relErrorDataTableValuesCollector.Successor = resultsCollector;
+      #endregion
+      subScopesProcessor.Successor = minAvgMaxTrainingMseAnalyzer;
+      minAvgMaxTrainingMseAnalyzer.Successor = minAvgMaxTestMseAnalyzer;
+      minAvgMaxTestMseAnalyzer.Successor = minAvgMaxTrainingRSquaredAnalyzer;
+      minAvgMaxTrainingRSquaredAnalyzer.Successor = minAvgMaxTestRSquaredAnalyzer;
+      minAvgMaxTestRSquaredAnalyzer.Successor = minAvgMaxTrainingRelErrorAnalyzer;
+      minAvgMaxTrainingRelErrorAnalyzer.Successor = minAvgMaxTestRelErrorAnalyzer;
+      minAvgMaxTestRelErrorAnalyzer.Successor = null;
+      #endregion
+      Initialize();
+    }
+    [StorableConstructor]
+    private SymbolicRegressionModelQualityAnalyzer(bool deserializing) : base() { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      SymbolicExpressionTreeParameter.DepthChanged += new EventHandler(SymbolicExpressionTreeParameter_DepthChanged);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      SymbolicRegressionModelQualityAnalyzer clone = (SymbolicRegressionModelQualityAnalyzer)base.Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+    private void SymbolicExpressionTreeParameter_DepthChanged(object sender, EventArgs e) {
+      minAvgMaxTrainingMseAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTrainingRelErrorAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTrainingRSquaredAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestMseAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestRelErrorAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      minAvgMaxTestRSquaredAnalyzer.ValueParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+    }
+  }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionModelQualityCalculator.cs

-                      r3666
+                      r3681
     #region parameter properties
     public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
       get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    public IValueLookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
     public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    public ILookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ILookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
     public ILookupParameter<DataAnalysisProblemData> ProblemDataParameter {
       get { return (ILookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
     public IValueLookupParameter<IntValue> SamplesStartParameter {
 …
       get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
     public IValueLookupParameter<DoubleValue> RSquaredQualityParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[RSQuaredQualityParameterName]; }
+    public ILookupParameter<DoubleValue> RSquaredQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[RSQuaredQualityParameterName]; }
+    }
     public IValueLookupParameter<DoubleValue> AverageRelativeErrorQualityParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[RelativeErrorQualityParameterName]; }
+    public ILookupParameter<DoubleValue> AverageRelativeErrorQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[RelativeErrorQualityParameterName]; }
+    }
     public IValueLookupParameter<DoubleValue> MeanSquaredErrorQualityParameter {
       get { return (IValueLookupParameter<DoubleValue>)Parameters[MeanSquaredErrorQualityParameterName]; }
+    public ILookupParameter<DoubleValue> MeanSquaredErrorQualityParameter {
+      get { return (ILookupParameter<DoubleValue>)Parameters[MeanSquaredErrorQualityParameterName]; }
+    }
     #endregion
 …
     public SymbolicRegressionModelQualityCalculator()
       : base() {
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic expression tree."));
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data containing the input varaibles for the symbolic regression problem."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used to calculate the output values of the symbolic expression tree."));
+      Parameters.Add(new LookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression tree to analyze."));
+      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data containing the input varaibles for the symbolic regression problem."));
       Parameters.Add(new ValueLookupParameter<IntValue>(SamplesStartParameterName, "The first index of the data set partition on which the model quality values should be calculated."));
       Parameters.Add(new ValueLookupParameter<IntValue>(SamplesEndParameterName, "The first index of the data set partition on which the model quality values should be calculated."));
 …
       SimpleMeanAbsolutePercentageErrorEvaluator simpleRelErrorEvaluator = new SimpleMeanAbsolutePercentageErrorEvaluator();
       SimpleMSEEvaluator simpleMseEvaluator = new SimpleMSEEvaluator();
+      Assigner clearValues = new Assigner();
       #endregion
 …
       simpleRelErrorEvaluator.ValuesParameter.ActualName = ValuesParameterName;
       simpleRelErrorEvaluator.AverageRelativeErrorParameter.ActualName = AverageRelativeErrorQualityParameter.Name;
+      clearValues.LeftSideParameter.ActualName = ValuesParameterName;
+      clearValues.RightSideParameter.Value = new DoubleMatrix();
       #endregion
 …
       simpleR2Evalator.Successor = simpleRelErrorEvaluator;
       simpleRelErrorEvaluator.Successor = simpleMseEvaluator;
+      simpleMseEvaluator.Successor = null;
+      simpleMseEvaluator.Successor = clearValues;
+      clearValues.Successor = null;
       #endregion

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionVariableFrequencyAnalyzer.cs

-                      r3665
+                      r3681
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
   [Item("PopulationSymbolicRegressionVariableFrequencyAnalyzer", "An operator for analyzing the variable frequencies in a population of symbolic regression solutions given in symbolic expression tree encoding.")]
+  [Item("SymbolicRegressionVariableFrequencyAnalyzer", "An operator for analyzing the variable frequencies of symbolic regression solutions given in symbolic expression tree encoding.")]
   [StorableClass]
   public sealed class PopulationSymbolicRegressionVariableFrequencyAnalyzer : SingleSuccessorOperator, ISymbolicRegressionSolutionPopulationAnalyzer {
+  public sealed class SymbolicRegressionVariableFrequencyAnalyzer : SingleSuccessorOperator, ISymbolicRegressionAnalyzer {
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string ProblemDataParameterName = "ProblemData";
 …
     #region parameter properties
     public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
     public ILookupParameter<DataTable> VariableFrequenciesParameter {
 …
     #endregion
     public PopulationSymbolicRegressionVariableFrequencyAnalyzer()
+    public SymbolicRegressionVariableFrequencyAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/ValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs

-                      r3665
+                      r3681
 using HeuristicLab.Problems.DataAnalysis.Symbolic.Symbols;
 using HeuristicLab.Problems.DataAnalysis;
+using HeuristicLab.Analysis;
+using System;
+using HeuristicLab.Optimization.Operators;
 namespace HeuristicLab.Problems.DataAnalysis.Regression.Symbolic.Analyzers {
 …
   /// An operator that analyzes the validation best scaled symbolic regression solution.
   /// </summary>
   [Item("PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer", "An operator that analyzes the validation best scaled symbolic regression solution.")]
+  [Item("ValidationBestScaledSymbolicRegressionSolutionAnalyzer", "An operator that analyzes the validation best scaled symbolic regression solution.")]
   [StorableClass]
   public sealed class PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer : AlgorithmOperator, ISymbolicRegressionSolutionPopulationAnalyzer {
+  public sealed class ValidationBestScaledSymbolicRegressionSolutionAnalyzer : AlgorithmOperator, ISymbolicRegressionAnalyzer {
     private const string SymbolicExpressionTreeParameterName = "SymbolicExpressionTree";
     private const string ScaledSymbolicExpressionTreeParameterName = "ScaledSymbolicExpressionTree";
 …
     private const string ResultsParameterName = "Results";
     public ILookupParameter<ItemArray<SymbolicExpressionTree>> SymbolicExpressionTreeParameter {
       get { return (ILookupParameter<ItemArray<SymbolicExpressionTree>>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
     public ILookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
       get { return (ILookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
     public ILookupParameter<DataAnalysisProblemData> ProblemDataParameter {
       get { return (ILookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    public ScopeTreeLookupParameter<SymbolicExpressionTree> SymbolicExpressionTreeParameter {
+      get { return (ScopeTreeLookupParameter<SymbolicExpressionTree>)Parameters[SymbolicExpressionTreeParameterName]; }
+    }
+    public IValueLookupParameter<ISymbolicExpressionTreeInterpreter> SymbolicExpressionTreeInterpreterParameter {
+      get { return (IValueLookupParameter<ISymbolicExpressionTreeInterpreter>)Parameters[SymbolicExpressionTreeInterpreterParameterName]; }
+    }
+    public IValueLookupParameter<DataAnalysisProblemData> ProblemDataParameter {
+      get { return (IValueLookupParameter<DataAnalysisProblemData>)Parameters[ProblemDataParameterName]; }
+    }
     public IValueLookupParameter<IntValue> SamplesStartParameter {
 …
       get { return (IValueLookupParameter<IntValue>)Parameters[SamplesEndParameterName]; }
+    }
     public ILookupParameter<DoubleValue> UpperEstimationLimitParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
     public ILookupParameter<DoubleValue> LowerEstimationLimitParameter {
       get { return (ILookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    public IValueLookupParameter<DoubleValue> UpperEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[UpperEstimationLimitParameterName]; }
+    }
+    public IValueLookupParameter<DoubleValue> LowerEstimationLimitParameter {
+      get { return (IValueLookupParameter<DoubleValue>)Parameters[LowerEstimationLimitParameterName]; }
+    }
     public ILookupParameter<SymbolicRegressionSolution> BestSolutionParameter {
 …
+    }
+    public PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer()
+    [Storable]
+    private BestQualityMemorizer validationQualityMemorizer;
+    [Storable]
+    private BestSymbolicRegressionSolutionAnalyzer bestSolutionAnalyzer;
+    public ValidationBestScaledSymbolicRegressionSolutionAnalyzer()
       : base() {
       Parameters.Add(new ScopeTreeLookupParameter<SymbolicExpressionTree>(SymbolicExpressionTreeParameterName, "The symbolic expression trees to analyze."));
       Parameters.Add(new LookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
       Parameters.Add(new LookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
+      Parameters.Add(new ValueLookupParameter<ISymbolicExpressionTreeInterpreter>(SymbolicExpressionTreeInterpreterParameterName, "The interpreter that should be used for the analysis of symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DataAnalysisProblemData>(ProblemDataParameterName, "The problem data for which the symbolic expression tree is a solution."));
       Parameters.Add(new ValueLookupParameter<IntValue>(SamplesStartParameterName, "The first index of the validation partition of the data set."));
       Parameters.Add(new ValueLookupParameter<IntValue>(SamplesEndParameterName, "The last index of the validation partition of the data set."));
       Parameters.Add(new LookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new LookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(UpperEstimationLimitParameterName, "The upper estimation limit that was set for the evaluation of the symbolic expression trees."));
+      Parameters.Add(new ValueLookupParameter<DoubleValue>(LowerEstimationLimitParameterName, "The lower estimation limit that was set for the evaluation of the symbolic expression trees."));
       Parameters.Add(new LookupParameter<SymbolicRegressionSolution>(BestSolutionParameterName, "The best symbolic regression solution."));
       Parameters.Add(new LookupParameter<DoubleValue>(BestSolutionQualityParameterName, "The quality of the best symbolic regression solution."));
 …
       SymbolicRegressionSolutionLinearScaler linearScaler = new SymbolicRegressionSolutionLinearScaler();
       SymbolicRegressionMeanSquaredErrorEvaluator validationMseEvaluator = new SymbolicRegressionMeanSquaredErrorEvaluator();
+      PopulationBestSymbolicRegressionSolutionAnalyzer bestSolutionAnalyzer = new PopulationBestSymbolicRegressionSolutionAnalyzer();
+      bestSolutionAnalyzer = new BestSymbolicRegressionSolutionAnalyzer();
+      validationQualityMemorizer = new BestQualityMemorizer();
+      BestAverageWorstQualityCalculator bestAvgWorstValidationQualityCalculator = new BestAverageWorstQualityCalculator();
+      DataTableValuesCollector validationValuesCollector = new DataTableValuesCollector();
+      ResultsCollector resultsCollector = new ResultsCollector();
       #endregion
 …
       linearScaler.AlphaParameter.ActualName = AlphaParameterName;
       linearScaler.BetaParameter.ActualName = BetaParameterName;
       linearScaler.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameterName;
+      linearScaler.SymbolicExpressionTreeParameter.ActualName = SymbolicExpressionTreeParameter.Name;
       linearScaler.ScaledSymbolicExpressionTreeParameter.ActualName = ScaledSymbolicExpressionTreeParameterName;
       validationMseEvaluator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameterName;
       validationMseEvaluator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameterName;
+      validationMseEvaluator.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+      validationMseEvaluator.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
       validationMseEvaluator.SymbolicExpressionTreeParameter.ActualName = ScaledSymbolicExpressionTreeParameterName;
       validationMseEvaluator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameterName;
+      validationMseEvaluator.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
       validationMseEvaluator.QualityParameter.ActualName = QualityParameterName;
       validationMseEvaluator.RegressionProblemDataParameter.ActualName = ProblemDataParameterName;
       validationMseEvaluator.SamplesStartParameter.ActualName = SamplesStartParameterName;
       validationMseEvaluator.SamplesEndParameter.ActualName = SamplesEndParameterName;
       bestSolutionAnalyzer.BestSolutionParameter.ActualName = BestSolutionParameterName;
       bestSolutionAnalyzer.BestSolutionQualityParameter.ActualName = BestSolutionQualityParameterName;
       bestSolutionAnalyzer.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameterName;
       bestSolutionAnalyzer.ProblemDataParameter.ActualName = ProblemDataParameterName;
+      validationMseEvaluator.RegressionProblemDataParameter.ActualName = ProblemDataParameter.Name;
+      validationMseEvaluator.SamplesStartParameter.ActualName = SamplesStartParameter.Name;
+      validationMseEvaluator.SamplesEndParameter.ActualName = SamplesEndParameter.Name;
+      bestSolutionAnalyzer.BestSolutionParameter.ActualName = BestSolutionParameter.Name;
+      bestSolutionAnalyzer.BestSolutionQualityParameter.ActualName = BestSolutionQualityParameter.Name;
+      bestSolutionAnalyzer.LowerEstimationLimitParameter.ActualName = LowerEstimationLimitParameter.Name;
+      bestSolutionAnalyzer.ProblemDataParameter.ActualName = ProblemDataParameter.Name;
       bestSolutionAnalyzer.QualityParameter.ActualName = QualityParameterName;
       bestSolutionAnalyzer.ResultsParameter.ActualName = ResultsParameterName;
       bestSolutionAnalyzer.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameterName;
+      bestSolutionAnalyzer.ResultsParameter.ActualName = ResultsParameter.Name;
+      bestSolutionAnalyzer.SymbolicExpressionTreeInterpreterParameter.ActualName = SymbolicExpressionTreeInterpreterParameter.Name;
       bestSolutionAnalyzer.SymbolicExpressionTreeParameter.ActualName = ScaledSymbolicExpressionTreeParameterName;
+      bestSolutionAnalyzer.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameterName;
+      bestSolutionAnalyzer.SymbolicExpressionTreeParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      bestSolutionAnalyzer.UpperEstimationLimitParameter.ActualName = UpperEstimationLimitParameter.Name;
+      bestAvgWorstValidationQualityCalculator.AverageQualityParameter.ActualName = "Current Average Validation Quality";
+      bestAvgWorstValidationQualityCalculator.BestQualityParameter.ActualName = "Current Best Validation Quality";
+      bestAvgWorstValidationQualityCalculator.MaximizationParameter.Value = new BoolValue(false);
+      bestAvgWorstValidationQualityCalculator.QualityParameter.ActualName = QualityParameterName;
+      bestAvgWorstValidationQualityCalculator.WorstQualityParameter.ActualName = "Current Worst Validation Quality";
+      validationQualityMemorizer.BestQualityParameter.ActualName = "Best Validation Quality";
+      validationQualityMemorizer.QualityParameter.ActualName = QualityParameterName;
+      validationQualityMemorizer.QualityParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      validationValuesCollector.DataTableParameter.ActualName = "Validation Qualities";
+      validationValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Validation Quality", null, "Current Best Validation Quality"));
+      validationValuesCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Validation Quality", null, "Best Validation Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Current Best Validation Quality", null, "Current Best Validation Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DoubleValue>("Best Validation Quality", null, "Best Validation Quality"));
+      resultsCollector.CollectedValues.Add(new LookupParameter<DataTable>("Validation Qualities"));
+      resultsCollector.ResultsParameter.ActualName = ResultsParameter.Name;
       #endregion
 …
       validationMseEvaluator.Successor = null;
       subScopesProc.Successor = bestSolutionAnalyzer;
+      bestSolutionAnalyzer.Successor = null;
+      bestSolutionAnalyzer.Successor = bestAvgWorstValidationQualityCalculator;
+      bestAvgWorstValidationQualityCalculator.Successor = validationQualityMemorizer;
+      validationQualityMemorizer.Successor = validationValuesCollector;
+      validationValuesCollector.Successor = resultsCollector;
+      resultsCollector.Successor = null;
       #endregion
+      Initialize();
+    }
+    [StorableConstructor]
+    private ValidationBestScaledSymbolicRegressionSolutionAnalyzer(bool deserializing) : base() { }
+    [StorableHook(HookType.AfterDeserialization)]
+    private void Initialize() {
+      SymbolicExpressionTreeParameter.DepthChanged += new EventHandler(SymbolicExpressionTreeParameter_DepthChanged);
+    }
+    public override IDeepCloneable Clone(Cloner cloner) {
+      ValidationBestScaledSymbolicRegressionSolutionAnalyzer clone = (ValidationBestScaledSymbolicRegressionSolutionAnalyzer)base.Clone(cloner);
+      clone.Initialize();
+      return clone;
+    }
+    private void SymbolicExpressionTreeParameter_DepthChanged(object sender, EventArgs e) {
+      validationQualityMemorizer.QualityParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+      bestSolutionAnalyzer.SymbolicExpressionTreeParameter.Depth = SymbolicExpressionTreeParameter.Depth;
+    }
+  }

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs

-                      r3666
+                      r3681
       get { return operators; }
+    }
     public IEnumerable<ISymbolicRegressionSolutionPopulationAnalyzer> Analyzers {
       get { return operators.OfType<ISymbolicRegressionSolutionPopulationAnalyzer>(); }
+    public IEnumerable<ISymbolicRegressionAnalyzer> Analyzers {
+      get { return operators.OfType<ISymbolicRegressionAnalyzer>(); }
+    }
     public DoubleValue PunishmentFactor {
 …
       operators = new List<IOperator>();
       operators.AddRange(ApplicationManager.Manager.GetInstances<ISymbolicExpressionTreeOperator>().OfType<IOperator>());
       operators.Add(new PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer());
       operators.Add(new PopulationMinAvgMaxTreeSizeAnalyzer());
       operators.Add(new PopulationSymbolicRegressionVariableFrequencyAnalyzer());
       operators.Add(new PopulationSymbolicRegressionModelQualityAnalyzer());
+      operators.Add(new ValidationBestScaledSymbolicRegressionSolutionAnalyzer());
+      operators.Add(new MinAvgMaxSymbolicExpressionTreeSizeAnalyzer());
+      operators.Add(new SymbolicRegressionVariableFrequencyAnalyzer());
+      operators.Add(new SymbolicRegressionModelQualityAnalyzer());
       ParameterizeOperators();
       ParameterizeAnalyzers();
 …
       foreach (var analyzer in Analyzers) {
         analyzer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
         var bestValidationSolutionAnalyzer = analyzer as PopulationValidationBestScaledSymbolicRegressionSolutionAnalyzer;
+        var bestValidationSolutionAnalyzer = analyzer as ValidationBestScaledSymbolicRegressionSolutionAnalyzer;
         if (bestValidationSolutionAnalyzer != null) {
           bestValidationSolutionAnalyzer.ProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
 …
           bestValidationSolutionAnalyzer.SamplesEndParameter.Value = ValidationSamplesEnd;
+        }
         var varFreqAnalyzer = analyzer as PopulationSymbolicRegressionVariableFrequencyAnalyzer;
+        var varFreqAnalyzer = analyzer as SymbolicRegressionVariableFrequencyAnalyzer;
         if (varFreqAnalyzer != null) {
           varFreqAnalyzer.ProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
+        }
         var modelQualityAnalyzer = analyzer as PopulationSymbolicRegressionModelQualityAnalyzer;
+        var modelQualityAnalyzer = analyzer as SymbolicRegressionModelQualityAnalyzer;
         if (modelQualityAnalyzer != null) {
           modelQualityAnalyzer.ProblemDataParameter.ActualName = DataAnalysisProblemDataParameter.Name;
 …
+        }
+      }
       foreach (ISymbolicExpressionTreePopulationAnalyzer analyzer in Operators.OfType<ISymbolicExpressionTreePopulationAnalyzer>()) {
+      foreach (ISymbolicExpressionTreeAnalyzer analyzer in Operators.OfType<ISymbolicExpressionTreeAnalyzer>()) {
         analyzer.SymbolicExpressionTreeParameter.ActualName = SolutionCreator.SymbolicExpressionTreeParameter.ActualName;
+      }

Context Navigation

Legend:

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Analyzers/MinAvgMaxSymbolicExpressionTreeSizeAnalyzer.cs

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding-3.3.csproj

trunk/sources/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.3/Interfaces/ISymbolicExpressionTreeAnalyzer.cs

trunk/sources/HeuristicLab.Problems.ArtificialAnt.Views/3.3/HeuristicLab.Problems.ArtificialAnt.Views-3.3.csproj

trunk/sources/HeuristicLab.Problems.ArtificialAnt.Views/3.3/HeuristicLabProblemsArtificialAntViewsPlugin.cs.frame

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Analyzers/BestAntTrailAnalyzer.cs

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/Analyzers/IAntTrailAnalyzer.cs

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/ArtificialAntProblem.cs

trunk/sources/HeuristicLab.Problems.ArtificialAnt/3.3/HeuristicLab.Problems.ArtificialAnt-3.3.csproj

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/HeuristicLab.Problems.DataAnalysis.Regression-3.3.csproj

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/BestSymbolicRegressionSolutionAnalyzer.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/ISymbolicRegressionAnalyzer.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionModelQualityAnalyzer.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionModelQualityCalculator.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/SymbolicRegressionVariableFrequencyAnalyzer.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/Analyzers/ValidationBestScaledSymbolicRegressionSolutionAnalyzer.cs

trunk/sources/HeuristicLab.Problems.DataAnalysis.Regression/3.3/Symbolic/SymbolicRegressionProblem.cs

Download in other formats: