Merge pull request #49 from kngwyu/scalar

Add i8/u8/i16/u16 support

Author: kngwyu

Cargo.toml

@@ -10,6 +10,7 @@ keywords = ["numpy", "python", "binding"]
 license-file = "LICENSE"
 
 [dependencies]
+cfg-if = "0.1.5"
 libc = "0.2"
 num-complex = "0.1"
 ndarray = "0.11"

appveyor.yml

@@ -14,6 +14,7 @@ install:
   - rustc -V
   - cargo -V
   - set RUST_BACKTRACE=1
+  - pip install numpy
 
 build_script:
   - cargo build --verbose

src/array.rs

@@ -1,4 +1,4 @@
-//! Untyped safe interface for NumPy ndarray
+//! Safe interface for NumPy ndarray
 
 use ndarray::*;
 use npyffi;
@@ -42,7 +42,7 @@ impl<'a, T: TypeNum> FromPyObject<'a> for &'a PyArray<T> {
         array
             .type_check()
             .map(|_| array)
-            .map_err(|err| err.into_pyerr("FromPyObject::extract failed"))
+            .map_err(|err| err.into_pyerr("FromPyObject::extract typecheck failed"))
     }
 }
 
@@ -324,12 +324,11 @@ impl<T: TypeNum> PyArray<T> {
     }
 
     fn type_check(&self) -> Result<(), ArrayCastError> {
-        let test = T::typenum();
         let truth = self.typenum();
-        if test == truth {
+        if T::is_same_type(truth) {
             Ok(())
         } else {
-            Err(ArrayCastError::to_rust(truth, test))
+            Err(ArrayCastError::to_rust(truth, T::npy_data_type()))
         }
     }
 
@@ -377,7 +376,7 @@ impl<T: TypeNum> PyArray<T> {
             np.get_type_object(npyffi::ArrayType::PyArray_Type),
             dims.len() as i32,
             dims.as_ptr() as *mut npy_intp,
-            T::typenum(),
+            T::typenum_default(),
             strides,
             data,
             0,                      // itemsize
@@ -397,8 +396,8 @@ impl<T: TypeNum> PyArray<T> {
     /// use numpy::{PyArray, PyArrayModule};
     /// let gil = pyo3::Python::acquire_gil();
     /// let np = PyArrayModule::import(gil.python()).unwrap();
-    /// let pyarray = PyArray::new(gil.python(), &np, &[2, 2]);
-    /// assert_eq!(pyarray.as_array().unwrap(), array![[0, 0], [0, 0]].into_dyn());
+    /// let pyarray = PyArray::<i32>::new(gil.python(), &np, &[4, 5, 6]);
+    /// assert_eq!(pyarray.shape(), &[4, 5, 6]);
     /// # }
     /// ```
     pub fn new(py: Python, np: &PyArrayModule, dims: &[usize]) -> Self {
@@ -423,7 +422,7 @@ impl<T: TypeNum> PyArray<T> {
     pub fn zeros(py: Python, np: &PyArrayModule, dims: &[usize], is_fortran: bool) -> Self {
         let dims: Vec<npy_intp> = dims.iter().map(|d| *d as npy_intp).collect();
         unsafe {
-            let descr = np.PyArray_DescrFromType(T::typenum());
+            let descr = np.PyArray_DescrFromType(T::typenum_default());
             let ptr = np.PyArray_Zeros(
                 dims.len() as i32,
                 dims.as_ptr() as *mut npy_intp,
@@ -452,7 +451,7 @@ impl<T: TypeNum> PyArray<T> {
     /// # }
     pub fn arange(py: Python, np: &PyArrayModule, start: f64, stop: f64, step: f64) -> Self {
         unsafe {
-            let ptr = np.PyArray_Arange(start, stop, step, T::typenum());
+            let ptr = np.PyArray_Arange(start, stop, step, T::typenum_default());
             Self::from_owned_ptr(py, ptr)
         }
     }

src/convert.rs

@@ -63,9 +63,9 @@ macro_rules! array_impls {
         $(
             impl<T: TypeNum> IntoPyArray for [T; $N] {
                 type Item = T;
-                fn into_pyarray(mut self, py: Python, np: &PyArrayModule) -> PyArray<T> {
+                fn into_pyarray(self, py: Python, np: &PyArrayModule) -> PyArray<T> {
                     let dims = [$N];
-                    let ptr = &mut self as *mut [T; $N];
+                    let ptr = Box::into_raw(Box::new(self));
                     unsafe {
                         PyArray::new_(py, np, &dims, null_mut(), ptr as *mut c_void)
                     }

src/error.rs

@@ -25,19 +25,16 @@ impl<T, E: IntoPyErr> IntoPyResult for Result<T, E> {
 #[derive(Debug)]
 pub enum ArrayCastError {
     /// Error for casting `PyArray` into `ArrayView` or `ArrayViewMut`
-    ToRust {
-        from: NpyDataType,
-        to: NpyDataType,
-    },
+    ToRust { from: NpyDataType, to: NpyDataType },
     /// Error for casting rust's `Vec` into numpy array.
     FromVec,
 }
 
 impl ArrayCastError {
-    pub(crate) fn to_rust(from: i32, to: i32) -> Self {
+    pub(crate) fn to_rust(from: i32, to: NpyDataType) -> Self {
         ArrayCastError::ToRust {
             from: NpyDataType::from_i32(from),
-            to: NpyDataType::from_i32(to),
+            to,
         }
     }
 }

src/lib.rs

@@ -1,5 +1,7 @@
 #![feature(specialization)]
 
+#[macro_use]
+extern crate cfg_if;
 extern crate libc;
 extern crate ndarray;
 extern crate num_complex;

src/types.rs

@@ -13,8 +13,12 @@ use super::npyffi::NPY_TYPES;
 #[derive(Clone, Debug, Eq, PartialEq)]
 pub enum NpyDataType {
     Bool,
+    Int8,
+    Int16,
     Int32,
     Int64,
+    Uint8,
+    Uint16,
     Uint32,
     Uint64,
     Float32,
@@ -28,46 +32,86 @@ impl NpyDataType {
     pub(crate) fn from_i32(npy_t: i32) -> Self {
         match npy_t {
             x if x == NPY_TYPES::NPY_BOOL as i32 => NpyDataType::Bool,
+            x if x == NPY_TYPES::NPY_BYTE as i32 => NpyDataType::Int8,
+            x if x == NPY_TYPES::NPY_SHORT as i32 => NpyDataType::Int16,
             x if x == NPY_TYPES::NPY_INT as i32 => NpyDataType::Int32,
-            x if x == NPY_TYPES::NPY_LONG as i32 => NpyDataType::Int64,
+            x if x == NPY_TYPES::NPY_LONG as i32 => NpyDataType::from_clong(false),
+            x if x == NPY_TYPES::NPY_LONGLONG as i32 => NpyDataType::Int64,
+            x if x == NPY_TYPES::NPY_UBYTE as i32 => NpyDataType::Uint8,
+            x if x == NPY_TYPES::NPY_USHORT as i32 => NpyDataType::Uint16,
             x if x == NPY_TYPES::NPY_UINT as i32 => NpyDataType::Uint32,
-            x if x == NPY_TYPES::NPY_ULONG as i32 => NpyDataType::Uint64,
+            x if x == NPY_TYPES::NPY_ULONG as i32 => NpyDataType::from_clong(true),
+            x if x == NPY_TYPES::NPY_ULONGLONG as i32 => NpyDataType::Uint64,
             x if x == NPY_TYPES::NPY_FLOAT as i32 => NpyDataType::Float32,
             x if x == NPY_TYPES::NPY_DOUBLE as i32 => NpyDataType::Float64,
             x if x == NPY_TYPES::NPY_CFLOAT as i32 => NpyDataType::Complex32,
             x if x == NPY_TYPES::NPY_CDOUBLE as i32 => NpyDataType::Complex64,
             _ => NpyDataType::Unsupported,
         }
     }
+    #[inline(always)]
+    fn from_clong(is_usize: bool) -> NpyDataType {
+        if cfg!(any(target_pointer_width = "32", windows)) {
+            if is_usize {
+                NpyDataType::Uint32
+            } else {
+                NpyDataType::Int32
+            }
+        } else if cfg!(all(target_pointer_width = "64", not(windows))) {
+            if is_usize {
+                NpyDataType::Uint64
+            } else {
+                NpyDataType::Int64
+            }
+        } else {
+            NpyDataType::Unsupported
+        }
+    }
 }
 
 pub trait TypeNum: Clone {
-    fn typenum_enum() -> NPY_TYPES;
-    fn typenum() -> i32 {
-        Self::typenum_enum() as i32
-    }
-    fn to_npy_data_type(self) -> NpyDataType;
+    fn is_same_type(other: i32) -> bool;
+    fn npy_data_type() -> NpyDataType;
+    fn typenum_default() -> i32;
 }
 
 macro_rules! impl_type_num {
-    ($t:ty, $npy_t:ident, $npy_dat_t:ident) => {
+    ($t:ty, $npy_dat_t:ident $(,$npy_types: ident)+) => {
         impl TypeNum for $t {
-            fn typenum_enum() -> NPY_TYPES {
-                NPY_TYPES::$npy_t
+            fn is_same_type(other: i32) -> bool {
+                $(other == NPY_TYPES::$npy_types as i32 ||)+ false
             }
-            fn to_npy_data_type(self) -> NpyDataType {
+            fn npy_data_type() -> NpyDataType {
                 NpyDataType::$npy_dat_t
             }
+            fn typenum_default() -> i32 {
+                let t = ($(NPY_TYPES::$npy_types, )+);
+                t.0 as i32
+            }
         }
     };
-} // impl_type_num!
+}
+
+impl_type_num!(bool, Bool, NPY_BOOL);
+impl_type_num!(i8, Int8, NPY_BYTE);
+impl_type_num!(i16, Int16, NPY_SHORT);
+impl_type_num!(u8, Uint8, NPY_UBYTE);
+impl_type_num!(u16, Uint16, NPY_USHORT);
+impl_type_num!(f32, Float32, NPY_FLOAT);
+impl_type_num!(f64, Float64, NPY_DOUBLE);
+impl_type_num!(c32, Complex32, NPY_CFLOAT);
+impl_type_num!(c64, Complex64, NPY_CDOUBLE);
 
-impl_type_num!(bool, NPY_BOOL, Bool);
-impl_type_num!(i32, NPY_INT, Int32);
-impl_type_num!(i64, NPY_LONG, Int64);
-impl_type_num!(u32, NPY_UINT, Uint32);
-impl_type_num!(u64, NPY_ULONG, Uint64);
-impl_type_num!(f32, NPY_FLOAT, Float32);
-impl_type_num!(f64, NPY_DOUBLE, Float64);
-impl_type_num!(c32, NPY_CFLOAT, Complex32);
-impl_type_num!(c64, NPY_CDOUBLE, Complex64);
+cfg_if! {
+    if #[cfg(any(target_pointer_width = "32", windows))] {
+        impl_type_num!(i32, Int32, NPY_INT, NPY_LONG);
+        impl_type_num!(u32, Uint32, NPY_UINT, NPY_ULONG);
+        impl_type_num!(i64, Int64, NPY_LONGLONG);
+        impl_type_num!(u64, Uint64, NPY_ULONGLONG);
+    } else if #[cfg(all(target_pointer_width = "64", not(windows)))] {
+        impl_type_num!(i32, Int32, NPY_INT);
+        impl_type_num!(u32, Uint32, NPY_UINT);
+        impl_type_num!(i64, Int64, NPY_LONG, NPY_LONGLONG);
+        impl_type_num!(u64, Uint64, NPY_LONG, NPY_ULONGLONG);
+    }
+}

tests/array.rs

@@ -92,7 +92,10 @@ fn iter_to_pyarray() {
     let gil = pyo3::Python::acquire_gil();
     let np = PyArrayModule::import(gil.python()).unwrap();
     let arr = PyArray::from_iter(gil.python(), &np, (0..10).map(|x| x * x));
-    assert_eq!(arr.as_slice().unwrap(), &[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]);
+    assert_eq!(
+        arr.as_slice().unwrap(),
+        &[0, 1, 4, 9, 16, 25, 36, 49, 64, 81]
+    );
 }
 
 #[test]
@@ -130,15 +133,6 @@ fn from_vec3() {
     );
 }
 
-#[test]
-fn from_small_array() {
-    let gil = pyo3::Python::acquire_gil();
-    let np = PyArrayModule::import(gil.python()).unwrap();
-    let array: [i32; 5] = [1, 2, 3, 4, 5];
-    let pyarray = array.into_pyarray(gil.python(), &np);
-    assert_eq!(pyarray.as_slice().unwrap(), &[1, 2, 3, 4, 5]);
-}
-
 #[test]
 fn from_eval() {
     let gil = pyo3::Python::acquire_gil();
@@ -168,3 +162,22 @@ fn from_eval_fail() {
     assert!(converted.is_err());
 }
 
+macro_rules! small_array_test {
+    ($($t: ident)+) => {
+        #[test]
+        fn from_small_array() {
+            let gil = pyo3::Python::acquire_gil();
+            let np = PyArrayModule::import(gil.python()).unwrap();
+            $({
+                let array: [$t; 2] = [$t::min_value(), $t::max_value()];
+                let pyarray = array.into_pyarray(gil.python(), &np);
+                assert_eq!(
+                    pyarray.as_slice().unwrap(),
+                    &[$t::min_value(), $t::max_value()]
+                );
+            })+
+        }
+    };
+}
+
+small_array_test!(i8 u8 i16 u16 i32 u32 i64 u64);