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.

Supported python version

Currently 2.7, 3.5, 3.6, 3.7 are supported.

By default, rust-numpy is built for Python3.

If you want to compile for Python2, please add a feature flag in Cargo.toml like

toml [dependencies.numpy] version = "0.4.0" features = ["python2"] .

You can also automatically specify python version in setup.py, using setuptools-rust.

Example

Execute a Python program from Rust and get results

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

[dependencies] pyo3 = "0.5.2" numpy = "0.4.0" ```

``` 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 = py.import("numpy")?; let dict = PyDict::new(py); dict.setitem("np", np)?; let pyarray: &PyArray1 = py .eval("np.absolute(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" ndarray = "0.12"

[dependencies.pyo3] version = "0.5.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, Py, 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>,
) -> Py<PyArrayDyn<f64>> {
    let x = x.as_array();
    let y = y.as_array();
    axpy(a, x, y).into_pyarray(py).to_owned()
}

// 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