Merge pull request #18 from jorenham/erf_inv

Author: jorenham

src/ffi.rs

@@ -31,6 +31,8 @@ unsafe extern "C" {
     // boost/math/special_functions/erf.hpp
     pub fn math_erf(x: f64) -> f64;
     pub fn math_erfc(x: f64) -> f64;
+    pub fn math_erf_inv(p: f64) -> f64;
+    pub fn math_erfc_inv(q: f64) -> f64;
 
     // boost/math/special_functions/factorials.hpp
     pub fn math_factorial(i: c_uint) -> f64;

src/math/special_functions/erf.rs

@@ -2,37 +2,62 @@
 
 use crate::ffi;
 
-/// Error function *erf(x)*
+/// Error function
 ///
+/// Corresponds to `boost::math::erf(x)` in C++.
 /// <https://boost.org/doc/libs/latest/libs/math/doc/html/math_toolkit/sf_erf/error_function.html>
 pub fn erf(x: f64) -> f64 {
     unsafe { ffi::math_erf(x) }
 }
 
-/// Complementary error function *erfc(x)*
+/// Complement of the error function
 ///
+/// Corresponds to `boost::math::erfc(x)` in C++.
 /// <https://boost.org/doc/libs/latest/libs/math/doc/html/math_toolkit/sf_erf/error_function.html>
 pub fn erfc(x: f64) -> f64 {
     unsafe { ffi::math_erfc(x) }
 }
 
+/// Inverse of [`erf`]
+///
+/// Corresponds to `boost::math::erf_inv(x)` in C++.
+/// <https://boost.org/doc/libs/latest/libs/math/doc/html/math_toolkit/sf_erf/error_inv.html>
+pub fn erf_inv(p: f64) -> f64 {
+    unsafe { ffi::math_erf_inv(p) }
+}
+
+/// Inverse of [`erfc`]
+///
+/// Corresponds to `boost::math::erfc_inv(q)` in C++.
+/// <https://boost.org/doc/libs/latest/libs/math/doc/html/math_toolkit/sf_erf/error_inv.html>
+pub fn erfc_inv(q: f64) -> f64 {
+    unsafe { ffi::math_erfc_inv(q) }
+}
+
 #[cfg(test)]
-mod tests {
+mod smoketests {
     use super::*;
 
     #[test]
     fn test_erf() {
-        assert_abs_diff_eq!(erf(0.0), 0.0, epsilon = f64::EPSILON);
-        assert_abs_diff_eq!(erf(-1.0) + erf(1.0), 0.0, epsilon = f64::EPSILON);
+        assert!(erf(1e-9).is_finite());
+        assert!(erf(1.0 - 1e-9).is_finite());
     }
 
     #[test]
     fn test_erfc() {
-        assert_abs_diff_eq!(erfc(0.0), 1.0, epsilon = f64::EPSILON);
+        assert!(erfc(1e-9).is_finite());
+        assert!(erfc(1.0 - 1e-9).is_finite());
+    }
+    #[test]
+    fn test_erf_inv() {
+        assert!(erf_inv(1e-9).is_finite());
+        assert!(erf_inv(1.0 - 1e-9).is_finite());
     }
 
     #[test]
-    fn test_erf_erfc_relation() {
-        assert_abs_diff_eq!(erf(1.0) + erfc(1.0), 1.0, epsilon = f64::EPSILON);
+    fn test_erfc_inv() {
+        assert!(erfc_inv(1e-9).is_finite());
+        assert!(erfc_inv(1.0 - 1e-9).is_finite());
     }
 }

wrapper.cpp

@@ -55,6 +55,8 @@ double math_digamma(double x) { return digamma(x); }
 // boost/math/special_functions/erf.hpp
 double math_erf(double x) { return erf(x); }
 double math_erfc(double x) { return erfc(x); }
+double math_erf_inv(double p) { return erf_inv(p); }
+double math_erfc_inv(double q) { return erfc_inv(q); }
 
 // boost/math/special_functions/factorials.hpp
 double math_factorial(unsigned i) { return factorial<double>(i); }