Changeset 17928 for branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis

Timestamp:

04/06/21 13:13:32 (4 years ago)

Author:

dpiringe

Message:

#3026

• merged trunk into branch

Location:

branches/3026_IntegrationIntoSymSpace

Files:

• . (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleProblemData.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs (modified) (5 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionVariableImpactsCalculator.cs (modified) (8 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationModel.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval.cs (deleted)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs (modified) (7 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/ShapeConstraints.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/ShapeConstraints.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisModel.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblem.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDependencyCalculator.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/IOnlineTimeSeriesCalculator.cs (modified) (1 diff)

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/DatasetExtensions.cs

@@ -96 +96 @@
     }
 
+    public static IntervalCollection GetIntervals(this IDataset dataset) {
+      IntervalCollection intervalCollection = new IntervalCollection();
+      foreach (var variable in dataset.DoubleVariables) { // intervals are only possible for double variables
+        var variableInterval = Interval.GetInterval(dataset.GetDoubleValues(variable));
+        intervalCollection.AddInterval(variable, variableInterval);
+      }
+
+      return intervalCollection;
+    }
+
     public static IEnumerable<KeyValuePair<string, IEnumerable<string>>> GetFactorVariableValues(
       this IDataset ds, IEnumerable<string> factorVariables, IEnumerable<int> rows) {

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -140 +140 @@
     <Compile Include="Implementation\ConstantModel.cs" />
     <Compile Include="Implementation\DataAnalysisModel.cs" />
-    <Compile Include="Implementation\Interval.cs" />
+    <Compile Include="Implementation\Interval\Interval.cs" />
+    <Compile Include="Implementation\Interval\IntervalCollection.cs" />
+    <Compile Include="Implementation\Interval\ShapeConstraint.cs" />
+    <Compile Include="Implementation\Interval\ShapeConstraintsParser.cs" />
     <Compile Include="Implementation\Regression\ConfidenceBoundRegressionSolution.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionModel.cs" />
     <Compile Include="Implementation\Regression\ConstantRegressionSolution.cs" />
+    <Compile Include="Implementation\Regression\ShapeConstraints.cs" />
     <Compile Include="Implementation\Regression\RegressionEnsembleProblemData.cs" />
     <Compile Include="Implementation\Regression\RegressionEnsembleModel.cs">

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleProblemData.cs

@@ -73 +73 @@
 
     public ClassificationEnsembleProblemData() : base() { }
+
     public ClassificationEnsembleProblemData(IClassificationProblemData classificationProblemData)
-      : base(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable) {
-      this.TrainingPartition.Start = classificationProblemData.TrainingPartition.Start;
-      this.TrainingPartition.End = classificationProblemData.TrainingPartition.End;
-      this.TestPartition.Start = classificationProblemData.TestPartition.Start;
-      this.TestPartition.End = classificationProblemData.TestPartition.End;
-      this.PositiveClass = classificationProblemData.PositiveClass;
+      : base(classificationProblemData) {
     }
 
@@ -85 +81 @@
       : base(dataset, allowedInputVariables, targetVariable) {
     }
+
+    public ClassificationEnsembleProblemData(Dataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<string> classNames, string positiveClass = null)
+      : base(dataset, allowedInputVariables, targetVariable, classNames, positiveClass) {
+    }
   }
 }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationEnsembleSolution.cs

@@ -260 +260 @@
       evaluationCache.Clear();
 
-      IClassificationProblemData problemData = new ClassificationProblemData(ProblemData.Dataset,
-                                                                     ProblemData.AllowedInputVariables,
-                                                                     ProblemData.TargetVariable);
-      problemData.TrainingPartition.Start = ProblemData.TrainingPartition.Start;
-      problemData.TrainingPartition.End = ProblemData.TrainingPartition.End;
-      problemData.TestPartition.Start = ProblemData.TestPartition.Start;
-      problemData.TestPartition.End = ProblemData.TestPartition.End;
+      IClassificationProblemData problemData = new ClassificationProblemData(ProblemData);
 
       foreach (var solution in ClassificationSolutions) {

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationProblemData.cs

@@ -306 +306 @@
         classNamesCache.Add(ClassNamesParameter.Value[i, 0]);
     }
+
     public override IDeepCloneable Clone(Cloner cloner) {
       if (this == emptyProblemData) return emptyProblemData;
@@ -311 +312 @@
     }
 
-    public ClassificationProblemData() : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariable) { }
+    public ClassificationProblemData() : this(defaultDataset, defaultAllowedInputVariables, defaultTargetVariable, Enumerable.Empty<string>()) { }
 
     public ClassificationProblemData(IClassificationProblemData classificationProblemData)
-      : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable) {
+      : this(classificationProblemData, classificationProblemData.Dataset) {
+    }
+
+    /// <summary>
+    /// This method satisfies a common use case: making a copy of the problem but providing a different dataset.
+    /// One must be careful here that the dataset passed is not modified, as that would invalidate the problem data internals.
+    /// Passing a ModifiableDataset to this constructor is therefore discouraged.
+    /// </summary>
+    /// <param name="classificationProblemData">The original instance of classification problem data.</param>
+    /// <param name="dataset">The new dataset.</param>
+    public ClassificationProblemData(IClassificationProblemData classificationProblemData, IDataset dataset)
+    : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable, classificationProblemData.ClassNames, classificationProblemData.PositiveClass) {
+
       TrainingPartition.Start = classificationProblemData.TrainingPartition.Start;
       TrainingPartition.End = classificationProblemData.TrainingPartition.End;
@@ -320 +333 @@
       TestPartition.End = classificationProblemData.TestPartition.End;
 
-      for (int i = 0; i < classificationProblemData.ClassNames.Count(); i++)
-        ClassNamesParameter.Value[i, 0] = classificationProblemData.ClassNames.ElementAt(i);
-
-      //mkommend: The positive class depends on the class names and as a result must only be set after the classe names parameter.
-      PositiveClass = classificationProblemData.PositiveClass;
-
       for (int i = 0; i < Classes; i++) {
         for (int j = 0; j < Classes; j++) {
@@ -333 +340 @@
     }
 
-    public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+    public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
+      IEnumerable<string> classNames = null,
+      string positiveClass = null, // can be null in which case it's set as the first class name
+      IEnumerable<ITransformation> transformations = null)
       : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
       var validTargetVariableValues = CheckVariablesForPossibleTargetVariables(dataset).Select(x => new StringValue(x).AsReadOnly()).ToList();
@@ -339 +349 @@
 
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(validTargetVariableValues), target));
-      Parameters.Add(new FixedValueParameter<StringMatrix>(ClassNamesParameterName, ""));
+      Parameters.Add(new FixedValueParameter<StringMatrix>(ClassNamesParameterName, "", new StringMatrix()));
       Parameters.Add(new ConstrainedValueParameter<StringValue>(PositiveClassParameterName, "The positive class which is used for quality measure calculation (e.g., specifity, sensitivity,...)"));
       Parameters.Add(new FixedValueParameter<DoubleMatrix>(ClassificationPenaltiesParameterName, ""));
 
       RegisterParameterEvents();
