Changeset 17918

Timestamp:

03/29/21 09:54:58 (3 years ago)

Author:

mkommend

Message:

#3105: Merge trunk changes into branch.

Location:

branches/3105_PythonFormatter

Files:

• . (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis.Views (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis.Views/3.4/RandomForestModelEvaluationView.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4 (modified) (1 prop)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GAM/GeneralizedAdditiveModelAlgorithm.cs (modified) (7 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GAM/Spline1dModel.cs (modified) (3 diffs)
• HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs (modified) (1 diff)
• HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelSurrogate.cs (modified) (1 diff)
• HeuristicLab.DataPreprocessing (modified) (1 prop)
• HeuristicLab.DataPreprocessing/3.4 (modified) (1 prop)
• HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs (modified) (1 diff)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding (modified) (1 prop)
• HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4 (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEConstraintsEvaluator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/MultiObjective/NMSEConstraintsEvaluator.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ShapeConstraintsAnalyzer.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/ShapeConstraintsAnalyzer.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSEConstraintsEvaluator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/Evaluators/NMSEConstraintsEvaluator.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs (modified) (1 diff)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/IntervalArithmeticGrammar.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Grammars/IntervalArithmeticGrammar.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs (modified) (3 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interfaces/IBoundsEstimator.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithBoundsEstimator.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalArithCompiledExpressionBoundsEstimator.cs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.cs (modified) (10 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/IntervalUtil.cs)
• HeuristicLab.Problems.DataAnalysis.Views (modified) (1 prop)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj (modified) (6 diffs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.Designer.cs (deleted)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/IntervalCollectionView.cs (deleted)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/Resources.Designer.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/Resources.Designer.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/Resources.resx (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Properties/Resources.resx)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/IntervalCollectionView.Designer.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/IntervalCollectionView.Designer.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/IntervalCollectionView.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/IntervalCollectionView.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartViewBase.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintView.Designer.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintView.Designer.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintView.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintView.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintsView.Designer.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintsView.Designer.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintsView.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/ShapeConstraintsView.cs)
• HeuristicLab.Problems.DataAnalysis.Views/3.4/Resources (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis.Views/3.4/Resources)
• 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/ClassificationProblemData.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs (modified) (5 diffs, 1 prop)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs (modified) (4 diffs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraint.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs (copied) (copied from trunk/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/ShapeConstraintsParser.cs)
• HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs (modified) (5 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/Regression/IRegressionProblemData.cs (modified) (3 diffs)
• HeuristicLab.Tests (modified) (1 prop)
• HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/IntervalTest.cs (modified) (14 diffs)
• HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs (modified) (2 diffs)

branches/3105_PythonFormatter/HeuristicLab.Algorithms.DataAnalysis.Views/3.4/RandomForestModelEvaluationView.cs

@@ -79 +79 @@
     private IContent CreateModel(int idx) {
       idx -= 1;
-      var rfModel = Content.Model as RandomForestModel;
+      var rfModel = Content.Model as IRandomForestModel;
       if (rfModel == null) return null;
       var regProblemData = Content.ProblemData as IRegressionProblemData;

branches/3105_PythonFormatter/HeuristicLab.Algorithms.DataAnalysis/3.4/GAM/GeneralizedAdditiveModelAlgorithm.cs

@@ -39 +39 @@
   [Creatable(CreatableAttribute.Categories.DataAnalysisRegression, Priority = 600)]
   public sealed class GeneralizedAdditiveModelAlgorithm : FixedDataAnalysisAlgorithm<IRegressionProblem> {
+
     #region ParameterNames
 
@@ -46 +47 @@
     private const string SetSeedRandomlyParameterName = "SetSeedRandomly";
     private const string CreateSolutionParameterName = "CreateSolution";
+
     #endregion
 
@@ -141 +143 @@
       var problemData = Problem.ProblemData;
       var ds = problemData.Dataset;
-      var trainRows = problemData.TrainingIndices;
-      var testRows = problemData.TestIndices;
+      var trainRows = problemData.TrainingIndices.ToArray();
+      var testRows = problemData.TestIndices.ToArray();
       var avgY = problemData.TargetVariableTrainingValues.Average();
       var inputVars = problemData.AllowedInputVariables.ToArray();
@@ -178 +180 @@
       double[] resTest = problemData.TargetVariableTestValues.Select(yi => yi - avgY).ToArray();
 
-      curRMSE.Value = res.StandardDeviation();
-      curRMSETest.Value = resTest.StandardDeviation();
-      rmseRow.Values.Add(res.StandardDeviation()); 
-      rmseRowTest.Values.Add(resTest.StandardDeviation());
+      curRMSE.Value = RMSE(res);
+      curRMSETest.Value = RMSE(resTest);
+      rmseRow.Values.Add(curRMSE.Value);
+      rmseRowTest.Values.Add(curRMSETest.Value);
 
 
@@ -197 +199 @@
           AddInPlace(resTest, f[inputIdx].GetEstimatedValues(ds, testRows));
 
-          rssTable[inputIdx, 0] = res.Variance();
+          rssTable[inputIdx, 0] = MSE(res);
           f[inputIdx] = RegressSpline(problemData, inputVar, res, lambda);
 
@@ -204 +206 @@
         }
 
-        curRMSE.Value = res.StandardDeviation(); 
-        curRMSETest.Value = resTest.StandardDeviation();
+        curRMSE.Value = RMSE(res);
+        curRMSETest.Value = RMSE(resTest);
         rmseRow.Values.Add(curRMSE.Value);
         rmseRowTest.Values.Add(curRMSETest.Value);
@@ -215 +217 @@
         var model = new RegressionEnsembleModel(f.Concat(new[] { new ConstantModel(avgY, problemData.TargetVariable) }));
         model.AverageModelEstimates = false;
-        var solution = model.CreateRegressionSolution((IRegressionProblemData)problemData.Clone());
+        var solution = model.CreateRegressionSolution((IRegressionProblemData)problemData.Clone());        
         Results.Add(new Result("Ensemble solution", solution));
       }
+    }
+
+    public static double MSE(IEnumerable<double> residuals) {
+      var mse  = residuals.Select(r => r * r).Average();
+      return mse;
+    }
+
+    public static double RMSE(IEnumerable<double> residuals) {
+      var mse = MSE(residuals);
+      var rmse = Math.Sqrt(mse);
+      return rmse;
     }
 

branches/3105_PythonFormatter/HeuristicLab.Algorithms.DataAnalysis/3.4/GAM/Spline1dModel.cs

@@ -26 +26 @@
 using HeuristicLab.Core;
 using HeuristicLab.Problems.DataAnalysis;
+using System;
 
 namespace HeuristicLab.Algorithms.DataAnalysis {
@@ -35 +36 @@
     private alglib.spline1d.spline1dinterpolant interpolant;
 
-    [Storable]
-    private readonly string[] variablesUsedForPrediction;
-    public override IEnumerable<string> VariablesUsedForPrediction {
-      get {
-        return variablesUsedForPrediction;
+    [Storable(OldName = "variablesUsedForPrediction")]
+    private string[] StorableVariablesUsedForPrediction {
+      set {
+        if (value.Length > 1) throw new ArgumentException("A one-dimensional spline model supports only one input variable.");
+        inputVariable = value[0];
       }
     }
+
+    [Storable]
+    private string inputVariable;
+    public override IEnumerable<string> VariablesUsedForPrediction => new[] { inputVariable };
 
     [StorableConstructor]
@@ -49 +54 @@
 
     private Spline1dModel(Spline1dModel orig, Cloner cloner) : base(orig, cloner) {
-      this.variablesUsedForPrediction = orig.VariablesUsedForPrediction.ToArray();
+      this.inputVariable = orig.inputVariable;
       this.interpolant = (alglib.spline1d.spline1dinterpolant)orig.interpolant.make_copy();
     }
     public Spline1dModel(alglib.spline1d.spline1dinterpolant interpolant, string targetVar, string inputVar)
-      : base(targetVar, "Spline model (1d)") {
-      this.interpolant = (alglib.spline1d.spline1dinterpolant)interpolant.make_copy();      
-      this.variablesUsedForPrediction = new string[] { inputVar };
+      : base(targetVar, $"Spline model ({inputVar})") {
+      this.interpolant = (alglib.spline1d.spline1dinterpolant)interpolant.make_copy();
+      this.inputVariable = inputVar;      
     }
 
 
-    public override IDeepCloneable Clone(Cloner cloner) {
-      return new Spline1dModel(this, cloner);
+    public override IDeepCloneable Clone(Cloner cloner) => new Spline1dModel(this, cloner);
+
+    public override IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData) {
+      var solution =  new RegressionSolution(this, (IRegressionProblemData)problemData.Clone());
+      solution.Name = $"Regression Spline ({inputVariable})";
+
+      return solution;
     }
 
-    public override IRegressionSolution CreateRegressionSolution(IRegressionProblemData problemData) {
-      return new RegressionSolution(this, (IRegressionProblemData)problemData.Clone());
-    }
-
-    public double GetEstimatedValue(double x) {
-      return alglib.spline1d.spline1dcalc(interpolant, x);
-    }
+    public double GetEstimatedValue(double x) => alglib.spline1d.spline1dcalc(interpolant, x);
 
     public override IEnumerable<double> GetEstimatedValues(IDataset dataset, IEnumerable<int> rows) {
-      var x = dataset.GetDoubleValues(VariablesUsedForPrediction.First(), rows).ToArray();
-      foreach (var xi in x) {
-        yield return GetEstimatedValue(xi);
-      }
+      return dataset.GetDoubleValues(inputVariable, rows).Select(GetEstimatedValue);
     }
 

branches/3105_PythonFormatter/HeuristicLab.Algorithms.DataAnalysis/3.4/GradientBoostedTrees/GradientBoostedTreesAlgorithm.cs

@@ -281 +281 @@
             new AccuracyMaximizationThresholdCalculator());
           var classificationProblemData = new ClassificationProblemData(problemData.Dataset,
-            problemData.AllowedInputVariables, problemData.TargetVariable, problemData.Transformations);
+            problemData.AllowedInputVariables, problemData.TargetVariable, transformations: problemData.Transformations);
           classificationProblemData.TrainingPartition.Start = Problem.ProblemData.TrainingPartition.Start;
           classificationProblemData.TrainingPartition.End = Problem.ProblemData.TrainingPartition.End;

branches/3105_PythonFormatter/HeuristicLab.Algorithms.DataAnalysis/3.4/RandomForest/RandomForestModelSurrogate.cs

@@ -135 +135 @@
     }
 
+    public override bool IsProblemDataCompatible(IDataAnalysisProblemData problemData, out string errorMessage) {
+      return ActualModel.IsProblemDataCompatible(problemData, out errorMessage);
+    }
+
     //RegressionModel methods
     public bool IsProblemDataCompatible(IRegressionProblemData problemData, out string errorMessage) {

branches/3105_PythonFormatter/HeuristicLab.DataPreprocessing/3.4/ProblemDataCreator.cs

@@ -96 +96 @@
         targetVariable = context.Data.VariableNames.First();
       var inputVariables = GetDoubleInputVariables(targetVariable);
-      var newProblemData = new ClassificationProblemData(ExportedDataset, inputVariables, targetVariable, Transformations) {
+      var newProblemData = new ClassificationProblemData(ExportedDataset, inputVariables, targetVariable, transformations: Transformations) {
         PositiveClass = oldProblemData.PositiveClass
       };

branches/3105_PythonFormatter/HeuristicLab.Encodings.SymbolicExpressionTreeEncoding/3.4/Crossovers/SubtreeCrossover.cs

@@ -55 +55 @@
       get { return (IValueLookupParameter<IntValue>)Parameters[MaximumSymbolicExpressionTreeDepthParameterName]; }
     }
-    public IFixedValueParameter<DoubleValue> CrossoverProbabilityParameter {
-      get { return (IFixedValueParameter<DoubleValue>)Parameters[CrossoverProbabilityParameterName]; }
+    public IFixedValueParameter<PercentValue> CrossoverProbabilityParameter {
+      get { return (IFixedValueParameter<PercentValue>)Parameters[CrossoverProbabilityParameterName]; }
     }
     #endregion
@@ -81 +81 @@
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeLengthParameterName, "The maximal length (number of nodes) of the symbolic expression tree."));
       Parameters.Add(new ValueLookupParameter<IntValue>(MaximumSymbolicExpressionTreeDepthParameterName, "The maximal depth of the symbolic expression tree (a tree with one node has depth = 0)."));
-      Parameters.Add(new ValueLookupParameter<PercentValue>(InternalCrossoverPointProbabilityParameterName, "The probability to select an internal crossover point (instead of a leaf node).", new PercentValue(0.9)));
-      Parameters.Add(new FixedValueParameter<DoubleValue>(CrossoverProbabilityParameterName, "", new DoubleValue(1)));
+      Parameters.Add(new ValueLookupParameter<PercentValue>(InternalCrossoverPointProbabilityParameterName, "The probability to select an internal crossover point (instead of a leaf node).", new PercentValue(0.9, true)));
+      Parameters.Add(new FixedValueParameter<PercentValue>(CrossoverProbabilityParameterName, "The probability that a crossover is performed. Otherwise a copy of the first parent is returned.", new PercentValue(1, true)));
     }
 
     [StorableHook(HookType.AfterDeserialization)]
     private void AfterDeserialization() {
+      // replace with PercentValue for files which had CrossoverProbability as DoubleValue
+      if (Parameters.ContainsKey(CrossoverProbabilityParameterName) && (Parameters[CrossoverProbabilityParameterName] is IFixedValueParameter<DoubleValue> oldParam)) {
+        var oldValue = oldParam.Value.Value;
+        Parameters.Remove(oldParam);
+        Parameters.Add(new FixedValueParameter<PercentValue>(CrossoverProbabilityParameterName, "The probability that a crossover is performed. Otherwise a copy of the first parent is returned.", new PercentValue(oldValue)));
+      }
       if (!Parameters.ContainsKey(CrossoverProbabilityParameterName)) {
-        Parameters.Add(new FixedValueParameter<DoubleValue>(CrossoverProbabilityParameterName, "", new DoubleValue(1)));
+        Parameters.Add(new FixedValueParameter<PercentValue>(CrossoverProbabilityParameterName, "The probability that a crossover is performed. Otherwise a copy of the first parent is returned.", new PercentValue(1, true)));
       }
     }
@@ -106 +112 @@
       double probability,
       double internalCrossoverPointProbability, int maxTreeLength, int maxTreeDepth) {
-      if ((probability < 1) && (random.NextDouble() >= probability)) return random.NextDouble() < 0.5 ? parent0 : parent1;
+      if ((probability < 1) && (random.NextDouble() >= probability)) return parent0;
       // select a random crossover point in the first parent 
       CutPoint crossoverPoint0;

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression-3.4.csproj

@@ -119 +119 @@
   </ItemGroup>
   <ItemGroup>
+    <Compile Include="MultiObjective\NMSEConstraintsEvaluator.cs" />
     <Compile Include="MultiObjective\PearsonRSquaredNestedTreeSizeEvaluator.cs" />
     <Compile Include="MultiObjective\PearsonRSquaredNumberOfVariablesEvaluator.cs" />
@@ -125 +126 @@
     <Compile Include="MultiObjective\SymbolicRegressionMultiObjectiveValidationBestSolutionAnalyzer.cs" />
     <Compile Include="Plugin.cs" />
+    <Compile Include="ShapeConstraintsAnalyzer.cs" />
     <Compile Include="SingleObjective\ConstantOptimizationAnalyzer.cs" />
+    <Compile Include="SingleObjective\Evaluators\NMSEConstraintsEvaluator.cs" />
     <Compile Include="SingleObjective\Evaluators\SymbolicRegressionMeanRelativeErrorEvaluator.cs" />
     <Compile Include="SingleObjective\SymbolicRegressionSolutionsAnalyzer.cs" />

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SingleObjective/SymbolicRegressionSingleObjectiveProblem.cs

@@ -91 +91 @@
         changed = true;
       }
+
+      if (!Operators.OfType<ShapeConstraintsAnalyzer>().Any()) {
+        Operators.Add(new ShapeConstraintsAnalyzer());
+        changed = true;
+      }
       if (changed) {
         ParameterizeOperators();
@@ -113 +118 @@
       Operators.Add(new SymbolicRegressionSolutionsAnalyzer());
       Operators.Add(new SymbolicExpressionTreePhenotypicSimilarityCalculator());
+      Operators.Add(new ShapeConstraintsAnalyzer());
       Operators.Add(new SymbolicRegressionPhenotypicDiversityAnalyzer(Operators.OfType<SymbolicExpressionTreePhenotypicSimilarityCalculator>()) { DiversityResultName = "Phenotypic Diversity" });
       ParameterizeOperators();

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic.Regression/3.4/SymbolicRegressionSolution.cs

@@ -109 +109 @@
           Add(new Result(ModelBoundsResultName, "Results concerning the derivation of symbolic regression solution", value));
         }
-
       }
     }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Converters/DerivativeCalculator.cs

@@ -149 +149 @@
         return Product(Product(CreateConstant(3.0), Square(f)), Derive(f, variableName));
       }
+      if (branch.Symbol is Power) {
+        // HL evaluators handle power strangely (exponent is rounded to an integer)
+        // here we only support the case when the exponent is a constant integer 
+        var exponent = branch.GetSubtree(1) as ConstantTreeNode;
+        if (exponent != null && Math.Truncate(exponent.Value) == exponent.Value) {
+          var newPower = (ISymbolicExpressionTreeNode)branch.Clone();
+          var f = (ISymbolicExpressionTreeNode)newPower.GetSubtree(0).Clone();
+          var newExponent = (ConstantTreeNode)newPower.GetSubtree(1);
+          newExponent.Value -= 1;
+          return Product(Product(CreateConstant(exponent.Value), newPower), Derive(f, variableName));
+        } else throw new NotSupportedException("Cannot derive non-integer powers");
+      }
       if (branch.Symbol is Absolute) {
         var f = (ISymbolicExpressionTreeNode)branch.GetSubtree(0).Clone();
@@ -263 +275 @@
           !(n.Symbol is Cube) &&
           !(n.Symbol is CubeRoot) &&
+          !(n.Symbol is Power) &&
           !(n.Symbol is Absolute) &&
           !(n.Symbol is AnalyticQuotient) &&
+          !(n.Symbol is HyperbolicTangent) &&
           !(n.Symbol is Sine) &&
           !(n.Symbol is Cosine) &&

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/HeuristicLab.Problems.DataAnalysis.Symbolic-3.4.csproj

@@ -107 +107 @@
       <Private>False</Private>
     </Reference>
-    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+    <Reference Include="HEAL.Attic, Version=1.4.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\..\bin\HEAL.Attic.dll</HintPath>
@@ -158 +158 @@
     <Compile Include="Formatters\SymbolicDataAnalysisExpressionCSharpFormatter.cs" />
     <Compile Include="Grammars\DataAnalysisGrammar.cs" />
+    <Compile Include="Grammars\IntervalArithmeticGrammar.cs" />
     <Compile Include="Hashing\HashExtensions.cs" />
     <Compile Include="Hashing\HashUtil.cs" />
@@ -164 +165 @@
     <Compile Include="Importer\SymbolicExpressionImporter.cs" />
     <Compile Include="Importer\Token.cs" />
+    <Compile Include="Interfaces\IBoundsEstimator.cs" />
     <Compile Include="Interfaces\IModelBacktransformator.cs" />
     <Compile Include="Interfaces\IVariableTreeNode.cs" />
@@ -169 +171 @@
     <Compile Include="Interpreter\BatchInstruction.cs" />
     <Compile Include="Interpreter\BatchOperations.cs" />
+    <Compile Include="Interpreter\IntervalArithBoundsEstimator.cs" />
+    <Compile Include="Interpreter\IntervalArithCompiledExpressionBoundsEstimator.cs" />
     <Compile Include="Interpreter\IntervalInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionCompiledTreeInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeBatchInterpreter.cs" />
     <Compile Include="Interpreter\SymbolicDataAnalysisExpressionTreeNativeInterpreter.cs" />
+    <Compile Include="IntervalUtil.cs" />
     <Compile Include="Selectors\DiversitySelector.cs" />
     <Compile Include="SymbolicDataAnalysisExpressionTreeAverageSimilarityCalculator.cs" />

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Importer/InfixExpressionParser.cs

@@ -64 +64 @@
     }
 
-    private class SymbolNameComparer : IEqualityComparer<ISymbol>, IComparer<ISymbol> {
+    private class SymbolComparer : IEqualityComparer<ISymbol>, IComparer<ISymbol> {
       public int Compare(ISymbol x, ISymbol y) {
         return x.Name.CompareTo(y.Name);
@@ -70 +70 @@
 
       public bool Equals(ISymbol x, ISymbol y) {
-        return Compare(x, y) == 0;
+        return x.GetType() == y.GetType();
       }
 
       public int GetHashCode(ISymbol obj) {
-        return obj.Name.GetHashCode();
+        return obj.GetType().GetHashCode();
       }
     }
@@ -80 +80 @@
     // the lookup table is also used in the corresponding formatter
     internal static readonly BidirectionalLookup<string, ISymbol>
-      knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolNameComparer());
+      knownSymbols = new BidirectionalLookup<string, ISymbol>(StringComparer.InvariantCulture, new SymbolComparer());
 
     private Constant constant = new Constant();

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/IntervalInterpreter.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
 
@@ -32 +34 @@
 namespace HeuristicLab.Problems.DataAnalysis.Symbolic {
   [StorableType("DE6C1E1E-D7C1-4070-847E-63B68562B10C")]
-  [Item("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.")]
+  [Item("IntervalInterpreter", "Interpreter for calculation of intervals of symbolic models.")]
   public sealed class IntervalInterpreter : ParameterizedNamedItem, IStatefulItem {
-
     private const string EvaluatedSolutionsParameterName = "EvaluatedSolutions";
-
-    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter {
-      get { return (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName]; }
-    }
+    public IFixedValueParameter<IntValue> EvaluatedSolutionsParameter =>
+      (IFixedValueParameter<IntValue>)Parameters[EvaluatedSolutionsParameterName];
 
     public int EvaluatedSolutions {
-      get { return EvaluatedSolutionsParameter.Value.Value; }
-      set { EvaluatedSolutionsParameter.Value.Value = value; }
+      get => EvaluatedSolutionsParameter.Value.Value;
+      set => EvaluatedSolutionsParameter.Value.Value = value;
     }
 
     [StorableConstructor]
     private IntervalInterpreter(StorableConstructorFlag _) : base(_) { }
+
     private IntervalInterpreter(IntervalInterpreter original, Cloner cloner)
-        : base(original, cloner) { }
+      : base(original, cloner) { }
 
     public IntervalInterpreter()
-        : base("IntervalInterpreter", "Intperter for calculation of intervals of symbolic models.") {
-      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName, "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
+      : base("IntervalInterpreter", "Interpreter for calculation of intervals of symbolic models.") {
+      Parameters.Add(new FixedValueParameter<IntValue>(EvaluatedSolutionsParameterName,
+        "A counter for the total number of solutions the interpreter has evaluated", new IntValue(0)));
     }
 
@@ -63 +64 @@
 
     #region IStatefulItem Members
+
     public void InitializeState() {
       EvaluatedSolutions = 0;
     }
+
     public void ClearState() { }
+
     #endregion
 
-    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IDataset dataset, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeInterval(
+      ISymbolicExpressionTree tree, IDataset dataset,
+      IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
       return GetSymbolicExpressionTreeInterval(tree, variableRanges);
     }
 
-    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree, IDataset dataset,
-      out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals, IEnumerable<int> rows = null) {
+    public Interval GetSymbolicExpressionTreeIntervals(
+      ISymbolicExpressionTree tree, IDataset dataset,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval>
+        nodeIntervals, IEnumerable<int> rows = null) {
       var variableRanges = DatasetUtil.GetVariableRanges(dataset, rows);
       return GetSymbolicExpressionTreeIntervals(tree, variableRanges, out nodeIntervals);
     }
 
-    public Interval GetSymbolicExpressionTreeInterval(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
+    public Interval GetSymbolicExpressionTreeInterval(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges) {
       lock (syncRoot) {
         EvaluatedSolutions++;
       }
-      int instructionCount = 0;
+
+      Interval outputInterval;
+
+      var instructionCount = 0;
       var instructions = PrepareInterpreterState(tree, variableRanges);
-      var outputInterval = Evaluate(instructions, ref instructionCount);
-
-      // because of numerical errors the bounds might be incorrect
-      if (outputInterval.LowerBound <= outputInterval.UpperBound)
-        return outputInterval;
-      else
-        return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
-    }
-
-
-    public Interval GetSymbolicExpressionTreeIntervals(ISymbolicExpressionTree tree,
-      IReadOnlyDictionary<string, Interval> variableRanges, out IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals) {
+      outputInterval = Evaluate(instructions, ref instructionCount);
+
+      return outputInterval.LowerBound <= outputInterval.UpperBound
+        ? outputInterval
+        : new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
+    }
+
+
+    public Interval GetSymbolicExpressionTreeIntervals(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges,
+      out IDictionary<ISymbolicExpressionTreeNode, Interval>
+        nodeIntervals) {
       lock (syncRoot) {
         EvaluatedSolutions++;
       }
-      int instructionCount = 0;
+
       var intervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       var instructions = PrepareInterpreterState(tree, variableRanges);
-      var outputInterval = Evaluate(instructions, ref instructionCount, intervals);
-
-      // fix incorrect intervals if necessary (could occur because of numerical errors)
+
+      Interval outputInterval;
+      var instructionCount = 0;
+      outputInterval = Evaluate(instructions, ref instructionCount, intervals);
+
       nodeIntervals = new Dictionary<ISymbolicExpressionTreeNode, Interval>();
       foreach (var kvp in intervals) {
@@ -119 +135 @@
       if (outputInterval.IsInfiniteOrUndefined || outputInterval.LowerBound <= outputInterval.UpperBound)
         return outputInterval;
-      else
-        return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
-    }
-
-
-    private static Instruction[] PrepareInterpreterState(ISymbolicExpressionTree tree, IReadOnlyDictionary<string, Interval> variableRanges) {
+
+      return new Interval(outputInterval.UpperBound, outputInterval.LowerBound);
+    }
+
+
+    private static Instruction[] PrepareInterpreterState(
+      ISymbolicExpressionTree tree,
+      IReadOnlyDictionary<string, Interval> variableRanges) {
       if (variableRanges == null)
         throw new ArgumentNullException("No variablew ranges are present!", nameof(variableRanges));
 
-      //Check if all variables used in the tree are present in the dataset
-      foreach (var variable in tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(n => n.VariableName).Distinct()) {
-        if (!variableRanges.ContainsKey(variable)) throw new InvalidOperationException($"No ranges for variable {variable} is present");
-      }
-
-      Instruction[] code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
-      foreach (Instruction instr in code.Where(i => i.opCode == OpCodes.Variable)) {
+      // Check if all variables used in the tree are present in the dataset
+      foreach (var variable in tree.IterateNodesPrefix().OfType<VariableTreeNode>().Select(n => n.VariableName)
+                                   .Distinct())
+        if (!variableRanges.ContainsKey(variable))
+          throw new InvalidOperationException($"No ranges for variable {variable} is present");
+
+      var code = SymbolicExpressionTreeCompiler.Compile(tree, OpCodes.MapSymbolToOpCode);
+      foreach (var instr in code.Where(i => i.opCode == OpCodes.Variable)) {
         var variableTreeNode = (VariableTreeNode)instr.dynamicNode;
         instr.data = variableRanges[variableTreeNode.VariableName];
       }
+
       return code;
     }
 
-    private Interval Evaluate(Instruction[] instructions, ref int instructionCounter, IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null) {
-      Instruction currentInstr = instructions[instructionCounter];
-      //Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
-      //Update instructionCounter, whenever Evaluate is called
+    // Use ref parameter, because the tree will be iterated through recursively from the left-side branch to the right side
+    // Update instructionCounter, whenever Evaluate is called
+    public static Interval Evaluate(
+    Instruction[] instructions, ref int instructionCounter,
+      IDictionary<ISymbolicExpressionTreeNode, Interval> nodeIntervals = null,
+      IReadOnlyDictionary<string, Interval> variableIntervals = null) {
+      var currentInstr = instructions[instructionCounter];
+
       instructionCounter++;
-      Interval result = null;
+      Interval result;
 
       switch (currentInstr.opCode) {
-        //Variables, Constants, ...
         case OpCodes.Variable: {
             var variableTreeNode = (VariableTreeNode)currentInstr.dynamicNode;
             var weightInterval = new Interval(variableTreeNode.Weight, variableTreeNode.Weight);
-            var variableInterval = (Interval)currentInstr.data;
+
+            Interval variableInterval;
+            if (variableIntervals != null && variableIntervals.ContainsKey(variableTreeNode.VariableName))
+              variableInterval = variableIntervals[variableTreeNode.VariableName];
+            else
+              variableInterval = (Interval)currentInstr.data;
 
             result = Interval.Multiply(variableInterval, weightInterval);
@@ -163 +191 @@
             break;
           }
-        //Elementary arithmetic rules
         case OpCodes.Add: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Add(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Sub: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             if (currentInstr.nArguments == 1)
               result = Interval.Multiply(new Interval(-1, -1), result);
 
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Subtract(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Mul: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Multiply(result, argumentInterval);
             }
+
             break;
           }
         case OpCodes.Div: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             if (currentInstr.nArguments == 1)
               result = Interval.Divide(new Interval(1, 1), result);
 
-            for (int i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
               result = Interval.Divide(result, argumentInterval);
             }
-            break;
-          }
-        //Trigonometric functions
+
+            break;
+          }
         case OpCodes.Sin: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Sine(argumentInterval);
             break;
           }
         case OpCodes.Cos: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Cosine(argumentInterval);
             break;
           }
         case OpCodes.Tan: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Tangens(argumentInterval);
             break;
           }
         case OpCodes.Tanh: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.HyperbolicTangent(argumentInterval);
             break;
           }
-        //Exponential functions
         case OpCodes.Log: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Logarithm(argumentInterval);
             break;
           }
         case OpCodes.Exp: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Exponential(argumentInterval);
             break;
           }
         case OpCodes.Square: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Square(argumentInterval);
             break;
           }
         case OpCodes.SquareRoot: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.SquareRoot(argumentInterval);
             break;
           }
         case OpCodes.Cube: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Cube(argumentInterval);
             break;
           }
         case OpCodes.CubeRoot: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.CubicRoot(argumentInterval);
             break;
           }
         case OpCodes.Absolute: {
-            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
+            var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
             result = Interval.Absolute(argumentInterval);
             break;
           }
         case OpCodes.AnalyticQuotient: {
-            result = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-            for (var i = 1; i < currentInstr.nArguments; i++) {
-              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals);
-              result = Interval.AnalyticalQuotient(result, argumentInterval);
+            result = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+            for (var i = 1; i < currentInstr.nArguments; i++) {
+              var argumentInterval = Evaluate(instructions, ref instructionCounter, nodeIntervals, variableIntervals);
+              result = Interval.AnalyticQuotient(result, argumentInterval);
             }
 
@@ -272 +301 @@
       }
 
