rgsl/
zeta.rs

1//
2// A rust binding for the GSL library by Guillaume Gomez (guillaume1.gomez@gmail.com)
3//
4
5//! The Riemann zeta function is defined in Abramowitz & Stegun, Section 23.2.
6
7/// The Riemann zeta function is defined by the infinite sum \zeta(s) = \sum_{k=1}^\infty k^{-s}.
8pub mod riemann {
9    use crate::{types, Value};
10    use std::mem::MaybeUninit;
11
12    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
13    #[doc(alias = "gsl_sf_zeta_int")]
14    pub fn zeta_int(n: i32) -> f64 {
15        unsafe { sys::gsl_sf_zeta_int(n) }
16    }
17
18    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
19    #[doc(alias = "gsl_sf_zeta_int_e")]
20    pub fn zeta_int_e(n: i32) -> Result<types::Result, Value> {
21        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
22        let ret = unsafe { sys::gsl_sf_zeta_int_e(n, result.as_mut_ptr()) };
23
24        result_handler!(ret, unsafe { result.assume_init() }.into())
25    }
26
27    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
28    #[doc(alias = "gsl_sf_zeta")]
29    pub fn zeta(x: f64) -> f64 {
30        unsafe { sys::gsl_sf_zeta(x) }
31    }
32
33    /// This routine computes the Riemann zeta function \zeta(s) for arbitrary s, s \ne 1.
34    #[doc(alias = "gsl_sf_zeta_e")]
35    pub fn zeta_e(x: f64) -> Result<types::Result, Value> {
36        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
37        let ret = unsafe { sys::gsl_sf_zeta_e(x, result.as_mut_ptr()) };
38
39        result_handler!(ret, unsafe { result.assume_init() }.into())
40    }
41}
42
43/// For large positive argument, the Riemann zeta function approaches one.
44/// In this region the fractional part is interesting, and therefore we need a function to evaluate it explicitly.
45pub mod riemann_mins_one {
46    use crate::{types, Value};
47    use std::mem::MaybeUninit;
48
49    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
50    #[doc(alias = "gsl_sf_zetam1_int")]
51    pub fn zetam1_int(n: i32) -> f64 {
52        unsafe { sys::gsl_sf_zetam1_int(n) }
53    }
54
55    /// This routine computes the Riemann zeta function \zeta(n) for integer n, n \ne 1.
56    #[doc(alias = "gsl_sf_zetam1_int_e")]
57    pub fn zetam1_int_e(n: i32) -> Result<types::Result, Value> {
58        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
59        let ret = unsafe { sys::gsl_sf_zetam1_int_e(n, result.as_mut_ptr()) };
60
61        result_handler!(ret, unsafe { result.assume_init() }.into())
62    }
63
64    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
65    #[doc(alias = "gsl_sf_zetam1")]
66    pub fn zetam1(x: f64) -> f64 {
67        unsafe { sys::gsl_sf_zetam1(x) }
68    }
69
70    /// This routine computes \zeta(s) - 1 for arbitrary s, s \ne 1.
71    #[doc(alias = "gsl_sf_zetam1_e")]
72    pub fn zetam1_e(x: f64) -> Result<types::Result, Value> {
73        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
74        let ret = unsafe { sys::gsl_sf_zetam1_e(x, result.as_mut_ptr()) };
75
76        result_handler!(ret, unsafe { result.assume_init() }.into())
77    }
78}
79
80/// The Hurwitz zeta function is defined by \zeta(s,q) = \sum_0^\infty (k+q)^{-s}.
81pub mod hurwitz {
82    use crate::{types, Value};
83    use std::mem::MaybeUninit;
84
85    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
86    #[doc(alias = "gsl_sf_hzeta")]
87    pub fn hzeta(s: f64, q: f64) -> f64 {
88        unsafe { sys::gsl_sf_hzeta(s, q) }
89    }
90
91    /// This routine computes the Hurwitz zeta function \zeta(s,q) for s > 1, q > 0.
92    #[doc(alias = "gsl_sf_hzeta_e")]
93    pub fn hzeta_e(s: f64, q: f64) -> Result<types::Result, Value> {
94        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
95        let ret = unsafe { sys::gsl_sf_hzeta_e(s, q, result.as_mut_ptr()) };
96
97        result_handler!(ret, unsafe { result.assume_init() }.into())
98    }
99}
100
101/// The eta function is defined by \eta(s) = (1-2^{1-s}) \zeta(s).
102pub mod eta {
103    use crate::{types, Value};
104    use std::mem::MaybeUninit;
105
106    /// This routine computes the eta function \eta(n) for integer n.
107    #[doc(alias = "gsl_sf_eta_int")]
108    pub fn eta_int(n: i32) -> f64 {
109        unsafe { sys::gsl_sf_eta_int(n) }
110    }
111
112    /// This routine computes the eta function \eta(n) for integer n.
113    #[doc(alias = "gsl_sf_eta_int_e")]
114    pub fn eta_int_e(n: i32) -> Result<types::Result, Value> {
115        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
116        let ret = unsafe { sys::gsl_sf_eta_int_e(n, result.as_mut_ptr()) };
117
118        result_handler!(ret, unsafe { result.assume_init() }.into())
119    }
120
121    /// This routine computes the eta function \eta(s) for arbitrary s.
122    #[doc(alias = "gsl_sf_eta")]
123    pub fn eta(s: f64) -> f64 {
124        unsafe { sys::gsl_sf_eta(s) }
125    }
126
127    /// This routine computes the eta function \eta(s) for arbitrary s.
128    #[doc(alias = "gsl_sf_eta_e")]
129    pub fn eta_e(s: f64) -> Result<types::Result, Value> {
130        let mut result = MaybeUninit::<sys::gsl_sf_result>::uninit();
131        let ret = unsafe { sys::gsl_sf_eta_e(s, result.as_mut_ptr()) };
132
133        result_handler!(ret, unsafe { result.assume_init() }.into())
134    }
135}
rgsl/zeta.rs

rgsl/
zeta.rs
