Simplify macros.

Author: KmolYuan

src/impl_float_maths.rs

@@ -5,33 +5,33 @@ 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])*
+    ($($(#[$meta1:meta])* fn $id1:ident $(#[$meta2:meta])* fn $id2:ident -> $func:ident)+) => {
+        $($(#[$meta1])*
         pub fn $id1(&self) -> Array<bool, D> {
             self.mapv(A::$func)
         }
         $(#[$meta2])*
         pub fn $id2(&self) -> bool {
             self.mapv(A::$func).iter().any(|&b|b)
-        }
+        })+
     };
 }
 
 macro_rules! unary_op {
-    ($(#[$meta:meta])* fn $id:ident) => {
-        $(#[$meta])*
+    ($($(#[$meta:meta])* fn $id:ident)+) => {
+        $($(#[$meta])*
         pub fn $id(&self) -> Array<A, D> {
             self.mapv(A::$id)
-        }
+        })+
     };
 }
 
 macro_rules! binary_op {
-    ($(#[$meta:meta])* fn $id:ident($ty:ty)) => {
-        $(#[$meta])*
+    ($($(#[$meta:meta])* fn $id:ident($ty:ty))+) => {
+        $($(#[$meta])*
         pub fn $id(&self, rhs: $ty) -> Array<A, D> {
             self.mapv(|v| A::$id(v, rhs))
-        }
+        })+
     };
 }
 
@@ -49,8 +49,7 @@ where
         fn is_nan
         /// Return `true` if any element is `NaN` (not a number).
         fn is_nan_any -> is_nan
-    }
-    boolean_op! {
+
         /// If the number is infinity, then `true` is returned for each element.
         fn is_infinite
         /// Return `true` if any element is infinity.
@@ -59,111 +58,88 @@ where
     unary_op! {
         /// The largest integer less than or equal to each element.
         fn floor
-    }
-    unary_op! {
+
         /// The smallest integer less than or equal to each element.
         fn ceil
-    }
-    unary_op! {
+
         /// The nearest integer of each element.
         fn round
-    }
-    unary_op! {
+
         /// The integer part of each element.
         fn trunc
-    }
-    unary_op! {
+
         /// The fractional part of each element.
         fn fract
-    }
-    unary_op! {
+
         /// Absolute of each element.
         fn abs
-    }
-    unary_op! {
+
         /// 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
-    }
-    unary_op! {
+
         /// The reciprocal (inverse) of each element, `1/x`.
         fn recip
-    }
-    binary_op! {
-        /// Integer power of each element.
-        ///
-        /// This function is generally faster than using float power.
-        fn powi(i32)
-    }
-    binary_op! {
-        /// Float power of each element.
-        fn powf(A)
-    }
-
-    /// Square of each element.
-    pub fn square(&self) -> Array<A, D> {
-        self.mapv(|v| v * v)
-    }
 
-    unary_op! {
         /// Square root of each element.
         fn sqrt
-    }
-    unary_op! {
+
         /// `e^x` of each element. (Exponential function)
         fn exp
-    }
-    unary_op! {
+
         /// `2^x` of each element.
         fn exp2
-    }
-    unary_op! {
+
         /// Natural logarithm of each element.
         fn ln
-    }
-    binary_op! {
-        /// Logarithm of each element with respect to an arbitrary base.
-        fn log(A)
-    }
-    unary_op! {
+
         /// Base 2 logarithm of each element.
         fn log2
-    }
-    unary_op! {
+
         /// Base 10 logarithm of each element.
         fn log10
-    }
-    binary_op! {
-        /// The positive difference between given number and each element.
-        fn abs_sub(A)
-    }
-    unary_op! {
+
         /// Cubic root of each element.
         fn cbrt
-    }
-    unary_op! {
+
         /// Sine of each element. (in radians)
         fn sin
-    }
-    unary_op! {
+
         /// Cosine of each element. (in radians)
         fn cos
-    }
-    unary_op! {
+
         /// Tangent of each element. (in radians)
         fn tan
-    }
-    unary_op! {
+
         /// Converts radians to degrees for each element.
         fn to_degrees
-    }
-    unary_op! {
+
         /// Converts degrees to radians for each element.
         fn to_radians
     }
+    binary_op! {
+        /// 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)
+    }
+
+    /// Square of each element.
+    pub fn square(&self) -> Array<A, D> {
+        self.mapv(|v| v * v)
+    }
 
     /// Limit the values for each element.
     ///