-      ResetTargetVariableDependentMembers();
+      ResetTargetVariableDependentMembers(); // correctly set the values of the parameters added above
+
+      // set the class names
+      if (classNames != null && classNames.Any()) {
+        // better to allocate lists because we use these multiple times below
+        var names = classNames.ToList();
+        var values = ClassValuesCache;
+
+        if (names.Count != values.Count) {
+          throw new ArgumentException();
+        }
+
+        ((IStringConvertibleMatrix)ClassNamesParameter.Value).Columns = 1;
+        ((IStringConvertibleMatrix)ClassNamesParameter.Value).Rows = names.Count;
+
+        for (int i = 0; i < names.Count; ++i) {
+          SetClassName(values[i], names[i]);
+        }
+      }
+
+      // set the positive class value
+      if (positiveClass != null) {
+        PositiveClass = positiveClass;
+      }
     }
 

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/ClassificationSolutionVariableImpactsCalculator.cs

@@ -26 +26 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 using HeuristicLab.Random;
 
@@ -173 +173 @@
 
       IList originalValues = null;
-      IList replacementValues = GetReplacementValues(modifiableDataset, variableName, model, rows, targetValues, out originalValues, replacementMethod, factorReplacementMethod);
-
-      double newValue = CalculateQualityForReplacement(model, modifiableDataset, variableName, originalValues, rows, replacementValues, targetValues);
+      IList replacementValues = GetReplacementValues(modifiableDataset, variableName, model, problemData.AllowedInputVariables, rows, targetValues, out originalValues, replacementMethod, factorReplacementMethod);
+
+      double newValue = CalculateQualityForReplacement(model, modifiableDataset, problemData.AllowedInputVariables, variableName, originalValues, rows, replacementValues, targetValues);
       double impact = quality - newValue;
 
