Add mapv, apply, applyv, visit

Author: bluss

src/impl_methods.rs

@@ -1095,8 +1095,9 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
         init
     }
 
-    /// Apply `f` elementwise and return a new array with
-    /// the results.
+    /// Create a new array with the results of applying `f` on a reference
+    /// to each element.
+    /// Elements are visited in arbitrary order.
     ///
     /// Return an array with the same shape as *self*.
     ///
@@ -1128,4 +1129,83 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
             }
         }
     }
+
+    /// Create a new array with the results of applying `f` on the value of
+    /// each element.
+    /// Elements are visited in arbitrary order.
+    ///
+    /// Return an array with the same shape as *self*.
+    ///
+    /// ```
+    /// use ndarray::arr2;
+    ///
+    /// let a = arr2(&[[ 0., 1.],
+    ///                [-1., 2.]]);
+    /// assert!(
+    ///     a.mapv(f32::abs) == arr2(&[[0., 1.],
+    ///                                [1., 2.]])
+    /// );
+    /// ```
+    pub fn mapv<B, F>(&self, mut f: F) -> OwnedArray<B, D>
+        where F: FnMut(A) -> B,
+              A: Clone,
+    {
+        self.map(move |x| f(x.clone()))
+    }
+
+    /// Modify the array in place by calling `f` with a mutable reference
+    /// to each element.
+    /// Elements are visited in arbitrary order.
+    pub fn apply<F>(&mut self, f: F)
+        where S: DataMut,
+              F: FnMut(&mut A),
+    {
+        self.unordered_foreach_mut(f);
+    }
+
+    /// Modify the array in place by calling a function `f` that maps
+    /// each element by value (from `A` to `A`).
+    /// Elements are visited in arbitrary order.
+    ///
+    /// ```
+    /// use ndarray::arr2;
+    ///
+    /// let mut a = arr2(&[[ 0., 1.],
+    ///                    [-1., 2.]]);
+    /// a.applyv(f32::exp);
+    /// ```
+    pub fn applyv<F>(&mut self, mut f: F)
+        where S: DataMut,
+              F: FnMut(A) -> A,
+              A: Clone,
+    {
+        self.unordered_foreach_mut(move |x| *x = f(x.clone()));
+    }
+
+    /// Visit each element in the array by calling `f` with a reference
+    /// to each element.
+    /// Elements are visited in arbitrary order.
+    pub fn visit<'a, F>(&'a self, mut f: F)
+        where F: FnMut(&A),
+              A: 'a,
+    {
+        if let Some(slc) = self.as_slice_memory_order() {
+            // FIXME: Use for loop when slice iterator is perf is restored
+            for i in 0..slc.len() {
+                f(&slc[i]);
+            }
+        } else {
+            for row in self.inner_iter() {
+                if let Some(slc) = row.into_slice() {
+                    for i in 0..slc.len() {
+                        f(&slc[i]);
+                    }
+                } else {
+                    for elt in row {
+                        f(elt);
+                    }
+                }
+            }
+        }
+    }
 }