Changeset 16738 for branches/2994-AutoDiffForIntervals

Timestamp:

04/01/19 19:19:14 (6 years ago)

Author:

gkronber

Message:

#2994: another unit test, smaller fixes and checks for invalid parameters

Location:

branches/2994-AutoDiffForIntervals

Files:

• HeuristicLab.Algorithms.DataAnalysis.ConstrainedNonlinearRegression/3.4/ConstrainedNonlinearRegression.cs (modified) (2 diffs)
• HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/Interpreter.cs (modified) (2 diffs)
• Tests/AutoDiffTest.cs (modified) (1 diff)

branches/2994-AutoDiffForIntervals/HeuristicLab.Algorithms.DataAnalysis.ConstrainedNonlinearRegression/3.4/ConstrainedNonlinearRegression.cs

@@ -207 +207 @@
     /// <returns></returns>
     public static ISymbolicRegressionSolution CreateRegressionSolution(RegressionProblemData problemData, string modelStructure, int maxIterations, bool applyLinearScaling, IRandom rand = null) {
+      if (applyLinearScaling) throw new NotSupportedException("Linear scaling is not yet supported in NLR with constraints.");
       var parser = new InfixExpressionParser();
       var tree = parser.Parse(modelStructure);
@@ -262 +263 @@
       foreach (var constraint in constraints) {
         if (constraint.IsDerivation) {
+          if (!problemData.AllowedInputVariables.Contains(constraint.Variable))
+            throw new ArgumentException($"Invalid constraint: the variable {constraint.Variable} does not exist in the dataset.");
           var df = DerivativeCalculator.Derive(treeForDerivation, constraint.Variable);
 

branches/2994-AutoDiffForIntervals/HeuristicLab.Problems.DataAnalysis.Symbolic/3.4/Interpreter/Interpreter.cs

@@ -389 +389 @@
       for (int i = 0; i < paramNodes.Length; ++i) {
         if (paramNodes[i] == null) continue;
-        lowerGradient[i] = l.Gradient.Elements[paramNodes[i]];
-        upperGradient[i] = u.Gradient.Elements[paramNodes[i]];
+        if (l.Gradient.Elements.TryGetValue(paramNodes[i], out AlgebraicDouble value)) lowerGradient[i] = value;
+        if (u.Gradient.Elements.TryGetValue(paramNodes[i], out value)) upperGradient[i] = value;
       }
       return new Interval(code[0].value.LowerBound.Value.Value, code[0].value.UpperBound.Value.Value);
@@ -827 +827 @@
       return this;
     }
+
+//     Exponentiation by a natural power[a, b] k:
+// 
+// if 0∈[a, b], then
+//   [a, b]^0  =  [0, 1]
+//   [a, b]^2n   =  [0, max(a2n, b2n)]
+//   [a, b]^2n+1   =  [a2n+1, b2n+1]
+// if [a, b]>0, then
+//   [a, b]^0  =  [1, 1]
+//   [a, b]^k>0  =  [ak, bk]
+// if [a, b]<0, then
+//   [a, b]^0  =  [1, 1]
+//   [a, b]^2n   =  [b2n, a2n]
+//   [a, b]^2n+1   =  [a2n+1, b2n+1]
 
     public AlgebraicInterval AssignIntPower(AlgebraicInterval a, int p) {

branches/2994-AutoDiffForIntervals/Tests/AutoDiffTest.cs

@@ -189 +189 @@
       }
 
+      {
+
+        // derivatives and intervals for flow psi problem
+        var intervals = new Dictionary<string, Interval>();
+        intervals.Add("x1", new Interval(60.0, 65.0));
+        intervals.Add("x2", new Interval(30.0, 40.0));
+        intervals.Add("x3", new Interval(5.0, 10.0));
+        intervals.Add("x4", new Interval(0.5, 0.8));
+        intervals.Add("x5", new Interval(0.2, 0.5));
+
+        var parser = new InfixExpressionParser();
+        var formatter = new InfixExpressionFormatter();
+
+        var expr = parser.Parse("x1*x2*x5*(1 - sqr(x4/x5)) + x3 * log(x5/x4)");
+
+        var dfdx1 = DerivativeCalculator.Derive(expr, "x1");
+        Assert.AreEqual("('x2' * 'x5' * ((SQR(('x4' / 'x5')) * (-1)) + 1))", formatter.Format(dfdx1));
+        // x2 x5 (1 - sqr(x4/x5))
+
+        var dfdx2 = DerivativeCalculator.Derive(expr, "x2");
+        Assert.AreEqual("('x1' * 'x5' * ((SQR(('x4' / 'x5')) * (-1)) + 1))", formatter.Format(dfdx2));
+        // x1 x5 (1 - sqr(x4/x5))
+
+        var dfdx3 = DerivativeCalculator.Derive(expr, "x3");
+        Assert.AreEqual("LOG(('x5' / 'x4'))", formatter.Format(dfdx3));
+        // log(x5/x4)
+
+        var dfdx4 = DerivativeCalculator.Derive(expr, "x4");
+        Assert.AreEqual("((('x1' * 'x2' * 'x5' * 'x4' * 2) / ('x5' * (-1*'x5'))) + (('x4' * 'x5' * 'x3') / ('x5' * SQR('x4') * (-1))))", formatter.Format(dfdx4));
+        // -2*x1*x2*x5*x4/x5*1/x5 + x3*1/(x5/x4)*x5/sqr(x4)
+
+        var dfdx5 = DerivativeCalculator.Derive(expr, "x5");
+        Assert.AreEqual("((('x4' * 'x3') / ('x5' * 'x4')) + ('x1' * 'x2' * ((SQR(('x4' / 'x5')) * (-1)) + 1)) + (('x1' * 'x2' * 'x5' * ('x4' * 'x4') * 2) / ('x5' * SQR('x5') * 1)))", formatter.Format(dfdx5));
+      }
+
+
     }
   }