Merge pull request #343 from bluss/into-dimensionality

Method .into_dimensionality::<Dim>()

Author: bluss

src/dimension/dimension_trait.rs

@@ -376,6 +376,19 @@ pub trait Dimension : Clone + Eq + Debug + Send + Sync + Default +
         IxDyn(self.slice())
     }
 
+    #[doc(hidden)]
+    fn from_dimension<D2: Dimension>(d: &D2) -> Option<Self> {
+        let mut s = Self::default();
+        if s.ndim() == d.ndim() {
+            for i in 0..d.ndim() {
+                s[i] = d[i];
+            }
+            Some(s)
+        } else {
+            None
+        }
+    }
+
     #[doc(hidden)]
     fn try_remove_axis(&self, axis: Axis) -> Self::Smaller;
 
@@ -790,14 +803,9 @@ impl Dimension for IxDyn
         self
     }
 
+    #[inline]
     fn zero_index(&self) -> Self {
-        const ZEROS: &'static [usize] = &[0; 4];
-        let n = self.ndim();
-        if n <= ZEROS.len() {
-            Dim(&ZEROS[..n])
-        } else {
-            Dim(vec![0; n])
-        }
+        IxDyn::zeros(self.ndim())
     }
 
     #[inline]
@@ -808,6 +816,10 @@ impl Dimension for IxDyn
             self.clone()
         }
     }
+
+    fn from_dimension<D2: Dimension>(d: &D2) -> Option<Self> {
+        Some(IxDyn(d.slice()))
+    }
     private_impl!{}
 }
 

src/dimension/dynindeximpl.rs

@@ -209,3 +209,16 @@ impl RemoveAxis for Dim<IxDynImpl> {
         Dim::new(self.ix().remove(axis.index()))
     }
 }
+
+impl IxDyn {
+    /// Create a new dimension value with `n` axes, all zeros
+    #[inline]
+    pub fn zeros(n: usize) -> IxDyn {
+        const ZEROS: &'static [usize] = &[0; 4];
+        if n <= ZEROS.len() {
+            Dim(&ZEROS[..n])
+        } else {
+            Dim(vec![0; n])
+        }
+    }
+}

src/impl_methods.rs

@@ -17,7 +17,7 @@ use imp_prelude::*;
 use arraytraits;
 use dimension;
 use iterators;
-use error::{self, ShapeError};
+use error::{self, ShapeError, ErrorKind};
 use super::zipsl;
 use super::ZipExt;
 use dimension::IntoDimension;
@@ -1061,6 +1061,35 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         }
     }
 
+    /// Convert an array or array view to another with the same type, but
+    /// different dimensionality type. Errors if the dimensions don't agree.
+    ///
+    /// ```
+    /// use ndarray::{ArrayD, Ix2, IxDyn};
+    ///
+    /// // Create a dynamic dimensionality array and convert it to an Array2
+    /// // (Ix2 dimension type).
+    ///
+    /// let array = ArrayD::<f64>::zeros(IxDyn(&[10, 10]));
+    ///
+    /// assert!(array.into_dimensionality::<Ix2>().is_ok());
+    /// ```
+    pub fn into_dimensionality<D2>(self) -> Result<ArrayBase<S, D2>, ShapeError>
+        where D2: Dimension
+    {
+        if let Some(dim) = D2::from_dimension(&self.dim) {
+            if let Some(strides) = D2::from_dimension(&self.strides) {
+                return Ok(ArrayBase {
+                    data: self.data,
+                    ptr: self.ptr,
+                    dim: dim,
+                    strides: strides,
+                });
+            }
+        }
+        Err(ShapeError::from_kind(ErrorKind::IncompatibleShape))
+    }
+
     /// Act like a larger size and/or shape array by *broadcasting*
     /// into a larger shape, if possible.
     ///

tests/ixdyn.rs

@@ -2,7 +2,7 @@
 extern crate ndarray;
 
 use ndarray::Array;
-use ndarray::Ix3;
+use ndarray::{Ix0, Ix1, Ix2, Ix3, IxDyn};
 use ndarray::IntoDimension;
 use ndarray::ShapeBuilder;
 
@@ -146,3 +146,18 @@ fn test_0_add_broad() {
     assert_eq!(b[0], 6.);
     assert_eq!(b[1], 7.);
 }
+
+#[test]
+fn test_into_dimension() {
+    let a = Array::linspace(0., 41., 6 * 7).into_shape((6, 7)).unwrap();
+    let a2 = a.clone().into_shape(IxDyn(&[6, 7])).unwrap();
+    let b = a2.clone().into_dimensionality::<Ix2>().unwrap();
+    assert_eq!(a, b);
+
+    assert!(a2.clone().into_dimensionality::<Ix0>().is_err());
+    assert!(a2.clone().into_dimensionality::<Ix1>().is_err());
+    assert!(a2.clone().into_dimensionality::<Ix3>().is_err());
+
+    let c = a2.clone().into_dimensionality::<IxDyn>().unwrap();
+    assert_eq!(a2, c);
+}