PoC: Python bindings

.gitignore

@@ -4,3 +4,5 @@ target/
 target/*
 *.log
 justfile
+.vscode
+.venv

Cargo.toml

@@ -3,6 +3,7 @@
 members = [
     "argmin",
     "argmin-math",
+    "argmin-py",
 ]
 
 exclude = [

argmin-py/Cargo.toml

@@ -0,0 +1,18 @@
+[package]
+name = "argmin-py"
+version = "0.1.0"
+edition = "2021"
+
+[lib]
+name = "argmin"
+crate-type = ["cdylib"]
+
+[dependencies]
+anyhow = "1.0.70"
+argmin_testfunctions = "0.1.1"
+argmin = {path="../argmin", default-features=false, features=[]}
+argmin-math = {path="../argmin-math", features=["ndarray_latest-serde"]}
+ndarray-linalg = { version = "0.16", features = ["netlib"] }
+ndarray = { version = "0.15", features = ["serde-1"] }
+numpy = "0.18.0"
+pyo3 = {version="0.18.1", features=["extension-module", "anyhow"]}

argmin-py/examples/newton.py

@@ -0,0 +1,26 @@
+# Copyright 2018-2023 argmin developers
+#
+# Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+# http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+# http://opensource.org/licenses/MIT>, at your option. This file may not be
+# copied, modified, or distributed except according to those terms.
+from argmin import Problem, Solver, Executor
+import numpy as np
+from scipy.optimize import rosen_der, rosen_hess
+
+
+def main():
+    problem = Problem(
+        gradient=rosen_der,
+        hessian=rosen_hess,
+    )
+    solver = Solver.Newton
+    executor = Executor(problem, solver)
+    executor.configure(param=np.array([-1.2, 1.0]), max_iters=8)
+
+    result = executor.run()
+    print(result)
+
+
+if __name__ == "__main__":
+    main()

argmin-py/src/executor.rs

@@ -0,0 +1,64 @@
+// Copyright 2018-2023 argmin developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+// TODO: docs
+
+use pyo3::{prelude::*, types::PyDict};
+
+use argmin::core;
+
+use crate::problem::Problem;
+use crate::solver::{DynamicSolver, Solver};
+use crate::types::{IterState, PyArray1};
+
+#[pyclass]
+pub struct Executor(Option<core::Executor<Problem, DynamicSolver, IterState>>);
+
+impl Executor {
+    /// Consumes the inner executor.
+    ///
+    /// PyObjects do not allow methods that consume the object itself, so this is a workaround
+    /// for using methods like `configure` and `run`.
+    fn take(&mut self) -> anyhow::Result<core::Executor<Problem, DynamicSolver, IterState>> {
+        let Some(inner) = self.0.take() else {
+            return Err(anyhow::anyhow!("Executor was already run."));
+        };
+        Ok(inner)
+    }
+}
+
+#[pymethods]
+impl Executor {
+    #[new]
+    fn new(problem: Problem, solver: Solver) -> Self {
+        Self(Some(core::Executor::new(problem, solver.into())))
+    }
+
+    #[pyo3(signature = (**kwargs))]
+    fn configure(&mut self, kwargs: Option<&PyDict>) -> PyResult<()> {
+        if let Some(kwargs) = kwargs {
+            let new_self = self.take()?.configure(|mut state| {
+                if let Some(param) = kwargs.get_item("param") {
+                    let param: &PyArray1 = param.extract().unwrap();
+                    state = state.param(param.to_owned_array());
+                }
+                if let Some(max_iters) = kwargs.get_item("max_iters") {
+                    state = state.max_iters(max_iters.extract().unwrap());
+                }
+                state
+            });
+            self.0 = Some(new_self);
+        }
+        Ok(())
+    }
+
+    fn run(&mut self) -> PyResult<String> {
+        // TODO: return usable OptimizationResult
+        let res = self.take()?.run();
+        Ok(res?.to_string())
+    }
+}

argmin-py/src/lib.rs

@@ -0,0 +1,24 @@
+// Copyright 2018-2023 argmin developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+// TODO: docs
+mod executor;
+mod problem;
+mod solver;
+mod types;
+
+use pyo3::prelude::*;
+
+#[pymodule]
+#[pyo3(name = "argmin")]
+fn argmin_py(_py: Python, m: &PyModule) -> PyResult<()> {
+    m.add_class::<executor::Executor>()?;
+    m.add_class::<problem::Problem>()?;
+    m.add_class::<solver::Solver>()?;
+
+    Ok(())
+}

argmin-py/src/problem.rs

@@ -0,0 +1,68 @@
+// Copyright 2018-2023 argmin developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+// TODO: docs
+
+use numpy::ToPyArray;
+use pyo3::{prelude::*, types::PyTuple};
+
+use argmin::core;
+
+use crate::types::{Array1, Array2, Scalar};
+
+#[pyclass]
+#[derive(Clone)]
+pub struct Problem {
+    gradient: PyObject,
+    hessian: PyObject,
+    // TODO: jacobian
+}
+
+#[pymethods]
+impl Problem {
+    #[new]
+    fn new(gradient: PyObject, hessian: PyObject) -> Self {
+        Self { gradient, hessian }
+    }
+}
+
+impl core::Gradient for Problem {
+    type Param = Array1;
+    type Gradient = Array1;
+
+    fn gradient(&self, param: &Self::Param) -> Result<Self::Gradient, argmin::core::Error> {
+        call(&self.gradient, param)
+    }
+}
+
+impl argmin::core::Hessian for Problem {
+    type Param = Array1;
+
+    type Hessian = Array2;
+
+    fn hessian(&self, param: &Self::Param) -> Result<Self::Hessian, core::Error> {
+        call(&self.hessian, param)
+    }
+}
+
+fn call<InputDimension, OutputDimension>(
+    callable: &PyObject,
+    param: &ndarray::Array<Scalar, InputDimension>,
+) -> Result<ndarray::Array<Scalar, OutputDimension>, argmin::core::Error>
+where
+    InputDimension: ndarray::Dimension,
+    OutputDimension: ndarray::Dimension,
+{
+    // TODO: prevent dynamic dispatch for every call
+    Python::with_gil(|py| {
+        let args = PyTuple::new(py, [param.to_pyarray(py)]);
+        let pyresult = callable.call(py, args, Default::default())?;
+        let pyarray = pyresult.extract::<&numpy::PyArray<Scalar, OutputDimension>>(py)?;
+        // TODO: try to get ownership instead of cloning
+        Ok(pyarray.to_owned_array())
+    })
+}

argmin-py/src/solver.rs

@@ -0,0 +1,51 @@
+// Copyright 2018-2023 argmin developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+// TODO: docs
+
+use pyo3::prelude::*;
+
+use argmin::{core, solver};
+
+use crate::{
+    problem::Problem,
+    types::{IterState, Scalar},
+};
+
+#[pyclass]
+#[derive(Clone)]
+pub enum Solver {
+    Newton,
+}
+
+pub enum DynamicSolver {
+    // NOTE: I tried using a Box<dyn Solver<> here, but Solver is not object safe.
+    Newton(solver::newton::Newton<Scalar>),
+}
+
+impl From<Solver> for DynamicSolver {
+    fn from(solver: Solver) -> Self {
+        match solver {
+            Solver::Newton => Self::Newton(solver::newton::Newton::new()),
+        }
+    }
+}
+
+impl core::Solver<Problem, IterState> for DynamicSolver {
+    // TODO: make this a trait method so we can return a dynamic
+    const NAME: &'static str = "Dynamic Solver";
+
+    fn next_iter(
+        &mut self,
+        problem: &mut core::Problem<Problem>,
+        state: IterState,
+    ) -> Result<(IterState, Option<core::KV>), core::Error> {
+        match self {
+            DynamicSolver::Newton(inner) => inner.next_iter(problem, state),
+        }
+    }
+}

argmin-py/src/types.rs

@@ -0,0 +1,15 @@
+// Copyright 2018-2023 argmin developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://apache.org/licenses/LICENSE-2.0> or the MIT license <LICENSE-MIT or
+// http://opensource.org/licenses/MIT>, at your option. This file may not be
+// copied, modified, or distributed except according to those terms.
+
+//! Base types for the Python extension.
+
+pub type Scalar = f64; // TODO: allow complex numbers
+pub type Array1 = ndarray::Array1<Scalar>;
+pub type Array2 = ndarray::Array2<Scalar>;
+pub type PyArray1 = numpy::PyArray1<Scalar>;
+
+pub type IterState = argmin::core::IterState<Array1, Array1, (), ndarray::Array2<Scalar>, Scalar>;

argmin/src/core/executor.rs

@@ -26,7 +26,7 @@ pub struct Executor<O, S, I> {
     /// Storage for observers
     observers: Observers<I>,
     /// Checkpoint
-    checkpoint: Option<Box<dyn Checkpoint<S, I>>>,
+    checkpoint: Option<Box<dyn Checkpoint<S, I> + Send>>,
     /// Indicates whether Ctrl-C functionality should be active or not
     ctrlc: bool,
     /// Indicates whether to time execution or not
@@ -298,7 +298,7 @@ where
     /// # }
     /// ```
     #[must_use]
-    pub fn add_observer<OBS: Observe<I> + 'static>(
+    pub fn add_observer<OBS: Observe<I> + 'static + Send>(
         mut self,
         observer: OBS,
         mode: ObserverMode,
@@ -340,7 +340,7 @@ where
     /// # }
     /// ```
     #[must_use]
-    pub fn checkpointing<C: 'static + Checkpoint<S, I>>(mut self, checkpoint: C) -> Self {
+    pub fn checkpointing<C: 'static + Checkpoint<S, I> + Send>(mut self, checkpoint: C) -> Self {
         self.checkpoint = Some(Box::new(checkpoint));
         self
     }

argmin/src/core/observers/mod.rs

@@ -188,7 +188,7 @@ pub trait Observe<I> {
     }
 }
 
-type ObserversVec<I> = Vec<(Arc<Mutex<dyn Observe<I>>>, ObserverMode)>;
+type ObserversVec<I> = Vec<(Arc<Mutex<dyn Observe<I> + Send>>, ObserverMode)>;
 
 /// Container for observers.
 ///
@@ -236,7 +236,7 @@ impl<I> Observers<I> {
     /// # #[cfg(feature = "slog-logger")]
     /// # assert!(!observers.is_empty());
     /// ```
-    pub fn push<OBS: Observe<I> + 'static>(
+    pub fn push<OBS: Observe<I> + 'static + Send>(
         &mut self,
         observer: OBS,
         mode: ObserverMode,