@@ -184 +184 @@
       string variableName,
       IClassificationModel model,
+      IEnumerable<string> allowedInputVariables,
       IEnumerable<int> rows,
       IEnumerable<double> targetValues,
@@ -196 +197 @@
       } else if (modifiableDataset.VariableHasType<string>(variableName)) {
         originalValues = modifiableDataset.GetReadOnlyStringValues(variableName).ToList();
-        replacementValues = GetReplacementValuesForString(model, modifiableDataset, variableName, rows, (List<string>)originalValues, targetValues, factorReplacementMethod);
+        replacementValues = GetReplacementValuesForString(model, modifiableDataset, allowedInputVariables, variableName, rows, (List<string>)originalValues, targetValues, factorReplacementMethod);
       } else {
         throw new NotSupportedException("Variable not supported");
@@ -254 +255 @@
     private static IList GetReplacementValuesForString(IClassificationModel model,
       ModifiableDataset modifiableDataset,
+      IEnumerable<string> allowedInputVariables,
       string variableName,
       IEnumerable<int> rows,
@@ -270 +272 @@
             List<string> curReplacementValues = Enumerable.Repeat(repl, modifiableDataset.Rows).ToList();
             //fholzing: this result could be used later on (theoretically), but is neglected for better readability/method consistency 
-            var newValue = CalculateQualityForReplacement(model, modifiableDataset, variableName, originalValues, rows, curReplacementValues, targetValues);
+            var newValue = CalculateQualityForReplacement(model, modifiableDataset, allowedInputVariables, variableName, originalValues, rows, curReplacementValues, targetValues);
             var curQuality = newValue;
 
@@ -308 +310 @@
       IClassificationModel model,
       ModifiableDataset modifiableDataset,
+      IEnumerable<string> allowedInputVariables,
       string variableName,
       IList originalValues,
@@ -317 +320 @@
       var discModel = model as IDiscriminantFunctionClassificationModel;
       if (discModel != null) {
-        var problemData = new ClassificationProblemData(modifiableDataset, modifiableDataset.VariableNames, model.TargetVariable);
+        var problemData = new ClassificationProblemData(modifiableDataset, allowedInputVariables, model.TargetVariable);
         discModel.RecalculateModelParameters(problemData, rows);
       }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Classification/DiscriminantFunctionClassificationModel.cs

@@ -74 +74 @@
       classValues = (double[])original.classValues.Clone();
       thresholds = (double[])original.thresholds.Clone();
+      thresholdCalculator = (IDiscriminantFunctionThresholdCalculator)original.thresholdCalculator.Clone();
     }
 

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

@@ -1 @@
-#region License Information
+#region License Information
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -23 +23 @@
 using System.Collections.Generic;
 using System.Linq;
+using HEAL.Attic;
 using HeuristicLab.Common;
 using HeuristicLab.Core;
 using HeuristicLab.Data;
 using HeuristicLab.Parameters;
-using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
@@ -34 +34 @@
   public class RegressionProblemData : DataAnalysisProblemData, IRegressionProblemData, IStorableContent {
     protected const string TargetVariableParameterName = "TargetVariable";
+    protected const string VariableRangesParameterName = "VariableRanges";
+    protected const string ShapeConstraintsParameterName = "ShapeConstraints";
     public string Filename { get; set; }
 
@@ -91 +93 @@
       problemData.Parameters.Add(new FixedValueParameter<IntRange>(TestPartitionParameterName, "", (IntRange)new IntRange(0, 0).AsReadOnly()));
       problemData.Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>()));
