Struct InteriorPoint 

pub struct InteriorPoint { /* private fields */ }

Interior Point (Barrier) method for inequality-constrained optimization.

Solves problems with inequality constraints:

minimize f(x)
subject to: g(x) ≤ 0  (inequality constraints)

Algorithm

Barrier function: B_μ(x) = f(x) - μ Σ log(-g_i(x))

for k = 1, 2, ..., max_iter:
    x_k = argmin B_μ(x)  (barrier subproblem)
    μ_k+1 = β * μ_k      (decrease barrier parameter)
    if ‖∇B_μ(x)‖ is small: converged

Key Features

• Log-barrier: Enforces g(x) < 0 via -μ log(-g_i(x))
• Path-following: Decreases μ → 0 to approach constrained optimum
• Self-concordant: Converges in O(√n log(1/ε)) iterations
• Warm start: Uses previous solution for next barrier value

Applications

• Linear programming: Constraints Ax ≤ b
• Quadratic programming: QP with inequality constraints
• Semidefinite programming: Matrix constraints X ⪰ 0
• Support Vector Machines: Soft-margin constraints
• Portfolio optimization: Long-only constraints (x ≥ 0)

Example

use aprender::optim::InteriorPoint;
use aprender::primitives::Vector;

// Minimize: x₁² + x₂² subject to -x₁ ≤ 0, -x₂ ≤ 0 (i.e., x ≥ 0)
let objective = |x: &Vector<f32>| x[0] * x[0] + x[1] * x[1];

let gradient = |x: &Vector<f32>| Vector::from_slice(&[2.0 * x[0], 2.0 * x[1]]);

// Inequality constraints: g(x) = [-x₁, -x₂] ≤ 0
let inequality = |x: &Vector<f32>| Vector::from_slice(&[-x[0], -x[1]]);

let inequality_jac = |_x: &Vector<f32>| {
    vec![Vector::from_slice(&[-1.0, 0.0]), Vector::from_slice(&[0.0, -1.0])]
};

let mut ip = InteriorPoint::new(50, 1e-6, 1.0);
let x0 = Vector::from_slice(&[1.0, 1.0]); // Feasible start
let result = ip.minimize(objective, gradient, inequality, inequality_jac, x0);

// Solution should be [0, 0] (constrained minimum)
assert!(result.solution[0].abs() < 1e-3);
assert!(result.solution[1].abs() < 1e-3);

References

• Nesterov & Nemirovskii (1994). “Interior-Point Polynomial Algorithms in Convex Programming.”
• Boyd & Vandenberghe (2004). “Convex Optimization.” Chapter 11.
• Wright (1997). “Primal-Dual Interior-Point Methods.”

Implementations

impl InteriorPoint

pub fn new(max_iter: usize, tol: f32, initial_mu: f32) -> InteriorPoint

Creates a new Interior Point optimizer.

Arguments

• max_iter - Maximum number of outer iterations
• tol - Convergence tolerance
• initial_mu - Initial barrier parameter (typically 1.0-10.0)

Example

use aprender::optim::InteriorPoint;

let optimizer = InteriorPoint::new(50, 1e-6, 1.0);

pub fn with_beta(self, beta: f32) -> InteriorPoint

Sets barrier decrease factor.

Arguments

• beta - Barrier decrease factor (0 < beta < 1, typically 0.1-0.5)

Example

use aprender::optim::InteriorPoint;

let optimizer = InteriorPoint::new(50, 1e-6, 1.0)
    .with_beta(0.1); // Aggressive barrier decrease

pub fn minimize<F, G, H, J>( &mut self, objective: F, gradient: G, inequality: H, inequality_jac: J, x0: Vector<f32>, ) -> OptimizationResult

where F: Fn(&Vector<f32>) -> f32, G: Fn(&Vector<f32>) -> Vector<f32>, H: Fn(&Vector<f32>) -> Vector<f32>, J: Fn(&Vector<f32>) -> Vec<Vector<f32>>,

Minimizes objective subject to inequality constraints.

Solves: minimize f(x) subject to g(x) ≤ 0

Arguments

• objective - Objective function f(x)
• gradient - Gradient ∇f(x)
• inequality - Inequality constraints g(x) ≤ 0 (returns vector)
• inequality_jac - Jacobian of inequality constraints ∇g(x)
• x0 - Initial feasible point (must satisfy g(x0) < 0 strictly)

Returns

Optimization result with constraint satisfaction metrics

Panics

Panics if initial point is infeasible (g(x0) ≥ 0 for any constraint)

Trait Implementations

impl Clone for InteriorPoint

fn clone(&self) -> InteriorPoint

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for InteriorPoint

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl Optimizer for InteriorPoint

fn step(&mut self, _params: &mut Vector<f32>, _gradients: &Vector<f32>)

Stochastic update (mini-batch mode) - for SGD, Adam, RMSprop.

fn reset(&mut self)

Resets the optimizer state (momentum, history, etc.).

fn minimize<F, G>( &mut self, _objective: F, _gradient: G, _x0: Vector<f32>, ) -> OptimizationResult

where F: Fn(&Vector<f32>) -> f32, G: Fn(&Vector<f32>) -> Vector<f32>,

Batch optimization (deterministic mode) - for L-BFGS, CG, Damped Newton.