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



#? *** permutation

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

#? * (dummy_permutation)
#? * (gsl_permutation_alloc <n>)
#? * (gsl_permutation_calloc <n>)
#? * (gsl_permutation_init <p>)
#? * (gsl_permutation_free <p>)
#? * (gsl_permutation_memcpy <dest> <src>)
#? * (gsl_permutation_fread <stream> <p>)
#? * (gsl_permutation_fwrite <stream> <p>)
#? * (gsl_permutation_fscanf <stream> <p>)
#? * (gsl_permutation_fprintf <stream> <p> <format>)
#? * (gsl_permutation_size <p>)
#? * (gsl_permutation_data <p>)
#? * (gsl_permutation_get <p> <i>)
#? * (gsl_permutation_swap <p> <i> <j>)
#? * (gsl_permutation_valid <p>)
#? * (gsl_permutation_reverse <p>)
#? * (gsl_permutation_inverse <inv> <p>)
#? * (gsl_permutation_next <p>)
#? * (gsl_permutation_prev <p>)
#? * (gsl_permute_char <p> <data> <stride> <n>)
#? * (gsl_permute_char_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_complex <p> <data> <stride> <n>)
#? * (gsl_permute_complex_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_complex_float <p> <data> <stride> <n>)
#? * (gsl_permute_complex_float_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_complex_long_double <p> <data> <stride> <n>)
#? * (gsl_permute_complex_long_double_inverse <p> <data> <stride> <n>)
#? * (gsl_permute <p> <data> <stride> <n>)
#? * (gsl_permute_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_float <p> <data> <stride> <n>)
#? * (gsl_permute_float_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_int <p> <data> <stride> <n>)
#? * (gsl_permute_int_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_long_double <p> <data> <stride> <n>)
#? * (gsl_permute_long_double_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_long <p> <data> <stride> <n>)
#? * (gsl_permute_long_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_short <p> <data> <stride> <n>)
#? * (gsl_permute_short_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_uchar <p> <data> <stride> <n>)
#? * (gsl_permute_uchar_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_uint <p> <data> <stride> <n>)
#? * (gsl_permute_uint_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_ulong <p> <data> <stride> <n>)
#? * (gsl_permute_ulong_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_ushort <p> <data> <stride> <n>)
#? * (gsl_permute_ushort_inverse <p> <data> <stride> <n>)
#? * (gsl_permute_vector_char <p> <v>)
#? * (gsl_permute_vector_char_inverse <p> <v>)
#? * (gsl_permute_vector_complex <p> <v>)
#? * (gsl_permute_vector_complex_inverse <p> <v>)
#? * (gsl_permute_vector_complex_float <p> <v>)
#? * (gsl_permute_vector_complex_float_inverse <p> <v>)
#? * (gsl_permute_vector_complex_long_double <p> <v>)
#? * (gsl_permute_vector_complex_long_double_inverse <p> <v>)
#? * (gsl_permute_vector <p> <v>)
#? * (gsl_permute_vector_inverse <p> <v>)
#? * (gsl_permute_vector_float <p> <v>)
#? * (gsl_permute_vector_float_inverse <p> <v>)
#? * (gsl_permute_vector_int <p> <v>)
#? * (gsl_permute_vector_int_inverse <p> <v>)
#? * (gsl_permute_vector_long_double <p> <v>)
#? * (gsl_permute_vector_long_double_inverse <p> <v>)
#? * (gsl_permute_vector_long <p> <v>)
#? * (gsl_permute_vector_long_inverse <p> <v>)
#? * (gsl_permute_vector_short <p> <v>)
#? * (gsl_permute_vector_short_inverse <p> <v>)
#? * (gsl_permute_vector_uchar <p> <v>)
#? * (gsl_permute_vector_uchar_inverse <p> <v>)
#? * (gsl_permute_vector_uint <p> <v>)
#? * (gsl_permute_vector_uint_inverse <p> <v>)
#? * (gsl_permute_vector_ulong <p> <v>)
#? * (gsl_permute_vector_ulong_inverse <p> <v>)
#? * (gsl_permute_vector_ushort <p> <v>)
#? * (gsl_permute_vector_ushort_inverse <p> <v>)

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


;;;;************************************************************************************
;;;;             gsl_permutation

