Struct BilevelProblem 

pub struct BilevelProblem<F, G>
where
    F: Fn(&[f64], &[f64]) -> f64,
    G: Fn(&[f64], &[f64]) -> f64,
{
    pub upper_obj: F,
    pub lower_obj: G,
    pub x0: Vec<f64>,
    pub y0: Vec<f64>,
    pub upper_constraints: Vec<Box<dyn Fn(&[f64], &[f64]) -> f64>>,
    pub lower_constraints: Vec<Box<dyn Fn(&[f64], &[f64]) -> f64>>,
    pub x_lb: Option<Vec<f64>>,
    pub x_ub: Option<Vec<f64>>,
    pub y_lb: Option<Vec<f64>>,
    pub y_ub: Option<Vec<f64>>,
}

Bilevel problem descriptor

Encapsulates upper and lower level objectives and optional constraints.

Fields

upper_obj: F

Upper-level objective F(x, y)

lower_obj: G

Lower-level objective f(x, y)

x0: Vec<f64>

Initial upper-level variables

y0: Vec<f64>

Initial lower-level variables

upper_constraints: Vec<Box<dyn Fn(&[f64], &[f64]) -> f64>>

Upper-level inequality constraints G_i(x,y) <= 0

lower_constraints: Vec<Box<dyn Fn(&[f64], &[f64]) -> f64>>

Lower-level inequality constraints g_j(x,y) <= 0

x_lb: Option<Vec<f64>>

Optional lower bounds on x

x_ub: Option<Vec<f64>>

Optional upper bounds on x

y_lb: Option<Vec<f64>>

Optional lower bounds on y

y_ub: Option<Vec<f64>>

Optional upper bounds on y

Implementations

impl<F, G> BilevelProblem<F, G>

where F: Fn(&[f64], &[f64]) -> f64, G: Fn(&[f64], &[f64]) -> f64,

pub fn new(upper_obj: F, lower_obj: G, x0: Vec<f64>, y0: Vec<f64>) -> Self

Create a new bilevel problem with no constraints

pub fn with_upper_constraint( self, constraint: impl Fn(&[f64], &[f64]) -> f64 + 'static, ) -> Self

Add an upper-level inequality constraint G(x,y) <= 0

pub fn with_lower_constraint( self, constraint: impl Fn(&[f64], &[f64]) -> f64 + 'static, ) -> Self

Add a lower-level inequality constraint g(x,y) <= 0

pub fn with_x_bounds(self, lb: Vec<f64>, ub: Vec<f64>) -> Self

Set bounds on upper-level variables

pub fn with_y_bounds(self, lb: Vec<f64>, ub: Vec<f64>) -> Self

Set bounds on lower-level variables

pub fn eval_upper(&self, x: &[f64], y: &[f64]) -> f64

Evaluate upper objective

pub fn eval_lower(&self, x: &[f64], y: &[f64]) -> f64

Evaluate lower objective

pub fn upper_constraint_violation(&self, x: &[f64], y: &[f64]) -> f64

Compute upper constraint violation (sum of max(0, G_i))

pub fn lower_constraint_violation(&self, x: &[f64], y: &[f64]) -> f64

Compute lower constraint violation (sum of max(0, g_j))

pub fn project_y(&self, y: &[f64]) -> Vec<f64>

Project y onto its bounds

pub fn project_x(&self, x: &[f64]) -> Vec<f64>

Project x onto its bounds