MathVecReal

Author: termoshtt

src/vecmath/ffi.rs

@@ -40,9 +40,17 @@ trait VecMath: Scalar {
 trait VecMathReal: Sized {
     /* Arthmetic */
     fn sqr(in_: &[Self], out: &mut [Self]);
-    fn linear_frac(in_: &[Self], out: &mut [Self]);
-    fn fmod(in_: &[Self], out: &mut [Self]);
-    fn remainder(in_: &[Self], out: &mut [Self]);
+    fn linear_frac(
+        a: &[Self],
+        b: &[Self],
+        scale_a: Self,
+        shift_a: Self,
+        scale_b: Self,
+        shift_b: Self,
+        out: &mut [Self],
+    );
+    fn fmod(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn remainder(a: &[Self], b: &[Self], out: &mut [Self]);
 
     /* Power and Root */
     fn inv(in_: &[Self], out: &mut [Self]);
@@ -51,20 +59,21 @@ trait VecMathReal: Sized {
     fn inv_cbrt(in_: &[Self], out: &mut [Self]);
     fn pow2o3(in_: &[Self], out: &mut [Self]);
     fn pow3o2(in_: &[Self], out: &mut [Self]);
-    fn powr(in_: &[Self], out: &mut [Self]);
-    fn hypot(in_: &[Self], out: &mut [Self]);
+    fn powr(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn hypot(a: &[Self], b: &[Self], out: &mut [Self]);
 
     /* Exponential and Logarithmic */
     fn exp2(in_: &[Self], out: &mut [Self]);
     fn exp10(in_: &[Self], out: &mut [Self]);
     fn expm1(in_: &[Self], out: &mut [Self]);
     fn log2(in_: &[Self], out: &mut [Self]);
+    fn log10(in_: &[Self], out: &mut [Self]);
     fn log1p(in_: &[Self], out: &mut [Self]);
     fn logb(in_: &[Self], out: &mut [Self]);
 
     /* Trigonometric */
-    fn sin_cos(in_: &[Self], out: &mut [Self]);
-    fn atan2(in_: &[Self], out: &mut [Self]);
+    fn sin_cos(theta: &[Self], sin: &mut [Self], cos: &mut [Self]);
+    fn atan2(sin: &[Self], cos: &[Self], theta: &mut [Self]);
 
     /* Special */
     fn erf(in_: &[Self], out: &mut [Self]);
@@ -84,17 +93,17 @@ trait VecMathReal: Sized {
     fn round(in_: &[Self], out: &mut [Self]);
     fn near_by_int(in_: &[Self], out: &mut [Self]);
     fn rint(in_: &[Self], out: &mut [Self]);
-    fn modf(in_: &[Self], out: &mut [Self]);
+    fn modf(a: &[Self], y: &mut [Self], z: &mut [Self]);
     fn frac(in_: &[Self], out: &mut [Self]);
 
     /* Miscellaneous */
-    fn copy_sign(in_: &[Self], out: &mut [Self]);
-    fn next_after(in_: &[Self], out: &mut [Self]);
-    fn fdim(in_: &[Self], out: &mut [Self]);
-    fn fmax(in_: &[Self], out: &mut [Self]);
-    fn fmin(in_: &[Self], out: &mut [Self]);
-    fn maxmag(in_: &[Self], out: &mut [Self]);
-    fn minmag(in_: &[Self], out: &mut [Self]);
+    fn copy_sign(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn next_after(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn fdim(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn fmax(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn fmin(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn maxmag(a: &[Self], b: &[Self], out: &mut [Self]);
+    fn minmag(a: &[Self], b: &[Self], out: &mut [Self]);
 }
 
 trait VecMathComplex: Sized {
@@ -128,7 +137,7 @@ macro_rules! impl_binary {
     };
 }
 
-macro_rules! impl_binary_scalar {
+macro_rules! impl_powx {
     ($scalar:ty, $name:ident, $impl_name:ident) => {
         fn $name(a: &[$scalar], b: $scalar, out: &mut [$scalar]) {
             assert_eq!(a.len(), out.len());
@@ -147,7 +156,7 @@ impl VecMath for f32 {
     impl_binary!(f32, div, vsDiv);
     impl_unary!(f32, sqrt, vsSqrt);
     impl_binary!(f32, pow, vsPow);
-    impl_binary_scalar!(f32, powx, vsPowx);
+    impl_powx!(f32, powx, vsPowx);
 
     impl_unary!(f32, exp, vsExp);
     impl_unary!(f32, ln, vsLn);
@@ -177,7 +186,7 @@ impl VecMath for f64 {
     impl_binary!(f64, div, vdDiv);
     impl_unary!(f64, sqrt, vdSqrt);
     impl_binary!(f64, pow, vdPow);
-    impl_binary_scalar!(f64, powx, vdPowx);
+    impl_powx!(f64, powx, vdPowx);
 
     impl_unary!(f64, exp, vdExp);
     impl_unary!(f64, ln, vdLn);
@@ -198,6 +207,155 @@ impl VecMath for f64 {
     impl_unary!(f64, atanh, vdAtanh);
 }
 
+macro_rules! impl_unary2 {
+    ($scalar:ty, $name:ident, $impl_name:ident) => {
+        fn $name(in_: &[$scalar], out1: &mut [$scalar], out2: &mut [$scalar]) {
+            assert_eq!(in_.len(), out1.len());
+            assert_eq!(in_.len(), out2.len());
+            let n = in_.len() as i32;
+            unsafe { $impl_name(n, in_.as_ptr(), out1.as_mut_ptr(), out2.as_mut_ptr()) }
+        }
+    };
+}
+
+macro_rules! impl_linearfrac {
+    ($scalar:ty, $name:ident, $impl_name:ident) => {
+        fn $name(
+            a: &[$scalar],
+            b: &[$scalar],
+            scale_a: $scalar,
+            shift_a: $scalar,
+            scale_b: $scalar,
+            shift_b: $scalar,
+            out: &mut [$scalar],
+        ) {
+            assert_eq!(a.len(), out.len());
+            assert_eq!(b.len(), out.len());
+            let n = out.len() as i32;
+            unsafe {
+                $impl_name(
+                    n,
+                    a.as_ptr(),
+                    b.as_ptr(),
+                    scale_a,
+                    shift_a,
+                    scale_b,
+                    shift_b,
+                    out.as_mut_ptr(),
+                )
+            }
+        }
+    };
+}
+
+impl VecMathReal for f32 {
+    impl_unary!(f32, sqr, vsSqr);
+    impl_linearfrac!(f32, linear_frac, vsLinearFrac);
+    impl_binary!(f32, fmod, vsFmod);
+    impl_binary!(f32, remainder, vsRemainder);
+
+    impl_unary!(f32, inv, vsInv);
+    impl_unary!(f32, inv_sqrt, vsInvSqrt);
+    impl_unary!(f32, cbrt, vsCbrt);
+    impl_unary!(f32, inv_cbrt, vsInvCbrt);
+    impl_unary!(f32, pow2o3, vsPow2o3);
+    impl_unary!(f32, pow3o2, vsPow3o2);
+    impl_binary!(f32, powr, vsPowr);
+    impl_binary!(f32, hypot, vsHypot);
+
+    impl_unary!(f32, exp2, vsExp2);
+    impl_unary!(f32, exp10, vsExp10);
+    impl_unary!(f32, expm1, vsExpm1);
+    impl_unary!(f32, log2, vsLog2);
+    impl_unary!(f32, log10, vsLog10);
+    impl_unary!(f32, log1p, vsLog1p);
+    impl_unary!(f32, logb, vsLogb);
+
+    impl_unary2!(f32, sin_cos, vsSinCos);
+    impl_binary!(f32, atan2, vsAtan2);
+
+    impl_unary!(f32, erf, vsErf);
+    impl_unary!(f32, erfc, vsErfc);
+    impl_unary!(f32, cdf_normal, vsCdfNorm);
+    impl_unary!(f32, erf_inv, vsErfInv);
+    impl_unary!(f32, erfc_inv, vsErfcInv);
+    impl_unary!(f32, cdf_normal_inv, vsCdfNormInv);
+    impl_unary!(f32, ln_gamma, vsLGamma);
+    impl_unary!(f32, gamma, vsTGamma);
+    impl_unary!(f32, exp_integral, vsExpInt1);
+
+    impl_unary!(f32, floor, vsFloor);
+    impl_unary!(f32, ceil, vsCeil);
+    impl_unary!(f32, trunc, vsTrunc);
+    impl_unary!(f32, round, vsRound);
+    impl_unary!(f32, near_by_int, vsNearbyInt);
+    impl_unary!(f32, rint, vsRint);
+    impl_unary2!(f32, modf, vsModf);
+    impl_unary!(f32, frac, vsFrac);
+
+    impl_binary!(f32, copy_sign, vsCopySign);
+    impl_binary!(f32, next_after, vsNextAfter);
+    impl_binary!(f32, fdim, vsFdim);
+    impl_binary!(f32, fmax, vsFmax);
+    impl_binary!(f32, fmin, vsFmin);
+    impl_binary!(f32, maxmag, vsMaxMag);
+    impl_binary!(f32, minmag, vsMinMag);
+}
+
+impl VecMathReal for f64 {
+    impl_unary!(f64, sqr, vdSqr);
+    impl_linearfrac!(f64, linear_frac, vdLinearFrac);
+    impl_binary!(f64, fmod, vdFmod);
+    impl_binary!(f64, remainder, vdRemainder);
+
+    impl_unary!(f64, inv, vdInv);
+    impl_unary!(f64, inv_sqrt, vdInvSqrt);
+    impl_unary!(f64, cbrt, vdCbrt);
+    impl_unary!(f64, inv_cbrt, vdInvCbrt);
+    impl_unary!(f64, pow2o3, vdPow2o3);
+    impl_unary!(f64, pow3o2, vdPow3o2);
+    impl_binary!(f64, powr, vdPowr);
+    impl_binary!(f64, hypot, vdHypot);
+
+    impl_unary!(f64, exp2, vdExp2);
+    impl_unary!(f64, exp10, vdExp10);
+    impl_unary!(f64, expm1, vdExpm1);
+    impl_unary!(f64, log2, vdLog2);
+    impl_unary!(f64, log10, vdLog10);
+    impl_unary!(f64, log1p, vdLog1p);
+    impl_unary!(f64, logb, vdLogb);
+
+    impl_unary2!(f64, sin_cos, vdSinCos);
+    impl_binary!(f64, atan2, vdAtan2);
+
+    impl_unary!(f64, erf, vdErf);
+    impl_unary!(f64, erfc, vdErfc);
+    impl_unary!(f64, cdf_normal, vdCdfNorm);
+    impl_unary!(f64, erf_inv, vdErfInv);
+    impl_unary!(f64, erfc_inv, vdErfcInv);
+    impl_unary!(f64, cdf_normal_inv, vdCdfNormInv);
+    impl_unary!(f64, ln_gamma, vdLGamma);
+    impl_unary!(f64, gamma, vdTGamma);
+    impl_unary!(f64, exp_integral, vdExpInt1);
+
+    impl_unary!(f64, floor, vdFloor);
+    impl_unary!(f64, ceil, vdCeil);
+    impl_unary!(f64, trunc, vdTrunc);
+    impl_unary!(f64, round, vdRound);
+    impl_unary!(f64, near_by_int, vdNearbyInt);
+    impl_unary!(f64, rint, vdRint);
+    impl_unary2!(f64, modf, vdModf);
+    impl_unary!(f64, frac, vdFrac);
+
+    impl_binary!(f64, copy_sign, vdCopySign);
+    impl_binary!(f64, next_after, vdNextAfter);
+    impl_binary!(f64, fdim, vdFdim);
+    impl_binary!(f64, fmax, vdFmax);
+    impl_binary!(f64, fmin, vdFmin);
+    impl_binary!(f64, maxmag, vdMaxMag);
+    impl_binary!(f64, minmag, vdMinMag);
+}
+
 macro_rules! impl_unary_c {
     ($scalar:ty, $mkl_complex:ty, $name:ident, $impl_name:ident) => {
         fn $name(in_: &[$scalar], out: &mut [$scalar]) {