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

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

use crate::Value;
use ffi::FFI;

ffi_wrapper!(
    RStatQuantileWorkspace,
    *mut sys::gsl_rstat_quantile_workspace,
    gsl_rstat_quantile_free
);

impl RStatQuantileWorkspace {
    #[doc(alias = "gsl_rstat_quantile_alloc")]
    pub fn new(p: f64) -> Option<Self> {
        let s = unsafe { sys::gsl_rstat_quantile_alloc(p) };
        if s.is_null() {
            None
        } else {
            Some(Self::wrap(s))
        }
    }

    #[cfg(feature = "v2_2")]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_2")))]
    #[doc(alias = "gsl_rstat_quantile_reset")]
    pub fn reset(&mut self) -> Value {
        Value::from(unsafe { sys::gsl_rstat_quantile_reset(self.unwrap_unique()) })
    }

    #[doc(alias = "gsl_rstat_quantile_add")]
    pub fn add(&mut self, x: f64) -> Value {
        Value::from(unsafe { sys::gsl_rstat_quantile_add(x, self.unwrap_unique()) })
    }

    #[doc(alias = "gsl_rstat_quantile_get")]
    pub fn get(&mut self) -> f64 {
        unsafe { sys::gsl_rstat_quantile_get(self.unwrap_unique()) }
    }
}

ffi_wrapper!(
    RStatWorkspace,
    *mut sys::gsl_rstat_workspace,
    gsl_rstat_free
);

impl RStatWorkspace {
    #[doc(alias = "gsl_rstat_alloc")]
    pub fn new() -> Option<Self> {
        let s = unsafe { sys::gsl_rstat_alloc() };
        if s.is_null() {
            None
        } else {
            Some(Self::wrap(s))
        }
    }

    #[doc(alias = "gsl_rstat_n")]
    pub fn n(&self) -> usize {
        unsafe { sys::gsl_rstat_n(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_add")]
    pub fn add(&mut self, x: f64) -> Value {
        Value::from(unsafe { sys::gsl_rstat_add(x, self.unwrap_unique()) })
    }

    #[doc(alias = "gsl_rstat_min")]
    pub fn min(&self) -> f64 {
        unsafe { sys::gsl_rstat_min(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_max")]
    pub fn max(&self) -> f64 {
        unsafe { sys::gsl_rstat_max(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_mean")]
    pub fn mean(&self) -> f64 {
        unsafe { sys::gsl_rstat_mean(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_variance")]
    pub fn variance(&self) -> f64 {
        unsafe { sys::gsl_rstat_variance(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_sd")]
    pub fn sd(&self) -> f64 {
        unsafe { sys::gsl_rstat_sd(self.unwrap_shared()) }
    }

    #[cfg(feature = "v2_2")]
    #[cfg_attr(feature = "dox", doc(cfg(feature = "v2_2")))]
    #[doc(alias = "gsl_rstat_rms")]
    pub fn rms(&self) -> f64 {
        unsafe { sys::gsl_rstat_rms(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_sd_mean")]
    pub fn sd_mean(&self) -> f64 {
        unsafe { sys::gsl_rstat_sd_mean(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_median")]
    pub fn median(&mut self) -> f64 {
        unsafe { sys::gsl_rstat_median(self.unwrap_unique()) }
    }

    #[doc(alias = "gsl_rstat_skew")]
    pub fn skew(&self) -> f64 {
        unsafe { sys::gsl_rstat_skew(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_kurtosis")]
    pub fn kurtosis(&self) -> f64 {
        unsafe { sys::gsl_rstat_kurtosis(self.unwrap_shared()) }
    }

    #[doc(alias = "gsl_rstat_reset")]
    pub fn reset(&mut self) -> Value {
        Value::from(unsafe { sys::gsl_rstat_reset(self.unwrap_unique()) })
    }
}