Fix names of a few GSL routines which prevent linking.

Author: Jakub Konka

src/bessel.rs

@@ -475,14 +475,14 @@ pub fn Knu_e(nu: f64, x: f64) -> (enums::value::Value, ::types::Result) {
 }
 
 /// This routine computes the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0.
-pub fn InKnu(nu: f64, x: f64) -> f64 {
-    unsafe { ffi::gsl_sf_bessel_InKnu(nu, x) }
+pub fn lnKnu(nu: f64, x: f64) -> f64 {
+    unsafe { ffi::gsl_sf_bessel_lnKnu(nu, x) }
 }
 
 /// This routine computes the logarithm of the irregular modified Bessel function of fractional order \nu, \ln(K_\nu(x)) for x>0, \nu>0.
-pub fn InKnu_e(nu: f64, x: f64) -> (enums::value::Value, ::types::Result) {
+pub fn lnKnu_e(nu: f64, x: f64) -> (enums::value::Value, ::types::Result) {
     let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
-    let ret = unsafe { ffi::gsl_sf_bessel_InKnu_e(nu, x, &mut result) };
+    let ret = unsafe { ffi::gsl_sf_bessel_lnKnu_e(nu, x, &mut result) };
 
     (ret, ::types::Result{val: result.val, err: result.err})
 }
@@ -656,4 +656,4 @@ pub fn zero_Jnu_e(nu: f64, s: u32) -> (enums::value::Value, ::types::Result) {
     let ret = unsafe { ffi::gsl_sf_bessel_zero_Jnu_e(nu, s, &mut result) };
 
     (ret, ::types::Result{val: result.val, err: result.err})
-}
+}

src/ffi.rs

@@ -214,8 +214,8 @@ extern "C" {
     // Irregular Modified Bessel Functions—Fractional Order
     pub fn gsl_sf_bessel_Knu(nu: c_double, x: c_double) -> c_double;
     pub fn gsl_sf_bessel_Knu_e(nu: c_double, x: c_double, result: *mut gsl_sf_result) -> enums::value::Value;
-    pub fn gsl_sf_bessel_InKnu(nu: c_double, x: c_double) -> c_double;
-    pub fn gsl_sf_bessel_InKnu_e(nu: c_double, x: c_double, result: *mut gsl_sf_result) -> enums::value::Value;
+    pub fn gsl_sf_bessel_lnKnu(nu: c_double, x: c_double) -> c_double;
+    pub fn gsl_sf_bessel_lnKnu_e(nu: c_double, x: c_double, result: *mut gsl_sf_result) -> enums::value::Value;
     pub fn gsl_sf_bessel_Knu_scaled(nu: c_double, x: c_double) -> c_double;
     pub fn gsl_sf_bessel_Knu_scaled_e(nu: c_double, x: c_double, result: *mut gsl_sf_result) -> enums::value::Value;
     // Irregular Cylindrical Bessel Functions
@@ -1979,10 +1979,10 @@ extern "C" {
     pub fn gsl_fft_complex_radix2_transform(data: gsl_complex_packed_array, stride: size_t, n: size_t, sign: ::FftDirection) -> enums::value::Value;
     pub fn gsl_fft_complex_radix2_backward(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
     pub fn gsl_fft_complex_radix2_inverse(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
-    pub fn gsl_fft_complex_radix2_diff_forward(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
-    pub fn gsl_fft_complex_radix2_diff_transform(data: gsl_complex_packed_array, stride: size_t, n: size_t, sign: ::FftDirection) -> enums::value::Value;
-    pub fn gsl_fft_complex_radix2_diff_backward(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
-    pub fn gsl_fft_complex_radix2_diff_inverse(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
+    pub fn gsl_fft_complex_radix2_dif_forward(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
+    pub fn gsl_fft_complex_radix2_dif_transform(data: gsl_complex_packed_array, stride: size_t, n: size_t, sign: ::FftDirection) -> enums::value::Value;
+    pub fn gsl_fft_complex_radix2_dif_backward(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
+    pub fn gsl_fft_complex_radix2_dif_inverse(data: gsl_complex_packed_array, stride: size_t, n: size_t) -> enums::value::Value;
     // Mixed-radix FFT routines for complex data
     pub fn gsl_fft_complex_wavetable_alloc(n: size_t) -> *mut gsl_fft_complex_wavetable;
     pub fn gsl_fft_complex_wavetable_free(w: *mut gsl_fft_complex_wavetable);
@@ -3328,4 +3328,4 @@ pub struct gsl_wavelet_type {
     pub name: *const c_char,
     pub init: Option<extern "C" fn(h1: *const *const c_double, g1: *const *const c_double, h2: *const *const c_double,
         g2: *const *const c_double, nc: *mut size_t, offset: *mut size_t, member: size_t) -> enums::value::Value>
-}
+}

src/fft.rs

@@ -186,22 +186,22 @@ pub mod radix2 {
 
     /// This is decimation-in-frequency version of the radix-2 FFT function.
     pub fn diff_forward(data: &mut[f64], stride: u64, n: u64) -> enums::value::Value {
-        unsafe { ffi::gsl_fft_complex_radix2_diff_forward(data.as_mut_ptr(), stride, n) }
+        unsafe { ffi::gsl_fft_complex_radix2_dif_forward(data.as_mut_ptr(), stride, n) }
     }
 
     /// This is decimation-in-frequency version of the radix-2 FFT function.
     pub fn diff_transform(data: &mut[f64], stride: u64, n: u64, sign: ::FftDirection) -> enums::value::Value {
-        unsafe { ffi::gsl_fft_complex_radix2_diff_transform(data.as_mut_ptr(), stride, n, sign) }
+        unsafe { ffi::gsl_fft_complex_radix2_dif_transform(data.as_mut_ptr(), stride, n, sign) }
     }
 
     /// This is decimation-in-frequency version of the radix-2 FFT function.
     pub fn diff_backward(data: &mut[f64], stride: u64, n: u64) -> enums::value::Value {
-        unsafe { ffi::gsl_fft_complex_radix2_diff_backward(data.as_mut_ptr(), stride, n) }
+        unsafe { ffi::gsl_fft_complex_radix2_dif_backward(data.as_mut_ptr(), stride, n) }
     }
 
     /// This is decimation-in-frequency version of the radix-2 FFT function.
     pub fn diff_inverse(data: &mut[f64], stride: u64, n: u64) -> enums::value::Value {
-        unsafe { ffi::gsl_fft_complex_radix2_diff_inverse(data.as_mut_ptr(), stride, n) }
+        unsafe { ffi::gsl_fft_complex_radix2_dif_inverse(data.as_mut_ptr(), stride, n) }
     }
 }
 
@@ -329,4 +329,4 @@ pub mod real_radix2 {
         unsafe { ffi::gsl_fft_halfcomplex_radix2_unpack(halfcomplex_coefficient.as_mut_ptr(), complex_coefficient.as_mut_ptr(),
             stride, n) }
     }
-}
+}