+      problemData.Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, "", new IntervalCollection()));
+      problemData.Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, "", new ShapeConstraints()));
       emptyProblemData = problemData;
     }
     #endregion
 
-    public IConstrainedValueParameter<StringValue> TargetVariableParameter {
-      get { return (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName]; }
-    }
+    #region parameter properties
+    public IConstrainedValueParameter<StringValue> TargetVariableParameter => (IConstrainedValueParameter<StringValue>)Parameters[TargetVariableParameterName];
+    public IFixedValueParameter<ShapeConstraints> ShapeConstraintsParameter => (IFixedValueParameter<ShapeConstraints>)Parameters[ShapeConstraintsParameterName];
+    public IFixedValueParameter<IntervalCollection> VariableRangesParameter => (IFixedValueParameter<IntervalCollection>)Parameters[VariableRangesParameterName];
+    #endregion
+
+    #region properties
+    public IntervalCollection VariableRanges {
+      get => VariableRangesParameter.Value;
+    }
+
+
+    public ShapeConstraints ShapeConstraints => ShapeConstraintsParameter.Value;
+
+
     public string TargetVariable {
       get { return TargetVariableParameter.Value.Value; }
@@ -109 +125 @@
       }
     }
-
-    public IEnumerable<double> TargetVariableValues {
-      get { return Dataset.GetDoubleValues(TargetVariable); }
-    }
-    public IEnumerable<double> TargetVariableTrainingValues {
-      get { return Dataset.GetDoubleValues(TargetVariable, TrainingIndices); }
-    }
-    public IEnumerable<double> TargetVariableTestValues {
-      get { return Dataset.GetDoubleValues(TargetVariable, TestIndices); }
-    }
+    public IEnumerable<double> TargetVariableValues => Dataset.GetDoubleValues(TargetVariable);
+    public IEnumerable<double> TargetVariableTrainingValues => Dataset.GetDoubleValues(TargetVariable, TrainingIndices);
+    public IEnumerable<double> TargetVariableTestValues => Dataset.GetDoubleValues(TargetVariable, TestIndices);
+    #endregion
+
 
 
@@ -125 +136 @@
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      if (!Parameters.ContainsKey(VariableRangesParameterName)) {
+        var intervalCollection = Dataset.GetIntervals();
+        Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
+      }
+      if (Parameters.ContainsKey("IntervalConstraints")) {
+        var param = (IFixedValueParameter<ShapeConstraints>)Parameters["IntervalConstraints"];
+        Parameters.Remove(param);
+        Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, param.Value));
+      }
+      if (!Parameters.ContainsKey(ShapeConstraintsParameterName)) {
+        Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, new ShapeConstraints()));
+      }
+
       RegisterParameterEvents();
     }
@@ -148 +172 @@
     }
 
-    public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
+    public RegressionProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
+      IEnumerable<ITransformation> transformations = null,
+      IntervalCollection variableRanges = null,
+      ShapeConstraints shapeConstraints = null)
       : base(dataset, allowedInputVariables, transformations ?? Enumerable.Empty<ITransformation>()) {
       var variables = InputVariables.Select(x => x.AsReadOnly()).ToList();
       Parameters.Add(new ConstrainedValueParameter<StringValue>(TargetVariableParameterName, new ItemSet<StringValue>(variables), variables.Where(x => x.Value == targetVariable).First()));
+      if (variableRanges == null) {
+        variableRanges = Dataset.GetIntervals();
+      }
+      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, variableRanges));
+
+      if (shapeConstraints == null) {
+        shapeConstraints = new ShapeConstraints();
+      }
+      Parameters.Add(new FixedValueParameter<ShapeConstraints>(ShapeConstraintsParameterName, shapeConstraints));
       RegisterParameterEvents();
     }
