Add min max axes operator is

bindings/python/Cargo.toml

@@ -9,8 +9,10 @@ crate-type = ["cdylib"]
 
 
 [dependencies]
-numpy = "0.19.0"
 pyo3 = { version = "0.19.2", features = ["extension-module"] }
-
-# Adjust the path to point to your rustynum-rs crate relative to the bindings/python directory
 rustynum-rs = { path = "../../rustynum-rs" }
+
+[profile.release]
+strip = true
+lto = true
+panic = "abort"

bindings/python/rustynum/__init__.py

@@ -346,31 +346,63 @@ def mean(
         )
         return NumArray(result, dtype=self.dtype)
 
-    def min(self) -> float:
+    def min(
+        self, axes: Union[None, int, Sequence[int]] = None
+    ) -> Union["NumArray", float]:
         """
-        Finds the minimum value in the NumArray.
+        Return the minimum along the specified axes.
+
+        Parameters:
+            axes: Optional; Axis or axes along which to find the minimum. If None,
+                  the minimum of all elements is computed as a scalar.
 
         Returns:
-            The minimum value as a float.
-        """
-        return (
-            _rustynum.min_f32(self.inner)
+            A new NumArray with the minimum values along the specified axes,
+            or a scalar if no axes are given.
+        """
+        if axes is None:
+            return (
+                _rustynum.min_f32(self.inner)
+                if self.dtype == "float32"
+                else _rustynum.min_f64(self.inner)
+            )
+
+        axes = [axes] if isinstance(axes, int) else axes
+        result = (
+            _rustynum.min_axes_f32(self.inner, axes)
             if self.dtype == "float32"
-            else _rustynum.min_f64(self.inner)
+            else _rustynum.min_axes_f64(self.inner, axes)
         )
+        return NumArray(result, dtype=self.dtype)
 
-    def max(self) -> float:
+    def max(
+        self, axes: Union[None, int, Sequence[int]] = None
+    ) -> Union["NumArray", float]:
         """
-        Finds the maximum value in the NumArray.
+        Return the maximum along the specified axes.
+
+        Parameters:
+            axes: Optional; Axis or axes along which to find the maximum. If None,
+                  the maximum of all elements is computed as a scalar.
 
         Returns:
-            The maximum value as a float.
-        """
-        return (
-            _rustynum.max_f32(self.inner)
+            A new NumArray with the maximum values along the specified axes,
+            or a scalar if no axes are given.
+        """
+        if axes is None:
+            return (
+                _rustynum.max_f32(self.inner)
+                if self.dtype == "float32"
+                else _rustynum.max_f64(self.inner)
+            )
+
+        axes = [axes] if isinstance(axes, int) else axes
+        result = (
+            _rustynum.max_axes_f32(self.inner, axes)
             if self.dtype == "float32"
-            else _rustynum.max_f64(self.inner)
+            else _rustynum.max_axes_f64(self.inner, axes)
         )
+        return NumArray(result, dtype=self.dtype)
 
     def __imul__(self, scalar: float) -> "NumArray":
         """

bindings/python/src/lib.rs

@@ -177,6 +177,32 @@ impl PyNumArrayF32 {
             inner: self.inner.sigmoid(),
         }
     }
+
+    fn min_axes(&self, axes: Option<&PyList>) -> PyResult<PyNumArrayF32> {
+        Python::with_gil(|py| {
+            let result = match axes {
+                Some(axes_list) => {
+                    let axes_vec: Vec<usize> = axes_list.extract()?;
+                    self.inner.min_axes(Some(&axes_vec))
+                }
+                None => self.inner.min_axes(None),
+            };
+            Ok(PyNumArrayF32 { inner: result })
+        })
+    }
+
+    fn max_axes(&self, axes: Option<&PyList>) -> PyResult<PyNumArrayF32> {
+        Python::with_gil(|py| {
+            let result = match axes {
+                Some(axes_list) => {
+                    let axes_vec: Vec<usize> = axes_list.extract()?;
+                    self.inner.max_axes(Some(&axes_vec))
+                }
+                None => self.inner.max_axes(None),
+            };
+            Ok(PyNumArrayF32 { inner: result })
+        })
+    }
 }
 
 #[pymethods]
@@ -320,6 +346,32 @@ impl PyNumArrayF64 {
             inner: self.inner.sigmoid(),
         }
     }
+
+    fn min_axes(&self, axes: Option<&PyList>) -> PyResult<PyNumArrayF64> {
+        Python::with_gil(|py| {
+            let result = match axes {
+                Some(axes_list) => {
+                    let axes_vec: Vec<usize> = axes_list.extract()?;
+                    self.inner.min_axes(Some(&axes_vec))
+                }
+                None => self.inner.min_axes(None),
+            };
+            Ok(PyNumArrayF64 { inner: result })
+        })
+    }
+
+    fn max_axes(&self, axes: Option<&PyList>) -> PyResult<PyNumArrayF64> {
+        Python::with_gil(|py| {
+            let result = match axes {
+                Some(axes_list) => {
+                    let axes_vec: Vec<usize> = axes_list.extract()?;
+                    self.inner.max_axes(Some(&axes_vec))
+                }
+                None => self.inner.max_axes(None),
+            };
+            Ok(PyNumArrayF64 { inner: result })
+        })
+    }
 }
 
 #[pymethods]
@@ -746,11 +798,35 @@ fn min_f32(a: &PyNumArrayF32) -> PyResult<f32> {
     Ok(a.inner.min())
 }
 
+#[pyfunction]
+fn min_axes_f32(a: &PyNumArrayF32, axes: Option<&PyList>) -> PyResult<PyNumArrayF32> {
+    let result = match axes {
+        Some(axes_list) => {
+            let axes_vec: Vec<usize> = axes_list.extract()?; // Convert PyList to Vec<usize>
+            a.inner.min_axes(Some(&axes_vec))
+        }
+        None => a.inner.min_axes(None),
+    };
+    Ok(PyNumArrayF32 { inner: result })
+}
+
 #[pyfunction]
 fn max_f32(a: &PyNumArrayF32) -> PyResult<f32> {
     Ok(a.inner.max())
 }
 
+#[pyfunction]
+fn max_axes_f32(a: &PyNumArrayF32, axes: Option<&PyList>) -> PyResult<PyNumArrayF32> {
+    let result = match axes {
+        Some(axes_list) => {
+            let axes_vec: Vec<usize> = axes_list.extract()?; // Convert PyList to Vec<usize>
+            a.inner.max_axes(Some(&axes_vec))
+        }
+        None => a.inner.max_axes(None),
+    };
+    Ok(PyNumArrayF32 { inner: result })
+}
+
 #[pyfunction]
 fn exp_f32(a: &PyNumArrayF32) -> PyNumArrayF32 {
     PyNumArrayF32 {
@@ -851,11 +927,35 @@ fn min_f64(a: &PyNumArrayF64) -> PyResult<f64> {
     Ok(a.inner.min())
 }
 
+#[pyfunction]
+fn min_axes_f64(a: &PyNumArrayF64, axes: Option<&PyList>) -> PyResult<PyNumArrayF64> {
+    let result = match axes {
+        Some(axes_list) => {
+            let axes_vec: Vec<usize> = axes_list.extract()?; // Convert PyList to Vec<usize>
+            a.inner.min_axes(Some(&axes_vec))
+        }
+        None => a.inner.min_axes(None),
+    };
+    Ok(PyNumArrayF64 { inner: result })
+}
+
 #[pyfunction]
 fn max_f64(a: &PyNumArrayF64) -> PyResult<f64> {
     Ok(a.inner.max())
 }
 
+#[pyfunction]
+fn max_axes_f64(a: &PyNumArrayF64, axes: Option<&PyList>) -> PyResult<PyNumArrayF64> {
+    let result = match axes {
+        Some(axes_list) => {
+            let axes_vec: Vec<usize> = axes_list.extract()?; // Convert PyList to Vec<usize>
+            a.inner.max_axes(Some(&axes_vec))
+        }
+        None => a.inner.max_axes(None),
+    };
+    Ok(PyNumArrayF64 { inner: result })
+}
+
 #[pyfunction]
 fn exp_f64(a: &PyNumArrayF64) -> PyNumArrayF64 {
     PyNumArrayF64 {
@@ -898,7 +998,9 @@ fn _rustynum(py: Python, m: &PyModule) -> PyResult<()> {
     m.add_function(wrap_pyfunction!(linspace_f32, m)?)?;
     m.add_function(wrap_pyfunction!(mean_f32, m)?)?;
     m.add_function(wrap_pyfunction!(min_f32, m)?)?;
+    m.add_function(wrap_pyfunction!(min_axes_f32, m)?)?;
     m.add_function(wrap_pyfunction!(max_f32, m)?)?;
+    m.add_function(wrap_pyfunction!(max_axes_f32, m)?)?;
     m.add_function(wrap_pyfunction!(exp_f32, m)?)?;
     m.add_function(wrap_pyfunction!(log_f32, m)?)?;
     m.add_function(wrap_pyfunction!(sigmoid_f32, m)?)?;