-      if (nodeIntervals != null)
+      if (!(nodeIntervals == null || nodeIntervals.ContainsKey(currentInstr.dynamicNode)))
         nodeIntervals.Add(currentInstr.dynamicNode, result);
 
@@ -278 +307 @@
     }
 
+
     public static bool IsCompatible(ISymbolicExpressionTree tree) {
-      var containsUnknownSyumbol = (
+      var containsUnknownSymbols = (
         from n in tree.Root.GetSubtree(0).IterateNodesPrefix()
         where
-          !(n.Symbol is Problems.DataAnalysis.Symbolic.Variable) &&
+          !(n.Symbol is Variable) &&
           !(n.Symbol is Constant) &&
           !(n.Symbol is StartSymbol) &&
@@ -292 +322 @@
           !(n.Symbol is Cosine) &&
           !(n.Symbol is Tangent) &&
+          !(n.Symbol is HyperbolicTangent) &&
           !(n.Symbol is Logarithm) &&
           !(n.Symbol is Exponential) &&
@@ -301 +332 @@
           !(n.Symbol is AnalyticQuotient)
         select n).Any();
-      return !containsUnknownSyumbol;
+      return !containsUnknownSymbols;
     }
   }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Views/3.4/HeuristicLab.Problems.DataAnalysis.Views-3.4.csproj

