|
| | Ipopt () |
| | Creates a new NLP Solver using a default as the DLL name.
|
| |
| | Ipopt (String DLL) |
| | Creates a NLP Solver for the given DLL file.
|
| |
| | Ipopt (String path, String DLL) |
| | Creates a NLP Solver for the given DLL file and path.
|
| |
| void | dispose () |
| | Dispose of the natively allocated memory.
|
| |
| boolean | create (int n, int m, int nele_jac, int nele_hess, int index_style) |
| | Create a new problem.
|
| |
| boolean | setIntegerOption (String keyword, int val) |
| | Function for setting an integer option.
|
| |
| boolean | setNumericOption (String keyword, double val) |
| | Function for setting a number option.
|
| |
| boolean | setStringOption (String keyword, String val) |
| | Function for setting a string option.
|
| |
| int | OptimizeNLP () |
| | This function actually solve the problem.
|
| |
| 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[]) |
| | Get primal and dual variable values of the current iterate.
|
| |
| 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[]) |
| | Get primal and dual infeasibility of the current iterate.
|
| |
| double[] | getVariableValues () |
| | Gives primal variable values at final point.
|
| |
| double | getObjectiveValue () |
| | Gives objective function value at final point.
|
| |
| int | getStatus () |
| | Gives Ipopt status of last OptimizeNLP call.
|
| |
| double[] | getConstraintValues () |
| | Gives constraint function values at final point.
|
| |
| double[] | getConstraintMultipliers () |
| | Gives constraint dual multipliers in final point.
|
| |
| double[] | getLowerBoundMultipliers () |
| | Gives dual multipliers for variable lower bounds in final point.
|
| |
| double[] | getUpperBoundMultipliers () |
| | Gives dual multipliers for variable upper bounds in final point.
|
| |
| 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) |
| | Intermediate Callback method for the user.
|
| |
| boolean | get_scaling_parameters (double[] obj_scaling, int n, double[] x_scaling, int m, double[] g_scaling, boolean[] use_x_g_scaling) |
| | If you using_scaling_parameters = true, this method should be overloaded.
|
| |
| int | get_number_of_nonlinear_variables () |
| | When LBFGS hessian approximation is used, this method should be overloaded.
|
| |
| boolean | get_list_of_nonlinear_variables (int num_nonlin_vars, int[] pos_nonlin_vars) |
| | When LBFGS hessian approximation is used, this method should be overloaded.
|
| |
|
| abstract boolean | get_bounds_info (int n, double[] x_l, double[] x_u, int m, double[] g_l, double[] g_u) |
| | Method to request bounds on the variables and constraints.
|
| |
| abstract 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) |
| | Method to request the starting point before iterating.
|
| |
| abstract boolean | eval_f (int n, double[] x, boolean new_x, double[] obj_value) |
| | Method to request the value of the objective function.
|
| |
| abstract boolean | eval_grad_f (int n, double[] x, boolean new_x, double[] grad_f) |
| | Method to request the gradient of the objective function.
|
| |
| abstract boolean | eval_g (int n, double[] x, boolean new_x, int m, double[] g) |
| | Method to request the constraint values.
|
| |
| abstract boolean | eval_jac_g (int n, double[] x, boolean new_x, int m, int nele_jac, int[] iRow, int[] jCol, double[] values) |
| | Method to request either the sparsity structure or the values of the Jacobian of the constraints.
|
| |
| abstract 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) |
| | Method to request either the sparsity structure or the values of the Hessian of the Lagrangian.
|
| |
| void | finalize () throws Throwable |
| |
|
| native boolean | AddIpoptIntOption (long ipopt, String keyword, int val) |
| |
| native boolean | AddIpoptNumOption (long ipopt, String keyword, double val) |
| |
| native boolean | AddIpoptStrOption (long ipopt, String keyword, String val) |
| |
| native long | CreateIpoptProblem (int n, int m, int nele_jac, int nele_hess, int index_style) |
| |
| native void | FreeIpoptProblem (long ipopt) |
| |
| 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 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 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[]) |
| |
A Java Native Interface for the Ipopt optimization solver.
Ipopt is a solver for large scale nonlinear optimization problems (NLP).
The Java Native Interface (JNI) is a programming framework that allows Java code running in the Java Virtual Machine (JVM) to call and be called by native applications (programs specific to a hardware and operating system platform) and libraries written in other languages, such as C and C++.
This class is a JNI hook around the C++ interface of Ipopt, as a consequence it will need a nativelly compiled DLL to run. For more details about Ipopt click here.
The user should subclass this class and implement the abstract methods. At some point before solving the problem the create(int, int, int, int, int) function should be called. For simple cases you can call this function in the constructor of your class.
Once the problem was created, OptimizeNLP() will solve the problem. Objects of this class can be reused to solve different problems, in other words, create(int, int, int, int, int) and OptimizeNLP() can be called multiple times.
Programmers must call dispose() when finished using a Ipopt object, otherwise the nativelly allocated memory will be disposed of only when the JVM call finalize() on it.
- Author
- Rafael de Pelegrini Soares
-
Edson C. do Valle
-
Tong Kewei, BeiHang University
Definition at line 44 of file Ipopt.java.
| abstract boolean org.coinor.Ipopt.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 |
|
) |
| |
|
abstractprotected |
Method to request the starting point before iterating.
The boolean variables indicate whether the algorithm requires to have x, z_L/z_u, and lambda initialized, respectively. If, for some reason, the algorithm requires initializations that cannot be provided, false should be returned and Ipopt will stop. The default options only require initial values for the primal variables.
Note, that the initial values for bound multiplier components for absent bounds are ignored.
- Parameters
-
| n | (in) the number of variables in the problem; it will have the same value that was specified in create() |
| init_x | (in) if true, this method must provide an initial value for the primal variables |
| x | (out) the initial values for the primal variables |
| init_z | (in) if true, this method must provide an initial value for the bound multipliers |
| z_L | (out) the initial values for the lower bound multipliers |
| z_U | (out) the initial values for the upper bound multipliers |
| m | (in) the number of constraints in the problem; it will have the same value that was specified in create() |
| init_lambda | (in) if true, this method must provide an initial value for the constraint multipliers |
| lambda | (out) the initial values for the constraint multipliers |
- Returns
- true on success, otherwise false
| abstract boolean org.coinor.Ipopt.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 |
|
) |
| |
|
abstractprotected |
Method to request either the sparsity structure or the values of the Hessian of the Lagrangian.
The Hessian matrix that Ipopt uses is the sum of the Hessian matrices of objective function (multiplied by obj_factor) and each constraint function (multiplied by lambda).
The arrays iRow and jCol only need to be filled once. If the iRow and jCol arguments are not NULL (first call to this function), then Ipopt expects that the sparsity structure of the Hessian (the row and column indices only) are written into iRow and jCol. At this call, the arguments x, lambda, and values will be NULL. If the arguments x, lambda, and values are not NULL, then Ipopt expects that the value of the Hessian as calculated from arrays x and lambda are stored in array values (using the same order as used when specifying the sparsity structure). At this call, the arguments iRow and jCol will be NULL.
As this matrix is symmetric, Ipopt expects that only the lower diagonal entries are specified.
- Parameters
-
| n | (in) the number of variables in the problem; it will have the same value that was specified in create() |
| x | (in) first call: NULL; later calls: the values for the primal variables at which the Hessian is to be evaluated |
| new_x | (in) false if any evaluation method (eval_*) was previously called with the same values in x, true otherwise; see also eval_f() |
| obj_factor | (in) factor in front of the objective term in the Hessian |
| m | (in) the number of constraints in the problem; it will have the same value that was specified in create() |
| lambda | (in) the values for the constraint multipliers at which the Hessian is to be evaluated |
| new_lambda | (in) false if any evaluation method was previously called with the same values in lambda, true otherwise |
| nele_hess | (in) the number of nonzero elements in the Hessian; it will have the same value that was specified in create() |
| iRow | (out) first call: array of length nele_hess to store the row indices of entries in the Hessian; later calls: NULL |
| jCol | (out) first call: array of length nele_hess to store the column indices of entries in the Hessian; later calls: NULL |
| values | (out) first call: NULL; later calls: array of length nele_hess to store the values of the entries in the Hessian |
- Returns
- true on success, otherwise false
| boolean org.coinor.Ipopt.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[] |
|
) |
| |
|
inline |
Get primal and dual variable values of the current iterate.
This method can be used to get the values of the current iterate during intermediate_callback(). The method expects the number of variables (dimension of x), number of constraints (dimension of g(x)), and allocated arrays of appropriate lengths as input.
The method translates the x(), c(), d(), y_c(), y_d(), z_L(), and z_U() vectors from Ipopt::IpoptData::curr() of the internal NLP representation into the form used by the TNLP. For the correspondence between scaled and unscaled solutions, see the detailed description of Ipopt::OrigIpoptNLP. If Ipopt is in restoration mode, it maps the current iterate of restoration NLP (see Ipopt::RestoIpoptNLP) back to the original TNLP.
If there are fixed variables and fixed_variable_treatment=make_parameter, then requesting z_L and z_U can trigger a reevaluation of the Gradient of the objective function and the Jacobian of the constraint functions.
- Parameters
-
| ip_data | (in) Ipopt Data (pass on value given to intermediate_callback) |
| ip_cq | (in) Ipopt Calculated Quantities (pass on value given to intermediate_callback) |
| scaled | (in) whether to retrieve scaled or unscaled iterate |
| n | (in) the number of variables \(x\) in the problem; can be arbitrary if skipping x, z_L, and z_U |
| x | (out) buffer to store value of primal variables \(x\), must have length at least n; pass null to skip retrieving x |
| z_L | (out) buffer to store the lower bound multipliers \(z_L\), must have length at least n; pass null to skip retrieving z_L and z_U |
| z_U | (out) buffer to store the upper bound multipliers \(z_U\), must have length at least n; pass null to skip retrieving z_L and z_U |
| m | (in) the number of constraints \(g(x)\); can be arbitrary if skipping g and lambda |
| g | (out) buffer to store the constraint values \(g(x)\), must have length at least m; pass null to skip retrieving g |
| lambda | (out) buffer to store the constraint multipliers \(\lambda\), must have length at least m; pass null to skip retrieving lambda |
- Returns
- Whether Ipopt has successfully filled the given arrays
- Since
- 3.14.0
Definition at line 640 of file Ipopt.java.
| boolean org.coinor.Ipopt.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[] |
|
) |
| |
|
inline |
Get primal and dual infeasibility of the current iterate.
This method can be used to get the violations of constraints and optimality conditions at the current iterate, e.g., during intermediate_callback(). The method expects the number of variables (dimension of x), number of constraints (dimension of g(x)), and allocated arrays of appropriate lengths as input.
The method makes the vectors behind (unscaled_)curr_nlp_constraint_violation(), (unscaled_)curr_dual_infeasibility(), (unscaled_)curr_complementarity() from Ipopt::IpoptCalculatedQuantities of the internal NLP representation available into the form used by the TNLP. If Ipopt is in restoration mode, it maps the current iterate of restoration NLP (see Ipopt::RestoIpoptNLP) back to the original TNLP.
- Note
- If in restoration phase, then requesting grad_lag_x can trigger a call to eval_grad_f().
-
Ipopt by default relaxes variable bounds (option bound_relax_factor > 0.0). x_L_violation and x_U_violation report the violation of a solution w.r.t. the original unrelaxed bounds. However, compl_x_L and compl_x_U use the relaxed variable bounds to calculate the complementarity.
- Parameters
-
| ip_data | (in) Ipopt Data (pass on value given to intermediate_callback) |
| ip_cq | (in) Ipopt Calculated Quantities (pass on value given to intermediate_callback) |
| scaled | (in) whether to retrieve scaled or unscaled violations |
| n | (in) the number of variables \(x\) in the problem; can be arbitrary if skipping compl_x_L, compl_x_U, and grad_lag_x |
| x_L_violation | (out) buffer to store violation of original lower bounds on variables (max(orig_x_L-x,0)), must have length at least n; pass NULL to skip retrieving orig_x_L |
| x_U_violation | (out) buffer to store violation of original upper bounds on variables (max(x-orig_x_U,0)), must have length at least n; pass NULL to skip retrieving orig_x_U |
| compl_x_L | (out) buffer to store violation of complementarity for lower bounds on variables ( \((x-x_L)z_L\)), must have length at least n; pass null to skip retrieving compl_x_L |
| compl_x_U | (out) buffer to store violation of complementarity for upper bounds on variables ( \((x_U-x)z_U\)), must have length at least n; pass null to skip retrieving compl_x_U |
| grad_lag_x | (out) buffer to store gradient of Lagrangian w.r.t. variables \(x\), must have length at least n; pass null to skip retrieving grad_lag_x |
| m | (in) the number of constraints \(g(x)\); can be arbitrary if skipping lambda |
| nlp_constraint_violation | (out) buffer to store violation of constraints \(max(g_l-g(x),g(x)-g_u,0)\), must have length at least m; pass null to skip retrieving constraint_violation |
| compl_g | (out) buffer to store violation of complementarity of constraint ( \((g(x)-g_l)*\lambda^+ + (g_l-g(x))*\lambda^-\), where \(\lambda^+=max(0,\lambda)\) and \(\lambda^-=max(0,-\lambda)\) (componentwise)), must have length at least m; pass null to skip retrieving compl_g |
- Returns
- Whether Ipopt has successfully filled the given arrays
- Since
- 3.14.0
Definition at line 689 of file Ipopt.java.
| boolean org.coinor.Ipopt.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 |
|
) |
| |
|
inline |
Intermediate Callback method for the user.
This method is called once per iteration (during the convergence check), and can be used to obtain information about the optimization status while Ipopt solves the problem, and also to request a premature termination.
The information provided by the entities in the argument list correspond to what Ipopt prints in the iteration summary (see also Ipopt Output), except for inf_pr, which by default corresponds to the original problem in the log but to the scaled internal problem in this callback. The value of algorithmmode is either REGULARMODE or RESTORATIONPHASEMODE.
The current iterate and violations of feasibility and optimality can be accessed via the methods get_curr_iterate() and get_curr_violations(). These methods translate values for the internal representation of the problem from ip_data and ip_cq objects.
- Returns
- If this method returns false, Ipopt will terminate with the User_Requested_Stop status.
It is not required to implement (overload) this method. The default implementation always returns true.
- Since
- 3.14.0
Definition at line 789 of file Ipopt.java.
