Add mapv, mapv_into, apply, applyv, visit

Author: bluss

src/impl_methods.rs

@@ -1095,8 +1095,10 @@ 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.
+    /// Call `f` by reference on each element and create a new array
+    /// with the results.
+    ///
+    /// Elements are visited in arbitrary order.
     ///
     /// Return an array with the same shape as *self*.
     ///
@@ -1128,4 +1130,103 @@ impl<A, S, D> ArrayBase<S, D> where S: Data<Elem=A>, D: Dimension
             }
         }
     }
+
+    /// Call `f` by value on each element and create a new array
+    /// with the new values.
+    ///
+    /// 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()))
+    }
+
+    /// Call `f` by value on each element, update the array with new values
+    /// and return it.
+    ///
+    /// Elements are visited in arbitrary order.
+    pub fn mapv_into<F>(mut self, f: F) -> Self
+        where S: DataMut,
+              F: FnMut(A) -> A,
+              A: Clone,
+    {
+        self.applyv(f);
+        self
+    }
+
+    /// Modify in place by calling `f` by mutable reference on 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 in place by calling `f` by value on each element. The
+    /// array is updated with the new values.
+    ///
+    /// Elements are visited in arbitrary order.
+    ///
+    /// ```
+    /// use ndarray::arr2;
+    ///
+    /// let mut a = arr2(&[[ 0., 1.],
+    ///                    [-1., 2.]]);
+    /// a.applyv(f32::exp);
+    /// assert!(
+    ///     a.allclose(&arr2(&[[1.00000, 2.71828],
+    ///                        [0.36788, 7.38906]]), 1e-5)
+    /// );
+    /// ```
+    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` by reference
+    /// on each element.
+    ///
+    /// Elements are visited in arbitrary order.
+    pub fn visit<'a, F>(&'a self, mut f: F)
+        where F: FnMut(&'a 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);
+                    }
+                }
+            }
+        }
+    }
 }