-
     private void RegisterParameterEvents() {
-      TargetVariableParameter.ValueChanged += new EventHandler(TargetVariableParameter_ValueChanged);
-    }
-    private void TargetVariableParameter_ValueChanged(object sender, EventArgs e) {
+      TargetVariableParameter.ValueChanged += new EventHandler(Parameter_ValueChanged);
+      // VariableRanges and ShapeConstraints are fixed parameters
+    }
+    private void Parameter_ValueChanged(object sender, EventArgs e) {
       OnChanged();
     }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisModel.cs

@@ -25 +25 @@
 
 namespace HeuristicLab.Problems.DataAnalysis {
-  [StorableType("f85ccf7a-7df5-431e-bc4d-be6f3c4c2338")]
   /// <summary>
   /// Interface for all data-analysis models (regression/classification/clustering).
   /// <remarks>All methods and properties in in this interface must be implemented thread safely</remarks>
   /// </summary>
+  [StorableType("f85ccf7a-7df5-431e-bc4d-be6f3c4c2338")]
   public interface IDataAnalysisModel : INamedItem {
     IEnumerable<string> VariablesUsedForPrediction { get; }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDataAnalysisProblem.cs

@@ -35 +35 @@
   [StorableType("c2f6fcdd-ab62-4423-be75-01aa694df411")]
   public interface IDataAnalysisProblem<T> : IDataAnalysisProblem
-  where T : class, IDataAnalysisProblemData {
+    where T : class, IDataAnalysisProblemData {
     new IValueParameter<T> ProblemDataParameter { get; }
     new T ProblemData { get; set; }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IDependencyCalculator.cs

@@ -22 +22 @@
 using System;
 using System.Collections.Generic;
+using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("3283B3FB-8467-4B99-9B6E-23BF3D1B8505")]
   public interface IDependencyCalculator {
     double Maximum { get; }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/IOnlineCalculator.cs

@@ -22 +22 @@
 
 using System;
+using HEAL.Attic;
+
 namespace HeuristicLab.Problems.DataAnalysis {
   [Flags]
+  [StorableType("8A28DDA1-4814-4B77-9457-0EE930BE9C73")]
   public enum OnlineCalculatorError {
     /// <summary>
@@ -38 +41 @@
     InsufficientElementsAdded = 2
   }
+
+  [StorableType("119C8242-3EE7-4C34-A7AC-68ABF76EB11B")]
   public interface IOnlineCalculator {
     OnlineCalculatorError ErrorState { get; }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/Regression/IRegressionProblemData.cs

@@ -1 +1 @@
 #region License Information
+
 /* HeuristicLab
  * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
@@ -18 +19 @@
  * along with HeuristicLab. If not, see <http://www.gnu.org/licenses/>.
  */
+
 #endregion
 
@@ -28 +30 @@
     string TargetVariable { get; set; }
 
+    IntervalCollection VariableRanges { get; }
+    ShapeConstraints ShapeConstraints { get; }
+
     IEnumerable<double> TargetVariableValues { get; }
     IEnumerable<double> TargetVariableTrainingValues { get; }

branches/3026_IntegrationIntoSymSpace/HeuristicLab.Problems.DataAnalysis/3.4/Interfaces/TimeSeriesPrognosis/IOnlineTimeSeriesCalculator.cs

@@ -22 +22 @@
 
 using System.Collections.Generic;
+using HEAL.Attic;
 
 namespace HeuristicLab.Problems.DataAnalysis {
+  [StorableType("7461AC5D-9D9A-4DCD-B32F-602260E58FFC")]
   public interface IOnlineTimeSeriesCalculator {
     OnlineCalculatorError ErrorState { get; }