Ipopt.java

Go to the documentation of this file.

package org.coinor;

import java.io.File;

public abstract class Ipopt
{
    private native boolean AddIpoptIntOption(long ipopt, String keyword, int val);

    private native boolean AddIpoptNumOption(long ipopt, String keyword, double val);

    private native boolean AddIpoptStrOption(long ipopt, String keyword, String val);

    private native long CreateIpoptProblem(int n,int m, 
            int nele_jac, int nele_hess, int index_style);

    private native void FreeIpoptProblem(long ipopt);

    private native int OptimizeTNLP(long ipopt,
            double x[], double g[],
            double obj_val[], double mult_g[], double mult_x_L[], double mult_x_U[],
            double callback_grad_f[], double callback_jac_g[], double callback_hess[]);


    public static final String DLLNAME = "jipopt";
    public static final String DLLPATH = "lib";

    public final static int C_STYLE = 0;
    public final static int FORTRAN_STYLE = 1;

    public final static int SOLVE_SUCCEEDED = 0;
    public final static int ACCEPTABLE_LEVEL = 1;
    public final static int INFEASIBLE_PROBLEM = 2;
    public final static int SEARCH_DIRECTION_TOO_SMALL = 3;
    public final static int DIVERGING_ITERATES = 4;
    public final static int USER_REQUESTED_STOP = 5;
    public final static int ITERATION_EXCEEDED = -1;
    public final static int RESTORATION_FAILED = -2;
    public final static int ERROR_IN_STEP_COMPUTATION = -3;
    public final static int CPUTIME_EXCEEDED = -4;
    public final static int NOT_ENOUGH_DEGREES_OF_FRE = -10;
    public final static int INVALID_PROBLEM_DEFINITION = -11;
    public final static int INVALID_OPTION = -12;
    public final static int INVALID_NUMBER_DETECTED = -13;
    public final static int UNRECOVERABLE_EXCEPTION = -100;
    public final static int NON_IPOPT_EXCEPTION = -101;
    public final static int INSUFFICIENT_MEMORY = -102;
    public final static int INTERNAL_ERROR = -199;

    private long ipopt;

    private double callback_grad_f[];
    private double callback_jac_g[];
    private double callback_hess[];

    private double x[];
    
    private double obj_val[] = {0.0};

    private double g[];

    private double mult_x_L[];

    private double mult_x_U[];

    private double mult_g[];

    private int status = INVALID_PROBLEM_DEFINITION;

    public Ipopt()
    {
        this(DLLPATH, DLLNAME);
    }

    public Ipopt(String path, String DLL)
    {
        // Loads the library
        File file = new File(path, System.mapLibraryName(DLL));
        System.load(file.getAbsolutePath());
    }

    abstract protected boolean get_bounds_info(int n, double[] x_l, double[] x_u,
            int m, double[] g_l, double[] g_u);
    
    abstract protected boolean get_starting_point(int n, boolean init_x, double[] x,
            boolean init_z, double[] z_L, double[] z_U,
            int m, boolean init_lambda, double[] lambda);
    
    abstract protected boolean eval_f(int n, double[] x, boolean new_x, double[] obj_value);
    
    abstract protected boolean eval_grad_f(int n, double[] x, boolean new_x, double[] grad_f);
    
    abstract protected boolean eval_g(int n, double[] x, boolean new_x, int m, double[] g);
    
    abstract protected boolean eval_jac_g(int n, double[] x, boolean new_x,
            int m, int nele_jac, int[] iRow, int[] jCol, double[] values);
    
    abstract protected boolean eval_h(int n, double[] x, boolean new_x, double obj_factor,
            int m, double[] lambda, boolean new_lambda,
            int nele_hess, int[] iRow, int[] jCol,
            double[] values);

    public void dispose()
    {
        // dispose the native implementation
        if( ipopt != 0 )
        {
            FreeIpoptProblem(ipopt);
            ipopt = 0;
        }
    }
    
    protected void finalize() throws Throwable
    {
        dispose();
    }

    public boolean create(int n, int m,  int nele_jac, int nele_hess, int index_style)
    {
        // delete any previously created native memory
        dispose();

        x = new double[n];
        // allocate the callback arguments
        callback_grad_f = new double[n];
        callback_jac_g = new double[nele_jac];
        callback_hess = new double[nele_hess];

        // the multiplier
        mult_x_U = new double[n];
        mult_x_L = new double[n];
        g = new double[m];
        mult_g = new double[m];

        //  Create the optimization problem and return a pointer to it
        ipopt = CreateIpoptProblem(n, m,  nele_jac, nele_hess, index_style);

        //System.out.println("Finish Java Obj");
        return ipopt == 0 ? false : true;
    }

    public boolean setIntegerOption(String keyword, int val)
    {
        return ipopt == 0 ? false : AddIpoptIntOption(ipopt, keyword, val);
    }

    public boolean setNumericOption(String keyword, double val)
    {
        return ipopt == 0 ? false : AddIpoptNumOption(ipopt, keyword, val);
    }

    public boolean setStringOption(String keyword, String val)
    {
        return ipopt == 0 ? false : AddIpoptStrOption(ipopt, keyword, val.toLowerCase());
    }

    public int OptimizeNLP()
    {
        this.status = this.OptimizeTNLP(ipopt,
                x, g, obj_val, mult_g, mult_x_L, mult_x_U,
                callback_grad_f, callback_jac_g, callback_hess);
        
        return this.status;
    }

    public double[] getVariableValues()
    {
        return x;
    }

    public double getObjectiveValue()
    {
        return obj_val[0];
    }

    public int getStatus()
    {
        return status;
    }

    public double[] getConstraintValues()
    {
        return g;
    }

    public double[] getConstraintMultipliers()
    {
        return mult_g;
    }

    public double[] getLowerBoundMultipliers()
    {
        return mult_x_L;
    }

    public double[] getUpperBoundMultipliers()
    {
        return mult_x_U;
    }

    public boolean get_scaling_parameters(double[] obj_scaling,
            int n, double[] x_scaling,
            int m, double[] g_scaling,
            boolean[] use_x_g_scaling)
    {
        return false;
    }

    public int get_number_of_nonlinear_variables()
    {
        return -1;
    }

    public boolean get_list_of_nonlinear_variables(int num_nonlin_vars,
            int[] pos_nonlin_vars)
    {
        return false;
    }
}