GSL 7.0.0

A rust binding for the GSL (the GNU scientific library)
Documentation 
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
126
127
128
129
130
131
132
133
134
135

//
// 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 crate::{types, Value};
    use std::mem::MaybeUninit;

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    #[doc(alias = "gsl_sf_zeta_int")]
    pub fn zeta_int(n: i32) -> f64 {
        unsafe { sys::gsl_sf_zeta_int(n) }
    }

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    #[doc(alias = "gsl_sf_zeta_int_e")]
    pub fn zeta_int_e(n: i32) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_zeta_int_e(n, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }

    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
    #[doc(alias = "gsl_sf_zeta")]
    pub fn zeta(x: f64) -> f64 {
        unsafe { sys::gsl_sf_zeta(x) }
    }

    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
    #[doc(alias = "gsl_sf_zeta_e")]
    pub fn zeta_e(x: f64) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_zeta_e(x, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }
}

/// 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 crate::{types, Value};
    use std::mem::MaybeUninit;

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    #[doc(alias = "gsl_sf_zetam1_int")]
    pub fn zetam1_int(n: i32) -> f64 {
        unsafe { sys::gsl_sf_zetam1_int(n) }
    }

    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
    #[doc(alias = "gsl_sf_zetam1_int_e")]
    pub fn zetam1_int_e(n: i32) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_zetam1_int_e(n, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }

    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
    #[doc(alias = "gsl_sf_zetam1")]
    pub fn zetam1(x: f64) -> f64 {
        unsafe { sys::gsl_sf_zetam1(x) }
    }

    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
    #[doc(alias = "gsl_sf_zetam1_e")]
    pub fn zetam1_e(x: f64) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_zetam1_e(x, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }
}

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

    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
    #[doc(alias = "gsl_sf_hzeta")]
    pub fn hzeta(s: f64, q: f64) -> f64 {
        unsafe { sys::gsl_sf_hzeta(s, q) }
    }

    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
    #[doc(alias = "gsl_sf_hzeta_e")]
    pub fn hzeta_e(s: f64, q: f64) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_hzeta_e(s, q, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }
}

/// The eta function is defined by \eta(s) = (1-2^{1-s}) \zeta(s).
pub mod eta {
    use crate::{types, Value};
    use std::mem::MaybeUninit;

    /// This routine computes the eta function \eta(n) for integer n.
    #[doc(alias = "gsl_sf_eta_int")]
    pub fn eta_int(n: i32) -> f64 {
        unsafe { sys::gsl_sf_eta_int(n) }
    }

    /// This routine computes the eta function \eta(n) for integer n.
    #[doc(alias = "gsl_sf_eta_int_e")]
    pub fn eta_int_e(n: i32) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_eta_int_e(n, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }

    /// This routine computes the eta function \eta(s) for arbitrary s.
    #[doc(alias = "gsl_sf_eta")]
    pub fn eta(s: f64) -> f64 {
        unsafe { sys::gsl_sf_eta(s) }
    }

    /// This routine computes the eta function \eta(s) for arbitrary s.
    #[doc(alias = "gsl_sf_eta_e")]
    pub fn eta_e(s: f64) -> Result<types::Result, Value> {
        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
        let ret = unsafe { sys::gsl_sf_eta_e(s, result.as_mut_ptr()) };

        result_handler!(ret, unsafe { result.assume_init() }.into())
    }
}