AbstractSQPOptimizer2.java

/*
 * 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.exception.LocalizedCoreFormats;
import org.hipparchus.exception.MathIllegalArgumentException;
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;

/**
 * Abstract class for Sequential Quadratic Programming solvers
 * @since 3.1
 */
public abstract class AbstractSQPOptimizer2 extends ConstraintOptimizer {

    /** Algorithm settings. */
    private SQPOption settings;

    /** Tolerance for symmetric matrix decomposition.
     * @since 4.1
     */
    private MatrixDecompositionTolerance matrixDecompositionTolerance;

    /** Objective function. */
    private TwiceDifferentiableFunction OBJ;

    /** Equality constraint (may be null). */
    private EqualityConstraint EQ;

    /** Inequality constraint (may be null). */
    private InequalityConstraint IQ;

    /** Inequality constraint (may be null). */
    private BoundedConstraint BOX;

    /** Simple Bounds (may be null). */
    private SimpleBounds SB;

    /** Default QPSolver. */
    private QPOptimizer QPSolver = new QPDualActiveSolver();

    /** Simple constructor.
     */
    protected AbstractSQPOptimizer2() {
        this.settings                     = new SQPOption();
        this.matrixDecompositionTolerance = new MatrixDecompositionTolerance(EigenDecompositionSymmetric.DEFAULT_EPSILON);
    }

    /** Getter for settings.
     * @return settings
     */
    public SQPOption getSettings() {
        return settings;
    }

    /** Getter for matrix decomposition tolerance.
     * @return matrix decomposition tolerance
     * @since 4.1
     */
    public MatrixDecompositionTolerance getMatrixDecompositionTolerance() {
        return matrixDecompositionTolerance;
    }

    /** Getter for objective function.
     * @return objective function
     */
    public TwiceDifferentiableFunction getObj() {
        return OBJ;
    }

    /** Getter for equality constraint.
     * @return equality constraint
     */
    public EqualityConstraint getEqConstraint() {
        return EQ;
    }

    /** Getter for inequality constraint.
     * @return inequality constraint
     */
    public InequalityConstraint getIqConstraint() {
        return IQ;
    }

     /** Getter for box constraint.
     * @return inequality constraint
     */
    public BoundedConstraint getBoxConstraint() {
        return BOX;
    }

     /** Getter for simple bounds.
     * @return simple bounds
     */
    public SimpleBounds getSimpleBounds() {
        return SB;
    }

    /** Getter for QP Solver.
     * @return QP Solver
     */
    public QPOptimizer getQPSolver() {
        return QPSolver;
    }

    @Override
    public LagrangeSolution optimize(OptimizationData... optData) {
        return super.optimize(optData);
    }

    @Override
    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();
                continue;
            }

            if (data instanceof EqualityConstraint) {
                EQ = (EqualityConstraint) data;
                continue;
            }
            if (data instanceof InequalityConstraint) {
                IQ = (InequalityConstraint) data;
                continue;
            }

            if (data instanceof BoundedConstraint) {
                BOX = (BoundedConstraint) data;
                continue;
            }

            if (data instanceof SimpleBounds) {
                SB = (SimpleBounds) data;
                continue;
            }

            if (data instanceof SQPOption) {
                settings = (SQPOption) data;
            }

            if (data instanceof QPOptimizer) {
                QPSolver = (QPOptimizer) data;
            }

            if (data instanceof MatrixDecompositionTolerance) {
                matrixDecompositionTolerance = (MatrixDecompositionTolerance) data;
            }

        }

        // if we got here, convexObjective exists
        int n = OBJ.dim();
        if (EQ != null) {
            int nDual = EQ.dimY();
            if (nDual > n) {
                throw new MathIllegalArgumentException(LocalizedOptimFormats.CONSTRAINTS_RANK, nDual, n);
            }
            int nTest = EQ.dim();
            if (nDual == 0) {
                throw new MathIllegalArgumentException(LocalizedCoreFormats.ZERO_NOT_ALLOWED);
            }
            MathUtils.checkDimension(nTest, n);
        }

    }

}