;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; LUSH Lisp Universal Shell
;;;   Copyright (C) 2002 Leon Bottou, Yann Le Cun, AT&T Corp, NECI.
;;; Includes parts of TL3:
;;;   Copyright (C) 1987-1999 Leon Bottou and Neuristique.
;;; Includes selected parts of SN3.2:
;;;   Copyright (C) 1991-2001 AT&T Corp.
;;;
;;; Includes information derived from the GSL (Gnu Scientific Library)
;;;   header files which are copyrighted and distributed under the GPL
;;;   by their respective authors.
;;;
;;; This program is free software; you can redistribute it and/or modify
;;; it under the terms of the GNU General Public License as published by
;;; the Free Software Foundation; either version 2 of the License, or
;;; (at your option) any later version.
;;;
;;; This program is distributed in the hope that it will be useful,
;;; but WITHOUT ANY WARRANTY; without even the implied warranty of
;;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
;;; GNU General Public License for more details.
;;;
;;; You should have received a copy of the GNU General Public License
;;; along with this program; if not, write to the Free Software
;;; Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111, USA
;;;
;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;

(libload "gsl/gsl-config")



#? *** statistics

;; dummy function that adds GSL C header files in C file
(eval `(de dummy_statistics () ,gsl-cpheader-cmd ()))

#? * (dummy_statistics)
#? * (gsl_stats_char_mean <data> <stride> <n>)
#? * (gsl_stats_char_variance <data> <stride> <n>)
#? * (gsl_stats_char_sd <data> <stride> <n>)
#? * (gsl_stats_char_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_char_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_char_absdev <data> <stride> <n>)
#? * (gsl_stats_char_skew <data> <stride> <n>)
#? * (gsl_stats_char_kurtosis <data> <stride> <n>)
#? * (gsl_stats_char_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_char_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_char_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_char_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_char_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_char_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_char_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_char_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_char_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_char_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_char_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_char_max <data> <stride> <n>)
#? * (gsl_stats_char_min <data> <stride> <n>)
#? * (gsl_stats_char_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_char_max_index <data> <stride> <n>)
#? * (gsl_stats_char_min_index <data> <stride> <n>)
#? * (gsl_stats_char_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_char_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_char_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_mean <data> <stride> <n>)
#? * (gsl_stats_variance <data> <stride> <n>)
#? * (gsl_stats_sd <data> <stride> <n>)
#? * (gsl_stats_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_absdev <data> <stride> <n>)
#? * (gsl_stats_skew <data> <stride> <n>)
#? * (gsl_stats_kurtosis <data> <stride> <n>)
#? * (gsl_stats_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_wmean <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wvariance <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wsd <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wvariance_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_wsd_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_wabsdev <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wskew <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wkurtosis <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_wvariance_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_wsd_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_wabsdev_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_wskew_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_wkurtosis_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_max <data> <stride> <n>)
#? * (gsl_stats_min <data> <stride> <n>)
#? * (gsl_stats_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_max_index <data> <stride> <n>)
#? * (gsl_stats_min_index <data> <stride> <n>)
#? * (gsl_stats_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_float_mean <data> <stride> <n>)
#? * (gsl_stats_float_variance <data> <stride> <n>)
#? * (gsl_stats_float_sd <data> <stride> <n>)
#? * (gsl_stats_float_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_float_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_float_absdev <data> <stride> <n>)
#? * (gsl_stats_float_skew <data> <stride> <n>)
#? * (gsl_stats_float_kurtosis <data> <stride> <n>)
#? * (gsl_stats_float_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_float_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_float_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_float_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_float_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_float_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_float_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_float_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_float_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_float_wmean <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wvariance <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wsd <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wvariance_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_float_wsd_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_float_wabsdev <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wskew <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wkurtosis <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_float_wvariance_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_float_wsd_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_float_wabsdev_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_float_wskew_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_float_wkurtosis_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_float_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_float_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_float_max <data> <stride> <n>)
#? * (gsl_stats_float_min <data> <stride> <n>)
#? * (gsl_stats_float_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_float_max_index <data> <stride> <n>)
#? * (gsl_stats_float_min_index <data> <stride> <n>)
#? * (gsl_stats_float_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_float_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_float_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_int_mean <data> <stride> <n>)
#? * (gsl_stats_int_variance <data> <stride> <n>)
#? * (gsl_stats_int_sd <data> <stride> <n>)
#? * (gsl_stats_int_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_int_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_int_absdev <data> <stride> <n>)
#? * (gsl_stats_int_skew <data> <stride> <n>)
#? * (gsl_stats_int_kurtosis <data> <stride> <n>)
#? * (gsl_stats_int_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_int_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_int_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_int_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_int_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_int_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_int_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_int_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_int_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_int_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_int_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_int_max <data> <stride> <n>)
#? * (gsl_stats_int_min <data> <stride> <n>)
#? * (gsl_stats_int_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_int_max_index <data> <stride> <n>)
#? * (gsl_stats_int_min_index <data> <stride> <n>)
#? * (gsl_stats_int_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_int_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_int_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_long_double_mean <data> <stride> <n>)
#? * (gsl_stats_long_double_variance <data> <stride> <n>)
#? * (gsl_stats_long_double_sd <data> <stride> <n>)
#? * (gsl_stats_long_double_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_absdev <data> <stride> <n>)
#? * (gsl_stats_long_double_skew <data> <stride> <n>)
#? * (gsl_stats_long_double_kurtosis <data> <stride> <n>)
#? * (gsl_stats_long_double_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_long_double_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_long_double_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_long_double_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_long_double_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_long_double_wmean <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wvariance <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wsd <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wvariance_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_wsd_with_fixed_mean <w> <wstride> <data> <stride> <n> <mean>)
#? * (gsl_stats_long_double_wabsdev <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wskew <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wkurtosis <w> <wstride> <data> <stride> <n>)
#? * (gsl_stats_long_double_wvariance_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_long_double_wsd_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_long_double_wabsdev_m <w> <wstride> <data> <stride> <n> <wmean>)
#? * (gsl_stats_long_double_wskew_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_long_double_wkurtosis_m_sd <w> <wstride> <data> <stride> <n> <wmean> <wsd>)
#? * (gsl_stats_long_double_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_long_double_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_long_double_max <data> <stride> <n>)
#? * (gsl_stats_long_double_min <data> <stride> <n>)
#? * (gsl_stats_long_double_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_long_double_max_index <data> <stride> <n>)
#? * (gsl_stats_long_double_min_index <data> <stride> <n>)
#? * (gsl_stats_long_double_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_long_double_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_long_double_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_long_mean <data> <stride> <n>)
#? * (gsl_stats_long_variance <data> <stride> <n>)
#? * (gsl_stats_long_sd <data> <stride> <n>)
#? * (gsl_stats_long_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_long_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_long_absdev <data> <stride> <n>)
#? * (gsl_stats_long_skew <data> <stride> <n>)
#? * (gsl_stats_long_kurtosis <data> <stride> <n>)
#? * (gsl_stats_long_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_long_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_long_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_long_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_long_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_long_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_long_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_long_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_long_max <data> <stride> <n>)
#? * (gsl_stats_long_min <data> <stride> <n>)
#? * (gsl_stats_long_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_long_max_index <data> <stride> <n>)
#? * (gsl_stats_long_min_index <data> <stride> <n>)
#? * (gsl_stats_long_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_long_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_long_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_short_mean <data> <stride> <n>)
#? * (gsl_stats_short_variance <data> <stride> <n>)
#? * (gsl_stats_short_sd <data> <stride> <n>)
#? * (gsl_stats_short_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_short_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_short_absdev <data> <stride> <n>)
#? * (gsl_stats_short_skew <data> <stride> <n>)
#? * (gsl_stats_short_kurtosis <data> <stride> <n>)
#? * (gsl_stats_short_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_short_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_short_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_short_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_short_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_short_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_short_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_short_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_short_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_short_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_short_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_short_max <data> <stride> <n>)
#? * (gsl_stats_short_min <data> <stride> <n>)
#? * (gsl_stats_short_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_short_max_index <data> <stride> <n>)
#? * (gsl_stats_short_min_index <data> <stride> <n>)
#? * (gsl_stats_short_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_short_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_short_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_uchar_mean <data> <stride> <n>)
#? * (gsl_stats_uchar_variance <data> <stride> <n>)
#? * (gsl_stats_uchar_sd <data> <stride> <n>)
#? * (gsl_stats_uchar_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_absdev <data> <stride> <n>)
#? * (gsl_stats_uchar_skew <data> <stride> <n>)
#? * (gsl_stats_uchar_kurtosis <data> <stride> <n>)
#? * (gsl_stats_uchar_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_uchar_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_uchar_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_uchar_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_uchar_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uchar_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_uchar_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_uchar_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_uchar_max <data> <stride> <n>)
#? * (gsl_stats_uchar_min <data> <stride> <n>)
#? * (gsl_stats_uchar_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_uchar_max_index <data> <stride> <n>)
#? * (gsl_stats_uchar_min_index <data> <stride> <n>)
#? * (gsl_stats_uchar_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_uchar_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_uchar_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_uint_mean <data> <stride> <n>)
#? * (gsl_stats_uint_variance <data> <stride> <n>)
#? * (gsl_stats_uint_sd <data> <stride> <n>)
#? * (gsl_stats_uint_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_absdev <data> <stride> <n>)
#? * (gsl_stats_uint_skew <data> <stride> <n>)
#? * (gsl_stats_uint_kurtosis <data> <stride> <n>)
#? * (gsl_stats_uint_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_uint_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_uint_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_uint_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_uint_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_uint_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_uint_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_uint_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_uint_max <data> <stride> <n>)
#? * (gsl_stats_uint_min <data> <stride> <n>)
#? * (gsl_stats_uint_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_uint_max_index <data> <stride> <n>)
#? * (gsl_stats_uint_min_index <data> <stride> <n>)
#? * (gsl_stats_uint_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_uint_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_uint_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_ulong_mean <data> <stride> <n>)
#? * (gsl_stats_ulong_variance <data> <stride> <n>)
#? * (gsl_stats_ulong_sd <data> <stride> <n>)
#? * (gsl_stats_ulong_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_absdev <data> <stride> <n>)
#? * (gsl_stats_ulong_skew <data> <stride> <n>)
#? * (gsl_stats_ulong_kurtosis <data> <stride> <n>)
#? * (gsl_stats_ulong_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_ulong_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_ulong_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_ulong_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_ulong_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ulong_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_ulong_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_ulong_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_ulong_max <data> <stride> <n>)
#? * (gsl_stats_ulong_min <data> <stride> <n>)
#? * (gsl_stats_ulong_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_ulong_max_index <data> <stride> <n>)
#? * (gsl_stats_ulong_min_index <data> <stride> <n>)
#? * (gsl_stats_ulong_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_ulong_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_ulong_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)
#? * (gsl_stats_ushort_mean <data> <stride> <n>)
#? * (gsl_stats_ushort_variance <data> <stride> <n>)
#? * (gsl_stats_ushort_sd <data> <stride> <n>)
#? * (gsl_stats_ushort_variance_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_sd_with_fixed_mean <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_absdev <data> <stride> <n>)
#? * (gsl_stats_ushort_skew <data> <stride> <n>)
#? * (gsl_stats_ushort_kurtosis <data> <stride> <n>)
#? * (gsl_stats_ushort_lag1_autocorrelation <data> <stride> <n>)
#? * (gsl_stats_ushort_covariance <data1> <stride1> <data2> <stride2> <n>)
#? * (gsl_stats_ushort_variance_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_sd_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_absdev_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_skew_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_ushort_kurtosis_m_sd <data> <stride> <n> <mean> <sd>)
#? * (gsl_stats_ushort_lag1_autocorrelation_m <data> <stride> <n> <mean>)
#? * (gsl_stats_ushort_covariance_m <data1> <stride1> <data2> <stride2> <n> <mean1> <mean2>)
#? * (gsl_stats_ushort_pvariance <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_ushort_ttest <data1> <stride1> <n1> <data2> <stride2> <n2>)
#? * (gsl_stats_ushort_max <data> <stride> <n>)
#? * (gsl_stats_ushort_min <data> <stride> <n>)
#? * (gsl_stats_ushort_minmax <min> <max> <data> <stride> <n>)
#? * (gsl_stats_ushort_max_index <data> <stride> <n>)
#? * (gsl_stats_ushort_min_index <data> <stride> <n>)
#? * (gsl_stats_ushort_minmax_index <min_index> <max_index> <data> <stride> <n>)
#? * (gsl_stats_ushort_median_from_sorted_data <sorted_data> <stride> <n>)
#? * (gsl_stats_ushort_quantile_from_sorted_data <sorted_data> <stride> <n> <f>)

;; ********************************************************







(de gsl_stats_char_mean (  data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_variance (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_sd (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_char_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_char_absdev (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_skew (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_kurtosis (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_char_lag1_autocorrelation (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_char_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_char_variance_m (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_char_sd_m (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_char_absdev_m (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_char_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_char_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_char_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_char_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_char_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_char_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_char_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_char_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_char_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_char_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_char_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_char_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_char_max (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_char_max (  $data ,$stride ,$n ) #} )            ;; char -> int
)

(de gsl_stats_char_min (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_char_min (  $data ,$stride ,$n ) #} )             ;; char -> int
)

(de gsl_stats_char_minmax (   min max data stride n )
    ((-gptr- "char *") min)
    ((-gptr- "char *") max)
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_char_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_char_max_index (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_char_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_char_min_index (   data stride n )
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_char_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_char_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_char_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_char_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const char *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_char_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_char_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const char *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_char_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_mean (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_variance (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_sd (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_absdev (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_skew (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_kurtosis (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_lag1_autocorrelation (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_variance_m (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_sd_m (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_absdev_m (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)




(de gsl_stats_wmean (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wmean (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_wvariance (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wvariance (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_wsd (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wsd (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_wvariance_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_wvariance_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_wsd_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_wsd_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_wabsdev (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wabsdev (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_wskew (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wskew (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_wkurtosis (   w wstride data stride n )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_wkurtosis (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)


(de gsl_stats_wvariance_m (   w wstride data stride n wmean )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_wvariance_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_wsd_m (   w wstride data stride n wmean )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_wsd_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_wabsdev_m (   w wstride data stride n wmean )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_wabsdev_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_wskew_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_wskew_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)

(de gsl_stats_wkurtosis_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_wkurtosis_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)




(de gsl_stats_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_max (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_max (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_min (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_min (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_minmax (   min max data stride n )
    ((-gptr- "double *") min)
    ((-gptr- "double *") max)
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_max_index (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_min_index (   data stride n )
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const double *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const double *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_float_mean (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_variance (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_sd (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_absdev (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_skew (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_kurtosis (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_lag1_autocorrelation (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_float_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const float *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const float *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_float_variance_m (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_sd_m (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_absdev_m (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_float_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_float_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_float_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_float_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_float_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const float *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const float *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_float_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)




(de gsl_stats_float_wmean (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wmean (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_float_wvariance (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wvariance (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_float_wsd (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wsd (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_float_wvariance_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_wvariance_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_wsd_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_float_wsd_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_float_wabsdev (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wabsdev (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_float_wskew (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wskew (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_float_wkurtosis (   w wstride data stride n )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_wkurtosis (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)


(de gsl_stats_float_wvariance_m (   w wstride data stride n wmean )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_float_wvariance_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_float_wsd_m (   w wstride data stride n wmean )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_float_wsd_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_float_wabsdev_m (   w wstride data stride n wmean )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_float_wabsdev_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_float_wskew_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_float_wskew_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)

(de gsl_stats_float_wkurtosis_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const float *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_float_wkurtosis_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)




(de gsl_stats_float_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const float *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const float *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_float_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_float_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const float *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const float *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_float_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_float_max (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (float #{  gsl_stats_float_max (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_min (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (float #{  gsl_stats_float_min (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_float_minmax (   min max data stride n )
    ((-gptr- "float *") min)
    ((-gptr- "float *") max)
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_float_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_float_max_index (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_float_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_float_min_index (   data stride n )
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_float_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_float_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const float *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_float_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_float_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const float *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_float_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_float_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const float *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_float_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_int_mean (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_variance (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_sd (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_int_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_int_absdev (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_skew (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_kurtosis (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_lag1_autocorrelation (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_int_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_int_variance_m (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_int_sd_m (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_int_absdev_m (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_int_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_int_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_int_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_int_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_int_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_int_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_int_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_int_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_int_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_int_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_int_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_int_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_int_max (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_int_max (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_min (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_int_min (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_int_minmax (   min max data stride n )
    ((-gptr- "int *") min)
    ((-gptr- "int *") max)
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_int_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_int_max_index (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_int_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_int_min_index (   data stride n )
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_int_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_int_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_int_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_int_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const int *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_int_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_int_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const int *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_int_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_long_double_mean (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_variance (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_sd (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_absdev (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_skew (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_kurtosis (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_lag1_autocorrelation (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_long_double_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const long double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const long double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_long_double_variance_m (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_sd_m (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_absdev_m (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_long_double_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_long_double_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_long_double_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_long_double_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_long_double_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const long double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const long double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_long_double_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)




(de gsl_stats_long_double_wmean (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wmean (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_wvariance (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wvariance (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_wsd (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wsd (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_wvariance_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_wvariance_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_wsd_with_fixed_mean (   w wstride data stride n mean )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_double_wsd_with_fixed_mean (  $w ,$wstride ,$data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_double_wabsdev (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wabsdev (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_wskew (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wskew (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)

(de gsl_stats_long_double_wkurtosis (   w wstride data stride n )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_wkurtosis (  $w ,$wstride ,$data ,$stride ,$n ) #} )
)


(de gsl_stats_long_double_wvariance_m (   w wstride data stride n wmean )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_long_double_wvariance_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_long_double_wsd_m (   w wstride data stride n wmean )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_long_double_wsd_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_long_double_wabsdev_m (   w wstride data stride n wmean )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean) 
    (double #{  gsl_stats_long_double_wabsdev_m (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ) #} )
)

(de gsl_stats_long_double_wskew_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_long_double_wskew_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)

(de gsl_stats_long_double_wkurtosis_m_sd (   w wstride data stride n wmean wsd )
    ((-gptr- "const long double *") w)
    ((-int-) wstride)                            ;; const size_t -> int
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) wmean)
    ((-double-) wsd) 
    (double #{  gsl_stats_long_double_wkurtosis_m_sd (  $w ,$wstride ,$data ,$stride ,$n ,$wmean ,$wsd ) #} )
)




(de gsl_stats_long_double_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const long double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const long double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_long_double_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const long double *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const long double *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_long_double_max (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_max (  $data ,$stride ,$n ) #} )       ;; long double -> double
)

(de gsl_stats_long_double_min (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_min (  $data ,$stride ,$n ) #} )          ;; long double -> double
)

(de gsl_stats_long_double_minmax (   min max data stride n )
    ((-gptr- "long double *") min)
    ((-gptr- "long double *") max)
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_long_double_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_long_double_max_index (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_double_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_long_double_min_index (   data stride n )
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_double_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_long_double_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const long double *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_long_double_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_long_double_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const long double *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_double_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_long_double_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const long double *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_long_double_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_long_mean (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_variance (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_sd (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_absdev (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_skew (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_kurtosis (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_long_lag1_autocorrelation (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_long_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_long_variance_m (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_sd_m (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_absdev_m (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_long_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_long_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_long_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_long_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_long_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_long_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_long_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_long_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_long_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_long_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_long_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_long_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_long_max (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_max (  $data ,$stride ,$n ) #} )       ;; long -> int
)

(de gsl_stats_long_min (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_min (  $data ,$stride ,$n ) #} )          ;; long -> int
)

(de gsl_stats_long_minmax (   min max data stride n )
    ((-gptr- "long *") min)
    ((-gptr- "long *") max)
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_long_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_long_max_index (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_long_min_index (   data stride n )
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_long_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_long_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_long_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_long_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const long *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_long_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_long_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const long *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_long_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_short_mean (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_variance (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_sd (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_short_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_short_absdev (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_skew (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_kurtosis (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_short_lag1_autocorrelation (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_short_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_short_variance_m (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_short_sd_m (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_short_absdev_m (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_short_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_short_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_short_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_short_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_short_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_short_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_short_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_short_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_short_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_short_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_short_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_short_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_short_max (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_short_max (  $data ,$stride ,$n ) #} )         ;; short -> int
)

(de gsl_stats_short_min (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_short_min (  $data ,$stride ,$n ) #} )         ;; short -> int
)

(de gsl_stats_short_minmax (   min max data stride n )
    ((-gptr- "short *") min)
    ((-gptr- "short *") max)
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_short_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_short_max_index (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_short_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_short_min_index (   data stride n )
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_short_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_short_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_short_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_short_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const short *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_short_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_short_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const short *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_short_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_uchar_mean (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_variance (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_sd (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uchar_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uchar_absdev (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_skew (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_kurtosis (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uchar_lag1_autocorrelation (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_uchar_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const unsigned char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_uchar_variance_m (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uchar_sd_m (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uchar_absdev_m (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uchar_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_uchar_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_uchar_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_uchar_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_uchar_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uchar_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_uchar_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const unsigned char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_uchar_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_uchar_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_uchar_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned char *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned char *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_uchar_max (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uchar_max (  $data ,$stride ,$n ) #} )    ;; unsigned char -> int
)

(de gsl_stats_uchar_min (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uchar_min (  $data ,$stride ,$n ) #} )        ;; unsigned char -> int
)

(de gsl_stats_uchar_minmax (   min max data stride n )
    ((-gptr- "unsigned char *") min)
    ((-gptr- "unsigned char *") max)
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_uchar_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_uchar_max_index (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uchar_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_uchar_min_index (   data stride n )
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uchar_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_uchar_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const unsigned char *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_uchar_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_uchar_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const unsigned char *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uchar_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_uchar_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const unsigned char *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_uchar_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_uint_mean (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_variance (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_sd (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uint_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uint_absdev (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_skew (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_kurtosis (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_uint_lag1_autocorrelation (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_uint_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const unsigned int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_uint_variance_m (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uint_sd_m (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uint_absdev_m (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_uint_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_uint_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_uint_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_uint_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_uint_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_uint_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_uint_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const unsigned int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_uint_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_uint_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_uint_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned int *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned int *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_uint_max (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uint_max (  $data ,$stride ,$n ) #} )             ;; unsigned int -> int
)

(de gsl_stats_uint_min (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uint_min (  $data ,$stride ,$n ) #} )           ;; unsigned int -> int
)

(de gsl_stats_uint_minmax (   min max data stride n )
    ((-gptr- "unsigned int *") min)
    ((-gptr- "unsigned int *") max)
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_uint_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_uint_max_index (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uint_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_uint_min_index (   data stride n )
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_uint_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_uint_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const unsigned int *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_uint_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_uint_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const unsigned int *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_uint_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_uint_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const unsigned int *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_uint_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_ulong_mean (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_variance (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_sd (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ulong_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ulong_absdev (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_skew (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_kurtosis (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ulong_lag1_autocorrelation (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_ulong_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const unsigned long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_ulong_variance_m (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ulong_sd_m (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ulong_absdev_m (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ulong_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_ulong_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_ulong_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_ulong_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_ulong_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ulong_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_ulong_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const unsigned long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_ulong_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_ulong_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_ulong_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned long *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned long *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_ulong_max (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ulong_max (  $data ,$stride ,$n ) #} )            ;; unsigned long -> int
)

(de gsl_stats_ulong_min (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ulong_min (  $data ,$stride ,$n ) #} )            ;; unsigned long -> int
)

(de gsl_stats_ulong_minmax (   min max data stride n )
    ((-gptr- "unsigned long *") min)
    ((-gptr- "unsigned long *") max)
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_ulong_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_ulong_max_index (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ulong_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_ulong_min_index (   data stride n )
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ulong_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_ulong_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const unsigned long *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_ulong_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_ulong_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const unsigned long *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ulong_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_ulong_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const unsigned long *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_ulong_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)









(de gsl_stats_ushort_mean (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_mean (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_variance (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_variance (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_sd (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_sd (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_variance_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_variance_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ushort_sd_with_fixed_mean (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_sd_with_fixed_mean (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ushort_absdev (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_absdev (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_skew (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_skew (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_kurtosis (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_kurtosis (  $data ,$stride ,$n ) #} )
)

(de gsl_stats_ushort_lag1_autocorrelation (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_lag1_autocorrelation (  $data ,$stride ,$n ) #} )
)


(de gsl_stats_ushort_covariance (   data1 stride1 data2 stride2 n )
    ((-gptr- "const unsigned short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_covariance (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ) #} )
)


(de gsl_stats_ushort_variance_m (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_variance_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ushort_sd_m (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_sd_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ushort_absdev_m (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_absdev_m (  $data ,$stride ,$n ,$mean ) #} )
)

(de gsl_stats_ushort_skew_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_ushort_skew_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_ushort_kurtosis_m_sd (   data stride n mean sd )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean)
    ((-double-) sd) 
    (double #{  gsl_stats_ushort_kurtosis_m_sd (  $data ,$stride ,$n ,$mean ,$sd ) #} )
)

(de gsl_stats_ushort_lag1_autocorrelation_m (   data stride n mean )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean) 
    (double #{  gsl_stats_ushort_lag1_autocorrelation_m (  $data ,$stride ,$n ,$mean ) #} )
)


(de gsl_stats_ushort_covariance_m (   data1 stride1 data2 stride2 n mean1 mean2 )
    ((-gptr- "const unsigned short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-gptr- "const unsigned short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) mean1)
    ((-double-) mean2) 
    (double #{  gsl_stats_ushort_covariance_m (  $data1 ,$stride1 ,$data2 ,$stride2 ,$n ,$mean1 ,$mean2 ) #} )
)



(de gsl_stats_ushort_pvariance (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_pvariance (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)

(de gsl_stats_ushort_ttest (   data1 stride1 n1 data2 stride2 n2 )
    ((-gptr- "const unsigned short *") data1)
    ((-int-) stride1)                            ;; const size_t -> int
    ((-int-) n1)                            ;; const size_t -> int
    ((-gptr- "const unsigned short *") data2)
    ((-int-) stride2)                            ;; const size_t -> int
    ((-int-) n2)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_ttest (  $data1 ,$stride1 ,$n1 ,$data2 ,$stride2 ,$n2 ) #} )
)


(de gsl_stats_ushort_max (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ushort_max (  $data ,$stride ,$n ) #} )         ;; unsigned short -> int
)

(de gsl_stats_ushort_min (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ushort_min (  $data ,$stride ,$n ) #} )         ;; unsigned short -> int
)

(de gsl_stats_ushort_minmax (   min max data stride n )
    ((-gptr- "unsigned short *") min)
    ((-gptr- "unsigned short *") max)
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_ushort_minmax (  $min ,$max ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_ushort_max_index (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ushort_max_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_ushort_min_index (   data stride n )
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (int #{  gsl_stats_ushort_min_index (  $data ,$stride ,$n ) #} )       ;; size_t -> int
)

(de gsl_stats_ushort_minmax_index (   min_index max_index data stride n )
    ((-gptr- "size_t *") min_index)
    ((-gptr- "size_t *") max_index)
    ((-gptr- "const unsigned short *") data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    #{  gsl_stats_ushort_minmax_index (  $min_index ,$max_index ,$data ,$stride ,$n ) #} 
    ()
)


(de gsl_stats_ushort_median_from_sorted_data (   sorted_data stride n )
    ((-gptr- "const unsigned short *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                             ;; const size_t -> int
    (double #{  gsl_stats_ushort_median_from_sorted_data (  $sorted_data ,$stride ,$n )  #} )
)

(de gsl_stats_ushort_quantile_from_sorted_data (   sorted_data stride n f )
    ((-gptr- "const unsigned short *") sorted_data)
    ((-int-) stride)                            ;; const size_t -> int
    ((-int-) n)                            ;; const size_t -> int
    ((-double-) f) 
    (double #{  gsl_stats_ushort_quantile_from_sorted_data (  $sorted_data ,$stride ,$n ,$f )  #} )
)




;; ********************************************************

(dhc-make ()
  dummy_statistics
  gsl_stats_char_mean
  gsl_stats_char_variance
  gsl_stats_char_sd
  gsl_stats_char_variance_with_fixed_mean
  gsl_stats_char_sd_with_fixed_mean
  gsl_stats_char_absdev
  gsl_stats_char_skew
  gsl_stats_char_kurtosis
  gsl_stats_char_lag1_autocorrelation
  gsl_stats_char_covariance
  gsl_stats_char_variance_m
  gsl_stats_char_sd_m
  gsl_stats_char_absdev_m
  gsl_stats_char_skew_m_sd
  gsl_stats_char_kurtosis_m_sd
  gsl_stats_char_lag1_autocorrelation_m
  gsl_stats_char_covariance_m
  gsl_stats_char_pvariance
  gsl_stats_char_ttest
  gsl_stats_char_max
  gsl_stats_char_min
  gsl_stats_char_minmax
  gsl_stats_char_max_index
  gsl_stats_char_min_index
  gsl_stats_char_minmax_index
  gsl_stats_char_median_from_sorted_data
  gsl_stats_char_quantile_from_sorted_data
  gsl_stats_mean
  gsl_stats_variance
  gsl_stats_sd
  gsl_stats_variance_with_fixed_mean
  gsl_stats_sd_with_fixed_mean
  gsl_stats_absdev
  gsl_stats_skew
  gsl_stats_kurtosis
  gsl_stats_lag1_autocorrelation
  gsl_stats_covariance
  gsl_stats_variance_m
  gsl_stats_sd_m
  gsl_stats_absdev_m
  gsl_stats_skew_m_sd
  gsl_stats_kurtosis_m_sd
  gsl_stats_lag1_autocorrelation_m
  gsl_stats_covariance_m
  gsl_stats_wmean
  gsl_stats_wvariance
  gsl_stats_wsd
  gsl_stats_wvariance_with_fixed_mean
  gsl_stats_wsd_with_fixed_mean
  gsl_stats_wabsdev
  gsl_stats_wskew
  gsl_stats_wkurtosis
  gsl_stats_wvariance_m
  gsl_stats_wsd_m
  gsl_stats_wabsdev_m
  gsl_stats_wskew_m_sd
  gsl_stats_wkurtosis_m_sd
  gsl_stats_pvariance
  gsl_stats_ttest
  gsl_stats_max
  gsl_stats_min
  gsl_stats_minmax
  gsl_stats_max_index
  gsl_stats_min_index
  gsl_stats_minmax_index
  gsl_stats_median_from_sorted_data
  gsl_stats_quantile_from_sorted_data
  gsl_stats_float_mean
  gsl_stats_float_variance
  gsl_stats_float_sd
  gsl_stats_float_variance_with_fixed_mean
  gsl_stats_float_sd_with_fixed_mean
  gsl_stats_float_absdev
  gsl_stats_float_skew
  gsl_stats_float_kurtosis
  gsl_stats_float_lag1_autocorrelation
  gsl_stats_float_covariance
  gsl_stats_float_variance_m
  gsl_stats_float_sd_m
  gsl_stats_float_absdev_m
  gsl_stats_float_skew_m_sd
  gsl_stats_float_kurtosis_m_sd
  gsl_stats_float_lag1_autocorrelation_m
  gsl_stats_float_covariance_m
  gsl_stats_float_wmean
  gsl_stats_float_wvariance
  gsl_stats_float_wsd
  gsl_stats_float_wvariance_with_fixed_mean
  gsl_stats_float_wsd_with_fixed_mean
  gsl_stats_float_wabsdev
  gsl_stats_float_wskew
  gsl_stats_float_wkurtosis
  gsl_stats_float_wvariance_m
  gsl_stats_float_wsd_m
  gsl_stats_float_wabsdev_m
  gsl_stats_float_wskew_m_sd
  gsl_stats_float_wkurtosis_m_sd
  gsl_stats_float_pvariance
  gsl_stats_float_ttest
  gsl_stats_float_max
  gsl_stats_float_min
  gsl_stats_float_minmax
  gsl_stats_float_max_index
  gsl_stats_float_min_index
  gsl_stats_float_minmax_index
  gsl_stats_float_median_from_sorted_data
  gsl_stats_float_quantile_from_sorted_data
  gsl_stats_int_mean
  gsl_stats_int_variance
  gsl_stats_int_sd
  gsl_stats_int_variance_with_fixed_mean
  gsl_stats_int_sd_with_fixed_mean
  gsl_stats_int_absdev
  gsl_stats_int_skew
  gsl_stats_int_kurtosis
  gsl_stats_int_lag1_autocorrelation
  gsl_stats_int_covariance
  gsl_stats_int_variance_m
  gsl_stats_int_sd_m
  gsl_stats_int_absdev_m
  gsl_stats_int_skew_m_sd
  gsl_stats_int_kurtosis_m_sd
  gsl_stats_int_lag1_autocorrelation_m
  gsl_stats_int_covariance_m
  gsl_stats_int_pvariance
  gsl_stats_int_ttest
  gsl_stats_int_max
  gsl_stats_int_min
  gsl_stats_int_minmax
  gsl_stats_int_max_index
  gsl_stats_int_min_index
  gsl_stats_int_minmax_index
  gsl_stats_int_median_from_sorted_data
  gsl_stats_int_quantile_from_sorted_data
  gsl_stats_long_double_mean
  gsl_stats_long_double_variance
  gsl_stats_long_double_sd
  gsl_stats_long_double_variance_with_fixed_mean
  gsl_stats_long_double_sd_with_fixed_mean
  gsl_stats_long_double_absdev
  gsl_stats_long_double_skew
  gsl_stats_long_double_kurtosis
  gsl_stats_long_double_lag1_autocorrelation
  gsl_stats_long_double_covariance
  gsl_stats_long_double_variance_m
  gsl_stats_long_double_sd_m
  gsl_stats_long_double_absdev_m
  gsl_stats_long_double_skew_m_sd
  gsl_stats_long_double_kurtosis_m_sd
  gsl_stats_long_double_lag1_autocorrelation_m
  gsl_stats_long_double_covariance_m
  gsl_stats_long_double_wmean
  gsl_stats_long_double_wvariance
  gsl_stats_long_double_wsd
  gsl_stats_long_double_wvariance_with_fixed_mean
  gsl_stats_long_double_wsd_with_fixed_mean
  gsl_stats_long_double_wabsdev
  gsl_stats_long_double_wskew
  gsl_stats_long_double_wkurtosis
  gsl_stats_long_double_wvariance_m
  gsl_stats_long_double_wsd_m
  gsl_stats_long_double_wabsdev_m
  gsl_stats_long_double_wskew_m_sd
  gsl_stats_long_double_wkurtosis_m_sd
  gsl_stats_long_double_pvariance
  gsl_stats_long_double_ttest
  gsl_stats_long_double_max
  gsl_stats_long_double_min
  gsl_stats_long_double_minmax
  gsl_stats_long_double_max_index
  gsl_stats_long_double_min_index
  gsl_stats_long_double_minmax_index
  gsl_stats_long_double_median_from_sorted_data
  gsl_stats_long_double_quantile_from_sorted_data
  gsl_stats_long_mean
  gsl_stats_long_variance
  gsl_stats_long_sd
  gsl_stats_long_variance_with_fixed_mean
  gsl_stats_long_sd_with_fixed_mean
  gsl_stats_long_absdev
  gsl_stats_long_skew
  gsl_stats_long_kurtosis
  gsl_stats_long_lag1_autocorrelation
  gsl_stats_long_covariance
  gsl_stats_long_variance_m
  gsl_stats_long_sd_m
  gsl_stats_long_absdev_m
  gsl_stats_long_skew_m_sd
  gsl_stats_long_kurtosis_m_sd
  gsl_stats_long_lag1_autocorrelation_m
  gsl_stats_long_covariance_m
  gsl_stats_long_pvariance
  gsl_stats_long_ttest
  gsl_stats_long_max
  gsl_stats_long_min
  gsl_stats_long_minmax
  gsl_stats_long_max_index
  gsl_stats_long_min_index
  gsl_stats_long_minmax_index
  gsl_stats_long_median_from_sorted_data
  gsl_stats_long_quantile_from_sorted_data
  gsl_stats_short_mean
  gsl_stats_short_variance
  gsl_stats_short_sd
  gsl_stats_short_variance_with_fixed_mean
  gsl_stats_short_sd_with_fixed_mean
  gsl_stats_short_absdev
  gsl_stats_short_skew
  gsl_stats_short_kurtosis
  gsl_stats_short_lag1_autocorrelation
  gsl_stats_short_covariance
  gsl_stats_short_variance_m
  gsl_stats_short_sd_m
  gsl_stats_short_absdev_m
  gsl_stats_short_skew_m_sd
  gsl_stats_short_kurtosis_m_sd
  gsl_stats_short_lag1_autocorrelation_m
  gsl_stats_short_covariance_m
  gsl_stats_short_pvariance
  gsl_stats_short_ttest
  gsl_stats_short_max
  gsl_stats_short_min
  gsl_stats_short_minmax
  gsl_stats_short_max_index
  gsl_stats_short_min_index
  gsl_stats_short_minmax_index
  gsl_stats_short_median_from_sorted_data
  gsl_stats_short_quantile_from_sorted_data
  gsl_stats_uchar_mean
  gsl_stats_uchar_variance
  gsl_stats_uchar_sd
  gsl_stats_uchar_variance_with_fixed_mean
  gsl_stats_uchar_sd_with_fixed_mean
  gsl_stats_uchar_absdev
  gsl_stats_uchar_skew
  gsl_stats_uchar_kurtosis
  gsl_stats_uchar_lag1_autocorrelation
  gsl_stats_uchar_covariance
  gsl_stats_uchar_variance_m
  gsl_stats_uchar_sd_m
  gsl_stats_uchar_absdev_m
  gsl_stats_uchar_skew_m_sd
  gsl_stats_uchar_kurtosis_m_sd
  gsl_stats_uchar_lag1_autocorrelation_m
  gsl_stats_uchar_covariance_m
  gsl_stats_uchar_pvariance
  gsl_stats_uchar_ttest
  gsl_stats_uchar_max
  gsl_stats_uchar_min
  gsl_stats_uchar_minmax
  gsl_stats_uchar_max_index
  gsl_stats_uchar_min_index
  gsl_stats_uchar_minmax_index
  gsl_stats_uchar_median_from_sorted_data
  gsl_stats_uchar_quantile_from_sorted_data
  gsl_stats_uint_mean
  gsl_stats_uint_variance
  gsl_stats_uint_sd
  gsl_stats_uint_variance_with_fixed_mean
  gsl_stats_uint_sd_with_fixed_mean
  gsl_stats_uint_absdev
  gsl_stats_uint_skew
  gsl_stats_uint_kurtosis
  gsl_stats_uint_lag1_autocorrelation
  gsl_stats_uint_covariance
  gsl_stats_uint_variance_m
  gsl_stats_uint_sd_m
  gsl_stats_uint_absdev_m
  gsl_stats_uint_skew_m_sd
  gsl_stats_uint_kurtosis_m_sd
  gsl_stats_uint_lag1_autocorrelation_m
  gsl_stats_uint_covariance_m
  gsl_stats_uint_pvariance
  gsl_stats_uint_ttest
  gsl_stats_uint_max
  gsl_stats_uint_min
  gsl_stats_uint_minmax
  gsl_stats_uint_max_index
  gsl_stats_uint_min_index
  gsl_stats_uint_minmax_index
  gsl_stats_uint_median_from_sorted_data
  gsl_stats_uint_quantile_from_sorted_data
  gsl_stats_ulong_mean
  gsl_stats_ulong_variance
  gsl_stats_ulong_sd
  gsl_stats_ulong_variance_with_fixed_mean
  gsl_stats_ulong_sd_with_fixed_mean
  gsl_stats_ulong_absdev
  gsl_stats_ulong_skew
  gsl_stats_ulong_kurtosis
  gsl_stats_ulong_lag1_autocorrelation
  gsl_stats_ulong_covariance
  gsl_stats_ulong_variance_m
  gsl_stats_ulong_sd_m
  gsl_stats_ulong_absdev_m
  gsl_stats_ulong_skew_m_sd
  gsl_stats_ulong_kurtosis_m_sd
  gsl_stats_ulong_lag1_autocorrelation_m
  gsl_stats_ulong_covariance_m
  gsl_stats_ulong_pvariance
  gsl_stats_ulong_ttest
  gsl_stats_ulong_max
  gsl_stats_ulong_min
  gsl_stats_ulong_minmax
  gsl_stats_ulong_max_index
  gsl_stats_ulong_min_index
  gsl_stats_ulong_minmax_index
  gsl_stats_ulong_median_from_sorted_data
  gsl_stats_ulong_quantile_from_sorted_data
  gsl_stats_ushort_mean
  gsl_stats_ushort_variance
  gsl_stats_ushort_sd
  gsl_stats_ushort_variance_with_fixed_mean
  gsl_stats_ushort_sd_with_fixed_mean
  gsl_stats_ushort_absdev
  gsl_stats_ushort_skew
  gsl_stats_ushort_kurtosis
  gsl_stats_ushort_lag1_autocorrelation
  gsl_stats_ushort_covariance
  gsl_stats_ushort_variance_m
  gsl_stats_ushort_sd_m
  gsl_stats_ushort_absdev_m
  gsl_stats_ushort_skew_m_sd
  gsl_stats_ushort_kurtosis_m_sd
  gsl_stats_ushort_lag1_autocorrelation_m
  gsl_stats_ushort_covariance_m
  gsl_stats_ushort_pvariance
  gsl_stats_ushort_ttest
  gsl_stats_ushort_max
  gsl_stats_ushort_min
  gsl_stats_ushort_minmax
  gsl_stats_ushort_max_index
  gsl_stats_ushort_min_index
  gsl_stats_ushort_minmax_index
  gsl_stats_ushort_median_from_sorted_data
  gsl_stats_ushort_quantile_from_sorted_data
)
