liteopt 0.1.0__tar.gz

liteopt-0.1.0/Cargo.lock

@@ -0,0 +1,177 @@
+# This file is automatically @generated by Cargo.
+# It is not intended for manual editing.
+version = 4
+
+[[package]]
+name = "autocfg"
+version = "1.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c08606f8c3cbf4ce6ec8e28fb0014a2c086708fe954eaa885384a6165172e7e8"
+
+[[package]]
+name = "heck"
+version = "0.5.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2304e00983f87ffb38b55b444b5e3b60a884b5d30c0fca7d82fe33449bbe55ea"
+
+[[package]]
+name = "indoc"
+version = "2.0.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "79cf5c93f93228cf8efb3ba362535fb11199ac548a09ce117c9b1adc3030d706"
+dependencies = [
+ "rustversion",
+]
+
+[[package]]
+name = "libc"
+version = "0.2.178"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "37c93d8daa9d8a012fd8ab92f088405fb202ea0b6ab73ee2482ae66af4f42091"
+
+[[package]]
+name = "liteopt"
+version = "0.1.0"
+
+[[package]]
+name = "liteopt-py"
+version = "0.1.0"
+dependencies = [
+ "liteopt",
+ "pyo3",
+]
+
+[[package]]
+name = "memoffset"
+version = "0.9.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "488016bfae457b036d996092f6cb448677611ce4449e970ceaf42695203f218a"
+dependencies = [
+ "autocfg",
+]
+
+[[package]]
+name = "once_cell"
+version = "1.21.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "42f5e15c9953c5e4ccceeb2e7382a716482c34515315f7b03532b8b4e8393d2d"
+
+[[package]]
+name = "portable-atomic"
+version = "1.11.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f84267b20a16ea918e43c6a88433c2d54fa145c92a811b5b047ccbe153674483"
+
+[[package]]
+name = "proc-macro2"
+version = "1.0.103"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "5ee95bc4ef87b8d5ba32e8b7714ccc834865276eab0aed5c9958d00ec45f49e8"
+dependencies = [
+ "unicode-ident",
+]
+
+[[package]]
+name = "pyo3"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "ab53c047fcd1a1d2a8820fe84f05d6be69e9526be40cb03b73f86b6b03e6d87d"
+dependencies = [
+ "indoc",
+ "libc",
+ "memoffset",
+ "once_cell",
+ "portable-atomic",
+ "pyo3-build-config",
+ "pyo3-ffi",
+ "pyo3-macros",
+ "unindent",
+]
+
+[[package]]
+name = "pyo3-build-config"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b455933107de8642b4487ed26d912c2d899dec6114884214a0b3bb3be9261ea6"
+dependencies = [
+ "target-lexicon",
+]
+
+[[package]]
+name = "pyo3-ffi"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1c85c9cbfaddf651b1221594209aed57e9e5cff63c4d11d1feead529b872a089"
+dependencies = [
+ "libc",
+ "pyo3-build-config",
+]
+
+[[package]]
+name = "pyo3-macros"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0a5b10c9bf9888125d917fb4d2ca2d25c8df94c7ab5a52e13313a07e050a3b02"
+dependencies = [
+ "proc-macro2",
+ "pyo3-macros-backend",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "pyo3-macros-backend"
+version = "0.27.2"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "03b51720d314836e53327f5871d4c0cfb4fb37cc2c4a11cc71907a86342c40f9"
+dependencies = [
+ "heck",
+ "proc-macro2",
+ "pyo3-build-config",
+ "quote",
+ "syn",
+]
+
+[[package]]
+name = "quote"
+version = "1.0.42"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "a338cc41d27e6cc6dce6cefc13a0729dfbb81c262b1f519331575dd80ef3067f"
+dependencies = [
+ "proc-macro2",
+]
+
+[[package]]
+name = "rustversion"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "b39cdef0fa800fc44525c84ccb54a029961a8215f9619753635a9c0d2538d46d"
+
+[[package]]
+name = "syn"
+version = "2.0.111"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "390cc9a294ab71bdb1aa2e99d13be9c753cd2d7bd6560c77118597410c4d2e87"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "unicode-ident",
+]
+
+[[package]]
+name = "target-lexicon"
+version = "0.13.3"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "df7f62577c25e07834649fc3b39fafdc597c0a3527dc1c60129201ccfcbaa50c"
+
+[[package]]
+name = "unicode-ident"
+version = "1.0.22"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "9312f7c4f6ff9069b165498234ce8be658059c6728633667c526e27dc2cf1df5"
+
+[[package]]
+name = "unindent"
+version = "0.2.4"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7264e107f553ccae879d21fbea1d6724ac785e8c3bfc762137959b5802826ef3"

