SQP and QP update

hipparchus-optim/nbactions.xml

@@ -0,0 +1,94 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<actions>
+        <action>
+            <actionName>test</actionName>
+            <packagings>
+                <packaging>*</packaging>
+            </packagings>
+            <goals>
+                <goal>test</goal>
+            </goals>
+            <properties>
+                <hipparchus.debug.sqp>false</hipparchus.debug.sqp>
+            </properties>
+        </action>
+        <action>
+            <actionName>test.single</actionName>
+            <packagings>
+                <packaging>*</packaging>
+            </packagings>
+            <goals>
+                <goal>process-test-classes</goal>
+                <goal>surefire:test</goal>
+            </goals>
+            <properties>
+                <test>${packageClassName}</test>
+                <hipparchus.debug.sqp>true</hipparchus.debug.sqp>
+                <Env.MAVEN_OPTS>-Xms512m -Xmx2048m</Env.MAVEN_OPTS>
+            </properties>
+        </action>
+        <action>
+            <actionName>build</actionName>
+            <packagings>
+                <packaging>*</packaging>
+            </packagings>
+            <goals>
+                <goal>install</goal>
+            </goals>
+            <properties>
+                <skipTests>true</skipTests>
+            </properties>
+        </action>
+        <action>
+            <actionName>run</actionName>
+            <packagings>
+                <packaging>jar</packaging>
+            </packagings>
+            <goals>
+                <goal>process-classes</goal>
+                <goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
+            </goals>
+            <properties>
+                <exec.vmArgs></exec.vmArgs>
+                <exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
+                <exec.appArgs></exec.appArgs>
+                <exec.mainClass>${packageClassName}</exec.mainClass>
+                <exec.executable>java</exec.executable>
+            </properties>
+        </action>
+        <action>
+            <actionName>debug</actionName>
+            <packagings>
+                <packaging>jar</packaging>
+            </packagings>
+            <goals>
+                <goal>process-classes</goal>
+                <goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
+            </goals>
+            <properties>
+                <exec.vmArgs>-agentlib:jdwp=transport=dt_socket,server=n,address=${jpda.address}</exec.vmArgs>
+                <exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
+                <exec.appArgs></exec.appArgs>
+                <exec.mainClass>${packageClassName}</exec.mainClass>
+                <exec.executable>java</exec.executable>
+                <jpda.listen>true</jpda.listen>
+            </properties>
+        </action>
+        <action>
+            <actionName>profile</actionName>
+            <packagings>
+                <packaging>jar</packaging>
+            </packagings>
+            <goals>
+                <goal>process-classes</goal>
+                <goal>org.codehaus.mojo:exec-maven-plugin:3.1.0:exec</goal>
+            </goals>
+            <properties>
+                <exec.vmArgs></exec.vmArgs>
+                <exec.args>${exec.vmArgs} -classpath %classpath ${exec.mainClass} ${exec.appArgs}</exec.args>
+                <exec.mainClass>${packageClassName}</exec.mainClass>
+                <exec.executable>java</exec.executable>
+                <exec.appArgs></exec.appArgs>
+            </properties>
+        </action>
+    </actions>

hipparchus-optim/src/main/java/org/hipparchus/optim/BaseMultivariateOptimizer.java