@@ -103 +103 @@
       <Private>False</Private>
     </Reference>
+    <Reference Include="HEAL.Attic, Version=1.5.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>..\..\bin\HEAL.Attic.dll</HintPath>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core">
@@ -221 +225 @@
     <Compile Include="Interfaces\IDataPreprocessorStarter.cs" />
     <Compile Include="Interfaces\IPartialDependencePlot.cs" />
-    <Compile Include="IntervalCollectionView.cs">
-      <SubType>UserControl</SubType>
-    </Compile>
-    <Compile Include="IntervalCollectionView.Designer.cs">
-      <DependentUpon>IntervalCollectionView.cs</DependentUpon>
-    </Compile>
     <Compile Include="MenuItems\ChangeDataOfOptimizersMenuItem.cs" />
     <Compile Include="MenuItems\ShrinkDataAnalysisRunsMenuItem.cs" />
@@ -242 +240 @@
       <DependentUpon>ProblemDataView.cs</DependentUpon>
     </Compile>
+    <Compile Include="Properties\Resources.Designer.cs">
+      <AutoGen>True</AutoGen>
+      <DesignTime>True</DesignTime>
+      <DependentUpon>Resources.resx</DependentUpon>
+    </Compile>
     <Compile Include="Regression\ConfidenceRegressionSolutionEstimatedValuesView.cs">
       <SubType>UserControl</SubType>