liteopt-0.1.0/Cargo.toml

@@ -0,0 +1,3 @@
+[workspace]
+members = ["liteopt-py"]
+resolver = "2"

liteopt-0.1.0/PKG-INFO

@@ -0,0 +1,46 @@
+Metadata-Version: 2.4
+Name: liteopt
+Version: 0.1.0
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Rust
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Requires-Dist: numpy>=1.24.4
+Summary: Lightweight gradient descent optimizer implemented in Rust
+Author-email: Taiki Ishigaki <taiki000ishigaki@gmail.com>
+License: MIT
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown; charset=UTF-8; variant=GFM
+Project-URL: Homepage, https://github.com/MathRobotics/liteopt
+Project-URL: Repository, https://github.com/MathRobotics/liteopt
+
+# liteopt
+
+A lightweight optimization library written in Rust with Python bindings.
+
+## Installation
+
+```bash
+pip install liteopt
+```
+
+## Usage
+
+```python
+import liteopt
+
+def f(x):
+    x0, x1 = x
+    return (1.0 - x0)**2 + 100.0 * (x1 - x0**2)**2
+
+def grad(x):
+    x0, x1 = x
+    df_dx = -2.0 * (1.0 - x0) - 400.0 * x0 * (x1 - x0**2)
+    df_dy = 200.0 * (x1 - x0**2)
+    return [df_dx, df_dy]
+
+x0 = [-1.2, 1.0]
+x_star, f_star, converged = liteopt.gd(f, grad, x0, step_size=1e-3, max_iters=200_000, tol_grad=1e-4)
+print(converged, x_star, f_star)
+```

liteopt-0.1.0/README.md

@@ -0,0 +1,29 @@
+# liteopt
+
+A lightweight optimization library written in Rust with Python bindings.
+
+## Installation
+
+```bash
+pip install liteopt
+```
+
+## Usage
+
+```python
+import liteopt
+
+def f(x):
+    x0, x1 = x
+    return (1.0 - x0)**2 + 100.0 * (x1 - x0**2)**2
+
+def grad(x):
+    x0, x1 = x
+    df_dx = -2.0 * (1.0 - x0) - 400.0 * x0 * (x1 - x0**2)
+    df_dy = 200.0 * (x1 - x0**2)
+    return [df_dx, df_dy]
+
+x0 = [-1.2, 1.0]
+x_star, f_star, converged = liteopt.gd(f, grad, x0, step_size=1e-3, max_iters=200_000, tol_grad=1e-4)
+print(converged, x_star, f_star)
+```

liteopt-0.1.0/liteopt-core/Cargo.toml

@@ -0,0 +1,8 @@
+[package]
+name = "liteopt"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "liteopt"
+crate-type = ["rlib"]

liteopt-0.1.0/liteopt-core/src/bin/quadratic.rs

