Updated ComplexFloat to be a bit more general and to have a few extra methods. Moved to a new module, and added a couple useful functions to Complex<T>.

Author: obsgolem

src/cast.rs

@@ -80,57 +80,6 @@ where
     }
 }
 
-pub trait RealConsts<T: Copy> {
-    #[cfg(has_assoc_const)]
-    const LN_2: T;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_2: T;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_10: T;
-
-    fn ln_2() -> T;
-    fn frac_ln_2() -> T;
-    fn frac_ln_10() -> T;
-}
-
-impl RealConsts<f32> for f32 {
-    #[cfg(has_assoc_const)]
-    const LN_2: f32 = 0.693147180559945309417232121458176568_f32;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_2: f32 = 1.442695040888963407359924681001892137_f32;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_10: f32 = 0.434294481903251827651128918916605082_f32;
-
-    fn ln_2() -> f32 {
-        0.693147180559945309417232121458176568_f32
-    }
-    fn frac_ln_2() -> f32 {
-        1.442695040888963407359924681001892137_f32
-    }
-    fn frac_ln_10() -> f32 {
-        0.434294481903251827651128918916605082_f32
-    }
-}
-
-impl RealConsts<f64> for f64 {
-    #[cfg(has_assoc_const)]
-    const LN_2: f64 = 0.693147180559945309417232121458176568_f64;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_2: f64 = 1.442695040888963407359924681001892137_f64;
-    #[cfg(has_assoc_const)]
-    const FRAC_LN_10: f64 = 0.434294481903251827651128918916605082_f64;
-
-    fn ln_2() -> f64 {
-        0.693147180559945309417232121458176568_f64
-    }
-    fn frac_ln_2() -> f64 {
-        1.442695040888963407359924681001892137_f64
-    }
-    fn frac_ln_10() -> f64 {
-        0.434294481903251827651128918916605082_f64
-    }
-}
-
 #[cfg(test)]
 mod test {
     use super::*;

src/complex_float.rs

@@ -0,0 +1,311 @@
+// Keeps us from accidentally creating a recursive impl rather than a real one.
+#![deny(unconditional_recursion)]
+
+use num_traits::{float::FloatCore, Float, FloatConst};
+
+use crate::Complex;
+
+/// Generic trait for floating point complex numbers
+/// This trait defines methods which are common to complex floating point numbers and regular floating point numbers.
+#[cfg(any(feature = "std", feature = "libm"))]
+pub trait ComplexFloat {
+    type Real;
+
+    /// Returns `true` if this value is `NaN` and false otherwise.
+    fn is_nan(self) -> bool;
+
+    /// Returns `true` if this value is positive infinity or negative infinity and
+    /// false otherwise.
+    fn is_infinite(self) -> bool;
+
+    /// Returns `true` if this number is neither infinite nor `NaN`.
+    fn is_finite(self) -> bool;
+
+    /// Returns `true` if the number is neither zero, infinite,
+    /// [subnormal][subnormal], or `NaN`.
+    /// [subnormal]: http://en.wikipedia.org/wiki/Denormal_number
+    fn is_normal(self) -> bool;
+
+    /// Take the reciprocal (inverse) of a number, `1/x`.
+    fn recip(self) -> Self;
+
+    /// Raises `self` to a signed integer power.
+    fn powi(self, exp: i32) -> Self;
+
+    /// Raises `self` to a real power.
+    fn powf(self, exp: Self::Real) -> Self;
+
+    /// Raises `self` to a complex power.
+    fn powc(self, exp: Complex<Self::Real>) -> Complex<Self::Real>;
+
+    /// Take the square root of a number.
+    fn sqrt(self) -> Self;
+
+    /// Returns `e^(self)`, (the exponential function).
+    fn exp(self) -> Self;
+
+    /// Returns `2^(self)`.
+    fn exp2(self) -> Self;
+
+    /// Returns the natural logarithm of the number.
+    fn ln(self) -> Self;
+
+    /// Returns the logarithm of the number with respect to an arbitrary base.
+    fn log(self, base: Self::Real) -> Self;
+
+    /// Returns the base 2 logarithm of the number.
+    fn log2(self) -> Self;
+
+    /// Returns the base 10 logarithm of the number.
+    fn log10(self) -> Self;
+
+    /// Take the cubic root of a number.
+    fn cbrt(self) -> Self;
+
+    /// Computes the sine of a number (in radians).
+    fn sin(self) -> Self;
+
+    /// Computes the cosine of a number (in radians).
+    fn cos(self) -> Self;
+
+    /// Computes the tangent of a number (in radians).
+    fn tan(self) -> Self;
+
+    /// Computes the arcsine of a number. Return value is in radians in
+    /// the range [-pi/2, pi/2] or NaN if the number is outside the range
+    /// [-1, 1].
+    fn asin(self) -> Self;
+
+    /// Computes the arccosine of a number. Return value is in radians in
+    /// the range [0, pi] or NaN if the number is outside the range
+    /// [-1, 1].
+    fn acos(self) -> Self;
+
+    /// Computes the arctangent of a number. Return value is in radians in the
+    /// range [-pi/2, pi/2];
+    fn atan(self) -> Self;
+
+    /// Hyperbolic sine function.
+    fn sinh(self) -> Self;
+
+    /// Hyperbolic cosine function.
+    fn cosh(self) -> Self;
+
+    /// Hyperbolic tangent function.
+    fn tanh(self) -> Self;
+
+    /// Inverse hyperbolic sine function.
+    fn asinh(self) -> Self;
+
+    /// Inverse hyperbolic cosine function.
+    fn acosh(self) -> Self;
+
+    /// Inverse hyperbolic tangent function.
+    fn atanh(self) -> Self;
+
+    /// Returns the real part of the number.
+    fn re(self) -> Self::Real;
+
+    /// Returns the imaginary part of the number which equals to zero.
+    fn im(self) -> Self::Real;
+
+    /// Returns the absolute value of the number.
+    fn abs(self) -> Self::Real;
+
+    /// Computes the argument of the number.
+    fn arg(self) -> Self::Real;
+
+    /// Comutes the complex conjugate of `self`.
+    ///
+    /// Formula: `a+bi -> a-bi`
+    fn conj(self) -> Self;
+}
+
+macro_rules! forward {
+    ($( $base:ident :: $method:ident ( self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
+        => {$(
+            #[inline]
+            fn $method(self $( , $arg : $ty )* ) -> $ret {
+                $base::$method(self $( , $arg )* )
+            }
+        )*};
+}
+
+macro_rules! forward_ref {
+    ($( Self :: $method:ident ( & self $( , $arg:ident : $ty:ty )* ) -> $ret:ty ; )*)
+        => {$(
+            #[inline]
+            fn $method(self $( , $arg : $ty )* ) -> $ret {
+                Self::$method(&self $( , $arg )* )
+            }
+        )*};
+}
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl<T> ComplexFloat for T
+where
+    T: Float + FloatConst,
+{
+    type Real = T;
+
+    fn re(self) -> Self::Real {
+        self
+    }
+
+    fn im(self) -> Self::Real {
+        T::zero()
+    }
+
+    fn abs(self) -> Self::Real {
+        self.abs()
+    }
+
+    fn arg(self) -> Self::Real {
+        if self > T::zero() {
+            T::zero()
+        } else if self < T::zero() {
+            T::PI()
+        } else {
+            T::nan()
+        }
+    }
+
+    fn powc(self, exp: Complex<Self::Real>) -> Complex<Self::Real> {
+        Complex::new(self, Self::Real::zero()).powc(exp)
+    }
+
+    fn conj(self) -> Self {
+        self
+    }
+
+    forward! {
+        Float::is_normal(self) -> bool;
+        Float::is_infinite(self) -> bool;
+        Float::is_finite(self) -> bool;
+        Float::is_nan(self) -> bool;
+        Float::recip(self) -> Self;
+        Float::powi(self, n: i32) -> Self;
+        Float::powf(self, f: Self) -> Self;
+        Float::sqrt(self) -> Self;
+        Float::cbrt(self) -> Self;
+        Float::exp(self) -> Self;
+        Float::exp2(self) -> Self;
+        Float::ln(self) -> Self;
+        Float::log(self, base: Self) -> Self;
+        Float::log2(self) -> Self;
+        Float::log10(self) -> Self;
+        Float::sin(self) -> Self;
+        Float::cos(self) -> Self;
+        Float::tan(self) -> Self;
+        Float::asin(self) -> Self;
+        Float::acos(self) -> Self;
+        Float::atan(self) -> Self;
+        Float::sinh(self) -> Self;
+        Float::cosh(self) -> Self;
+        Float::tanh(self) -> Self;
+        Float::asinh(self) -> Self;
+        Float::acosh(self) -> Self;
+        Float::atanh(self) -> Self;
+    }
+}
+
+#[cfg(any(feature = "std", feature = "libm"))]
+impl<T: Float + FloatCore + FloatConst> ComplexFloat for Complex<T> {
+    type Real = T;
+
+    fn re(self) -> Self::Real {
+        self.re
+    }
+
+    fn im(self) -> Self::Real {
+        self.im
+    }
+
+    fn abs(self) -> Self::Real {
+        self.norm()
+    }
+
+    fn arg(self) -> Self::Real {
+        Complex::arg(self)
+    }
+
+    fn recip(self) -> Self {
+        self.finv()
+    }
+
+    fn powc(self, exp: Complex<Self::Real>) -> Complex<Self::Real> {
+        self.powc(exp)
+    }
+
+    forward! {
+        Complex::exp2(self) -> Self;
+        Complex::log(self, base: Self::Real) -> Self;
+        Complex::log2(self) -> Self;
+        Complex::log10(self) -> Self;
+        Complex::is_normal(self) -> bool;
+        Complex::is_infinite(self) -> bool;
+        Complex::is_finite(self) -> bool;
+        Complex::is_nan(self) -> bool;
+        Complex::powf(self, f: Self::Real) -> Self;
+        Complex::sqrt(self) -> Self;
+        Complex::cbrt(self) -> Self;
+        Complex::exp(self) -> Self;
+        Complex::ln(self) -> Self;
+        Complex::sin(self) -> Self;
+        Complex::cos(self) -> Self;
+        Complex::tan(self) -> Self;
+        Complex::asin(self) -> Self;
+        Complex::acos(self) -> Self;
+        Complex::atan(self) -> Self;
+        Complex::sinh(self) -> Self;
+        Complex::cosh(self) -> Self;
+        Complex::tanh(self) -> Self;
+        Complex::asinh(self) -> Self;
+        Complex::acosh(self) -> Self;
+        Complex::atanh(self) -> Self;
+    }
+
+    forward_ref! {
+        Self::powi(&self, n: i32) -> Self;
+        Self::conj(&self) -> Self;
+    }
+}
+
+#[cfg(test)]
+mod test {
+    use crate::{complex_float::ComplexFloat, test::float::close, Complex, Complex64};
+
+    pub const _0_0i: Complex64 = Complex { re: 0.0, im: 0.0 };
+    pub const _1_0i: Complex64 = Complex { re: 1.0, im: 0.0 };
+    pub const _1_1i: Complex64 = Complex { re: 1.0, im: 1.0 };
+    pub const _0_1i: Complex64 = Complex { re: 0.0, im: 1.0 };
+    pub const _neg1_1i: Complex64 = Complex { re: -1.0, im: 1.0 };
+    pub const _05_05i: Complex64 = Complex { re: 0.5, im: 0.5 };
+    pub const all_consts: [Complex64; 5] = [_0_0i, _1_0i, _1_1i, _neg1_1i, _05_05i];
+    pub const _4_2i: Complex64 = Complex { re: 4.0, im: 2.0 };
+
+    #[test]
+    fn test_exp2() {
+        assert!(close(ComplexFloat::exp2(_0_0i), _1_0i));
+    }
+
+    #[test]
+    fn test_powi() {
+        assert!(close(ComplexFloat::powi(_0_1i, 4), _1_0i));
+    }
+
+    #[test]
+    fn test_powz() {
+        assert!(close(_1_0i.powc(_0_1i), _1_0i));
+    }
+
+    #[test]
+    fn test_log2() {
+        assert!(close(_1_0i.log2(), _0_0i));
+    }
+
+    #[test]
+    fn test_log10() {
+        assert!(close(_1_0i.log10(), _0_0i));
+    }
+}