;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
;;;
;;; 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")



#? *** sort

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

#? * (dummy_sort)
#? * (gsl_sort_char <data> <stride> <n>)
#? * (gsl_sort_char_index <p> <data> <stride> <n>)
#? * (gsl_sort_char_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_char_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_char_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_char_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort <data> <stride> <n>)
#? * (gsl_sort_index <p> <data> <stride> <n>)
#? * (gsl_sort_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_float <data> <stride> <n>)
#? * (gsl_sort_float_index <p> <data> <stride> <n>)
#? * (gsl_sort_float_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_float_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_float_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_float_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_int <data> <stride> <n>)
#? * (gsl_sort_int_index <p> <data> <stride> <n>)
#? * (gsl_sort_int_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_int_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_int_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_int_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_long_double <data> <stride> <n>)
#? * (gsl_sort_long_double_index <p> <data> <stride> <n>)
#? * (gsl_sort_long_double_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_long_double_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_long_double_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_long_double_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_long <data> <stride> <n>)
#? * (gsl_sort_long_index <p> <data> <stride> <n>)
#? * (gsl_sort_long_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_long_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_long_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_long_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_short <data> <stride> <n>)
#? * (gsl_sort_short_index <p> <data> <stride> <n>)
#? * (gsl_sort_short_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_short_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_short_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_short_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_uchar <data> <stride> <n>)
#? * (gsl_sort_uchar_index <p> <data> <stride> <n>)
#? * (gsl_sort_uchar_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_uchar_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_uchar_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_uchar_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_uint <data> <stride> <n>)
#? * (gsl_sort_uint_index <p> <data> <stride> <n>)
#? * (gsl_sort_uint_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_uint_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_uint_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_uint_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_ulong <data> <stride> <n>)
#? * (gsl_sort_ulong_index <p> <data> <stride> <n>)
#? * (gsl_sort_ulong_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_ulong_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_ulong_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_ulong_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_ushort <data> <stride> <n>)
#? * (gsl_sort_ushort_index <p> <data> <stride> <n>)
#? * (gsl_sort_ushort_smallest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_ushort_smallest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_ushort_largest <dest> <k> <src> <stride> <n>)
#? * (gsl_sort_ushort_largest_index <p> <k> <src> <stride> <n>)
#? * (gsl_sort_vector_char <v>)
#? * (gsl_sort_vector_char_index <p> <v>)
#? * (gsl_sort_vector_char_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_char_largest <dest> <k> <v>)
#? * (gsl_sort_vector_char_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_char_largest_index <p> <k> <v>)
#? * (gsl_sort_vector <v>)
#? * (gsl_sort_vector_index <p> <v>)
#? * (gsl_sort_vector_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_largest <dest> <k> <v>)
#? * (gsl_sort_vector_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_float <v>)
#? * (gsl_sort_vector_float_index <p> <v>)
#? * (gsl_sort_vector_float_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_float_largest <dest> <k> <v>)
#? * (gsl_sort_vector_float_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_float_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_int <v>)
#? * (gsl_sort_vector_int_index <p> <v>)
#? * (gsl_sort_vector_int_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_int_largest <dest> <k> <v>)
#? * (gsl_sort_vector_int_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_int_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_long_double <v>)
#? * (gsl_sort_vector_long_double_index <p> <v>)
#? * (gsl_sort_vector_long_double_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_long_double_largest <dest> <k> <v>)
#? * (gsl_sort_vector_long_double_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_long_double_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_long <v>)
#? * (gsl_sort_vector_long_index <p> <v>)
#? * (gsl_sort_vector_long_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_long_largest <dest> <k> <v>)
#? * (gsl_sort_vector_long_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_long_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_short <v>)
#? * (gsl_sort_vector_short_index <p> <v>)
#? * (gsl_sort_vector_short_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_short_largest <dest> <k> <v>)
#? * (gsl_sort_vector_short_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_short_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_uchar <v>)
#? * (gsl_sort_vector_uchar_index <p> <v>)
#? * (gsl_sort_vector_uchar_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_uchar_largest <dest> <k> <v>)
#? * (gsl_sort_vector_uchar_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_uchar_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_uint <v>)
#? * (gsl_sort_vector_uint_index <p> <v>)
#? * (gsl_sort_vector_uint_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_uint_largest <dest> <k> <v>)
#? * (gsl_sort_vector_uint_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_uint_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_ulong <v>)
#? * (gsl_sort_vector_ulong_index <p> <v>)
#? * (gsl_sort_vector_ulong_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_ulong_largest <dest> <k> <v>)
#? * (gsl_sort_vector_ulong_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_ulong_largest_index <p> <k> <v>)
#? * (gsl_sort_vector_ushort <v>)
#? * (gsl_sort_vector_ushort_index <p> <v>)
#? * (gsl_sort_vector_ushort_smallest <dest> <k> <v>)
#? * (gsl_sort_vector_ushort_largest <dest> <k> <v>)
#? * (gsl_sort_vector_ushort_smallest_index <p> <k> <v>)
#? * (gsl_sort_vector_ushort_largest_index <p> <k> <v>)
#? * (gsl_heapsort <array> <count> <size> <compare>)
#? * (gsl_heapsort_index <p> <array> <count> <size> <compare>)

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



