add some simple constructors for fortran ordered arrays

Author: vbarrielle

src/dimension.rs

@@ -152,6 +152,26 @@ pub unsafe trait Dimension : Clone + Eq {
         strides
     }
 
+    fn fortran_strides(&self) -> Self {
+        // Compute fortran array strides
+        // Shape (a, b, c) => Give strides (1, a, a * b)
+        let mut strides = self.clone();
+        {
+            let mut it = strides.slice_mut().iter_mut();
+            // Set first element to 1
+            for rs in it.by_ref() {
+                *rs = 1;
+                break;
+            }
+            let mut cum_prod = 1;
+            for (rs, dim) in it.zip(self.slice().iter()) {
+                cum_prod *= *dim;
+                *rs = cum_prod;
+            }
+        }
+        strides
+    }
+
     #[inline]
     fn first_index(&self) -> Option<Self>
     {

src/lib.rs

@@ -612,12 +612,43 @@ impl<S, A, D> ArrayBase<S, D>
         }
     }
 
+    /// Create an array with copies of `elem`, dimension `dim` and fortran
+    /// ordering.
+    ///
+    /// ```
+    /// use ndarray::Array;
+    /// use ndarray::arr3;
+    ///
+    /// let a = Array::from_elem_f((2, 2, 2), 1.);
+    ///
+    /// assert!(
+    ///     a == arr3(&[[[1., 1.],
+    ///                  [1., 1.]],
+    ///                 [[1., 1.],
+    ///                  [1., 1.]]])
+    /// );
+    /// assert!(a.strides() == &[1, 2, 4]);
+    /// ```
+    pub fn from_elem_f(dim: D, elem: A) -> ArrayBase<S, D> where A: Clone
+    {
+        let v = vec![elem; dim.size()];
+        unsafe {
+            Self::from_vec_dim_f(dim, v)
+        }
+    }
+
     /// Create an array with zeros, dimension `dim`.
     pub fn zeros(dim: D) -> ArrayBase<S, D> where A: Clone + libnum::Zero
     {
         Self::from_elem(dim, libnum::zero())
     }
 
+    /// Create an array with zeros, dimension `dim` and fortran ordering.
+    pub fn zeros_f(dim: D) -> ArrayBase<S, D> where A: Clone + libnum::Zero
+    {
+        Self::from_elem_f(dim, libnum::zero())
+    }
+
     /// Create an array with default values, dimension `dim`.
     pub fn default(dim: D) -> ArrayBase<S, D>
         where A: Default
@@ -642,6 +673,22 @@ impl<S, A, D> ArrayBase<S, D>
         }
     }
 
+    /// Create an array from a vector (with no allocation needed),
+    /// using fortran ordering to interpret the data.
+    ///
+    /// Unsafe because dimension is unchecked, and must be correct.
+    pub unsafe fn from_vec_dim_f(dim: D, mut v: Vec<A>) -> ArrayBase<S, D>
+    {
+        debug_assert!(dim.size() == v.len());
+        ArrayBase {
+            ptr: v.as_mut_ptr(),
+            data: DataOwned::new(v),
+            strides: dim.fortran_strides(),
+            dim: dim
+        }
+    }
+
+
     /// Create an array from a vector and interpret it according to the
     /// provided dimensions and strides. No allocation needed.
     ///