(de gsl_permutation_alloc (    n )
    ((-int-) n)                     ;; size_t -> int
    (gptr #{ gsl_permutation_alloc (  $n) #} )          ;; gsl_permutation  * -> gptr
)

(de gsl_permutation_calloc (    n )
    ((-int-) n)                     ;; size_t -> int
    (gptr #{ gsl_permutation_calloc (  $n) #} )          ;; gsl_permutation  * -> gptr
)

(de gsl_permutation_init (    p )
    ((-gptr- "gsl_permutation *") p) 
    #{ gsl_permutation_init (  $p) #} 
    ()
)

(de gsl_permutation_free (    p )
    ((-gptr- "gsl_permutation *") p) 
    #{ gsl_permutation_free (  $p) #} 
    ()
)

(if (> gsl-libversion 1.0)
    (de gsl_permutation_memcpy (    dest  src )
      ((-gptr- "gsl_permutation *") dest) 
      ((-gptr- "const gsl_permutation *") src) 
      (int #{ gsl_permutation_memcpy (  $dest ,$src) #} )
      )
  (de gsl_permutation_memcpy (    dest  src )
    ((-gptr- "gsl_permutation *") dest) 
    ((-gptr- "const gsl_permutation *") src) 
    (error "not available in this version of GSL") ()))

(de gsl_permutation_fread (    stream  p )
    ((-gptr- "FILE *") stream) 
    ((-gptr- "gsl_permutation *") p) 
    (int #{ gsl_permutation_fread (  $stream ,$p) #} )
)

(de gsl_permutation_fwrite (    stream  p )
    ((-gptr- "FILE *") stream) 
    ((-gptr- "const gsl_permutation *") p) 
    (int #{ gsl_permutation_fwrite (  $stream ,$p) #} )
)

(de gsl_permutation_fscanf (    stream  p )
    ((-gptr- "FILE *") stream) 
    ((-gptr- "gsl_permutation *") p) 
    (int #{ gsl_permutation_fscanf (  $stream ,$p) #} )
)

(de gsl_permutation_fprintf (    stream  p   format )
    ((-gptr- "FILE *") stream) 
    ((-gptr- "const gsl_permutation *") p) 
    ((-gptr- "const char *") format) 
    (int #{ gsl_permutation_fprintf (  $stream ,$p ,$format) #} )
)


(de gsl_permutation_size (    p )
    ((-gptr- "const gsl_permutation *") p) 
    (int #{ gsl_permutation_size (  $p) #} )                ;; size_t -> int
)

(de gsl_permutation_data (    p )
    ((-gptr- "const gsl_permutation *") p) 
    (gptr #{ gsl_permutation_data (  $p) #} )          ;; size_t * -> gptr
)


(de gsl_permutation_get (    p  i )
    ((-gptr- "const gsl_permutation *") p) 
    ((-int-) i)                     ;; size_t -> int
    (int #{ gsl_permutation_get (  $p ,$i) #} )                ;; size_t -> int
)

(de gsl_permutation_swap (    p  i  j )
    ((-gptr- "gsl_permutation *") p) 
    ((-int-) i)                     ;; size_t -> int
    ((-int-) j)                     ;; size_t -> int
    (int #{ gsl_permutation_swap (  $p ,$i ,$j) #} )
)


(de gsl_permutation_valid (    p )
    ((-gptr- "gsl_permutation *") p) 
    (int #{ gsl_permutation_valid (  $p) #} )
)

(de gsl_permutation_reverse (    p )
    ((-gptr- "gsl_permutation *") p) 
    #{ gsl_permutation_reverse (  $p) #} 
    ()
)

(de gsl_permutation_inverse (    inv  p )
    ((-gptr- "gsl_permutation *") inv) 
    ((-gptr- "const gsl_permutation *") p) 
    (int #{ gsl_permutation_inverse (  $inv ,$p) #} )
)

(de gsl_permutation_next (    p )
    ((-gptr- "gsl_permutation *") p) 
    (int #{ gsl_permutation_next (  $p) #} )
)

(de gsl_permutation_prev (    p )
    ((-gptr- "gsl_permutation *") p) 
    (int #{ gsl_permutation_prev (  $p) #} )
)



;;;;*******************************************************************************************
;;;;         gsl_permute




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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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













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

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






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

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






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

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






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

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






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

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






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

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






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

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






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

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



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

(dhc-make ()
  dummy_permutation
  gsl_permutation_alloc
  gsl_permutation_calloc
  gsl_permutation_init
  gsl_permutation_free
  gsl_permutation_memcpy
  gsl_permutation_fread
  gsl_permutation_fwrite
  gsl_permutation_fscanf
  gsl_permutation_fprintf
  gsl_permutation_size
  gsl_permutation_data
  gsl_permutation_get
  gsl_permutation_swap
  gsl_permutation_valid
  gsl_permutation_reverse
  gsl_permutation_inverse
  gsl_permutation_next
  gsl_permutation_prev
  gsl_permute_char
  gsl_permute_char_inverse
  gsl_permute_complex
  gsl_permute_complex_inverse
  gsl_permute_complex_float
  gsl_permute_complex_float_inverse
  gsl_permute_complex_long_double
  gsl_permute_complex_long_double_inverse
  gsl_permute
  gsl_permute_inverse
  gsl_permute_float
  gsl_permute_float_inverse
  gsl_permute_int
  gsl_permute_int_inverse
  gsl_permute_long_double
  gsl_permute_long_double_inverse
  gsl_permute_long
  gsl_permute_long_inverse
  gsl_permute_short
  gsl_permute_short_inverse
  gsl_permute_uchar
  gsl_permute_uchar_inverse
  gsl_permute_uint
  gsl_permute_uint_inverse
  gsl_permute_ulong
  gsl_permute_ulong_inverse
  gsl_permute_ushort
  gsl_permute_ushort_inverse
  gsl_permute_vector_char
  gsl_permute_vector_char_inverse
  gsl_permute_vector_complex
  gsl_permute_vector_complex_inverse
  gsl_permute_vector_complex_float
  gsl_permute_vector_complex_float_inverse
  gsl_permute_vector_complex_long_double
  gsl_permute_vector_complex_long_double_inverse
  gsl_permute_vector
  gsl_permute_vector_inverse
  gsl_permute_vector_float
  gsl_permute_vector_float_inverse
  gsl_permute_vector_int
  gsl_permute_vector_int_inverse
  gsl_permute_vector_long_double
  gsl_permute_vector_long_double_inverse
  gsl_permute_vector_long
  gsl_permute_vector_long_inverse
  gsl_permute_vector_short
  gsl_permute_vector_short_inverse
  gsl_permute_vector_uchar
  gsl_permute_vector_uchar_inverse
  gsl_permute_vector_uint
  gsl_permute_vector_uint_inverse
  gsl_permute_vector_ulong
  gsl_permute_vector_ulong_inverse
  gsl_permute_vector_ushort
  gsl_permute_vector_ushort_inverse
)