@@ -0,0 +1,39 @@
+use liteopt::{EuclideanSpace, GradientDescent};
+
+fn main() {
+    let space = EuclideanSpace;
+
+    let solver = GradientDescent {
+        space,
+        step_size: 1e-3,
+        max_iters: 200_000,
+        tol_grad: 1e-4,
+    };
+
+    // initial point
+    let x0 = vec![-1.2, 1.0];
+
+    // objective function f(x, y) = (1 - x)^2 + 100 (y - x^2)^2
+    let value_fn = |x: &Vec<f64>| {
+        let x0 = x[0];
+        let x1 = x[1];
+        (1.0 - x0).powi(2) + 100.0 * (x1 - x0 * x0).powi(2)
+    };
+
+    // gradient of the objective function
+    let grad_fn = |x: &Vec<f64>, grad: &mut Vec<f64>| {
+        let x0 = x[0];
+        let x1 = x[1];
+
+        grad[0] = -2.0 * (1.0 - x0) - 400.0 * x0 * (x1 - x0 * x0);
+        grad[1] = 200.0 * (x1 - x0 * x0);
+    };
+
+    let result = solver.minimize_with_fn(x0, value_fn, grad_fn);
+
+    println!("converged: {}", result.converged);
+    println!("iters    : {}", result.iters);
+    println!("x*       : {:?}", result.x);
+    println!("f(x*)    : {}", result.f);
+    println!("‖grad‖   : {}", result.grad_norm);
+}

liteopt-0.1.0/liteopt-core/src/lib.rs

