1
  2
  3
  4
  5
  6
  7
  8
  9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125

//
// A rust binding for the GSL library by Guillaume Gomez (guillaume1.gomez@gmail.com)
//

//! The Riemann zeta function is defined in Abramowitz & Stegun, Section 23.2.

/// The Riemann zeta function is defined by the infinite sum \zeta(s) = \sum_{k=1}^\infty k^{-s}.
pub mod riemann {
    use ffi;
    use std::mem::zeroed;
    use enums;

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    pub fn zeta_int(n: i32) -> f64 {
        unsafe { ffi::gsl_sf_zeta_int(n) }
    }

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    pub fn zeta_int_e(n: i32) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_zeta_int_e(n, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }

    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
    pub fn zeta(x: f64) -> f64 {
        unsafe { ffi::gsl_sf_zeta(x) }
    }

    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
    pub fn zeta_e(x: f64) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_zeta_e(x, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }
}

/// For large positive argument, the Riemann zeta function approaches one.
/// In this region the fractional part is interesting, and therefore we need a function to evaluate it explicitly.
pub mod riemann_mins_one {
    use ffi;
    use std::mem::zeroed;
    use enums;

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    pub fn zetam1_int(n: i32) -> f64 {
        unsafe { ffi::gsl_sf_zetam1_int(n) }
    }

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    pub fn zetam1_int_e(n: i32) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_zetam1_int_e(n, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }

    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
    pub fn zetam1(x: f64) -> f64 {
        unsafe { ffi::gsl_sf_zetam1(x) }
    }

    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
    pub fn zetam1_e(x: f64) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_zetam1_e(x, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }
}

/// The Hurwitz zeta function is defined by \zeta(s,q) = \sum_0^\infty (k+q)^{-s}.
pub mod hurwitz {
    use ffi;
    use std::mem::zeroed;
    use enums;

    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
    pub fn hzeta(s: f64, q: f64) -> f64 {
        unsafe { ffi::gsl_sf_hzeta(s, q) }
    }

    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
    pub fn hzeta_e(s: f64, q: f64) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_hzeta_e(s, q, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }
}

/// The eta function is defined by \eta(s) = (1-2^{1-s}) \zeta(s).
pub mod eta {
    use ffi;
    use std::mem::zeroed;
    use enums;

    /// This routine computes the eta function \eta(n) for integer n.
    pub fn eta_int(n: i32) -> f64 {
        unsafe { ffi::gsl_sf_eta_int(n) }
    }

    /// This routine computes the eta function \eta(n) for integer n.
    pub fn eta_int_e(n: i32) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_eta_int_e(n, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }

    /// This routine computes the eta function \eta(s) for arbitrary s.
    pub fn eta(s: f64) -> f64 {
        unsafe { ffi::gsl_sf_eta(s) }
    }

    /// This routine computes the eta function \eta(s) for arbitrary s.
    pub fn eta_e(s: f64) -> (enums::Value, ::types::Result) {
        let mut result = unsafe { zeroed::<ffi::gsl_sf_result>() };
        let ret = unsafe { ffi::gsl_sf_eta_e(s, &mut result) };

        (ret, ::types::Result{val: result.val, err: result.err})
    }
}