Improved test coverage.

Author: maisonobe

hipparchus-optim/src/main/java/org/hipparchus/optim/nonlinear/vector/constrained/Constraint.java

@@ -36,7 +36,7 @@ public interface Constraint extends VectorDifferentiableFunction, OptimizationDa
 
     /** Check how much a point overshoots the constraint.
      * <p>
-     * The overshoots is zero if the point fulfills the constraint, and
+     * The overshoot is zero if the point fulfills the constraint, and
      * positive if the {@link #value(RealVector) value} of the constraint
      * is on the wrong side of {@link #getLowerBound() lower} or {@link
      * #getUpperBound() upper} boundaries.

hipparchus-optim/src/main/java/org/hipparchus/optim/nonlinear/vector/constrained/LineSearch.java

@@ -100,10 +100,7 @@ public LineSearch(final double eps, final int maxHistory, final double mu, final
         this.maxBadSteps         = maxBadSteps;
         this.history             = new LinkedList<>();
         this.nonMonotoneEnabled  = false;
-        this.monotoneFailures    = 0;
-        this.badStepCount        = 0;
-        this.badStepDetected     = false;
-        this.badStepFailed       = false;
+        resetBadStepCount();
     }
 
     /** Check if bad step has been detected.
@@ -113,8 +110,8 @@ public boolean isBadStepDetected() {
         return badStepDetected;
     }
 
-    /** Check if too many conscutive bad step have been detected.
-     * @return true if too many conscutive bad step have been detected
+    /** Check if too many consecutive bad step have been detected.
+     * @return true if too many consecutive bad step have been detected
      */
     public boolean isBadStepFailed() {
         return badStepFailed;
@@ -132,7 +129,6 @@ public int getIteration() {
     public void resetBadStepCount() {
         badStepCount = 0;
         monotoneFailures = 0;
-
         badStepDetected = false;
         badStepFailed = false;
     }
@@ -149,12 +145,12 @@ public void updateHistory(final double fx) {
         }
     }
 
-    /** Verify Armjo condition for accept step.
+    /** Verify Armijo condition for accept step.
      * @param fxNew penalty at candidate point x+dx*alpha
      * @param fxCurrent penalty at the current point
      * @param alpha step length
      * @param directionalDeriv penalty gradient
-     * @return true o false
+     * @return true or false
      */
     public boolean acceptStep(double fxNew, double fxCurrent, double alpha, double directionalDeriv) {
         double ref = fxCurrent;
@@ -163,7 +159,7 @@ public boolean acceptStep(double fxNew, double fxCurrent, double alpha, double d
                 ref = FastMath.max(ref, v);
             }
         }
-        // alfaPenalty - currentPenalty) > getSettings().getMu() * alpha * currentPenaltyGrad
+        // alfaPenalty - currentPenalty > getSettings().getMu() * alpha * currentPenaltyGrad
         return fxNew < ref + sigma * alpha * directionalDeriv;
     }
 
@@ -250,7 +246,7 @@ public double search(final MeritFunctionL2 f) {
 
     }
 
