Fix ndarray to use from_shape_vec constructors

Author: bluss

src/data_traits.rs

@@ -83,8 +83,8 @@ unsafe impl<A> DataMut for Rc<Vec<A>>
             // Create a new vec if the current view is less than half of
             // backing data.
             unsafe {
-                *self_ = ArrayBase::from_vec_dim_unchecked(self_.dim.clone(),
-                                                           self_.iter()
+                *self_ = ArrayBase::from_shape_vec_unchecked(self_.dim.clone(),
+                                                             self_.iter()
                                                             .cloned()
                                                             .collect());
             }

src/free_functions.rs

@@ -13,7 +13,7 @@ use imp_prelude::*;
 /// Create a zero-dimensional array with the element `x`.
 pub fn arr0<A>(x: A) -> OwnedArray<A, ()>
 {
-    unsafe { ArrayBase::from_vec_dim_unchecked((), vec![x]) }
+    unsafe { ArrayBase::from_shape_vec_unchecked((), vec![x]) }
 }
 
 /// Create a one-dimensional array with elements from `xs`.
@@ -129,7 +129,7 @@ pub fn arr2<A: Clone, V: FixedInitializer<Elem = A>>(xs: &[V]) -> OwnedArray<A,
         result.extend_from_slice(snd.as_init_slice());
     }
     unsafe {
-        ArrayBase::from_vec_dim_unchecked(dim, result)
+        ArrayBase::from_shape_vec_unchecked(dim, result)
     }
 }
 
@@ -167,7 +167,7 @@ pub fn arr3<A: Clone, V: FixedInitializer<Elem=U>, U: FixedInitializer<Elem=A>>(
         }
     }
     unsafe {
-        ArrayBase::from_vec_dim_unchecked(dim, result)
+        ArrayBase::from_shape_vec_unchecked(dim, result)
     }
 }
 

src/impl_constructors.rs

@@ -8,6 +8,9 @@
 
 //! Constructor methods for ndarray
 //!
+//!
+
+#![allow(deprecated)] // from_shape_vec
 
 use libnum::{Zero, One, Float};
 
@@ -39,7 +42,8 @@ pub trait ShapeBuilder {
     type Dim: Dimension;
 
     fn f(self) -> Shape<Self::Dim>;
-    fn strides(self, st: Self::Dim) -> StrideShape<Self::Dim>;
+    fn set_f(self, is_f: bool) -> Shape<Self::Dim>;
+    fn strides(self, strides: Self::Dim) -> StrideShape<Self::Dim>;
 }
 
 impl<D> From<D> for Shape<D>
@@ -83,8 +87,9 @@ impl<D> ShapeBuilder for D
     where D: Dimension
 {
     type Dim = D;
-    fn f(self) -> Shape<D> {
-        Shape::from(self).f()
+    fn f(self) -> Shape<D> { self.set_f(true) }
+    fn set_f(self, is_f: bool) -> Shape<D> {
+        Shape::from(self).set_f(is_f)
     }
     fn strides(self, st: D) -> StrideShape<D> {
         Shape::from(self).strides(st)
@@ -95,8 +100,9 @@ impl<D> ShapeBuilder for Shape<D>
     where D: Dimension
 {
     type Dim = D;
-    fn f(mut self) -> Self {
-        self.is_c = false;
+    fn f(self) -> Self { self.set_f(true) }
+    fn set_f(mut self, is_f: bool) -> Self {
+        self.is_c = !is_f;
         self
     }
     fn strides(self, st: D) -> StrideShape<D> {
@@ -124,7 +130,7 @@ impl<S> ArrayBase<S, Ix>
     /// let array = OwnedArray::from_vec(vec![1., 2., 3., 4.]);
     /// ```
     pub fn from_vec(v: Vec<S::Elem>) -> ArrayBase<S, Ix> {
-        unsafe { Self::from_vec_dim_unchecked(v.len() as Ix, v) }
+        unsafe { Self::from_shape_vec_unchecked(v.len() as Ix, v) }
     }
 
     /// Create a one-dimensional array from an iterable.

src/impl_methods.rs

@@ -91,7 +91,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
             (self.iter().cloned().collect(), self.dim.default_strides())
         };
         unsafe {
-            ArrayBase::from_vec_dim_stride_unchecked(self.dim.clone(), strides, data)
+            ArrayBase::from_shape_vec_unchecked(self.dim.clone().strides(strides), data)
         }
     }
 
@@ -427,7 +427,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
             let mut dim = self.dim();
             dim.set_axis(axis, 0);
             unsafe {
-                OwnedArray::from_vec_dim_unchecked(dim, vec![])
+                OwnedArray::from_shape_vec_unchecked(dim, vec![])
             }
         } else {
             stack(axis, &subs).unwrap()
@@ -800,7 +800,7 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         } else {
             let v = self.iter().map(|x| x.clone()).collect::<Vec<A>>();
             unsafe {
-                ArrayBase::from_vec_dim_unchecked(shape, v)
+                ArrayBase::from_shape_vec_unchecked(shape, v)
             }
         }
     }
@@ -1150,13 +1150,13 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         if let Some(slc) = self.as_slice_memory_order() {
             let v = ::iterators::to_vec(slc.iter().map(f));
             unsafe {
-                ArrayBase::from_vec_dim_stride_unchecked(
-                    self.dim.clone(), self.strides.clone(), v)
+                ArrayBase::from_shape_vec_unchecked(
+                    self.dim.clone().strides(self.strides.clone()), v)
             }
         } else {
             let v = ::iterators::to_vec(self.iter().map(f));
             unsafe {
-                ArrayBase::from_vec_dim_unchecked(self.dim.clone(), v)
+                ArrayBase::from_shape_vec_unchecked(self.dim.clone(), v)
             }
         }
     }

src/linalg/impl_linalg.rs

@@ -230,11 +230,7 @@ impl<A, S, S2> Dot<ArrayBase<S2, (Ix, Ix)>> for ArrayBase<S, (Ix, Ix)>
         let mut c;
         unsafe {
             v.set_len(m * n);
-            if !column_major {
-                c = OwnedArray::from_vec_dim_unchecked((m, n), v);
-            } else {
-                c = OwnedArray::from_vec_dim_unchecked_f((m, n), v);
-            }
+            c = OwnedArray::from_shape_vec_unchecked((m, n).set_f(column_major), v);
         }
         mat_mul_impl(A::one(), &a, &b, A::zero(), &mut c.view_mut());
         c
@@ -293,7 +289,7 @@ impl<A, S, S2> Dot<ArrayBase<S2, Ix>> for ArrayBase<S, (Ix, Ix)>
             }
         }
         unsafe {
-            ArrayBase::from_vec_dim_unchecked(m, res_elems)
+            ArrayBase::from_shape_vec_unchecked(m, res_elems)
         }
     }
 }

src/stacking.rs

@@ -57,7 +57,7 @@ pub fn stack<'a, A, D>(axis: Axis, arrays: &[ArrayView<'a, A, D>])
     unsafe {
         v.set_len(size);
     }
-    let mut res = try!(OwnedArray::from_vec_dim(res_dim, v));
+    let mut res = try!(OwnedArray::from_shape_vec(res_dim, v));
 
     {
         let mut assign_view = res.view_mut();