one-indexed-vec 0.2.0

A one-based (1-indexed) wrapper around Vec<T>: element at position N is accessed via vec[N].
Documentation
//! One-dimensional optimization.

/// Golden section search for a minimum on `[a, b]`.
pub fn golden_section<F>(f: F, mut a: f64, mut b: f64, tol: f64, max_iter: usize) -> f64
where
    F: Fn(f64) -> f64,
{
    const INV_PHI: f64 = 0.618_033_988_749_895;
    let mut c = b - INV_PHI * (b - a);
    let mut d = a + INV_PHI * (b - a);
    let mut fc = f(c);
    let mut fd = f(d);
    for _ in 0..max_iter {
        if (b - a).abs() < tol {
            break;
        }
        if fc < fd {
            b = d;
            d = c;
            fd = fc;
            c = b - INV_PHI * (b - a);
            fc = f(c);
        } else {
            a = c;
            c = d;
            fc = fd;
            d = a + INV_PHI * (b - a);
            fd = f(d);
        }
    }
    0.5 * (a + b)
}

/// 1-D gradient descent: `x ← x − lr · f'(x)`.
pub fn gradient_descent_1d<D>(df: D, mut x: f64, lr: f64, tol: f64, max_iter: usize) -> f64
where
    D: Fn(f64) -> f64,
{
    for _ in 0..max_iter {
        let g = df(x);
        if g.abs() < tol {
            break;
        }
        x -= lr * g;
    }
    x
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn golden_min_quadratic() {
        let r = golden_section(|x| (x - 3.0).powi(2), 0.0, 10.0, 1e-10, 200);
        assert!((r - 3.0).abs() < 1e-6);
    }

    #[test]
    fn gd_min_quadratic() {
        let r = gradient_descent_1d(|x| 2.0 * (x - 3.0), 0.0, 0.1, 1e-10, 1000);
        assert!((r - 3.0).abs() < 1e-6);
    }
}