@@ -254 +257 @@
       <DependentUpon>ConfidenceRegressionSolutionLineChartView.cs</DependentUpon>
     </Compile>
+    <Compile Include="Regression\IntervalCollectionView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Regression\IntervalCollectionView.Designer.cs">
+      <DependentUpon>IntervalCollectionView.cs</DependentUpon>
+    </Compile>
     <Compile Include="Regression\RegressionEnsembleSolutionModelWeightsView.cs">
       <SubType>UserControl</SubType>
@@ -343 +352 @@
     <Compile Include="Regression\RegressionSolutionScatterPlotView.Designer.cs">
       <DependentUpon>RegressionSolutionScatterPlotView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Regression\ShapeConstraintsView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Regression\ShapeConstraintsView.Designer.cs">
+      <DependentUpon>ShapeConstraintsView.cs</DependentUpon>
+    </Compile>
+    <Compile Include="Regression\ShapeConstraintView.cs">
+      <SubType>UserControl</SubType>
+    </Compile>
+    <Compile Include="Regression\ShapeConstraintView.Designer.cs">
+      <DependentUpon>ShapeConstraintView.cs</DependentUpon>
     </Compile>
     <Compile Include="Solution Views\ClassificationSolutionView.cs">
@@ -605 +626 @@
       <DependentUpon>AbstractFeatureCorrelationView.cs</DependentUpon>
     </EmbeddedResource>
