Crate ipopt

ipopt-rs

This crate provides a safe Rust interface to the Ipopt non-linear optimization library. From the Ipopt webpage:

Ipopt (Interior Point OPTimizer, pronounced eye-pea-Opt) is a software package for large-scale nonlinear optimization. It is designed to find (local) solutions of mathematical optimization problems of the from

   min     f(x)
   x in R^n

   s.t.       g_L <= g(x) <= g_U
              x_L <=  x   <= x_U

where f(x): R^n --> R is the objective function, and g(x): R^n --> R^m are the constraint functions. The vectors g_L and g_U denote the lower and upper bounds on the constraints, and the vectors x_L and x_U are the bounds on the variables x. The functions f(x) and g(x) can be nonlinear and nonconvex, but should be twice continuously differentiable. Note that equality constraints can be formulated in the above formulation by setting the corresponding components of g_L and g_U to the same value.

This crate aims to

• reduce the boilerplate, especially for setting up simple unconstrained problems, and
• prevent common mistakes when defining optimization problems as early as possible.

Examples

Solve a simple unconstrained problem using L-BFGS: minimize (x - 1)^2 + (y -1)^2

use approx::*;
use ipopt::*;

struct NLP {
}

impl BasicProblem for NLP {
    // There are two independent variables: x and y.
    fn num_variables(&self) -> usize {
        2
    }    
    // The variables are unbounded. Any lower bound lower than -10^19 and upper bound higher
    // than 10^19 is treated effectively as infinity. These absolute infinity limits can be
    // changed via the `nlp_lower_bound_inf` and `nlp_upper_bound_inf` Ipopt options.
    fn bounds(&self, x_l: &mut [Number], x_u: &mut [Number]) -> bool {
        x_l.swap_with_slice(vec![-1e20; 2].as_mut_slice());
        x_u.swap_with_slice(vec![1e20; 2].as_mut_slice());
        true
    }

    // Set the initial conditions for the solver.
    fn initial_point(&self, x: &mut [Number]) -> bool {
        x.swap_with_slice(vec![0.0, 0.0].as_mut_slice());
        true
    }

    // The objective to be minimized.
    fn objective(&self, x: &[Number], new_x: bool, obj: &mut Number) -> bool {
        *obj = (x[0] - 1.0)*(x[0] - 1.0) + (x[1] - 1.0)*(x[1] - 1.0);
        true
    }

    // Objective gradient is used to find a new search direction to find the critical point.
    fn objective_grad(&self, x: &[Number], new_x: bool, grad_f: &mut [Number]) -> bool {
        grad_f[0] = 2.0*(x[0] - 1.0);
        grad_f[1] = 2.0*(x[1] - 1.0);
        true
    }
}

fn main() {
    let nlp = NLP { };
    let mut ipopt = Ipopt::new_unconstrained(nlp).unwrap();

    // Set Ipopt specific options here a list of all options is available at
    // https://www.coin-or.org/Ipopt/documentation/node40.html
    ipopt.set_option("tol", 1e-9); // set error tolerance
    ipopt.set_option("print_level", 5); // set the print level (5 is the default)

    let solve_result = ipopt.solve();

    assert_eq!(solve_result.status, SolveStatus::SolveSucceeded);
    assert_relative_eq!(solve_result.objective_value, 0.0, epsilon = 1e-10);
    let solution = solve_result.solver_data.solution;
    assert_relative_eq!(solution.primal_variables[0], 1.0, epsilon = 1e-10);
    assert_relative_eq!(solution.primal_variables[1], 1.0, epsilon = 1e-10);
}

See the tests for more examples including constrained optimization.

Structs

IntermediateCallbackData

Pieces of solver data available from Ipopt after each iteration inside the intermediate callback.

Ipopt

Ipopt non-linear optimization problem solver.

Solution

The solution of the optimization problem including variables, bound multipliers and Lagrange multipliers. This struct stores immutable slices to the solution data.

SolveResult

A data structure to store data returned by the solver.

SolverData

An interface to access internal solver data including the input problem immutably.

SolverDataMut

An interface to mutably access the input problem which Ipopt owns. This method also returns the solver paramters as immutable.

Enums

AlgorithmMode

Enum that indicates in which mode the algorithm is at some point in time.

CreateError

Problem create error type. This type is higher level than CreateProblemStatus and it captures inconsistencies with the input before even calling CreateIpoptProblem internally adding safety to this wrapper.

IndexingStyle

Zero-based indexing (C Style) or one-based indexing (Fortran style).

IpoptOption

Type of option you can specify to Ipopt. This is used internally for conversion.

SolveStatus

Program return status.

Traits

BasicProblem

The callback interface for a non-linear problem to be solved by Ipopt.

ConstrainedProblem

Extends the BasicProblem trait to enable equality and inequality constraints.

NewtonProblem

An extension to the BasicProblem trait that enables full Newton iterations in Ipopt.

Type Aliases

Index

IntermediateCallback

Type defining the callback function for giving intermediate execution control to the user.

Number