@@ -0,0 +1,350 @@
+//! liteopt: A tiny, lightweight optimization toolbox
+//!
+//! - `Space`: an abstraction of vector spaces
+//! - `EuclideanSpace` (`Vec<f64>`): its concrete implementation
+//! - `Objective`: a generic objective function interface
+//! - `GradientDescent`: a gradient descent solver
+//!
+//! Start with simple optimization on R^n.
+
+/// Trait that represents an abstract "space".
+///
+/// MVP implements only EuclideanSpace (Vec<f64>), leaving room for
+/// future manifolds such as SO(3) or SE(3).
+pub trait Space {
+    /// Type representing points/vectors on the space.
+    type Point: Clone;
+
+    /// Return a zero-like vector with the same shape as x.
+    fn zero_like(&self, x: &Self::Point) -> Self::Point;
+
+    /// Vector norm.
+    fn norm(&self, v: &Self::Point) -> f64;
+
+    /// Return v scaled by the scalar alpha.
+    fn scale(&self, v: &Self::Point, alpha: f64) -> Self::Point;
+
+    /// Compute x + v (result is a point).
+    fn add(&self, x: &Self::Point, v: &Self::Point) -> Self::Point;
+
+    /// Compute y - x (result is a vector).
+    fn difference(&self, x: &Self::Point, y: &Self::Point) -> Self::Point;
+
+    /// Return the point reached by moving from x along direction by step alpha.
+    ///
+    /// By default this matches the Euclidean update
+    ///   x_{k+1} = x_k + alpha * direction
+    /// in Euclidean space.
+    fn retract(&self, x: &Self::Point, direction: &Self::Point, alpha: f64) -> Self::Point {
+        let step = self.scale(direction, alpha);
+        self.add(x, &step)
+    }
+}
+
+/// Simple Euclidean space representing R^n as Vec<f64>.
+#[derive(Clone, Copy, Debug, Default)]
+pub struct EuclideanSpace;
+
+impl Space for EuclideanSpace {
+    type Point = Vec<f64>;
+
+    fn zero_like(&self, x: &Self::Point) -> Self::Point {
+        vec![0.0; x.len()]
+    }
+
+    fn norm(&self, v: &Self::Point) -> f64 {
+        v.iter().map(|vi| vi * vi).sum::<f64>().sqrt()
+    }
+
+    fn scale(&self, v: &Self::Point, alpha: f64) -> Self::Point {
+        v.iter().map(|vi| alpha * vi).collect()
+    }
+
+    fn add(&self, x: &Self::Point, v: &Self::Point) -> Self::Point {
+        x.iter().zip(v.iter()).map(|(xi, vi)| xi + vi).collect()
+    }
+
+    fn difference(&self, x: &Self::Point, y: &Self::Point) -> Self::Point {
+        y.iter().zip(x.iter()).map(|(yi, xi)| yi - xi).collect()
+    }
+}
+
+/// Objective function to be minimized.
+///
+/// - `S::Point` represents points on the space
+/// - In `gradient` the user computes the gradient and writes into the buffer
+pub trait Objective<S: Space> {
+    /// Function value f(x) at x.
+    fn value(&self, x: &S::Point) -> f64;
+
+    /// Write the gradient ∇f(x) at x into grad.
+    ///
+    /// grad is assumed to be pre-initialized, e.g., via zero_like(x).
+    fn gradient(&self, x: &S::Point, grad: &mut S::Point);
+}
+
+/// Configuration for gradient descent.
+#[derive(Clone, Debug)]
+pub struct GradientDescent<S: Space> {
+    /// Space to operate on (MVP can fix this to EuclideanSpace).
+    pub space: S,
+    /// Learning rate / step size.
+    pub step_size: f64,
+    /// Maximum number of iterations.
+    pub max_iters: usize,
+    /// Considered converged when the gradient norm falls below this threshold.
+    pub tol_grad: f64,
+}
+
+/// Struct that holds the optimization result.
+#[derive(Clone, Debug)]
+pub struct OptimizeResult<P> {
+    pub x: P,
+    pub f: f64,
+    pub iters: usize,
+    pub grad_norm: f64,
+    pub converged: bool,
+}
+
+impl<S: Space> GradientDescent<S> {
+    pub fn minimize<O>(&self, obj: &O, mut x: S::Point) -> OptimizeResult<S::Point>
+    where
+        O: Objective<S>,
+    {
+        let mut grad = self.space.zero_like(&x);
+
+        for k in 0..self.max_iters {
+            // Compute gradient.
+            obj.gradient(&x, &mut grad);
+
+            let grad_norm = self.space.norm(&grad);
+            if grad_norm < self.tol_grad {
+                let f = obj.value(&x);
+                return OptimizeResult {
+                    x,
+                    f,
+                    iters: k,
+                    grad_norm,
+                    converged: true,
+                };
+            }
+
+            // x_{k+1} = Retr_x( - step_size * grad )
+            // direction = -grad
+            let direction = self.space.scale(&grad, -1.0);
+            x = self.space.retract(&x, &direction, self.step_size);
+        }
+
+        let f = obj.value(&x);
+        let grad_norm = self.space.norm(&grad);
+        OptimizeResult {
+            x,
+            f,
+            iters: self.max_iters,
+            grad_norm,
+            converged: false,
+        }
+    }
+
+    /// ★ Minimize using user-provided value and gradient functions.
+    pub fn minimize_with_fn<F, G>(
+        &self,
+        mut x: S::Point,
+        value_fn: F,
+        grad_fn: G,
+    ) -> OptimizeResult<S::Point>
+    where
+        F: Fn(&S::Point) -> f64,
+        G: Fn(&S::Point, &mut S::Point),
+    {
+        let mut grad = self.space.zero_like(&x);
+
+        for k in 0..self.max_iters {
+            // call the user-provided gradient function
+            grad_fn(&x, &mut grad);
+
+            let grad_norm = self.space.norm(&grad);
+            if grad_norm < self.tol_grad {
+                let f = value_fn(&x);
+                return OptimizeResult {
+                    x,
+                    f,
+                    iters: k,
+                    grad_norm,
+                    converged: true,
+                };
+            }
+
+            let direction = self.space.scale(&grad, -1.0);
+            x = self.space.retract(&x, &direction, self.step_size);
+        }
+
+        let f = value_fn(&x);
+        let grad_norm = self.space.norm(&grad);
+        OptimizeResult {
+            x,
+            f,
+            iters: self.max_iters,
+            grad_norm,
+            converged: false,
+        }
+    }
+}
+
+//
+// Tests and examples: quadratic / Rosenbrock
+//
+
+/// Example quadratic of the form f(x) = 0.5 * x^T A x - b^T x.
+pub struct Quadratic {
+    pub a: f64,
+    pub b: f64,
+}
+
+impl Objective<EuclideanSpace> for Quadratic {
+    fn value(&self, x: &Vec<f64>) -> f64 {
+        // Treat as 1D for simplicity:
+        // f(x) = 0.5 * a * x^2 - b * x
+        let x0 = x[0];
+        0.5 * self.a * x0 * x0 - self.b * x0
+    }
+
+    fn gradient(&self, x: &Vec<f64>, grad: &mut Vec<f64>) {
+        let x0 = x[0];
+        // Gradient: df/dx = a * x - b
+        grad[0] = self.a * x0 - self.b;
+    }
+}
+
+/// Example 2D Rosenbrock function.
+/// f(x, y) = (1 - x)^2 + 100 (y - x^2)^2
+pub struct Rosenbrock;
+
+impl Objective<EuclideanSpace> for Rosenbrock {
+    fn value(&self, x: &Vec<f64>) -> f64 {
+        let x0 = x[0];
+        let x1 = x[1];
+        (1.0 - x0).powi(2) + 100.0 * (x1 - x0 * x0).powi(2)
+    }
+
+    fn gradient(&self, x: &Vec<f64>, grad: &mut Vec<f64>) {
+        let x0 = x[0];
+        let x1 = x[1];
+
+        // df/dx = -2(1 - x) - 400x(y - x^2)
+        grad[0] = -2.0 * (1.0 - x0) - 400.0 * x0 * (x1 - x0 * x0);
+        // df/dy = 200(y - x^2)
+        grad[1] = 200.0 * (x1 - x0 * x0);
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn quadratic_minimization() {
+        // f(x) = 0.5 * a x^2 - b x
+        // Minimizer is x* = b / a
+        let obj = Quadratic { a: 2.0, b: 4.0 }; // f(x) = x^2 - 4x => x* = 2
+        let space = EuclideanSpace;
+        let solver = GradientDescent {
+            space,
+            step_size: 0.1,
+            max_iters: 1000,
+            tol_grad: 1e-6,
+        };
+
+        let x0 = vec![0.0];
+        let result = solver.minimize(&obj, x0);
+
+        assert!(result.converged);
+        assert!((result.x[0] - 2.0).abs() < 1e-3);
+    }
+
+    #[test]
+    fn rosenbrock_minimization() {
+        let obj = Rosenbrock;
+        let space = EuclideanSpace;
+        let solver = GradientDescent {
+            space,
+            step_size: 1e-3,
+            max_iters: 200_000,
+            tol_grad: 1e-4,
+        };
+
+        let x0 = vec![-1.2, 1.0];
+        let result = solver.minimize(&obj, x0);
+
+        // True minimizer is (1,1)
+        assert!((result.x[0] - 1.0).abs() < 5e-2);
+        assert!((result.x[1] - 1.0).abs() < 5e-2);
+    }
+
+    #[test]
+    fn nonlinear_minimization_with_fn() {
+        let space = EuclideanSpace;
+        let solver = GradientDescent {
+            space,
+            step_size: 1e-3,
+            max_iters: 200_000,
+            tol_grad: 1e-4,
+        };
+
+        // initial point
+        let x0 = vec![0.0, 0.0];
+
+        // objective function 
+        // p = [ cos(x) + cos(x+y)
+        //       sin(x) + sin(x+y)] 
+        let p_fn = |x: &Vec<f64>| {
+            let p = vec![
+                f64::cos(x[0]) + f64::cos(x[0] + x[1]),
+                f64::sin(x[0]) + f64::sin(x[0] + x[1]),
+            ];
+            p
+        };
+        let dp_fn = |x: &Vec<f64>| {
+            let dp = vec![
+                vec![
+                    -(f64::sin(x[0]) + f64::sin(x[0] + x[1])),
+                    -f64::sin(x[0] + x[1]),
+                ],
+                vec![
+                    f64::cos(x[0]) + f64::cos(x[0] + x[1]),
+                    -f64::sin(x[0] + x[1]),
+                ],
+            ];
+            dp
+        };
+        let target = vec![0.5, (f64::sqrt(3.0) + 2.0) / 2.0];
+        use std::f64::consts::PI;
+
+
+        let value_fn = |x: &Vec<f64>| {
+            let x0_target = target[0];
+            let x1_target = target[1];
+            let p = p_fn(x);
+            let residual = vec![p[0] - x0_target, p[1] - x1_target];
+            0.5 * (residual[0].powi(2) + residual[1].powi(2))
+        };
+
+        // gradient of the objective function
+        let grad_fn = |x: &Vec<f64>, grad: &mut Vec<f64>| {
+            let x0_target = target[0];
+            let x1_target = target[1];
+            let p = p_fn(x);
+            let residual = vec![p[0] - x0_target, p[1] - x1_target];
+
+            let dp = dp_fn(x);
+            grad[0] = residual[0] * dp[0][0] + residual[1] * dp[1][0];
+            grad[1] = residual[0] * dp[0][1] + residual[1] * dp[1][1];
+        };
+
+        let result = solver.minimize_with_fn(x0, value_fn, grad_fn);
+
+        // True minimizer is (pi/3, pi/6)
+        assert!((result.x[0] - PI/3.0).abs() < 1e-3);
+        assert!((result.x[1] - PI/6.0).abs() < 1e-3);
+    }
+}

liteopt-0.1.0/liteopt-py/Cargo.toml

@@ -0,0 +1,13 @@
+[package]
+name = "liteopt-py"
+version = "0.1.0"
+edition = "2021"
+readme = "README.md"
+
+[lib]
+name = "liteopt"
+crate-type = ["cdylib"]
+
+[dependencies]
+liteopt_core = { package = "liteopt", path = "../liteopt-core" }
+pyo3 = { version = "0.27", features = ["extension-module"] }

liteopt-0.1.0/liteopt-py/README.md

@@ -0,0 +1,29 @@
+# liteopt
+
+A lightweight optimization library written in Rust with Python bindings.
+
+## Installation
+
+```bash
+pip install liteopt
+```
+
+## Usage
+
+```python
+import liteopt
+
+def f(x):
+    x0, x1 = x
+    return (1.0 - x0)**2 + 100.0 * (x1 - x0**2)**2
+
+def grad(x):
+    x0, x1 = x
+    df_dx = -2.0 * (1.0 - x0) - 400.0 * x0 * (x1 - x0**2)
+    df_dy = 200.0 * (x1 - x0**2)
+    return [df_dx, df_dy]
+
+x0 = [-1.2, 1.0]
+x_star, f_star, converged = liteopt.gd(f, grad, x0, step_size=1e-3, max_iters=200_000, tol_grad=1e-4)
+print(converged, x_star, f_star)
+```

liteopt-0.1.0/liteopt-py/src/lib.rs

@@ -0,0 +1,72 @@
+use liteopt_core::{EuclideanSpace, GradientDescent};
+use pyo3::prelude::*;
+
+/// Gradient Descent optimizer exposed to Python.
+///
+/// f:    callable(x: list[float]) -> float
+/// grad: callable(x: list[float]) -> list[float]
+#[pyfunction]
+fn gd(
+    py: Python<'_>,
+    f: Py<PyAny>,
+    grad: Py<PyAny>,
+    x0: Vec<f64>,
+    step_size: f64,
+    max_iters: usize,
+    tol_grad: f64,
+) -> PyResult<(Vec<f64>, f64, bool)> {
+    let space = EuclideanSpace;
+    let solver = GradientDescent {
+        space,
+        step_size,
+        max_iters,
+        tol_grad,
+    };
+
+    let f_obj = f.clone_ref(py);
+    let grad_obj = grad.clone_ref(py);
+
+    // closure for calling Python function f(x)
+    let f_closure = move |x: &Vec<f64>| -> f64 {
+        let arg = x.clone();
+        let res = f_obj
+            .call1(py, (arg,))
+            .expect("failed to call objective function from Python");
+        res.extract::<f64>(py)
+            .expect("objective function must return float")
+    };
+
+    // closure for calling Python gradient function grad(x)
+    let grad_closure = move |x: &Vec<f64>, grad_out: &mut Vec<f64>| {
+        let arg = x.clone();
+        let res = grad_obj
+            .call1(py, (arg,))
+            .expect("failed to call gradient function from Python");
+        let g: Vec<f64> = res
+            .extract(py)
+            .expect("gradient function must return list[float]");
+
+        assert_eq!(
+            g.len(),
+            grad_out.len(),
+            "gradient length mismatch: expected {}, got {}",
+            grad_out.len(),
+            g.len()
+        );
+
+        for (o, gi) in grad_out.iter_mut().zip(g.iter()) {
+            *o = *gi;
+        }
+    };
+
+    let result = solver.minimize_with_fn(x0, f_closure, grad_closure);
+
+    Ok((result.x, result.f, result.converged))
+}
+
+/// Python module definition
+#[pymodule]
+fn liteopt(_py: Python, m: &Bound<PyModule>) -> PyResult<()> {
+    m.add_function(wrap_pyfunction!(gd, m)?)?;
+    Ok(())
+}

liteopt-0.1.0/liteopt-py/tests/test_liteopt.py

@@ -0,0 +1,27 @@
+import numpy as np
+import liteopt
+
+def f(x):
+    x = np.asarray(x)
+    return float((1.0 - x[0])**2 + 100.0 * (x[1] - x[0]**2)**2)
+
+def grad(x):
+    x = np.asarray(x)
+    df_dx = -2.0 * (1.0 - x[0]) - 400.0 * x[0] * (x[1] - x[0]**2)
+    df_dy = 200.0 * (x[1] - x[0]**2)
+    return [float(df_dx), float(df_dy)]
+
+def main():
+    x0 = [-1.2, 1.0]
+    x_star, f_star, converged = liteopt.gd(
+        f, grad, x0,
+        step_size=1e-3,
+        max_iters=200_000,
+        tol_grad=1e-10,
+    )
+    print("converged:", converged)
+    print("x*:", x_star, "f(x*):", f_star)
+    print("expected x*:", [1.0, 1.0], "f(x*):", f([1.0, 1.0]))
+
+if __name__ == "__main__":
+    main()

liteopt-0.1.0/pyproject.toml

@@ -0,0 +1,33 @@
+[build-system]
+requires = ["maturin>=1.5,<2.0"]
+build-backend = "maturin"
+
+[project]
+name = "liteopt"
+version = "0.1.0"
+description = "Lightweight gradient descent optimizer implemented in Rust"
+readme = "README.md"
+requires-python = ">=3.8"
+license = { text = "MIT" }
+authors = [
+  { name = "Taiki Ishigaki", email = "taiki000ishigaki@gmail.com" }
+]
+classifiers = [
+  "Programming Language :: Python",
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Rust",
+  "License :: OSI Approved :: MIT License",
+  "Operating System :: OS Independent",
+]
+
+dependencies = [
+    "numpy>=1.24.4",
+]
+
+[project.urls]
+Homepage = "https://github.com/MathRobotics/liteopt"
+Repository = "https://github.com/MathRobotics/liteopt"
+
+[tool.maturin]
+manifest-path = "liteopt-py/Cargo.toml"
+# module-name = "liteopt"