@@ -37,7 +37,7 @@
 public abstract class BaseMultivariateOptimizer<P>
     extends BaseOptimizer<P> {
     /** Initial guess. */
-    private double[] start;
+    public double[] start;
     /** Lower bounds. */
     private double[] lowerBound;
     /** Upper bounds. */

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

@@ -173,6 +173,17 @@ public RealMatrix getScaledA() {
     public RealVector getScaledQ() {
         return D.operate(q.mapMultiply(c));
     }
+
+    /** Get scaled constraint constant vector.
+ * For constraints A x + b >= 0 and scaling A_s = E A D,
+ * the constant term must be scaled as b_s = E b.
+ *
+ * @param c0 unscaled constraint constant vector
+ * @return scaled constraint constant vector
+ */
+public RealVector getScaledC0(final RealVector c0) {
+    return E.operate(c0);
+}
 
     /** Get scaled upper bound
      * @param lb1 unscaled lower bound
@@ -226,16 +237,34 @@ RealVector scaleX(RealVector x) {
      * @param v vector to limit
      * @return rescaled vector, taking scaling limits into account
      */
-    private RealVector limitScaling(RealVector v) {
-
-        RealVector result = new ArrayRealVector(v.getDimension());
-        for (int i = 0; i < v.getDimension(); i++) {
-            result.setEntry(i,  v.getEntry(i) < MIN_SCALING ? 1.0 : v.getEntry(i));
-            result.setEntry(i,  v.getEntry(i) > MAX_SCALING ? MAX_SCALING : v.getEntry(i));
+//    private RealVector limitScaling(RealVector v) {
+//
+//        RealVector result = new ArrayRealVector(v.getDimension());
+//        for (int i = 0; i < v.getDimension(); i++) {
+//            result.setEntry(i,  v.getEntry(i) < MIN_SCALING ? 1.0 : v.getEntry(i));
+//            result.setEntry(i,  v.getEntry(i) > MAX_SCALING ? MAX_SCALING : v.getEntry(i));
+//        }
+//
+//        return result;
+//
+//    }
+   private RealVector limitScaling(final RealVector v) {
+    final RealVector result = new ArrayRealVector(v.getDimension());
+
+    for (int i = 0; i < v.getDimension(); i++) {
+        final double vi = v.getEntry(i);
+
+        if (!Double.isFinite(vi) || vi <= 0.0) {
+            result.setEntry(i, 1.0);
+        } else if (vi < MIN_SCALING) {
+            result.setEntry(i, 1.0);
+        } else if (vi > MAX_SCALING) {
+            result.setEntry(i, MAX_SCALING);
+        } else {
+            result.setEntry(i, vi);
         }
-
-        return result;
-
     }
 
+    return result;
+}
 }

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

@@ -36,7 +36,7 @@ public class ADMMQPOption implements OptimizationData {
     public static final double DEFAULT_ALPHA = 1.6;
 
     /** Default Value for Enabling Problem Scaling. */
-    public static final boolean DEFAULT_SCALING = true;
+    public static final boolean DEFAULT_SCALING = false;
 
     /** Default Value for the Max Iteration for the scaling. */
     public static final int DEFAULT_SCALING_MAX_ITERATION = 10;

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

@@ -21,6 +21,7 @@
 import org.hipparchus.linear.EigenDecompositionSymmetric;
 import org.hipparchus.optim.LocalizedOptimFormats;
 import org.hipparchus.optim.OptimizationData;
+import org.hipparchus.optim.SimpleBounds;
 import org.hipparchus.optim.nonlinear.scalar.ObjectiveFunction;
 import org.hipparchus.util.MathUtils;
 
@@ -39,17 +40,20 @@ public abstract class AbstractSQPOptimizer2 extends ConstraintOptimizer {
     private MatrixDecompositionTolerance matrixDecompositionTolerance;
 
     /** Objective function. */
-    private TwiceDifferentiableFunction obj;
+    private TwiceDifferentiableFunction OBJ;
 
     /** Equality constraint (may be null). */
-    private EqualityConstraint eqConstraint;
+    private EqualityConstraint EQ;
 
     /** Inequality constraint (may be null). */
-    private InequalityConstraint iqConstraint;
+    private InequalityConstraint IQ;
 
     /** Inequality constraint (may be null). */
-    private BoundedConstraint boxConstraint;
-
+    private BoundedConstraint BOX;
+
+    /** Simple Bounds (may be null). */
+    private SimpleBounds SB;
+
     /** Default QPSolver. */
     private QPOptimizer QPSolver = new QPDualActiveSolver();
 
@@ -79,28 +83,35 @@ public MatrixDecompositionTolerance getMatrixDecompositionTolerance() {
      * @return objective function
      */
     public TwiceDifferentiableFunction getObj() {
-        return obj;
+        return OBJ;
     }
 
     /** Getter for equality constraint.
      * @return equality constraint
      */
     public EqualityConstraint getEqConstraint() {
-        return eqConstraint;
+        return EQ;
     }
 
     /** Getter for inequality constraint.
      * @return inequality constraint
      */
     public InequalityConstraint getIqConstraint() {
-        return iqConstraint;
+        return IQ;
     }
 
      /** Getter for box constraint.
      * @return inequality constraint
      */
     public BoundedConstraint getBoxConstraint() {
-        return boxConstraint;
+        return BOX;
+    }
+
+     /** Getter for simple bounds.
+     * @return simple bounds
+     */
+    public SimpleBounds getSimpleBounds() {
+        return SB;
     }
 
     /** Getter for QP Solver.
@@ -120,22 +131,41 @@ public void parseOptimizationData(OptimizationData... optData) {
         super.parseOptimizationData(optData);
         for (OptimizationData data : optData) {
 
+            if (data instanceof SQPProblem) {
+                SQPProblem problem = (SQPProblem) data;
+                OBJ = new SQPObj(problem);
+
+                EQ= (problem.hasEquality())?new SQPEq((SQPProblem) data):null;
+                IQ= (problem.hasInequality())?new SQPIneq((SQPProblem) data):null;
+
+                double[] lb = ((SQPProblem) data).getBoundsLB();
+                double[]ub = ((SQPProblem) data).getBoundsUB();
+                SB = (problem.hasBounds())?new SimpleBounds(lb,ub):null;
+
+                continue;
+            }
+
             if (data instanceof ObjectiveFunction) {
-                obj = (TwiceDifferentiableFunction) ((ObjectiveFunction) data).getObjectiveFunction();
+                OBJ = (TwiceDifferentiableFunction) ((ObjectiveFunction) data).getObjectiveFunction();
                 continue;
             }
 
             if (data instanceof EqualityConstraint) {
-                eqConstraint = (EqualityConstraint) data;
+                EQ = (EqualityConstraint) data;
                 continue;
             }
             if (data instanceof InequalityConstraint) {
-                iqConstraint = (InequalityConstraint) data;
+                IQ = (InequalityConstraint) data;
                 continue;
             }
 
             if (data instanceof BoundedConstraint) {
-                boxConstraint = (BoundedConstraint) data;
+                BOX = (BoundedConstraint) data;
+                continue;
+            }
+
+            if (data instanceof SimpleBounds) {
+                SB = (SimpleBounds) data;
                 continue;
             }
 
@@ -154,13 +184,13 @@ public void parseOptimizationData(OptimizationData... optData) {
         }
 
         // if we got here, convexObjective exists
-        int n = obj.dim();
-        if (eqConstraint != null) {
-            int nDual = eqConstraint.dimY();
+        int n = OBJ.dim();
+        if (EQ != null) {
+            int nDual = EQ.dimY();
             if (nDual > n) {
                 throw new MathIllegalArgumentException(LocalizedOptimFormats.CONSTRAINTS_RANK, nDual, n);
             }
-            int nTest = eqConstraint.dim();
+            int nTest = EQ.dim();
             if (nDual == 0) {
                 throw new MathIllegalArgumentException(LocalizedCoreFormats.ZERO_NOT_ALLOWED);
             }