-    /** Iterativ search (either monotone or non-monotone).
+    /** Iterative search (either monotone or non-monotone).
      * @param f penalty function
      * @param fxCurrent penalty function at current point
      * @param directionalDeriv directional derivative

hipparchus-optim/src/main/java/org/hipparchus/optim/nonlinear/vector/constrained/MeritFunctionL2.java

@@ -223,7 +223,6 @@ public double value(double alpha) {
             RealVector yi = yAlpha.getSubVector(me, mi);
 
             RealVector yk = yAlpha.getSubVector(me, mi);
-            //RealVector yk = y.getSubVector(me, mi);
 
             iqEval = iqConstraint.value(xAlpha);
             RealVector gk = iqEval.subtract(iqConstraint.getLowerBound());
@@ -305,7 +304,7 @@ public RealVector gradY() {
         RealVector partial = new ArrayRealVector(y.getDimension());
         if (eqConstraint != null) {
             me = eqConstraint.dimY();
-             RealVector g = this.eqEval.subtract(eqConstraint.getLowerBound());
+            RealVector g = this.eqEval.subtract(eqConstraint.getLowerBound());
             partial.setSubVector(0, g.mapMultiply(-1.0));
         }
 
@@ -330,7 +329,7 @@ public RealVector gradY() {
     }
 
     /**
-     * Update Weight Vector Rj.
+     * Update weight vector Rj.
      * called after QP solution before update the penalty function
      * @param H hessina Matrix (updated after line search)
      * @param newY last estimate of multiplier (updated after line search)
@@ -340,7 +339,7 @@ public RealVector gradY() {
      * @param iterations current iteration
      */
      public void updateRj(RealMatrix H, RealVector newY, RealVector newDx, RealVector newU, double sigmaValue, int iterations) {
-        //calculate sigma vector that depends on iterations
+        // calculate sigma vector that depends on iterations
         if (newY.getDimension() == 0) {
             return;
         }

hipparchus-optim/src/test/java/org/hipparchus/optim/nonlinear/vector/constrained/LinearSearchTest.java

@@ -0,0 +1,65 @@
+/*
+ * Licensed to the Hipparchus project under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The Hipparchus project licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      https://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package org.hipparchus.optim.nonlinear.vector.constrained;
+
+
+import org.hipparchus.linear.ArrayRealVector;
+import org.hipparchus.linear.RealVector;
+import org.junit.jupiter.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+class LinearSearchTest {
+
+    @Test
+    public void testMonotoneSuccess() {
+        final LineSearch ls = new LineSearch(1.0e-7, 5, 1.0e-4, 0.5, 50, 2);
+        double d = ls.search(buildMeritFunction(0.99, 0.8));
+        Assertions.assertEquals(0.125, d, 1.0e-3);
+        Assertions.assertFalse(ls.isBadStepDetected());
+        Assertions.assertFalse(ls.isBadStepFailed());
+    }
+
+    @Test
+    public void testBadStep() {
+        final LineSearch ls = new LineSearch(1.0e-7, 5, 1.0e-4, 0.5, 50, 2);
+        double d = ls.search(buildMeritFunction(-2.0, -0.5));
+        Assertions.assertEquals(7.071e-7, d, 1.0e-10);
+        Assertions.assertTrue(ls.isBadStepDetected());
+        Assertions.assertFalse(ls.isBadStepFailed());
+    }
+
+    private MeritFunctionL2 buildMeritFunction(final double startX, final double startY) {
+        final TwiceDifferentiableFunction objective = new RosenbrockFunction();
+        final InequalityConstraint iqConstraint =
+                new LinearInequalityConstraint(new double[][] {
+                        { 1, 0 }, { -1, 0 }, { 0, 1 }, { 0, -1 }
+                }, new double[] {
+                        -1.5, -1.5, -1.5, -1.5
+                });
+        final RealVector x = new ArrayRealVector(new double[] { startX, startY });
+        final MeritFunctionL2 f = new MeritFunctionL2(objective, null, iqConstraint, x);
+        f.update(objective.gradient(x),
+                 null,
+                 iqConstraint.gradient(x.toArray()),
+                 x,
+                 new ArrayRealVector(iqConstraint.dimY()),
+                 new ArrayRealVector(new double[] { -1.0, 1.0 }),
+                 new ArrayRealVector(new double[4]));
+        return f;
+    }
+
+}

hipparchus-optim/src/test/java/org/hipparchus/optim/nonlinear/vector/constrained/RosenbrookConstraint.java

@@ -18,65 +18,49 @@
 
 import org.hipparchus.linear.Array2DRowRealMatrix;
 import org.hipparchus.linear.ArrayRealVector;
+import org.hipparchus.linear.MatrixUtils;
 import org.hipparchus.linear.RealMatrix;
 import org.hipparchus.linear.RealVector;
 
-public class RosenbrookConstraint extends LinearInequalityConstraint {
+public class RosenbrookConstraint extends InequalityConstraint {
 
-    public RosenbrookConstraint(RealMatrix m, RealVector b) {
-        super(m, b);
+    public RosenbrookConstraint(final double[] b) {
+        super(MatrixUtils.createRealVector(b));
     }
 
      @Override
-    public RealVector value(RealVector x) {
-        RealVector a=new ArrayRealVector(5);
-       a.setEntry(0,-x.getEntry(0)*x.getEntry(0)-x.getEntry(1)*x.getEntry(1));
-       a.setEntry(1,x.getEntry(0));
-       a.setEntry(2,-x.getEntry(0));
-        a.setEntry(3,x.getEntry(1));
-       a.setEntry(4,-x.getEntry(1));
-
-         return a;
+    public RealVector value(final RealVector x) {
+        final double x0 = x.getEntry(0);
+        final double x1 = x.getEntry(1);
+        final RealVector a = new ArrayRealVector(5);
+        a.setEntry(0, -x0 * x0 - x1 * x1);
+        a.setEntry(1,  x0);
+        a.setEntry(2, -x0);
+        a.setEntry(3,  x1);
+        a.setEntry(4, -x1);
+        return a;
     }
 
      @Override
-    public RealMatrix jacobian(RealVector x) {
-      RealMatrix a= new Array2DRowRealMatrix(5,2);
-      a.setEntry(0, 0,-2*x.getEntry(0));
-      a.setEntry(0, 1,-2*x.getEntry(1));
-      a.setEntry(1, 0,1);
-       a.setEntry(2, 0,-1);
-        a.setEntry(3, 1,1);
-          a.setEntry(4, 1,-1);
-        return a;
+    public RealMatrix jacobian(final RealVector x) {
+      final RealMatrix a = new Array2DRowRealMatrix(5, 2);
+      a.setEntry(0, 0, -2 * x.getEntry(0));
+      a.setEntry(0, 1, -2 * x.getEntry(1));
+      a.setEntry(1, 0,  1);
+      a.setEntry(2, 0, -1);
+      a.setEntry(3, 1,  1);
+      a.setEntry(4, 1, -1);
+      return a;
     }
-//
-//    @Override
-//      public RealVector getLowerBound()
-//    {   RealVector lb=new ArrayRealVector(9);
-//        lb.setEntry(0,25.0);
-//        lb.setEntry(1,1.0);
-//        lb.setEntry(2,1.0);
-//        lb.setEntry(3,1.0);
-//        lb.setEntry(4,1.0);
-//        lb.setEntry(5,-5.0);
-//        lb.setEntry(6,-5.0);
-//        lb.setEntry(7,-5.0);
-//        lb.setEntry(8,-5.0);
-//        return lb;
-//    }
-//
-//    /**
-// * Return Upper Bound .
-// * @return Upper Bound Vector
-// */
-//      @Override
-//     public RealVector getUpperBound()
-//    {
-//        return new ArrayRealVector(9,Double.POSITIVE_INFINITY);
-//    }
-//      @Override
-     public int dimY(){
+
+    @Override
+    public int dim(){
+         return 2;
+     }
+
+    @Override
+    public int dimY(){
          return 5;
      }
+
 }

hipparchus-optim/src/test/java/org/hipparchus/optim/nonlinear/vector/constrained/SQPOptimizerSTest.java

@@ -106,8 +106,7 @@ void testRosenbrock() {
                       0.0, 1.6e-13,
                       new ObjectiveFunction(new RosenbrockFunction()),
                       new double[] { 2, 2 },
-                      new RosenbrookConstraint(MatrixUtils.createRealMatrix(5, 2),
-                                               MatrixUtils.createRealVector(new double[]{ -2, -1.5, -1.5, -1.5, -1.5 })));
+                      new RosenbrookConstraint(new double[]{ -2, -1.5, -1.5, -1.5, -1.5 }));
     }
 
     @Test