Struct BacktrackingLineSearch 

pub struct BacktrackingLineSearch { /* private fields */ }

Backtracking line search with Armijo condition.

Starts with step size α = 1 and repeatedly shrinks it by factor ρ until the Armijo condition is satisfied:

f(x + α*d) ≤ f(x) + c₁*α*∇f(x)ᵀd

This ensures sufficient decrease in the objective function.

Parameters

• c1: Armijo constant (typical: 1e-4), controls acceptable decrease
• rho: Backtracking factor (typical: 0.5), shrinkage rate for α
• max_iter: Maximum backtracking iterations (safety limit)

Example

use aprender::optim::{BacktrackingLineSearch, LineSearch};
use aprender::primitives::Vector;

let line_search = BacktrackingLineSearch::new(1e-4, 0.5, 50);

// Define a simple quadratic function
let f = |x: &Vector<f32>| x[0] * x[0] + x[1] * x[1];
let grad = |x: &Vector<f32>| Vector::from_slice(&[2.0 * x[0], 2.0 * x[1]]);

let x = Vector::from_slice(&[1.0, 1.0]);
let d = Vector::from_slice(&[-2.0, -2.0]); // Descent direction

let alpha = line_search.search(&f, &grad, &x, &d);
assert!(alpha > 0.0);

Implementations

impl BacktrackingLineSearch

pub fn new(c1: f32, rho: f32, max_iter: usize) -> Self

Creates a new backtracking line search.

Arguments

• c1 - Armijo constant (typical: 1e-4)
• rho - Backtracking factor (typical: 0.5)
• max_iter - Maximum iterations (typical: 50)

Example

use aprender::optim::BacktrackingLineSearch;

let line_search = BacktrackingLineSearch::new(1e-4, 0.5, 50);

Trait Implementations

impl Clone for BacktrackingLineSearch

fn clone(&self) -> BacktrackingLineSearch

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BacktrackingLineSearch

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

Formats the value using the given formatter.

impl Default for BacktrackingLineSearch

fn default() -> Self

Creates a backtracking line search with default parameters.

Defaults: c1=1e-4, rho=0.5, max_iter=50

impl LineSearch for BacktrackingLineSearch

fn search<F, G>(&self, f: &F, grad: &G, x: &Vector<f32>, d: &Vector<f32>) -> f32

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

Finds a suitable step size along the search direction.