implement owning constructors taking dimensions and strides

Author: vbarrielle

src/dimension.rs

@@ -10,6 +10,38 @@ pub fn stride_offset(n: Ix, stride: Ix) -> isize
     (n as isize) * ((stride as Ixs) as isize)
 }
 
+/// Check whether `stride` is strictly positive
+#[inline]
+pub fn stride_is_positive(stride: Ix) -> bool
+{
+    (stride as Ixs) > 0
+}
+
+/// Check whether the given dimension and strides are memory safe
+/// to index the provided slice.
+///
+/// To be safe, no stride may be negative, and the 
+pub fn can_index_slice<A, D: Dimension>(data: &[A],
+                                        dim: &D,
+                                        strides: &D
+                                       ) -> bool
+{
+    if strides.slice().iter().cloned().all(stride_is_positive) {
+        let mut last_index = dim.clone();
+        for mut index in last_index.slice_mut().iter_mut() {
+            *index -= 1;
+        }
+        if let Some(offset) = dim.stride_offset_checked(strides, &last_index) {
+            // offset is guaranteed to be positive so no issue converting
+            // to usize here
+            if (offset as usize) < data.len() {
+                return true;
+            }
+        }
+    }
+    false
+}
+
 /// Trait for the shape and index types of arrays.
 ///
 /// `unsafe` because of the assumptions in the default methods.

src/lib.rs

@@ -75,7 +75,7 @@ use std::marker::PhantomData;
 
 use it::ZipSlices;
 
-pub use dimension::{Dimension, RemoveAxis};
+pub use dimension::{Dimension, RemoveAxis, can_index_slice};
 pub use dimension::NdIndex;
 pub use indexes::Indexes;
 pub use shape_error::ShapeError;
@@ -634,6 +634,40 @@ impl<S, A, D> ArrayBase<S, D>
             dim: dim
         }
     }
+
+    /// Create an array from a vector and interpret it according to the
+    /// provided dimensions and strides. No allocation needed.
+    ///
+    /// Unsafe because dimension and strides are unchecked.
+    pub unsafe fn from_vec_dim_stride_uchk(dim: D,
+                                           strides: D,
+                                           mut v: Vec<A>
+                                          ) -> ArrayBase<S, D>
+    {
+        ArrayBase {
+            ptr: v.as_mut_ptr(),
+            data: DataOwned::new(v),
+            strides: strides,
+            dim: dim
+        }
+    }
+
+    /// Create an array from a vector and interpret it according to the
+    /// provided dimensions and strides. No allocation needed.
+    ///
+    /// **Panics** if the stride and dimensions point outside the vector's
+    /// memory.
+    pub fn from_vec_dim_stride(dim: D,
+                               strides: D,
+                               v: Vec<A>
+                              ) -> ArrayBase<S, D>
+    {
+        assert!(dimension::can_index_slice(&v, &dim, &strides),
+                "dim and strides index out of the vector's memory");
+        unsafe {
+            Self::from_vec_dim_stride_uchk(dim, strides, v)
+        }
+    }
 }