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.4.1" numpy = "0.3" ```

``` rust extern crate numpy; extern crate pyo3; use numpy::{IntoPyResult, PyArray, PyArrayModule}; use pyo3::prelude::{ObjectProtocol, PyDict, PyResult, Python};

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 = PyArrayModule::import(py)?; let dict = PyDict::new(py); dict.setitem("np", np.aspymodule())?; let pyarray: &PyArray = py .eval("np.array([1, 2, 3], dtype='int32')", Some(&dict), None)? .extract()?; let slice = pyarray.asslice().intopyresult("Array Cast failed")?; 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.3" ndarray = "0.11"

[dependencies.pyo3] version = "^0.4.1" features = ["extension-module"] ```

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

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

[pymodinit]

fn rust_ext(py: Python, m: &PyModule) -> PyResult<()> { // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! // You must write this statement for the PyArray type checker to work correctly // !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! let _np = PyArrayModule::import(py)?;

// immutable example
fn axpy(a: f64, x: ArrayViewD<f64>, y: ArrayViewD<f64>) -> ArrayD<f64> {
    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: &PyArray<f64>, y: &PyArray<f64>) -> PyResult<PyArray<f64>> {
    let np = PyArrayModule::import(py)?;
    let x = x.as_array().into_pyresult("x must be f64 array")?;
    let y = y.as_array().into_pyresult("y must be f64 array")?;
    Ok(axpy(a, x, y).into_pyarray(py, &np))
}

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

Ok(())

} ```

Contribution

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

Version