Ipopt.java

Go to the documentation of this file.

/* Copyright (C) 2007 VRTech Industrial Technologies - www.vrtech.com.br.
 * Copyright (C) 2007 Tong Kewei, Beihang University, - www.buaa.edu.cn.
 * All Rights Reserved.
 * This code is published under the Eclipse Public License.
 */
 
package org.coinor;
 
import java.io.File;
 
public abstract class Ipopt
{
   /* Native function should not be used directly */
   private native boolean AddIpoptIntOption(
      long   ipopt,
      String keyword,
      int    val
   );
 
   /* Native function should not be used directly */
   private native boolean AddIpoptNumOption(
      long   ipopt,
      String keyword,
      double val
   );
 
   /* Native function should not be used directly */
   private native boolean AddIpoptStrOption(
      long   ipopt,
      String keyword,
      String val
   );
 
   /* Native function should not be used directly */
   private native long CreateIpoptProblem(
      int n,
      int m,
      int nele_jac,
      int nele_hess,
      int index_style
   );
 
   /* Native function should not be used directly */
   private native void FreeIpoptProblem(
      long ipopt
   );
 
   /* Native function should not be used directly */
   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[]
   );
 
   /* Native function should not be used directly */
   private native boolean GetCurrIterate(
      long     ipopt,
      long     ip_data,
      long     ip_cq,
      boolean  scaled,
      int      n,
      double   x[],
      double   z_L[],
      double   z_U[],
      int      m,
      double   g[],
      double   lambda[]
   );
 
   /* Native function should not be used directly */
   private native boolean GetCurrViolations(
      long     ipopt,
      long     ip_data,
      long     ip_cq,
      boolean  scaled,
      int      n,
      double   x_L_violation[],
      double   x_U_violation[],
      double   compl_x_L[],
      double   compl_x_U[],
      double   grad_lag_x[],
      int      m,
      double   nlp_constraint_violation[],
      double   compl_g[]
   );
 
   public final static int C_STYLE = 0;
 
   public final static int FORTRAN_STYLE = 1;
 
   /* The possible Ipopt status return codes: should be kept in sync with Ipopt return codes */
   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 WALLTIME_EXCEEDED = -5;           
   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;
 
   /* The possible algorithm modes (passed to intermediate_callback) */
   public final static int REGULARMODE = 0;            
   public final static int RESTORATIONPHASEMODE = 1;   
 
   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};
 
   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()
   {
      if( System.getProperty("os.name").toLowerCase().indexOf("win") >= 0 )
      {
         /* for Ipopt releases, it should be ipopt-3.dll
          * for other intermediate versions, it should be ipopt-0.dll
          * with MinGW, libtool adds a "lib" prefix
          * finally, try also without version info
          */
         final String[] candidates = { "ipopt-3", "ipopt-0", "libipopt-3", "libipopt-0", "ipopt", "libipopt" };
         boolean loadedlib = false;
         for( String c : candidates )
         {
            try
            {
               /* This loads the Ipopt library with RTLD_LOCAL, which means that symbols loaded are not made available for future dlopen() calls.
                * This causes a problem when using MKL, which loads an additional library at runtime, e.g., libmkl_avx2, because this lib references
                * to symbols that could be resolved in previously load MKL libraries - but are not because of RTLD_LOCAL.
                * TODO should one add some kind of workaround to load the Ipopt lib with RTLD_GLOBAL?, e.g.,
                *     https://stackoverflow.com/questions/5425034/java-load-shared-libraries-with-dependencies
                *     https://github.com/victor-paltz/global-load-library
                */
               System.loadLibrary(c);
               loadedlib = true;
               break;
            }
            catch( UnsatisfiedLinkError e )
            { }
         }
         if( !loadedlib )
         {
            throw new UnsatisfiedLinkError("Could not load Ipopt library. Check your java.library.path.");
         }
      }
      else
      {
         System.loadLibrary("ipopt");
      }
   }
 
   public Ipopt(
      String DLL)
   {
      // Loads the library
      System.loadLibrary(DLL);
   }
 
   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;
      }
   }
 
   @Deprecated
   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];
      g = new double[m];
 
      // 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];
      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)
   {
      if( ipopt == 0 )
      {
         return false;
      }
 
      return AddIpoptIntOption(ipopt, keyword, val);
   }
 
   public boolean setNumericOption(
      String keyword,
      double val)
   {
      if( ipopt == 0 )
      {
         return false;
      }
 
      return AddIpoptNumOption(ipopt, keyword, val);
   }
 
   public boolean setStringOption(
      String keyword,
      String val)
   {
      if( ipopt == 0 )
      {
         return false;
      }
 
      return 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 boolean get_curr_iterate(
      long     ip_data,
      long     ip_cq,
      boolean  scaled,
      int      n,
      double   x[],
      double   z_L[],
      double   z_U[],
      int      m,
      double   g[],
      double   lambda[]
   )
   {
      return this.GetCurrIterate(ipopt, ip_data, ip_cq, scaled, n, x, z_L, z_U, m, g, lambda);
   }
 
   public boolean get_curr_violations(
      long     ip_data,
      long     ip_cq,
      boolean  scaled,
      int      n,
      double   x_L_violation[],
      double   x_U_violation[],
      double   compl_x_L[],
      double   compl_x_U[],
      double   grad_lag_x[],
      int      m,
      double   nlp_constraint_violation[],
      double   compl_g[]
   )
   {
      return this.GetCurrViolations(ipopt, ip_data, ip_cq, scaled, n, x_L_violation, x_U_violation, compl_x_L, compl_x_U, grad_lag_x, m, nlp_constraint_violation, compl_g);
   }
 
   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 intermediate_callback(
      int      algorithmmode,
      int      iter,
      double   obj_value,
      double   inf_pr,
      double   inf_du,
      double   mu,
      double   d_norm,
      double   regularization_size,
      double   alpha_du,
      double   alpha_pr,
      int      ls_trials,
      long     ip_data,
      long     ip_cq)
   {
      return true;
   }
 
   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;
   }
}