rust-numpy

Build Status Build status Crate

Rust bindings for the NumPy C-API

API documentation

Requirements

Note Starting from 0.3, rust-numpy migrated from rust-cpython to pyo3. If you want to use rust-cpython, use version 0.2.1 from crates.io.

Example

Execute a Python program from Rust and get results

``` toml [package] name = "numpy-test"

[dependencies] pyo3 = "^0.5.0-alpha.2" numpy = "0.4.0-alpha.1" ```

``` rust extern crate numpy; extern crate pyo3; use numpy::{PyArray1, getarraymodule}; use pyo3::prelude::{ObjectProtocol, PyResult, Python}; use pyo3::types::PyDict;

fn main() -> Result<(), ()> { let gil = Python::acquiregil(); main(gil.python()).maperr(|e| { eprintln!("error! :{:?}", e); // we can't display python error type via ::std::fmt::Display // so print error here manually e.printandsetsyslastvars(gil.python()); }) }

fn main<'py>(py: Python<'py>) -> PyResult<()> { let np = getarraymodule(py)?; let dict = PyDict::new(py); dict.setitem("np", np)?; let pyarray: &PyArray1 = py .eval("np.array([1, 2, 3], dtype='int32')", Some(&dict), None)? .extract()?; let slice = pyarray.asslice(); asserteq!(slice, &[1, 2, 3]); Ok(()) } ```

Write a Python module in Rust

Please see the example directory for a complete example

```toml [lib] name = "rust_ext" crate-type = ["cdylib"]

[dependencies] numpy = "0.4.0-alpha.1" ndarray = "0.12"

[dependencies.pyo3] version = "^0.5.0-alpha.2" features = ["extension-module"] ```

```rust extern crate ndarray; extern crate numpy; extern crate pyo3;

use ndarray::{ArrayD, ArrayViewD, ArrayViewMutD}; use numpy::{IntoPyArray, PyArrayDyn}; use pyo3::prelude::{pymodinit, PyModule, PyResult, Python};

[pymodinit]

fn rustext(py: Python, m: &PyModule) -> PyResult<()> { // immutable example fn axpy(a: f64, x: ArrayViewD, y: ArrayViewD) -> ArrayD { a * &x + &y }

// mutable example (no return)
fn mult(a: f64, mut x: ArrayViewMutD<f64>) {
    x *= a;
}

// wrapper of `axpy`
#[pyfn(m, "axpy")]
fn axpy_py(
    py: Python,
    a: f64,
    x: &PyArrayDyn<f64>,
    y: &PyArrayDyn<f64>,
) -> PyResult<PyArrayDyn<f64>> {
    // you can convert numpy error into PyErr via ?
    let x = x.as_array();
    // you can also specify your error context, via closure
    let y = y.as_array();
    Ok(axpy(a, x, y).into_pyarray(py).to_owned(py))
}

// wrapper of `mult`
#[pyfn(m, "mult")]
fn mult_py(_py: Python, a: f64, x: &PyArrayDyn<f64>) -> PyResult<()> {
    let x = x.as_array_mut();
    mult(a, x);
    Ok(())
}

Ok(())

} ```

Contribution

This project is still in pre-alpha. We need your feedback. Don't hesitate to open issues!

Version