Apply most of the suggestions.

Author: KmolYuan

src/lib.rs

@@ -112,22 +112,21 @@
 //! For conversion between `ndarray`, [`nalgebra`](https://crates.io/crates/nalgebra) and
 //! [`image`](https://crates.io/crates/image) check out [`nshare`](https://crates.io/crates/nshare).
 
-
 extern crate alloc;
 
-#[cfg(feature = "std")]
-extern crate std;
 #[cfg(not(feature = "std"))]
 extern crate core as std;
+#[cfg(feature = "std")]
+extern crate std;
 
 #[cfg(feature = "blas")]
 extern crate cblas_sys;
 
 #[cfg(feature = "docs")]
 pub mod doc;
 
-use std::marker::PhantomData;
 use alloc::sync::Arc;
+use std::marker::PhantomData;
 
 pub use crate::dimension::dim::*;
 pub use crate::dimension::{Axis, AxisDescription, Dimension, IntoDimension, RemoveAxis};
@@ -146,16 +145,16 @@ use crate::iterators::Baseiter;
 use crate::iterators::{ElementsBase, ElementsBaseMut, Iter, IterMut};
 
 pub use crate::arraytraits::AsArray;
+pub use crate::linalg_traits::LinalgScalar;
 #[cfg(feature = "std")]
 pub use crate::linalg_traits::NdFloat;
-pub use crate::linalg_traits::LinalgScalar;
 
 #[allow(deprecated)] // stack_new_axis
 pub use crate::stacking::{concatenate, stack, stack_new_axis};
 
-pub use crate::math_cell::MathCell;
 pub use crate::impl_views::IndexLonger;
-pub use crate::shape_builder::{Shape, ShapeBuilder, ShapeArg, StrideShape};
+pub use crate::math_cell::MathCell;
+pub use crate::shape_builder::{Shape, ShapeArg, ShapeBuilder, StrideShape};
 
 #[macro_use]
 mod macro_utils;
@@ -176,8 +175,7 @@ mod data_traits;
 pub use crate::aliases::*;
 
 pub use crate::data_traits::{
-    Data, DataMut, DataOwned, DataShared, RawData, RawDataClone, RawDataMut,
-    RawDataSubst,
+    Data, DataMut, DataOwned, DataShared, RawData, RawDataClone, RawDataMut, RawDataSubst,
 };
 
 mod free_functions;
@@ -200,9 +198,9 @@ mod partial;
 mod shape_builder;
 #[macro_use]
 mod slice;
+mod low_level_util;
 mod split_at;
 mod stacking;
-mod low_level_util;
 #[macro_use]
 mod zip;
 
@@ -1502,12 +1500,10 @@ impl<'a, A> CowRepr<'a, A> {
 // Consider the doc effect of ordering modules here.
 mod impl_clone;
 
-mod impl_internal_constructors;
 mod impl_constructors;
+mod impl_internal_constructors;
 
 mod impl_methods;
-#[cfg(feature = "std")]
-mod impl_float_maths;
 mod impl_owned_array;
 mod impl_special_element_types;
 
@@ -1566,9 +1562,7 @@ where
         let d = self.dim.try_remove_axis(axis);
         let s = self.strides.try_remove_axis(axis);
         // safe because new dimension, strides allow access to a subset of old data
-        unsafe {
-            self.with_strides_dim(s, d)
-        }
+        unsafe { self.with_strides_dim(s, d) }
     }
 }
 

src/impl_float_maths.rs renamed to src/numeric/impl_float_maths.rs

@@ -1,25 +1,35 @@
-//! Element-wise methods for ndarray
+// Element-wise methods for ndarray
 
+#[cfg(feature = "std")]
 use num_traits::Float;
 
 use crate::imp_prelude::*;
 