(de  gsl_sort_char (data stride n )
     ((-gptr- "char *") data)
     ((-int-)  stride)
     ((-int-)  n)
     #{ gsl_sort_char ( $data ,$stride ,$n) #} 
     ()
)

(de  gsl_sort_char_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const char *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_char_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_char_smallest (  dest  k  src  stride  n )
     ((-gptr- "char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_char_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_char_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_char_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_char_largest (  dest  k  src  stride  n )
     ((-gptr- "char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_char_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_char_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_char_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)



(de  gsl_sort (  data  stride  n )
     ((-gptr- "double *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const double *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_smallest (  dest  k  src  stride  n )
     ((-gptr- "double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_largest (  dest  k  src  stride  n )
     ((-gptr- "double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)




(de  gsl_sort_float (  data  stride  n )
     ((-gptr- "float *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_float ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_float_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const float *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_float_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_float_smallest (  dest  k  src  stride  n )
     ((-gptr- "float *") dest) 
     ((-int-)  k) 
     ((-gptr- "const float *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_float_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_float_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const float *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_float_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_float_largest (  dest  k  src  stride  n )
     ((-gptr- "float *") dest) 
     ((-int-)  k) 
     ((-gptr- "const float *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_float_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_float_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const float *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_float_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)



(de  gsl_sort_int (  data  stride  n )
     ((-gptr- "int *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_int ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_int_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const int *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_int_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_int_smallest (  dest  k  src  stride  n )
     ((-gptr- "int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_int_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_int_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_int_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_int_largest (  dest  k  src  stride  n )
     ((-gptr- "int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_int_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_int_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_int_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)



(de  gsl_sort_long_double (  data  stride  n )
     ((-gptr- "long double *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_long_double ( $data ,$stride ,$n ) #} 
     ()
)

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


(de  gsl_sort_long_double_smallest (  dest  k  src  stride  n )
     ((-gptr- "long double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const long double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_double_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_long_double_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const long double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_double_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_long_double_largest (  dest  k  src  stride  n )
     ((-gptr- "long double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const long double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_double_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_long_double_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const long double *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_double_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)




(de  gsl_sort_long (  data  stride  n )
     ((-gptr- "long *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_long ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_long_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const long *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_long_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_long_smallest (  dest  k  src  stride  n )
     ((-gptr- "long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_long_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_long_largest (  dest  k  src  stride  n )
     ((-gptr- "long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_long_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_long_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)



(de  gsl_sort_short (  data  stride  n )
     ((-gptr- "short *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_short ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_short_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const short *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_short_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_short_smallest (  dest  k  src  stride  n )
     ((-gptr- "short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_short_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_short_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_short_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_short_largest (  dest  k  src  stride  n )
     ((-gptr- "short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_short_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_short_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_short_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)



(de  gsl_sort_uchar (  data  stride  n )
     ((-gptr- "unsigned char *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_uchar ( $data ,$stride ,$n ) #} 
     ()
)

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


(de  gsl_sort_uchar_smallest (  dest  k  src  stride  n )
     ((-gptr- "unsigned char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uchar_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_uchar_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uchar_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_uchar_largest (  dest  k  src  stride  n )
     ((-gptr- "unsigned char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uchar_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_uchar_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned char *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uchar_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)




(de  gsl_sort_uint (  data  stride  n )
     ((-gptr- "unsigned int *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_uint ( $data ,$stride ,$n ) #} 
     ()
)

(de  gsl_sort_uint_index (  p  data  stride  n )
     ((-gptr- "size_t *") p) 
     ((-gptr- "const unsigned int *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_uint_index ( $p ,$data ,$stride ,$n ) #} 
     ()
)


(de  gsl_sort_uint_smallest (  dest  k  src  stride  n )
     ((-gptr- "unsigned int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uint_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_uint_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uint_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_uint_largest (  dest  k  src  stride  n )
     ((-gptr- "unsigned int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uint_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_uint_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned int *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_uint_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)




(de  gsl_sort_ulong (  data  stride  n )
     ((-gptr- "unsigned long *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_ulong ( $data ,$stride ,$n ) #} 
     ()
)

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


(de  gsl_sort_ulong_smallest (  dest  k  src  stride  n )
     ((-gptr- "unsigned long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ulong_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_ulong_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ulong_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_ulong_largest (  dest  k  src  stride  n )
     ((-gptr- "unsigned long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ulong_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_ulong_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned long *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ulong_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)




(de  gsl_sort_ushort (  data  stride  n )
     ((-gptr- "unsigned short *") data) 
     ((-int-)  stride) 
     ((-int-)  n) 
     #{ gsl_sort_ushort ( $data ,$stride ,$n ) #} 
     ()
)

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


(de  gsl_sort_ushort_smallest (  dest  k  src  stride  n )
     ((-gptr- "unsigned short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ushort_smallest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_ushort_smallest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ushort_smallest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)


(de  gsl_sort_ushort_largest (  dest  k  src  stride  n )
     ((-gptr- "unsigned short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const unsigned short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ushort_largest ( $dest ,$k ,$src ,$stride ,$n ) #} )
)

(de  gsl_sort_ushort_largest_index (  p  k  src  stride  n )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const unsigned short *") src) 
     ((-int-)  stride) 
     ((-int-)  n) 
     (int #{ gsl_sort_ushort_largest_index ( $p ,$k ,$src ,$stride ,$n ) #} )
)






(de  gsl_sort_vector_char (  v )
     ((-gptr- "gsl_vector_char *") v) 
     #{ gsl_sort_vector_char ( $v ) #} 
     ()
)

(de  gsl_sort_vector_char_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_char *") v) 
     (int #{ gsl_sort_vector_char_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_char_smallest (  dest  k  v )
     ((-gptr- "char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_char *") v) 
     (int #{ gsl_sort_vector_char_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_char_largest (  dest  k  v )
     ((-gptr- "char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_char *") v) 
     (int #{ gsl_sort_vector_char_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_char_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_char *") v) 
     (int #{ gsl_sort_vector_char_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_char_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_char *") v) 
     (int #{ gsl_sort_vector_char_largest_index ( $p ,$k ,$v ) #} )
)




(de  gsl_sort_vector (  v )
     ((-gptr- "gsl_vector *") v) 
     #{ gsl_sort_vector ( $v ) #} 
     ()
)

(de  gsl_sort_vector_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector *") v) 
     (int #{ gsl_sort_vector_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_smallest (  dest  k  v )
     ((-gptr- "double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector *") v) 
     (int #{ gsl_sort_vector_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_largest (  dest  k  v )
     ((-gptr- "double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector *") v) 
     (int #{ gsl_sort_vector_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector *") v) 
     (int #{ gsl_sort_vector_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector *") v) 
     (int #{ gsl_sort_vector_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_float (  v )
     ((-gptr- "gsl_vector_float *") v) 
     #{ gsl_sort_vector_float ( $v ) #} 
     ()
)

(de  gsl_sort_vector_float_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_float *") v) 
     (int #{ gsl_sort_vector_float_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_float_smallest (  dest  k  v )
     ((-gptr- "float *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_float *") v) 
     (int #{ gsl_sort_vector_float_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_float_largest (  dest  k  v )
     ((-gptr- "float *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_float *") v) 
     (int #{ gsl_sort_vector_float_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_float_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_float *") v) 
     (int #{ gsl_sort_vector_float_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_float_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_float *") v) 
     (int #{ gsl_sort_vector_float_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_int (  v )
     ((-gptr- "gsl_vector_int *") v) 
     #{ gsl_sort_vector_int ( $v ) #} 
     ()
)

(de  gsl_sort_vector_int_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_int *") v) 
     (int #{ gsl_sort_vector_int_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_int_smallest (  dest  k  v )
     ((-gptr- "int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_int *") v) 
     (int #{ gsl_sort_vector_int_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_int_largest (  dest  k  v )
     ((-gptr- "int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_int *") v) 
     (int #{ gsl_sort_vector_int_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_int_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_int *") v) 
     (int #{ gsl_sort_vector_int_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_int_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_int *") v) 
     (int #{ gsl_sort_vector_int_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_long_double (  v )
     ((-gptr- "gsl_vector_long_double *") v) 
     #{ gsl_sort_vector_long_double ( $v ) #} 
     ()
)

(de  gsl_sort_vector_long_double_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_long_double *") v) 
     (int #{ gsl_sort_vector_long_double_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_long_double_smallest (  dest  k  v )
     ((-gptr- "long double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long_double *") v) 
     (int #{ gsl_sort_vector_long_double_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_long_double_largest (  dest  k  v )
     ((-gptr- "long double *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long_double *") v) 
     (int #{ gsl_sort_vector_long_double_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_long_double_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long_double *") v) 
     (int #{ gsl_sort_vector_long_double_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_long_double_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long_double *") v) 
     (int #{ gsl_sort_vector_long_double_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_long (  v )
     ((-gptr- "gsl_vector_long *") v) 
     #{ gsl_sort_vector_long ( $v ) #} 
     ()
)

(de  gsl_sort_vector_long_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_long *") v) 
     (int #{ gsl_sort_vector_long_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_long_smallest (  dest  k  v )
     ((-gptr- "long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long *") v) 
     (int #{ gsl_sort_vector_long_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_long_largest (  dest  k  v )
     ((-gptr- "long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long *") v) 
     (int #{ gsl_sort_vector_long_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_long_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long *") v) 
     (int #{ gsl_sort_vector_long_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_long_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_long *") v) 
     (int #{ gsl_sort_vector_long_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_short (  v )
     ((-gptr- "gsl_vector_short *") v) 
     #{ gsl_sort_vector_short ( $v ) #} 
     ()
)

(de  gsl_sort_vector_short_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_short *") v) 
     (int #{ gsl_sort_vector_short_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_short_smallest (  dest  k  v )
     ((-gptr- "short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_short *") v) 
     (int #{ gsl_sort_vector_short_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_short_largest (  dest  k  v )
     ((-gptr- "short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_short *") v) 
     (int #{ gsl_sort_vector_short_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_short_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_short *") v) 
     (int #{ gsl_sort_vector_short_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_short_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_short *") v) 
     (int #{ gsl_sort_vector_short_largest_index ( $p ,$k ,$v ) #} )
)


(de  gsl_sort_vector_uchar (  v )
     ((-gptr- "gsl_vector_uchar *") v) 
     #{ gsl_sort_vector_uchar ( $v ) #} 
     ()
)

(de  gsl_sort_vector_uchar_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_uchar *") v) 
     (int #{ gsl_sort_vector_uchar_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_uchar_smallest (  dest  k  v )
     ((-gptr- "unsigned char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uchar *") v) 
     (int #{ gsl_sort_vector_uchar_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_uchar_largest (  dest  k  v )
     ((-gptr- "unsigned char *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uchar *") v) 
     (int #{ gsl_sort_vector_uchar_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_uchar_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uchar *") v) 
     (int #{ gsl_sort_vector_uchar_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_uchar_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uchar *") v) 
     (int #{ gsl_sort_vector_uchar_largest_index ( $p ,$k ,$v ) #} )
)



(de  gsl_sort_vector_uint (  v )
     ((-gptr- "gsl_vector_uint *") v) 
     #{ gsl_sort_vector_uint ( $v ) #} 
     ()
)

(de  gsl_sort_vector_uint_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_uint *") v) 
     (int #{ gsl_sort_vector_uint_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_uint_smallest (  dest  k  v )
     ((-gptr- "unsigned int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uint *") v) 
     (int #{ gsl_sort_vector_uint_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_uint_largest (  dest  k  v )
     ((-gptr- "unsigned int *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uint *") v) 
     (int #{ gsl_sort_vector_uint_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_uint_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uint *") v) 
     (int #{ gsl_sort_vector_uint_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_uint_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_uint *") v) 
     (int #{ gsl_sort_vector_uint_largest_index ( $p ,$k ,$v ) #} )
)





(de  gsl_sort_vector_ulong (  v )
     ((-gptr- "gsl_vector_ulong *") v) 
     #{ gsl_sort_vector_ulong ( $v ) #} 
     ()
)

(de  gsl_sort_vector_ulong_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_ulong *") v) 
     (int #{ gsl_sort_vector_ulong_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_ulong_smallest (  dest  k  v )
     ((-gptr- "unsigned long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ulong *") v) 
     (int #{ gsl_sort_vector_ulong_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_ulong_largest (  dest  k  v )
     ((-gptr- "unsigned long *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ulong *") v) 
     (int #{ gsl_sort_vector_ulong_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_ulong_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ulong *") v) 
     (int #{ gsl_sort_vector_ulong_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_ulong_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ulong *") v) 
     (int #{ gsl_sort_vector_ulong_largest_index ( $p ,$k ,$v ) #} )
)




(de  gsl_sort_vector_ushort (  v )
     ((-gptr- "gsl_vector_ushort *") v) 
     #{ gsl_sort_vector_ushort ( $v ) #} 
     ()
)

(de  gsl_sort_vector_ushort_index (  p  v )
     ((-gptr- "gsl_permutation *") p) 
     ((-gptr- "const gsl_vector_ushort *") v) 
     (int #{ gsl_sort_vector_ushort_index ( $p ,$v ) #} )
)


(de  gsl_sort_vector_ushort_smallest (  dest  k  v )
     ((-gptr- "unsigned short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ushort *") v) 
     (int #{ gsl_sort_vector_ushort_smallest ( $dest ,$k ,$v ) #} )
)

(de  gsl_sort_vector_ushort_largest (  dest  k  v )
     ((-gptr- "unsigned short *") dest) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ushort *") v) 
     (int #{ gsl_sort_vector_ushort_largest ( $dest ,$k ,$v ) #} )
)


(de  gsl_sort_vector_ushort_smallest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ushort *") v) 
     (int #{ gsl_sort_vector_ushort_smallest_index ( $p ,$k ,$v ) #} )
)

(de  gsl_sort_vector_ushort_largest_index (  p  k  v )
     ((-gptr- "size_t *") p) 
     ((-int-)  k) 
     ((-gptr- "const gsl_vector_ushort *") v) 
     (int #{ gsl_sort_vector_ushort_largest_index ( $p ,$k ,$v ) #} )
)


;;;;***********************************************************************
;;;;               gsl_heapsort


(de gsl_heapsort (    array  count  size  compare )
    ((-gptr- "void *") array) 
    ((-int-) count)                     ;; size_t -> int
    ((-int-) size)                     ;; size_t -> int
    ((-gptr-) compare)                  ;; gsl_comparison_fn_t ( function pointer) -> gptr
    #{ gsl_heapsort (  $array ,$count ,$size ,$compare) #} 
    ()
)

(de gsl_heapsort_index (    p  array  count  size  compare )
    ((-gptr- "size_t *") p) 
    ((-gptr- "const void *") array) 
    ((-int-) count)                     ;; size_t -> int
    ((-int-) size)                     ;; size_t -> int
    ((-gptr-) compare)                   ;; gsl_comparison_fn_t (function pointer ) -> gptr
    (int #{ gsl_heapsort_index (  $p ,$array ,$count ,$size ,$compare) #} )
)



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

(dhc-make ()
  dummy_sort
  gsl_sort_char
  gsl_sort_char_index
  gsl_sort_char_smallest
  gsl_sort_char_smallest_index
  gsl_sort_char_largest
  gsl_sort_char_largest_index
  gsl_sort
  gsl_sort_index
  gsl_sort_smallest
  gsl_sort_smallest_index
  gsl_sort_largest
  gsl_sort_largest_index
  gsl_sort_float
  gsl_sort_float_index
  gsl_sort_float_smallest
  gsl_sort_float_smallest_index
  gsl_sort_float_largest
  gsl_sort_float_largest_index
  gsl_sort_int
  gsl_sort_int_index
  gsl_sort_int_smallest
  gsl_sort_int_smallest_index
  gsl_sort_int_largest
  gsl_sort_int_largest_index
  gsl_sort_long_double
  gsl_sort_long_double_index
  gsl_sort_long_double_smallest
  gsl_sort_long_double_smallest_index
  gsl_sort_long_double_largest
  gsl_sort_long_double_largest_index
  gsl_sort_long
  gsl_sort_long_index
  gsl_sort_long_smallest
  gsl_sort_long_smallest_index
  gsl_sort_long_largest
  gsl_sort_long_largest_index
  gsl_sort_short
  gsl_sort_short_index
  gsl_sort_short_smallest
  gsl_sort_short_smallest_index
  gsl_sort_short_largest
  gsl_sort_short_largest_index
  gsl_sort_uchar
  gsl_sort_uchar_index
  gsl_sort_uchar_smallest
  gsl_sort_uchar_smallest_index
  gsl_sort_uchar_largest
  gsl_sort_uchar_largest_index
  gsl_sort_uint
  gsl_sort_uint_index
  gsl_sort_uint_smallest
  gsl_sort_uint_smallest_index
  gsl_sort_uint_largest
  gsl_sort_uint_largest_index
  gsl_sort_ulong
  gsl_sort_ulong_index
  gsl_sort_ulong_smallest
  gsl_sort_ulong_smallest_index
  gsl_sort_ulong_largest
  gsl_sort_ulong_largest_index
  gsl_sort_ushort
  gsl_sort_ushort_index
  gsl_sort_ushort_smallest
  gsl_sort_ushort_smallest_index
  gsl_sort_ushort_largest
  gsl_sort_ushort_largest_index
  gsl_sort_vector_char
  gsl_sort_vector_char_index
  gsl_sort_vector_char_smallest
  gsl_sort_vector_char_largest
  gsl_sort_vector_char_smallest_index
  gsl_sort_vector_char_largest_index
  gsl_sort_vector
  gsl_sort_vector_index
  gsl_sort_vector_smallest
  gsl_sort_vector_largest
  gsl_sort_vector_smallest_index
  gsl_sort_vector_largest_index
  gsl_sort_vector_float
  gsl_sort_vector_float_index
  gsl_sort_vector_float_smallest
  gsl_sort_vector_float_largest
  gsl_sort_vector_float_smallest_index
  gsl_sort_vector_float_largest_index
  gsl_sort_vector_int
  gsl_sort_vector_int_index
  gsl_sort_vector_int_smallest
  gsl_sort_vector_int_largest
  gsl_sort_vector_int_smallest_index
  gsl_sort_vector_int_largest_index
  gsl_sort_vector_long_double
  gsl_sort_vector_long_double_index
  gsl_sort_vector_long_double_smallest
  gsl_sort_vector_long_double_largest
  gsl_sort_vector_long_double_smallest_index
  gsl_sort_vector_long_double_largest_index
  gsl_sort_vector_long
  gsl_sort_vector_long_index
  gsl_sort_vector_long_smallest
  gsl_sort_vector_long_largest
  gsl_sort_vector_long_smallest_index
  gsl_sort_vector_long_largest_index
  gsl_sort_vector_short
  gsl_sort_vector_short_index
  gsl_sort_vector_short_smallest
  gsl_sort_vector_short_largest
  gsl_sort_vector_short_smallest_index
  gsl_sort_vector_short_largest_index
  gsl_sort_vector_uchar
  gsl_sort_vector_uchar_index
  gsl_sort_vector_uchar_smallest
  gsl_sort_vector_uchar_largest
  gsl_sort_vector_uchar_smallest_index
  gsl_sort_vector_uchar_largest_index
  gsl_sort_vector_uint
  gsl_sort_vector_uint_index
  gsl_sort_vector_uint_smallest
  gsl_sort_vector_uint_largest
  gsl_sort_vector_uint_smallest_index
  gsl_sort_vector_uint_largest_index
  gsl_sort_vector_ulong
  gsl_sort_vector_ulong_index
  gsl_sort_vector_ulong_smallest
  gsl_sort_vector_ulong_largest
  gsl_sort_vector_ulong_smallest_index
  gsl_sort_vector_ulong_largest_index
  gsl_sort_vector_ushort
  gsl_sort_vector_ushort_index
  gsl_sort_vector_ushort_smallest
  gsl_sort_vector_ushort_largest
  gsl_sort_vector_ushort_smallest_index
  gsl_sort_vector_ushort_largest_index
  gsl_heapsort
  gsl_heapsort_index
)