+    <EmbeddedResource Include="Properties\Resources.resx">
+      <Generator>ResXFileCodeGenerator</Generator>
+      <LastGenOutput>Resources.Designer.cs</LastGenOutput>
+    </EmbeddedResource>
   </ItemGroup>
   <ItemGroup>
-    <Reference Include="HEAL.Attic, Version=1.0.0.0, Culture=neutral, PublicKeyToken=ba48961d6f65dcec, processorArchitecture=MSIL">
-      <SpecificVersion>False</SpecificVersion>
-      <HintPath>..\..\bin\HEAL.Attic.dll</HintPath>
-      <Private>False</Private>
-    </Reference>
+    <EmbeddedResource Include="Resources\shapeConstraintsHelp.rtf" />
+    <None Include="Resources\VS2008ImageLibrary_Annotations_Information.png" />
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis.Views/3.4/Regression/RegressionSolutionLineChartViewBase.cs

@@ -81 +81 @@
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].LegendText = ESTIMATEDVALUES_TRAINING_SERIES_NAME;
         this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].ChartType = SeriesChartType.FastLine;
-        this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].EmptyPointStyle.Color = this.chart.Series[ESTIMATEDVALUES_TRAINING_SERIES_NAME].Color;
         int[] trainingIdx;
         double[] trainingY;