-macro_rules! boolean_op {
-    ($($(#[$meta1:meta])* fn $id1:ident $(#[$meta2:meta])* fn $id2:ident -> $func:ident)+) => {
-        $($(#[$meta1])*
+#[cfg(feature = "std")]
+macro_rules! boolean_ops {
+    ($(#[$meta1:meta])* fn $func:ident
+    $(#[$meta2:meta])* fn $all:ident
+    $(#[$meta3:meta])* fn $any:ident) => {
+        $(#[$meta1])*
         #[must_use = "method returns a new array and does not mutate the original value"]
-        pub fn $id1(&self) -> Array<bool, D> {
+        pub fn $func(&self) -> Array<bool, D> {
             self.mapv(A::$func)
         }
         $(#[$meta2])*
         #[must_use = "method returns a new boolean value and does not mutate the original value"]
-        pub fn $id2(&self) -> bool {
-            self.mapv(A::$func).iter().any(|&b| b)
-        })+
+        pub fn $all(&self) -> bool {
+            $crate::Zip::from(self).all(|&elt| !elt.$func())
+        }
+        $(#[$meta3])*
+        #[must_use = "method returns a new boolean value and does not mutate the original value"]
+        pub fn $any(&self) -> bool {
+            !self.$all()
+        }
     };
 }
 
-macro_rules! unary_op {
+#[cfg(feature = "std")]
+macro_rules! unary_ops {
     ($($(#[$meta:meta])* fn $id:ident)+) => {
         $($(#[$meta])*
         #[must_use = "method returns a new array and does not mutate the original value"]
@@ -29,7 +39,8 @@ macro_rules! unary_op {
     };
 }
 
-macro_rules! binary_op {
+#[cfg(feature = "std")]
+macro_rules! binary_ops {
     ($($(#[$meta:meta])* fn $id:ident($ty:ty))+) => {
         $($(#[$meta])*
         #[must_use = "method returns a new array and does not mutate the original value"]
@@ -39,103 +50,87 @@ macro_rules! binary_op {
     };
 }
 
-/// # Element-wise methods for Float Array
+/// # Element-wise methods for float arrays
 ///
 /// Element-wise math functions for any array type that contains float number.
+#[cfg(feature = "std")]
 impl<A, S, D> ArrayBase<S, D>
 where
-    A: Float,
+    A: 'static + Float,
     S: Data<Elem = A>,
     D: Dimension,
 {
-    boolean_op! {
+    boolean_ops! {
         /// If the number is `NaN` (not a number), then `true` is returned for each element.
         fn is_nan
+        /// Return `true` if all elements are `NaN` (not a number).
+        fn is_all_nan
         /// Return `true` if any element is `NaN` (not a number).
-        fn is_any_nan -> is_nan
-
+        fn is_any_nan
+    }
+    boolean_ops! {
         /// If the number is infinity, then `true` is returned for each element.
         fn is_infinite
+        /// Return `true` if all elements are infinity.
+        fn is_all_infinite
         /// Return `true` if any element is infinity.
-        fn is_any_infinite -> is_infinite
+        fn is_any_infinite
     }
-    unary_op! {
+    unary_ops! {
         /// The largest integer less than or equal to each element.
         fn floor
-
         /// The smallest integer less than or equal to each element.
         fn ceil
-
         /// The nearest integer of each element.
         fn round
-
         /// The integer part of each element.
         fn trunc
-
         /// The fractional part of each element.
         fn fract
-
         /// Absolute of each element.
         fn abs
-
         /// Sign number of each element.
         ///
         /// + `1.0` for all positive numbers.
         /// + `-1.0` for all negative numbers.
         /// + `NaN` for all `NaN` (not a number).
         fn signum
-
         /// The reciprocal (inverse) of each element, `1/x`.
         fn recip
-
         /// Square root of each element.
         fn sqrt
-
         /// `e^x` of each element (exponential function).
         fn exp
-
         /// `2^x` of each element.
         fn exp2
-
         /// Natural logarithm of each element.
         fn ln
-
         /// Base 2 logarithm of each element.
         fn log2
-
         /// Base 10 logarithm of each element.
         fn log10
-
         /// Cubic root of each element.
         fn cbrt
-
         /// Sine of each element (in radians).
         fn sin
-
         /// Cosine of each element (in radians).
         fn cos
-
         /// Tangent of each element (in radians).
         fn tan
-
         /// Converts radians to degrees for each element.
         fn to_degrees
-
         /// Converts degrees to radians for each element.
         fn to_radians
     }
-    binary_op! {
+    binary_ops! {
         /// Integer power of each element.
         ///
         /// This function is generally faster than using float power.
         fn powi(i32)
-
         /// Float power of each element.
         fn powf(A)
-
         /// Logarithm of each element with respect to an arbitrary base.
         fn log(A)
-
         /// The positive difference between given number and each element.
         fn abs_sub(A)
     }
@@ -145,18 +140,37 @@ where
     pub fn pow2(&self) -> Array<A, D> {
         self.mapv(|v: A| v * v)
     }
+}
 
-    /// Limit the values for each element.
+impl<A, S, D> ArrayBase<S, D>
+where
+    A: 'static + PartialOrd + Clone,
+    S: Data<Elem = A>,
+    D: Dimension,
+{
+    /// Limit the values for each element, similar to NumPy's `clip` function.
     ///
     /// ```
-    /// use ndarray::{Array1, array};
+    /// use ndarray::array;
     ///
-    /// let a = Array1::range(0., 10., 1.);
-    /// assert_eq!(a.clip(1., 8.), array![1., 1., 2., 3., 4., 5., 6., 7., 8., 8.]);
-    /// assert_eq!(a.clip(8., 1.), array![1., 1., 1., 1., 1., 1., 1., 1., 1., 1.]);
-    /// assert_eq!(a.clip(3., 6.), array![3., 3., 3., 3., 4., 5., 6., 6., 6., 6.]);
+    /// let a = array![0., 1., 2., 3., 4., 5., 6., 7., 8., 9.];
+    /// assert_eq!(a.clamp(1., 8.), array![1., 1., 2., 3., 4., 5., 6., 7., 8., 8.]);
+    /// assert_eq!(a.clamp(3., 6.), array![3., 3., 3., 3., 4., 5., 6., 6., 6., 6.]);
     /// ```
-    pub fn clip(&self, min: A, max: A) -> Array<A, D> {
-        self.mapv(|v| A::min(A::max(v, min), max))
+    ///
+    /// # Panics
+    ///
+    /// Panics if `min > max`, `min` is `NaN`, or `max` is `NaN`.
+    pub fn clamp(&self, min: A, max: A) -> Array<A, D> {
+        assert!(min <= max, "min must be less than or equal to max");
+        self.mapv(|v| {
+            if v < min {
+                min.clone()
+            } else if v > max {
+                max.clone()
+            } else {
+                v
+            }
+        })
     }
 }

src/numeric/mod.rs

@@ -1 +1,3 @@
 mod impl_numeric;
+
+mod impl_float_maths;