@@ -120 +119 @@
         double min = double.MaxValue, max = double.MinValue;
         foreach (var point in chart.Series.SelectMany(x => x.Points)) {
-          if (!point.YValues.Any() || double.IsInfinity(point.YValues[0]) || double.IsNaN(point.YValues[0]))
+          if (point.IsEmpty || !point.YValues.Any() || double.IsInfinity(point.YValues[0]) || double.IsNaN(point.YValues[0]))
             continue;
           var y = point.YValues[0];

branches/3105_PythonFormatter/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/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/HeuristicLab.Problems.DataAnalysis-3.4.csproj

@@ -142 +142 @@
     <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/3105_PythonFormatter/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;
@@ -314 +315 @@
 
     public ClassificationProblemData(IClassificationProblemData classificationProblemData)
-      : this(classificationProblemData.Dataset, classificationProblemData.AllowedInputVariables, classificationProblemData.TargetVariable, classificationProblemData.ClassNames, classificationProblemData.PositiveClass) {
-      
+      : 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;
       TestPartition.Start = classificationProblemData.TestPartition.Start;
       TestPartition.End = classificationProblemData.TestPartition.End;
-      
+
       for (int i = 0; i < Classes; i++) {
         for (int j = 0; j < Classes; j++) {
@@ -328 +340 @@
     }
 
-    public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable, IEnumerable<ITransformation> transformations = null)
-      : this(dataset, allowedInputVariables, targetVariable, Enumerable.Empty<string>(), null, transformations) { }
-
     public ClassificationProblemData(IDataset dataset, IEnumerable<string> allowedInputVariables, string targetVariable,
-      IEnumerable<string> classNames,
+      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)
@@ -348 +357 @@
 
       // set the class names
-      if (classNames.Any()) {
+      if (classNames != null && classNames.Any()) {
         // better to allocate lists because we use these multiple times below
         var names = classNames.ToList();
-        var values = ClassValues.ToList();
+        var values = ClassValuesCache;
 
         if (names.Count != values.Count) {

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/Interval.cs

@@ -33 +33 @@
     [Storable]
     public double UpperBound { get; private set; }
+
+    public double Width => UpperBound - LowerBound;
 
     [StorableConstructor]
@@ -67 +69 @@
     }
 
+    private Interval(double v) : this(v, v) { }
+
     public bool Contains(double value) {
       return LowerBound <= value && value <= UpperBound;
@@ -126 +130 @@
         return false;
 
-      return (UpperBound.IsAlmost(other.UpperBound) || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
-        && (LowerBound.IsAlmost(other.LowerBound) || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
+      return (UpperBound==other.UpperBound || (double.IsNaN(UpperBound) && double.IsNaN(other.UpperBound)))
+        && (LowerBound==other.LowerBound || (double.IsNaN(LowerBound) && double.IsNaN(other.LowerBound)));
     }
 
@@ -267 +271 @@
     }
 
-    public static Interval AnalyticalQuotient(Interval a, Interval b) {
+    public static Interval AnalyticQuotient(Interval a, Interval b) {
       var dividend = a;
       var divisor = Add(Square(b), new Interval(1.0, 1.0));
@@ -276 +280 @@
     }
     #endregion
+
+    #region arithmetic overloads
+    public static Interval operator +(Interval a, Interval b) => Add(a, b);
+    public static Interval operator +(Interval a, double b) => Add(a, new Interval(b));
+    public static Interval operator +(double a, Interval b) => Add(new Interval(a), b);
+    public static Interval operator -(Interval a, Interval b) => Subtract(a, b);
+    public static Interval operator -(Interval a, double b) => Subtract(a, new Interval(b));
+    public static Interval operator -(double a, Interval b) => Subtract(new Interval(a), b);
+    public static Interval operator -(Interval a) => Subtract(new Interval(0), a);
+    public static Interval operator *(Interval a, Interval b) => Multiply(a, b);
+    public static Interval operator *(Interval a, double b) => Multiply(a, new Interval(b));
+    public static Interval operator *(double a, Interval b) => Multiply(new Interval(a), b);
+    public static Interval operator /(Interval a, Interval b) => Divide(a, b);
+    public static Interval operator /(Interval a, double b) => Divide(a, new Interval(b));
+    public static Interval operator /(double a, Interval b) => Divide(new Interval(a), b);
+    public static Interval Exponential(double a) { return Exponential(new Interval(a)); }
+    public static Interval Logarithm(double a) { return Logarithm(new Interval(a)); }
+    public static Interval Sine(double a) { return Sine(new Interval(a)); }
+    public static Interval Cosine(double a) { return Cosine(new Interval(a)); }
+    public static Interval Tangens(double a) { return Tangens(new Interval(a)); }
+    public static Interval HyperbolicTangent(double a) { return HyperbolicTangent(new Interval(a)); }
+    public static Interval Square(double a) { return Square(new Interval(a)); }
+    public static Interval Cube(double a) { return Cube(new Interval(a)); }
+    public static Interval SquareRoot(double a) { return SquareRoot(new Interval(a)); }
+    public static Interval CubicRoot(double a) { return CubicRoot(new Interval(a)); }
+    public static Interval Absolute(double a) { return Absolute(new Interval(a)); }
+    public static Interval AnalyticQuotient(Interval a, double b) { return AnalyticQuotient(a, new Interval(b)); }
+    public static Interval AnalyticQuotient(double a, Interval b) { return AnalyticQuotient(new Interval(a), b); }
+    public static Interval AnalyticQuotient(double a, double b) { return AnalyticQuotient(new Interval(a), new Interval(b)); }
+    #endregion
   }
 }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Interval/IntervalCollection.cs

@@ -1 +1 @@
 #region License Information
 /* HeuristicLab
- * Copyright (C) 2002-2019 Heuristic and Evolutionary Algorithms Laboratory (HEAL)
+ * Copyright (C) Heuristic and Evolutionary Algorithms Laboratory (HEAL)
  *
  * This file is part of HeuristicLab.
@@ -34 +34 @@
       get => HeuristicLab.Common.Resources.VSImageLibrary.Object;
     }
-    private IDictionary<string, Interval> intervals { get; } = new Dictionary<string, Interval>();
 
-    [Storable(Name = "StorableIntervalInformation")]
+    private IDictionary<string, Interval> intervals { get; set; } = new Dictionary<string, Interval>();
+
+    [Storable(OldName = "StorableIntervalInformation")]
     private KeyValuePair<string, double[]>[] StorableIntervalInformation {
+      set {
+        foreach (var varInt in value)
+          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
+      }
+    }
+
+    [Storable]
+    private object[] StorableIntervals {
       get {
-        var l = new List<KeyValuePair<string, double[]>>();
-        foreach (var varInt in intervals)
+        var names = intervals.Keys.ToArray();
+        var lowerBounds = intervals.Values.Select(i => i.LowerBound).ToArray();
+        var upperBounds = intervals.Values.Select(i => i.UpperBound).ToArray();
 
-          l.Add(new KeyValuePair<string, double[]>(varInt.Key,
-            new double[] { varInt.Value.LowerBound, varInt.Value.UpperBound }));
-        return l.ToArray();
+        return new object[] { names, lowerBounds, upperBounds };
       }
 
       set {
-        foreach (var varInt in value)
-          intervals.Add(varInt.Key, new Interval(varInt.Value[0], varInt.Value[1]));
+        var names = (string[])value[0];
+        var lowerBounds = (double[])value[1];
+        var upperBounds = (double[])value[2];
+
+        for (int i = 0; i < names.Length; i++) {
+          intervals.Add(names[i], new Interval(lowerBounds[i], upperBounds[i]));
+        }
       }
     }
@@ -80 +93 @@
     public void SetInterval(string identifier, Interval interval) {
       intervals[identifier] = interval;
+      RaiseChanged();
     }
 
     public void AddInterval(string identifier, Interval interval) {
       intervals.Add(identifier, interval);
+      RaiseChanged();
     }
 
     public void DeleteInterval(string identifier) {
       intervals.Remove(identifier);
+      RaiseChanged();
     }
 
     public IReadOnlyDictionary<string, Interval> GetReadonlyDictionary() {
+      return intervals.ToDictionary(pair => pair.Key, pair => pair.Value);
+    }
+
+    public IDictionary<string, Interval> GetDictionary() {
       return intervals.ToDictionary(pair => pair.Key, pair => pair.Value);
     }
@@ -98 +118 @@
         yield return Tuple.Create(variableInterval.Key, variableInterval.Value);
     }
+
+    public event EventHandler Changed;
+    private void RaiseChanged() {
+      var handler = Changed;
+      if (handler != null)
+        handler(this, EventArgs.Empty);
+    }
+
   }
 }

branches/3105_PythonFormatter/HeuristicLab.Problems.DataAnalysis/3.4/Implementation/Regression/RegressionProblemData.cs

@@ -35 +35 @@
     protected const string TargetVariableParameterName = "TargetVariable";
     protected const string VariableRangesParameterName = "VariableRanges";
-    protected const string IntervalConstraintsParameterName = "IntervalConstraints";
+    protected const string ShapeConstraintsParameterName = "ShapeConstraints";
     public string Filename { get; set; }
 
@@ -94 +94 @@
       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;
 
 
@@ -120 +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
+
 
 
@@ -137 +137 @@
     private void AfterDeserialization() {
       if (!Parameters.ContainsKey(VariableRangesParameterName)) {
-        var intervalCollection = CalculateDatasetIntervals(this.Dataset);
+        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();
     }
@@ -163 +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()));
-      var intervalCollection = CalculateDatasetIntervals(this.Dataset);
-      Parameters.Add(new FixedValueParameter<IntervalCollection>(VariableRangesParameterName, intervalCollection));
+      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 static IntervalCollection CalculateDatasetIntervals(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;
-    }
-
     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/3105_PythonFormatter/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;}
+    IntervalCollection VariableRanges { get; }
+    ShapeConstraints ShapeConstraints { get; }
 
     IEnumerable<double> TargetVariableValues { get; }

branches/3105_PythonFormatter/HeuristicLab.Tests/HeuristicLab.Problems.DataAnalysis-3.4/IntervalTest.cs

@@ -12 +12 @@
     private readonly Interval e = new Interval(4, 6);
 
+    private void CheckLowerAndUpperBoundOfInterval(Interval expected, Interval calculated) {
+      var lowerBoundExpected = expected.LowerBound;
+      var upperBoundExpected = expected.UpperBound;
+      var lowerBoundCalculated = calculated.LowerBound;
+      var upperBoundCalculated = calculated.UpperBound;
+
+      if(double.IsNaN(lowerBoundExpected) && double.IsNaN(lowerBoundCalculated)) {
+        Assert.IsTrue(double.IsNaN(lowerBoundExpected) && double.IsNaN(lowerBoundCalculated));
+      } else if (double.IsNaN(upperBoundExpected) && double.IsNaN(upperBoundCalculated)) {
+        Assert.IsTrue(double.IsNaN(upperBoundExpected) && double.IsNaN(upperBoundCalculated));
+      } else {
+        Assert.AreEqual(lowerBoundExpected, lowerBoundCalculated, 1e-9);
+        Assert.AreEqual(upperBoundExpected, upperBoundCalculated, 1e-9);
+      } 
+    }
+
     [TestMethod]
     [TestCategory("Problems.DataAnalysis")]
@@ -33 +49 @@
 
       //[-1, 1] - [-2, 2] = [-3, 3]
-      Assert.AreEqual<Interval>(Interval.Subtract(a, b), new Interval(-3, 3));
+      CheckLowerAndUpperBoundOfInterval(Interval.Subtract(a, b), new Interval(-3, 3));
       //([-1, 1] - [-2, 2]) - [0, 3] = [-6, 3]
-      Assert.AreEqual<Interval>(Interval.Subtract(Interval.Subtract(a, b), c), new Interval(-6, 3));
+      CheckLowerAndUpperBoundOfInterval(Interval.Subtract(Interval.Subtract(a, b), c), new Interval(-6, 3));
       //([-1, 1] - [0, 3]) - [-2, 2] = [-6, 3]
-      Assert.AreEqual<Interval>(Interval.Subtract(Interval.Subtract(a, c), b), new Interval(-6, 3));
+      CheckLowerAndUpperBoundOfInterval(Interval.Subtract(Interval.Subtract(a, c), b), new Interval(-6, 3));
     }
 
@@ -47 +63 @@
 
       //[-1, 1] * [-2, 2] = [-2, 2]
-      Assert.AreEqual<Interval>(Interval.Multiply(a, b), new Interval(-2, 2));
+      CheckLowerAndUpperBoundOfInterval(Interval.Multiply(a, b), new Interval(-2, 2));
       //([-1, 1] * [-2, 2]) * [0, 3] = [-6, 6]
-      Assert.AreEqual<Interval>(Interval.Multiply(Interval.Multiply(a, b), c), new Interval(-6, 6));
+      CheckLowerAndUpperBoundOfInterval(Interval.Multiply(Interval.Multiply(a, b), c), new Interval(-6, 6));
       //([-1, 1] * [0, 3]) * [-2, 2] = [-6, 6]
-      Assert.AreEqual<Interval>(Interval.Multiply(Interval.Multiply(a, c), b), new Interval(-6, 6));
+      CheckLowerAndUpperBoundOfInterval(Interval.Multiply(Interval.Multiply(a, c), b), new Interval(-6, 6));
 
       // [-2, 0] * [-2, 0]  = [0, 4]
-      Assert.AreEqual<Interval>(new Interval(0, 4), Interval.Multiply(new Interval(-2, 0), new Interval(-2, 0)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0, 4), Interval.Multiply(new Interval(-2, 0), new Interval(-2, 0)));
     }
 
@@ -64 +80 @@
 
       //[4, 6] / [1, 3] = [4/3, 6]
-      Assert.AreEqual<Interval>(Interval.Divide(e, d), new Interval(4.0 / 3.0, 6));
+      CheckLowerAndUpperBoundOfInterval(Interval.Divide(e, d), new Interval(4.0 / 3.0, 6));
       //([4, 6] / [1, 3]) / [1, 3] = [4/9, 6]
-      Assert.AreEqual<Interval>(Interval.Divide(Interval.Divide(e, d), d), new Interval(4.0 / 9.0, 6));
+      CheckLowerAndUpperBoundOfInterval(Interval.Divide(Interval.Divide(e, d), d), new Interval(4.0 / 9.0, 6));
       //[4, 6] / [0, 3] = [4/3, +Inf]
-      Assert.AreEqual<Interval>(Interval.Divide(e, c), new Interval(4.0 / 3.0, double.PositiveInfinity));
+      CheckLowerAndUpperBoundOfInterval(Interval.Divide(e, c), new Interval(4.0 / 3.0, double.PositiveInfinity));
       //[-1, 1] / [0, 3] = [+Inf, -Inf]
-      Assert.AreEqual<Interval>(Interval.Divide(a, c), new Interval(double.NegativeInfinity, double.PositiveInfinity));
+      CheckLowerAndUpperBoundOfInterval(Interval.Divide(a, c), new Interval(double.NegativeInfinity, double.PositiveInfinity));
       //Devision by 0 ==> IsInfiniteOrUndefined == true
       Assert.IsTrue(Interval.Divide(e, c).IsInfiniteOrUndefined);
       //Devision by 0 ==> IsInfiniteOrUndefined == true
       Assert.IsTrue(Interval.Divide(a, c).IsInfiniteOrUndefined);
-      Assert.AreEqual<Interval>(Interval.Divide(d, b), new Interval(double.NegativeInfinity, double.PositiveInfinity));
+      CheckLowerAndUpperBoundOfInterval(Interval.Divide(d, b), new Interval(double.NegativeInfinity, double.PositiveInfinity));
     }
 
@@ -84 +100 @@
       //sine depends on interval
       //sin([0, 2*pi]) = [-1, 1]
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
       //sin([-pi/2, pi/2]) = [sin(-pi/2), sin(pi/2)]
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(-1 * Math.PI / 2, Math.PI / 2)), new Interval(-1, 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(-1 * Math.PI / 2, Math.PI / 2)), new Interval(-1, 1));
       //sin([0, pi/2]) = [sin(0), sin(pi/2)]
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(0, Math.PI / 2)), new Interval(0, 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(0, Math.PI / 2)), new Interval(0, 1));
       //sin([pi, 3*pi/2]) = [sin(pi), sin(3*pi/2)]
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(Math.PI, 3 * Math.PI / 2)), new Interval(-1, 0));
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(1, 2)), new Interval(Math.Min(Math.Sin(1), Math.Sin(2)), 1));
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(1, 3)), new Interval(Math.Min(Math.Sin(1), Math.Sin(3)), 1));
-      Assert.AreEqual<Interval>(Interval.Sine(new Interval(Math.PI, 5 * Math.PI / 2)), new Interval(-1, 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(Math.PI, 3 * Math.PI / 2)), new Interval(-1, 0));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(1, 2)), new Interval(Math.Min(Math.Sin(1), Math.Sin(2)), 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(1, 3)), new Interval(Math.Min(Math.Sin(1), Math.Sin(3)), 1));
+      CheckLowerAndUpperBoundOfInterval(Interval.Sine(new Interval(Math.PI, 5 * Math.PI / 2)), new Interval(-1, 1));
     }
 
@@ -101 +117 @@
     public void CosineIntervalTest() {
       //Cosine uses sine Interval.Sine(Interval.Subtract(a, new Interval(Math.PI / 2, Math.PI / 2)));
-      Assert.AreEqual<Interval>(Interval.Cosine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
-      Assert.AreEqual<Interval>(new Interval(-1, 1), Interval.Cosine(new Interval(Math.PI, 4 * Math.PI / 2)));
+      CheckLowerAndUpperBoundOfInterval(Interval.Cosine(new Interval(0, 2 * Math.PI)), new Interval(-1, 1));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, 1), Interval.Cosine(new Interval(Math.PI, 4 * Math.PI / 2)));
     }
 
@@ -110 +126 @@
     public void LogIntervalTest() {
       //Log([3, 5]) = [log(3), log(5)]
-      Assert.AreEqual<Interval>(new Interval(Math.Log(3), Math.Log(5)), Interval.Logarithm(new Interval(3, 5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(Math.Log(3), Math.Log(5)), Interval.Logarithm(new Interval(3, 5)));
       //Log([0.5, 1]) = [log(0.5), log(1)]
-      Assert.AreEqual<Interval>(new Interval(Math.Log(0.5), 0), Interval.Logarithm(new Interval(0.5, 1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(Math.Log(0.5), 0), Interval.Logarithm(new Interval(0.5, 1)));
       //Log([-1, 5]) = [NaN, log(5)]
       var result = Interval.Logarithm(new Interval(-1, 5));
-      Assert.AreEqual<Interval>(new Interval(double.NaN, Math.Log(5)),result);
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NaN, Math.Log(5)),result);
       Assert.IsTrue(result.IsInfiniteOrUndefined);
     }
@@ -125 +141 @@
     public void ExponentialIntervalTest() {
       //Exp([0, 1]) = [exp(0), exp(1)]
-      Assert.AreEqual<Interval>(new Interval(1, Math.Exp(1)), Interval.Exponential(new Interval(0, 1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(1, Math.Exp(1)), Interval.Exponential(new Interval(0, 1)));
     }
 
@@ -133 +149 @@
     [TestProperty("Time", "short")]
     public void SquareIntervalTest() {
-      Assert.AreEqual<Interval>(new Interval(1, 4), Interval.Square(new Interval(1, 2)));
-      Assert.AreEqual<Interval>(new Interval(1, 4), Interval.Square(new Interval(-2, -1)));
-      Assert.AreEqual<Interval>(new Interval(0, 4), Interval.Square(new Interval(-2, 2)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(1, 4), Interval.Square(new Interval(1, 2)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(1, 4), Interval.Square(new Interval(-2, -1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0, 4), Interval.Square(new Interval(-2, 2)));
     }
 
@@ -142 +158 @@
     [TestProperty("Time", "short")]
     public void SquarerootIntervalTest() {
-      Assert.AreEqual<Interval>(new Interval(-2, 2), Interval.SquareRoot(new Interval(1, 4)));
-      Assert.AreEqual<Interval>(new Interval(double.NaN, double.NaN), Interval.SquareRoot(new Interval(-4, -1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-2, 2), Interval.SquareRoot(new Interval(1, 4)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NaN, double.NaN), Interval.SquareRoot(new Interval(-4, -1)));
     }
 
@@ -150 +166 @@
     [TestProperty("Time", "short")]
     public void CubeIntervalTest() {
-      Assert.AreEqual<Interval>(new Interval(1, 8), Interval.Cube(new Interval(1, 2)));
-      Assert.AreEqual<Interval>(new Interval(-8, -1), Interval.Cube(new Interval(-2, -1)));
-      Assert.AreEqual<Interval>(new Interval(-8, 8), Interval.Cube(new Interval(-2, 2)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(1, 8), Interval.Cube(new Interval(1, 2)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-8, -1), Interval.Cube(new Interval(-2, -1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-8, 8), Interval.Cube(new Interval(-2, 2)));
     }
 
@@ -159 +175 @@
     [TestProperty("Time", "short")]
     public void CubeRootIntervalTest() {
-      Assert.AreEqual<Interval>(new Interval(1, 2), Interval.CubicRoot(new Interval(1, 8)));
-      Assert.AreEqual<Interval>(new Interval(-2, -2), Interval.CubicRoot(new Interval(-8, -8)));
-      Assert.AreEqual<Interval>(new Interval(-2, 2), Interval.CubicRoot(new Interval(-8, 8)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(1, 2), Interval.CubicRoot(new Interval(1, 8)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-2, -2), Interval.CubicRoot(new Interval(-8, -8)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-2, 2), Interval.CubicRoot(new Interval(-8, 8)));
       Assert.AreEqual(new Interval(2, 2), Interval.CubicRoot(new Interval(8, 8)));
       Assert.AreEqual(new Interval(-Math.Pow(6, 1.0 / 3), 2), Interval.CubicRoot(new Interval(-6, 8)));
@@ -204 +220 @@
       //Assert.AreEqual(new Interval(aZero.LowerBound/Math.Sqrt(5), aZero.UpperBound/Math.Sqrt(5)), Interval.AnalyticalQuotient(aZero, bNeg));
       //Assert.AreEqual(new Interval(aNeg.LowerBound/Math.Sqrt(5), aNeg.UpperBound/Math.Sqrt(17)), Interval.AnalyticalQuotient(aNeg, bNeg));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticalQuotient(aPos, bZero));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticalQuotient(aPos, bPos));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticalQuotient(aZero, bNeg));
+      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticQuotient(aPos, bZero));
+      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticQuotient(aPos, bPos));
+      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.AnalyticQuotient(aZero, bNeg));
     }
 
@@ -313 +329 @@
     [TestProperty("Time", "short")]
     public void GeometricTest() {
-      Assert.AreEqual(new Interval(-1, -0.936456687290796), Interval.Cosine(new Interval(3, 3.5)));
-      Assert.AreEqual(new Interval(-1, -0.936456687290796), Interval.Cosine(new Interval(-3.5, -3)));
-      Assert.AreEqual(new Interval(-1, 1), Interval.Cosine(new Interval(-3.5, 3)));
-      Assert.AreEqual(new Interval(-0.839071529076452, 0.843853958732493), Interval.Cosine(new Interval(10, 12)));
-      Assert.AreEqual(new Interval(0.136737218207833, 0.907446781450197), Interval.Cosine(new Interval(13, 14)));
-      Assert.AreEqual(new Interval(-0.839071529076452, 1), Interval.Cosine(new Interval(10, 14)));
-      Assert.AreEqual(new Interval(-1, 0.136737218207833), Interval.Cosine(new Interval(14, 16)));
-      Assert.AreEqual(new Interval(-0.839071529076452, 0.004425697988051), Interval.Cosine(new Interval(-11, -10)));
-      Assert.AreEqual(new Interval(0.136737218207833, 0.907446781450197), Interval.Cosine(new Interval(-14, -13)));
-      Assert.AreEqual(new Interval(-1, 0.136737218207833), Interval.Cosine(new Interval(-16, -14)));
-      Assert.AreEqual(new Interval(0.101585703696621, 1), Interval.Cosine(new Interval(-102, -100)));
-      Assert.AreEqual(new Interval(-1, 1), Interval.Cosine(new Interval(4.6e15, 4.7e15)));
-      Assert.AreEqual(new Interval(0.87758256189037265, 0.87758256189037276), Interval.Cosine(new Interval(0.5, 0.5)));
-      Assert.AreEqual(new Interval(-0.09904103659872825, 0.8775825618903728), Interval.Cosine(new Interval(0.5, 1.67)));
-      Assert.AreEqual(new Interval(-1.0, 0.77556587851025016), Interval.Cosine(new Interval(2.1, 5.6)));
-      Assert.AreEqual(new Interval(-1.0, 1.0), Interval.Cosine(new Interval(0.5, 8.5)));
-      Assert.AreEqual(new Interval(-1.0, -0.09904103659872801), Interval.Cosine(new Interval(1.67, 3.2)));
-
-
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(double.NegativeInfinity, double.PositiveInfinity)));
-      Assert.AreEqual(new Interval(0, 1.55740772465490223051), Interval.Tangens(new Interval(0, 1)));
-      Assert.AreEqual(new Interval(-1.55740772465490223051, 0), Interval.Tangens(new Interval(-1, 0)));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(-2, -1)));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(202, 203)));
-      Assert.AreEqual(new Interval(0.54630248984379048, 0.5463024898437906), Interval.Tangens(new Interval(0.5, 0.5)));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(0.5,
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, -0.936456687290796), Interval.Cosine(new Interval(3, 3.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, -0.936456687290796), Interval.Cosine(new Interval(-3.5, -3)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, 1), Interval.Cosine(new Interval(-3.5, 3)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-0.839071529076452, 0.843853958732493), Interval.Cosine(new Interval(10, 12)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.136737218207833, 0.907446781450197), Interval.Cosine(new Interval(13, 14)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-0.839071529076452, 1), Interval.Cosine(new Interval(10, 14)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, 0.136737218207833), Interval.Cosine(new Interval(14, 16)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-0.839071529076452, 0.004425697988051), Interval.Cosine(new Interval(-11, -10)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.136737218207833, 0.907446781450197), Interval.Cosine(new Interval(-14, -13)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, 0.136737218207833), Interval.Cosine(new Interval(-16, -14)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.101585703696621, 1), Interval.Cosine(new Interval(-102, -100)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1, 1), Interval.Cosine(new Interval(4.6e15, 4.7e15)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.87758256189037265, 0.87758256189037276), Interval.Cosine(new Interval(0.5, 0.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-0.09904103659872825, 0.8775825618903728), Interval.Cosine(new Interval(0.5, 1.67)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 0.77556587851025016), Interval.Cosine(new Interval(2.1, 5.6)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 1.0), Interval.Cosine(new Interval(0.5, 8.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, -0.09904103659872801), Interval.Cosine(new Interval(1.67, 3.2)));
+
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(double.NegativeInfinity, double.PositiveInfinity)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0, 1.55740772465490223051), Interval.Tangens(new Interval(0, 1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.55740772465490223051, 0), Interval.Tangens(new Interval(-1, 0)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(-2, -1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(202, 203)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.54630248984379048, 0.5463024898437906), Interval.Tangens(new Interval(0.5, 0.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(0.5,
         1.67)));
-      //Assert.AreEqual(new Interval(-10.047182299210307, 0.5847385445957865), Interval.Tangens(new Interval(1.67, 3.2)));
-      Assert.AreEqual(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(
+
+      CheckLowerAndUpperBoundOfInterval(new Interval(double.NegativeInfinity, double.PositiveInfinity), Interval.Tangens(new Interval(
         6.638314112824137, 8.38263151220128)));
 
-
-
-      Assert.AreEqual(new Interval(0.47942553860420295, 0.47942553860420301), Interval.Sine(new Interval(0.5, 0.5)));
-      Assert.AreEqual(new Interval(4.7942553860420295e-01, 1.0), Interval.Sine(new Interval(0.5, 1.67)));
-      Assert.AreEqual(new Interval(-5.8374143427580093e-02, 9.9508334981018021e-01), Interval.Sine(new Interval(1.67,
+      CheckLowerAndUpperBoundOfInterval(new Interval(0.47942553860420295, 0.47942553860420301), Interval.Sine(new Interval(0.5, 0.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(4.7942553860420295e-01, 1.0), Interval.Sine(new Interval(0.5, 1.67)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-5.8374143427580093e-02, 9.9508334981018021e-01), Interval.Sine(new Interval(1.67,
         3.2)));
-      Assert.AreEqual(new Interval(-1.0, 0.863209366648874), Interval.Sine(new Interval(2.1, 5.6)));
-      Assert.AreEqual(new Interval(-1.0, 1.0), Interval.Sine(new Interval(0.5, 8.5)));
-      Assert.AreEqual(new Interval(-1.0, 0.9775301176650971), Interval.Sine(new Interval(-4.5, 0.1)));
-      Assert.AreEqual(new Interval(-1.0, 1.0), Interval.Sine(new Interval(1.3, 6.3)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 0.863209366648874), Interval.Sine(new Interval(2.1, 5.6)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 1.0), Interval.Sine(new Interval(0.5, 8.5)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 0.9775301176650971), Interval.Sine(new Interval(-4.5, 0.1)));
+      CheckLowerAndUpperBoundOfInterval(new Interval(-1.0, 1.0), Interval.Sine(new Interval(1.3, 6.3)));
     }
 

branches/3105_PythonFormatter/HeuristicLab.Visualization.ChartControlsExtensions/3.3/ChartUtil.cs

@@ -88 +88 @@
     private static double RoundDown(this double value, int decimalRank) {
       if (decimalRank > 0) {
-        var floor = (int)Math.Floor(value);
-        var pow = (int)Math.Pow(10, decimalRank);
+        var floor = Math.Floor(value);
+        var pow = Math.Pow(10, decimalRank);
         var mod = Mod(floor, pow);
         return floor - mod;
@@ -98 +98 @@
     private static double RoundUp(this double value, int decimalRank) {
       if (decimalRank > 0) {
-        var ceil = (int)Math.Ceiling(value);
-        var pow = (int)Math.Pow(10, decimalRank);
+        var ceil = Math.Ceiling(value);
+        var pow = Math.Pow(10, decimalRank);
         var mod = Mod(ceil, pow);
         return ceil - mod + pow;