id
int64 0
45.1k
| file_name
stringlengths 4
68
| file_path
stringlengths 14
193
| content
stringlengths 32
9.62M
| size
int64 32
9.62M
| language
stringclasses 1
value | extension
stringclasses 6
values | total_lines
int64 1
136k
| avg_line_length
float64 3
903k
| max_line_length
int64 3
4.51M
| alphanum_fraction
float64 0
1
| repo_name
stringclasses 779
values | repo_stars
int64 0
882
| repo_forks
int64 0
108
| repo_open_issues
int64 0
90
| repo_license
stringclasses 8
values | repo_extraction_date
stringclasses 146
values | sha
stringlengths 64
64
| __index_level_0__
int64 0
45.1k
| exdup_ids_cmlisp_stkv2
sequencelengths 1
47
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
31,731 | cl-nono.asd | robotjunkyard_cl-nono/cl-nono.asd | ;;;;;; cl-nono.asd
;;;
;;; This is an ASDF system definition file for the CL-NONO project.
;;;
;;; I've never futzed with ASDF directly too much, and IMO it is best to let
;;; Quicklisp by Zach Beane (http://www.quicklisp.org) handle this for you.
;;; Where quicklisp installs itself (usually 'quicklisp' dir under your respective
;;; user home directory), there will be a 'local-projects' directory. In that,
;;; make directory symbolic links to the actual location of your project's main
;;; source folder. For CL-NONO I have this directory junction made:
;;;
;;; Directory of C:\Users\Nick\AppData\Roaming\quicklisp\local-projects
;;;
;;; 10/21/2016 02:04 AM <DIR> .
;;; 10/21/2016 02:04 AM <DIR> ..
;;; 10/21/2016 02:04 AM <JUNCTION> cl-nono [c:\src\cl-nono]
;;; 10/21/2016 02:04 AM 40 system-index.txt
;;;
;;; With this 'CL-NONO' symbolic link here, Quicklisp allows me to load the
;;; entire CL-NONO project by simply type in the SBCL repl:
;;;
;;; (quicklisp:quickload :CL-NONO)
;;;
;;; It will then see CL-NONO under local-projects, and then it knows what to
;;; load when it sees this very file you are reading right now.
;;;
;;; You can also skip ASDF stuff altogether and just load the LOADME.LISP file
;;; instead. It's easier for new users.
(asdf:defsystem #:cl-nono
:description "A small, simple Nonogram puzzle game written in Common Lisp"
:author "Nick Baker <[email protected]>"
:license "GPL3"
:depends-on (#:lispbuilder-sdl-image
#:lispbuilder-sdl)
:serial t
:components ((:file "package")
(:file "types")
(:file "vars")
(:file "pictures")
(:file "puzzle")
(:file "board")
(:file "serial")
(:file "cl-nono")))
| 1,774 | Common Lisp | .asd | 43 | 38.255814 | 82 | 0.662616 | robotjunkyard/cl-nono | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:01 AM (Europe/Amsterdam) | 576d0c301c8cb4fe002a62609b28f0d4d3794a39bf631c78392ac2d7a73ba66c | 31,731 | [
-1
] |
31,755 | package.lisp | appleby_cl-opsresearch/package.lisp | ;;;; package.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(defpackage #:cl-opsresearch
(:use #:cl)
(:export
#:Problem
#:release
#:name-of
))
(defpackage #:or-cffi
(:use #:cl)
(:export
#:with-foreign-alloc
))
(defpackage #:or-milp
(:use #:cl)
(:export
#:Problem
#:read-mls
))
| 1,040 | Common Lisp | .lisp | 36 | 26.444444 | 74 | 0.664665 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | c58b32879e5a3a4483545d7e813a467cd94d573ec76f0deb769e7badbd7ed285 | 31,755 | [
-1
] |
31,756 | cl-opsresearch.lisp | appleby_cl-opsresearch/cl-opsresearch.lisp | ;;;; cl-opsresearch.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:cl-opsresearch)
;;; "cl-opsresearch" goes here. Hacks and glory await!
| 872 | Common Lisp | .lisp | 20 | 42.15 | 74 | 0.699292 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 07a53bd57b1b1a64bc5431b65d349162ce9f4d5128dcad201fbd5d286217cff1 | 31,756 | [
-1
] |
31,757 | package.lisp | appleby_cl-opsresearch/subsystem/or-cluster/package.lisp | ;;;; package.lisp
;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2016 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 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 Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;
;;;; END LICENSE BLOCK ;;;;;
(defpackage #:or-cluster
(:use #:cl))
| 894 | Common Lisp | .lisp | 21 | 41.095238 | 80 | 0.706897 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 4fb1ae71dea9cc0ddbaa84d019f641dda60397b7b716433fb70e6badf7253838 | 31,757 | [
-1
] |
31,758 | or-cluster.lisp | appleby_cl-opsresearch/subsystem/or-cluster/or-cluster.lisp | ;;;; or-cluster.lisp
;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2016 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 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 Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;
;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-cluster)
;;; "or-cluster" goes here. Hacks and glory await!
| 935 | Common Lisp | .lisp | 21 | 43.095238 | 80 | 0.70989 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 7a9c67d608e058a30eaf27e9a52b1ee282c50b9998f481e953a5a0fb03c8c480 | 31,758 | [
-1
] |
31,759 | package.lisp | appleby_cl-opsresearch/subsystem/or-fann/package.lisp | ;;;; package.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(defpackage #:or-fann
(:use #:cl)
(:export
#:start
#:fann-net
#:name
#:run
#:randomize-weights
#:with-network
#:print-parameters
#:get-num-input
#:get-num-output
#:get-total-neurons
#:get-total-connections
#:get-connection-rate
#:get-num-layers
#:get-network-type
#:get-layer-array
#:get-bias-array
))
(defpackage #:fann
(:use #:cl))
| 1,205 | Common Lisp | .lisp | 40 | 26.625 | 74 | 0.652885 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | d0dcba1b511578d3c62c6f8a7809a5d4b1ba302c4095bf742a7d2038d2b4b7eb | 31,759 | [
-1
] |
31,760 | or-fann.lisp | appleby_cl-opsresearch/subsystem/or-fann/or-fann.lisp | ;;;; or-fann.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-fann)
(defvar *lib-loaded* nil)
(cffi:define-foreign-library fann
(t (:default "libfann")))
(defun start ()
(unless *lib-loaded*
(cffi:use-foreign-library fann))
(setf *lib-loaded* T))
(start) | 1,005 | Common Lisp | .lisp | 27 | 35.333333 | 74 | 0.688592 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 09b716f8f21ace860f98d0ad8634079ae870499e7ddbe3274dd7cb88bc81038b | 31,760 | [
-1
] |
31,761 | network.lisp | appleby_cl-opsresearch/subsystem/or-fann/network.lisp | ;;;; network.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-fann)
(cffi:defcenum fann_nettype_enum :FANN-NETTYPE-LAYER :FANN-NETTYPE-SHORTCUT)
;; COMMON BASE
(defclass Network (cl-opsresearch:Problem)
((name :reader name)
(fann-net :reader fann-net)))
(defmethod release ((net Network))
(fann:fann-destroy (fann-net net)))
(defmethod randomize-weights ((net Network) min max)
(fann:fann-randomize-weights (fann-net net) min max))
(defmethod run ((net Network) inputs)
(or-cffi:with-foreign-alloc
(array :double :initial-contents inputs)
(fann:fann-run (fann-net net) array)))
(defmethod initialize-instance :after ((net Network) &key (net-type :STANDARD) (name "Anonymous") (layers nil) (connection-rate nil))
(unless layers (error "The keyword argument :layers must be provides for an OR-FANN:NETWORK !!!"))
(or-cffi:with-foreign-alloc
(array :unsigned-int :initial-contents layers)
(setf (slot-value net 'name) name)
(setf (slot-value net 'fann-net)
(cond
((eq net-type :SPARSE)
(unless connection-rate (error "The keyword argument :connection-rate must be provided for a :SPARSE type of OR-FANN:NETWORK !!!"))
(fann:fann-create-sparse-array connection-rate (length layers) array))
((eq net-type :SHORTCUT) (fann:fann-create-shortcut-array (length layers) array))
((eq net-type :STANDARD) (fann:fann-create-standard-array (length layers) array))
(T (error (format nil "The keyword argument :net-type is unrecognized: ~A" net-type)))))))
(defmacro with-network ((var &rest init-options) &body body)
(let ((obj (gensym)))
`(let (,var ,obj)
(unwind-protect
(progn (setq ,obj (make-instance 'Network ,@init-options)
,var ,obj)
,@body)
(unless (null ,obj)
(release ,obj))))))
| 2,618 | Common Lisp | .lisp | 54 | 43.462963 | 144 | 0.670713 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 458d8588844d7791d4896d65d9047397c5583b1dca83919a7c23ee11a475da7d | 31,761 | [
-1
] |
31,762 | parameters.lisp | appleby_cl-opsresearch/subsystem/or-fann/parameters.lisp | ;;;; parameters.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-fann)
(defmethod print-parameters ((net Network))
(fann:fann-print-parameters (fann-net net)))
(defmethod get-num-input ((net Network))
(fann:fann-get-num-input (fann-net net)))
(defmethod get-total-neurons ((net Network))
(fann:fann-get-total-neurons (fann-net net)))
(defmethod get-total-connections ((net Network))
(fann:fann-get-total-connections (fann-net net)))
(defmethod get-connection-rate ((net Network))
(fann:fann-get-connection-rate (fann-net net)))
(defmethod get-num-layers ((net Network))
(fann:fann-get-num-layers (fann-net net)))
(defmethod get-network-type ((net Network))
(cffi:foreign-enum-keyword 'fann_nettype_enum (cffi:pointer-address (fann:fann-get-network-type (fann-net net)))))
(defmethod get-layer-array ((net Network))
(let ((n (get-num-layers net)))
(cffi::with-foreign-object
(array :uint n)
(fann:fann-get-layer-array (fann-net net) array)
(loop for i from 0 below n
collect (cffi:mem-aref array :uint i)))))
(defmethod get-bias-array ((net Network))
(let ((n (get-num-layers net)))
(cffi::with-foreign-object
(array :int n)
(fann:fann-get-bias-array (fann-net net) array)
(loop for i from 0 below n
collect (cffi:mem-aref array :int i)))))
| 2,070 | Common Lisp | .lisp | 47 | 40.829787 | 116 | 0.691542 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 6ffcb4dbd8d319f44a27466a9d18fa3e16b89584faaa58801e8dcc2719f6b3ca | 31,762 | [
-1
] |
31,763 | fann.lisp | appleby_cl-opsresearch/subsystem/or-fann/swig/fann.lisp | (in-package #:fann)
;;; This file was automatically generated by SWIG (http://www.swig.org).
;;; Version 3.0.7
;;;
;;; Do not make changes to this file unless you know what you are doing--modify
;;; the SWIG interface file instead.
;;;SWIG wrapper code starts here
(cl:defmacro defanonenum (cl:&body enums)
"Converts anonymous enums to defconstants."
`(cl:progn ,@(cl:loop for value in enums
for index = 0 then (cl:1+ index)
when (cl:listp value) do (cl:setf index (cl:second value)
value (cl:first value))
collect `(cl:defconstant ,value ,index))))
(cl:eval-when (:compile-toplevel :load-toplevel)
(cl:unless (cl:fboundp 'swig-lispify)
(cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
(cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
(cl:cond
((cl:null lst)
rest)
((cl:upper-case-p c)
(helper (cl:cdr lst) 'upper
(cl:case last
((lower digit) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:lower-case-p c)
(helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
((cl:digit-char-p c)
(helper (cl:cdr lst) 'digit
(cl:case last
((upper lower) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:char-equal c #\_)
(helper (cl:cdr lst) '_ (cl:cons #\- rest)))
(cl:t
(cl:error "Invalid character: ~A" c)))))
(cl:let ((fix (cl:case flag
((constant enumvalue) "+")
(variable "*")
(cl:t ""))))
(cl:intern
(cl:concatenate
'cl:string
fix
(cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
fix)
package))))))
;;;SWIG wrapper code ends here
(cffi:defctype #.(swig-lispify "fann_type" 'typename) :double)
(cl:export '#.(swig-lispify "fann_type" 'typename))
(cl:defconstant #.(swig-lispify "NULL" 'constant) 0)
(cl:export '#.(swig-lispify "NULL" 'constant))
(cffi:defcfun ("fann_create_standard" #.(swig-lispify "fann_create_standard" 'function)) :pointer
(num_layers :unsigned-int)
&rest)
(cl:export '#.(swig-lispify "fann_create_standard" 'function))
(cffi:defcfun ("fann_create_standard_array" #.(swig-lispify "fann_create_standard_array" 'function)) :pointer
(num_layers :unsigned-int)
(layers :pointer))
(cl:export '#.(swig-lispify "fann_create_standard_array" 'function))
(cffi:defcfun ("fann_create_sparse" #.(swig-lispify "fann_create_sparse" 'function)) :pointer
(connection_rate :float)
(num_layers :unsigned-int)
&rest)
(cl:export '#.(swig-lispify "fann_create_sparse" 'function))
(cffi:defcfun ("fann_create_sparse_array" #.(swig-lispify "fann_create_sparse_array" 'function)) :pointer
(connection_rate :float)
(num_layers :unsigned-int)
(layers :pointer))
(cl:export '#.(swig-lispify "fann_create_sparse_array" 'function))
(cffi:defcfun ("fann_create_shortcut" #.(swig-lispify "fann_create_shortcut" 'function)) :pointer
(num_layers :unsigned-int)
&rest)
(cl:export '#.(swig-lispify "fann_create_shortcut" 'function))
(cffi:defcfun ("fann_create_shortcut_array" #.(swig-lispify "fann_create_shortcut_array" 'function)) :pointer
(num_layers :unsigned-int)
(layers :pointer))
(cl:export '#.(swig-lispify "fann_create_shortcut_array" 'function))
(cffi:defcfun ("fann_destroy" #.(swig-lispify "fann_destroy" 'function)) :void
(ann :pointer))
(cl:export '#.(swig-lispify "fann_destroy" 'function))
(cffi:defcfun ("fann_copy" #.(swig-lispify "fann_copy" 'function)) :pointer
(ann :pointer))
(cl:export '#.(swig-lispify "fann_copy" 'function))
(cffi:defcfun ("fann_run" #.(swig-lispify "fann_run" 'function)) :pointer
(ann :pointer)
(input :pointer))
(cl:export '#.(swig-lispify "fann_run" 'function))
(cffi:defcfun ("fann_randomize_weights" #.(swig-lispify "fann_randomize_weights" 'function)) :void
(ann :pointer)
(min_weight :double)
(max_weight :double))
(cl:export '#.(swig-lispify "fann_randomize_weights" 'function))
(cffi:defcfun ("fann_init_weights" #.(swig-lispify "fann_init_weights" 'function)) :void
(ann :pointer)
(train_data :pointer))
(cl:export '#.(swig-lispify "fann_init_weights" 'function))
(cffi:defcfun ("fann_print_connections" #.(swig-lispify "fann_print_connections" 'function)) :void
(ann :pointer))
(cl:export '#.(swig-lispify "fann_print_connections" 'function))
(cffi:defcfun ("fann_print_parameters" #.(swig-lispify "fann_print_parameters" 'function)) :void
(ann :pointer))
(cl:export '#.(swig-lispify "fann_print_parameters" 'function))
(cffi:defcfun ("fann_get_num_input" #.(swig-lispify "fann_get_num_input" 'function)) :unsigned-int
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_num_input" 'function))
(cffi:defcfun ("fann_get_num_output" #.(swig-lispify "fann_get_num_output" 'function)) :unsigned-int
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_num_output" 'function))
(cffi:defcfun ("fann_get_total_neurons" #.(swig-lispify "fann_get_total_neurons" 'function)) :unsigned-int
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_total_neurons" 'function))
(cffi:defcfun ("fann_get_total_connections" #.(swig-lispify "fann_get_total_connections" 'function)) :unsigned-int
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_total_connections" 'function))
(cffi:defcfun ("fann_get_network_type" #.(swig-lispify "fann_get_network_type" 'function)) :pointer
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_network_type" 'function))
(cffi:defcfun ("fann_get_connection_rate" #.(swig-lispify "fann_get_connection_rate" 'function)) :float
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_connection_rate" 'function))
(cffi:defcfun ("fann_get_num_layers" #.(swig-lispify "fann_get_num_layers" 'function)) :unsigned-int
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_num_layers" 'function))
(cffi:defcfun ("fann_get_layer_array" #.(swig-lispify "fann_get_layer_array" 'function)) :void
(ann :pointer)
(layers :pointer))
(cl:export '#.(swig-lispify "fann_get_layer_array" 'function))
(cffi:defcfun ("fann_get_bias_array" #.(swig-lispify "fann_get_bias_array" 'function)) :void
(ann :pointer)
(bias :pointer))
(cl:export '#.(swig-lispify "fann_get_bias_array" 'function))
(cffi:defcfun ("fann_get_connection_array" #.(swig-lispify "fann_get_connection_array" 'function)) :void
(ann :pointer)
(connections :pointer))
(cl:export '#.(swig-lispify "fann_get_connection_array" 'function))
(cffi:defcfun ("fann_set_weight_array" #.(swig-lispify "fann_set_weight_array" 'function)) :void
(ann :pointer)
(connections :pointer)
(num_connections :unsigned-int))
(cl:export '#.(swig-lispify "fann_set_weight_array" 'function))
(cffi:defcfun ("fann_set_weight" #.(swig-lispify "fann_set_weight" 'function)) :void
(ann :pointer)
(from_neuron :unsigned-int)
(to_neuron :unsigned-int)
(weight :double))
(cl:export '#.(swig-lispify "fann_set_weight" 'function))
(cffi:defcfun ("fann_set_user_data" #.(swig-lispify "fann_set_user_data" 'function)) :void
(ann :pointer)
(user_data :pointer))
(cl:export '#.(swig-lispify "fann_set_user_data" 'function))
(cffi:defcfun ("fann_get_user_data" #.(swig-lispify "fann_get_user_data" 'function)) :pointer
(ann :pointer))
(cl:export '#.(swig-lispify "fann_get_user_data" 'function))
| 7,885 | Common Lisp | .lisp | 155 | 43.716129 | 114 | 0.636874 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 7cea20415abd5f492c3b77e50144c2b64e80c0c19e716deee344732ae3e498e9 | 31,763 | [
-1
] |
31,764 | problem.lisp | appleby_cl-opsresearch/subsystem/or-glpk/problem.lisp | ;;;; problem.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-glpk)
(defclass Problem (or-milp:Problem)(
(glp-prob :reader glp-prob :initarg glp-prob :initform (glp:glp-create-prob))))
(defmethod initialize-instance :after ((p Problem) &key (name nil))
(when name (glp:glp-set-prob-name (glp-prob p) name )))
(defmethod release ((problem Problem))
(glp:glp-delete-prob (glp-prob problem)))
(defmethod name ((problem Problem))
(glp:glp-get-prob-name (glp-prob problem)))
(defmethod read-mps ((problem Problem) path &key format)
(if (eq format :fixed)
(glp:glp-read-mps (glp-prob problem) glp:+GLP-MPS-DECK+ (cffi:null-pointer) (namestring path))
(glp:glp-read-mps (glp-prob problem) glp:+GLP-MPS-FILE+ (cffi:null-pointer) (namestring path))))
(defmethod write-mps ((problem Problem) path &key format)
(if (eq format :fixed)
(glp:glp-write-mps (glp-prob problem) glp:+GLP-MPS-DECK+ (cffi:null-pointer) (namestring path))
(glp:glp-write-mps (glp-prob problem) glp:+GLP-MPS-FILE+ (cffi:null-pointer) (namestring path))))
(defmethod read-cplex-lp ((problem Problem) path)
(glp:glp-read-lp (glp-prob problem) (cffi:null-pointer) (namestring path)))
(defmethod write-cplex-lp ((problem Problem) path)
(glp:glp-write-lp (glp-prob problem) (cffi:null-pointer) (namestring path)))
(defmacro with-problem ((var &rest init-options) &body body)
(let ((obj (gensym)))
`(let (,var ,obj)
(unwind-protect
(progn (setq ,obj (make-instance 'problem ,@init-options)
,var ,obj)
,@body)
(unless (null ,obj)
(release ,obj))))))
| 2,380 | Common Lisp | .lisp | 48 | 45.479167 | 101 | 0.676293 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | f057e631fcf85cf25c517788c6caf25fabfe478621799c14efb605584670dc01 | 31,764 | [
-1
] |
31,765 | package.lisp | appleby_cl-opsresearch/subsystem/or-glpk/package.lisp | ;;;; package.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(defpackage #:or-glpk
(:use #:cl)
(:export
#:glp-prob
#:name
#:with-problem
#:write-cplex-lp
#:read-cplex-lp
#:write-mps
#:read-mps
))
(defpackage #:glp
(:use #:cl))
| 977 | Common Lisp | .lisp | 31 | 29.225806 | 74 | 0.669851 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 772e49b2529f96c997fb459e46b293339eb42bf237f21c8b3502248573f6cd86 | 31,765 | [
-1
] |
31,766 | or-glpk.lisp | appleby_cl-opsresearch/subsystem/or-glpk/or-glpk.lisp | ;;;; or-glpk.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-glpk)
(defvar *lib-loaded* nil)
(cffi:define-foreign-library glpk
(t (:default "libglpk")))
(defun start ()
(unless *lib-loaded*
(cffi:use-foreign-library glpk)
(setf *lib-loaded* T)))
(start)
| 999 | Common Lisp | .lisp | 27 | 35.333333 | 74 | 0.693582 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | e167eac5fc76bbbdf3bbda80db91693cdc9eee9235f933216aed22af1568810d | 31,766 | [
-1
] |
31,767 | glpk.lisp | appleby_cl-opsresearch/subsystem/or-glpk/swig/glpk.lisp | (in-package #:glp)
;;; This file was automatically generated by SWIG (http://www.swig.org).
;;; Version 3.0.5
;;;
;;; Do not make changes to this file unless you know what you are doing--modify
;;; the SWIG interface file instead.
;;;SWIG wrapper code starts here
(cl:defmacro defanonenum (cl:&body enums)
"Converts anonymous enums to defconstants."
`(cl:progn ,@(cl:loop for value in enums
for index = 0 then (cl:1+ index)
when (cl:listp value) do (cl:setf index (cl:second value)
value (cl:first value))
collect `(cl:defconstant ,value ,index))))
(cl:eval-when (:compile-toplevel :load-toplevel)
(cl:unless (cl:fboundp 'swig-lispify)
(cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
(cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
(cl:cond
((cl:null lst)
rest)
((cl:upper-case-p c)
(helper (cl:cdr lst) 'upper
(cl:case last
((lower digit) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:lower-case-p c)
(helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
((cl:digit-char-p c)
(helper (cl:cdr lst) 'digit
(cl:case last
((upper lower) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:char-equal c #\_)
(helper (cl:cdr lst) '_ (cl:cons #\- rest)))
(cl:t
(cl:error "Invalid character: ~A" c)))))
(cl:let ((fix (cl:case flag
((constant enumvalue) "+")
(variable "*")
(cl:t ""))))
(cl:intern
(cl:concatenate
'cl:string
fix
(cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
fix)
package))))))
;;;SWIG wrapper code ends here
(cl:defconstant #.(swig-lispify "GLP_MAJOR_VERSION" 'constant) 4)
(cl:export '#.(swig-lispify "GLP_MAJOR_VERSION" 'constant))
(cl:defconstant #.(swig-lispify "GLP_MINOR_VERSION" 'constant) 52)
(cl:export '#.(swig-lispify "GLP_MINOR_VERSION" 'constant))
(cffi:defctype #.(swig-lispify "glp_prob" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_prob" 'typename))
(cl:defconstant #.(swig-lispify "GLP_MIN" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GLP_MAX" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GLP_CV" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_CV" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IV" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_IV" 'constant))
(cl:defconstant #.(swig-lispify "GLP_BV" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_BV" 'constant))
(cl:defconstant #.(swig-lispify "GLP_FR" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_FR" 'constant))
(cl:defconstant #.(swig-lispify "GLP_LO" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_LO" 'constant))
(cl:defconstant #.(swig-lispify "GLP_UP" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_UP" 'constant))
(cl:defconstant #.(swig-lispify "GLP_DB" 'constant) 4)
(cl:export '#.(swig-lispify "GLP_DB" 'constant))
(cl:defconstant #.(swig-lispify "GLP_FX" 'constant) 5)
(cl:export '#.(swig-lispify "GLP_FX" 'constant))
(cl:defconstant #.(swig-lispify "GLP_BS" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_BS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NL" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_NL" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NU" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_NU" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NF" 'constant) 4)
(cl:export '#.(swig-lispify "GLP_NF" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NS" 'constant) 5)
(cl:export '#.(swig-lispify "GLP_NS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SF_GM" 'constant) #x01)
(cl:export '#.(swig-lispify "GLP_SF_GM" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SF_EQ" 'constant) #x10)
(cl:export '#.(swig-lispify "GLP_SF_EQ" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SF_2N" 'constant) #x20)
(cl:export '#.(swig-lispify "GLP_SF_2N" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SF_SKIP" 'constant) #x40)
(cl:export '#.(swig-lispify "GLP_SF_SKIP" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SF_AUTO" 'constant) #x80)
(cl:export '#.(swig-lispify "GLP_SF_AUTO" 'constant))
(cl:defconstant #.(swig-lispify "GLP_SOL" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_SOL" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IPT" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_IPT" 'constant))
(cl:defconstant #.(swig-lispify "GLP_MIP" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_MIP" 'constant))
(cl:defconstant #.(swig-lispify "GLP_UNDEF" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_UNDEF" 'constant))
(cl:defconstant #.(swig-lispify "GLP_FEAS" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_FEAS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_INFEAS" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_INFEAS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NOFEAS" 'constant) 4)
(cl:export '#.(swig-lispify "GLP_NOFEAS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_OPT" 'constant) 5)
(cl:export '#.(swig-lispify "GLP_OPT" 'constant))
(cl:defconstant #.(swig-lispify "GLP_UNBND" 'constant) 6)
(cl:export '#.(swig-lispify "GLP_UNBND" 'constant))
(cffi:defcstruct #.(swig-lispify "glp_bfcp" 'classname)
(#.(swig-lispify "msg_lev" 'slotname) :int)
(#.(swig-lispify "type" 'slotname) :int)
(#.(swig-lispify "lu_size" 'slotname) :int)
(#.(swig-lispify "piv_tol" 'slotname) :double)
(#.(swig-lispify "piv_lim" 'slotname) :int)
(#.(swig-lispify "suhl" 'slotname) :int)
(#.(swig-lispify "eps_tol" 'slotname) :double)
(#.(swig-lispify "max_gro" 'slotname) :double)
(#.(swig-lispify "nfs_max" 'slotname) :int)
(#.(swig-lispify "upd_tol" 'slotname) :double)
(#.(swig-lispify "nrs_max" 'slotname) :int)
(#.(swig-lispify "rs_size" 'slotname) :int)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_bfcp" 'classname))
(cl:export '#.(swig-lispify "msg_lev" 'slotname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "lu_size" 'slotname))
(cl:export '#.(swig-lispify "piv_tol" 'slotname))
(cl:export '#.(swig-lispify "piv_lim" 'slotname))
(cl:export '#.(swig-lispify "suhl" 'slotname))
(cl:export '#.(swig-lispify "eps_tol" 'slotname))
(cl:export '#.(swig-lispify "max_gro" 'slotname))
(cl:export '#.(swig-lispify "nfs_max" 'slotname))
(cl:export '#.(swig-lispify "upd_tol" 'slotname))
(cl:export '#.(swig-lispify "nrs_max" 'slotname))
(cl:export '#.(swig-lispify "rs_size" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_bfcp" 'typename) #.(swig-lispify "glp_bfcp" 'classname))
(cl:export '#.(swig-lispify "glp_bfcp" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_smcp" 'classname)
(#.(swig-lispify "msg_lev" 'slotname) :int)
(#.(swig-lispify "meth" 'slotname) :int)
(#.(swig-lispify "pricing" 'slotname) :int)
(#.(swig-lispify "r_test" 'slotname) :int)
(#.(swig-lispify "tol_bnd" 'slotname) :double)
(#.(swig-lispify "tol_dj" 'slotname) :double)
(#.(swig-lispify "tol_piv" 'slotname) :double)
(#.(swig-lispify "obj_ll" 'slotname) :double)
(#.(swig-lispify "obj_ul" 'slotname) :double)
(#.(swig-lispify "it_lim" 'slotname) :int)
(#.(swig-lispify "tm_lim" 'slotname) :int)
(#.(swig-lispify "out_frq" 'slotname) :int)
(#.(swig-lispify "out_dly" 'slotname) :int)
(#.(swig-lispify "presolve" 'slotname) :int)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_smcp" 'classname))
(cl:export '#.(swig-lispify "msg_lev" 'slotname))
(cl:export '#.(swig-lispify "meth" 'slotname))
(cl:export '#.(swig-lispify "pricing" 'slotname))
(cl:export '#.(swig-lispify "r_test" 'slotname))
(cl:export '#.(swig-lispify "tol_bnd" 'slotname))
(cl:export '#.(swig-lispify "tol_dj" 'slotname))
(cl:export '#.(swig-lispify "tol_piv" 'slotname))
(cl:export '#.(swig-lispify "obj_ll" 'slotname))
(cl:export '#.(swig-lispify "obj_ul" 'slotname))
(cl:export '#.(swig-lispify "it_lim" 'slotname))
(cl:export '#.(swig-lispify "tm_lim" 'slotname))
(cl:export '#.(swig-lispify "out_frq" 'slotname))
(cl:export '#.(swig-lispify "out_dly" 'slotname))
(cl:export '#.(swig-lispify "presolve" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_smcp" 'typename) #.(swig-lispify "glp_smcp" 'classname))
(cl:export '#.(swig-lispify "glp_smcp" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_iptcp" 'classname)
(#.(swig-lispify "msg_lev" 'slotname) :int)
(#.(swig-lispify "ord_alg" 'slotname) :int)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_iptcp" 'classname))
(cl:export '#.(swig-lispify "msg_lev" 'slotname))
(cl:export '#.(swig-lispify "ord_alg" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_iptcp" 'typename) #.(swig-lispify "glp_iptcp" 'classname))
(cl:export '#.(swig-lispify "glp_iptcp" 'typename))
(cffi:defctype #.(swig-lispify "glp_tree" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_tree" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_iocp" 'classname)
(#.(swig-lispify "msg_lev" 'slotname) :int)
(#.(swig-lispify "br_tech" 'slotname) :int)
(#.(swig-lispify "bt_tech" 'slotname) :int)
(#.(swig-lispify "tol_int" 'slotname) :double)
(#.(swig-lispify "tol_obj" 'slotname) :double)
(#.(swig-lispify "tm_lim" 'slotname) :int)
(#.(swig-lispify "out_frq" 'slotname) :int)
(#.(swig-lispify "out_dly" 'slotname) :int)
(#.(swig-lispify "cb_func" 'slotname) :pointer)
(#.(swig-lispify "cb_info" 'slotname) :pointer)
(#.(swig-lispify "cb_size" 'slotname) :int)
(#.(swig-lispify "pp_tech" 'slotname) :int)
(#.(swig-lispify "mip_gap" 'slotname) :double)
(#.(swig-lispify "mir_cuts" 'slotname) :int)
(#.(swig-lispify "gmi_cuts" 'slotname) :int)
(#.(swig-lispify "cov_cuts" 'slotname) :int)
(#.(swig-lispify "clq_cuts" 'slotname) :int)
(#.(swig-lispify "presolve" 'slotname) :int)
(#.(swig-lispify "binarize" 'slotname) :int)
(#.(swig-lispify "fp_heur" 'slotname) :int)
(#.(swig-lispify "ps_heur" 'slotname) :int)
(#.(swig-lispify "ps_tm_lim" 'slotname) :int)
(#.(swig-lispify "use_sol" 'slotname) :int)
(#.(swig-lispify "save_sol" 'slotname) :string)
(#.(swig-lispify "alien" 'slotname) :int)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_iocp" 'classname))
(cl:export '#.(swig-lispify "msg_lev" 'slotname))
(cl:export '#.(swig-lispify "br_tech" 'slotname))
(cl:export '#.(swig-lispify "bt_tech" 'slotname))
(cl:export '#.(swig-lispify "tol_int" 'slotname))
(cl:export '#.(swig-lispify "tol_obj" 'slotname))
(cl:export '#.(swig-lispify "tm_lim" 'slotname))
(cl:export '#.(swig-lispify "out_frq" 'slotname))
(cl:export '#.(swig-lispify "out_dly" 'slotname))
(cl:export '#.(swig-lispify "cb_func" 'slotname))
(cl:export '#.(swig-lispify "cb_info" 'slotname))
(cl:export '#.(swig-lispify "cb_size" 'slotname))
(cl:export '#.(swig-lispify "pp_tech" 'slotname))
(cl:export '#.(swig-lispify "mip_gap" 'slotname))
(cl:export '#.(swig-lispify "mir_cuts" 'slotname))
(cl:export '#.(swig-lispify "gmi_cuts" 'slotname))
(cl:export '#.(swig-lispify "cov_cuts" 'slotname))
(cl:export '#.(swig-lispify "clq_cuts" 'slotname))
(cl:export '#.(swig-lispify "presolve" 'slotname))
(cl:export '#.(swig-lispify "binarize" 'slotname))
(cl:export '#.(swig-lispify "fp_heur" 'slotname))
(cl:export '#.(swig-lispify "ps_heur" 'slotname))
(cl:export '#.(swig-lispify "ps_tm_lim" 'slotname))
(cl:export '#.(swig-lispify "use_sol" 'slotname))
(cl:export '#.(swig-lispify "save_sol" 'slotname))
(cl:export '#.(swig-lispify "alien" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_iocp" 'typename) #.(swig-lispify "glp_iocp" 'classname))
(cl:export '#.(swig-lispify "glp_iocp" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_attr" 'classname)
(#.(swig-lispify "level" 'slotname) :int)
(#.(swig-lispify "origin" 'slotname) :int)
(#.(swig-lispify "klass" 'slotname) :int)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_attr" 'classname))
(cl:export '#.(swig-lispify "level" 'slotname))
(cl:export '#.(swig-lispify "origin" 'slotname))
(cl:export '#.(swig-lispify "klass" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_attr" 'typename) #.(swig-lispify "glp_attr" 'classname))
(cl:export '#.(swig-lispify "glp_attr" 'typename))
(cl:defconstant #.(swig-lispify "GLP_ON" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_ON" 'constant))
(cl:defconstant #.(swig-lispify "GLP_OFF" 'constant) 0)
(cl:export '#.(swig-lispify "GLP_OFF" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IROWGEN" 'constant) #x01)
(cl:export '#.(swig-lispify "GLP_IROWGEN" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IBINGO" 'constant) #x02)
(cl:export '#.(swig-lispify "GLP_IBINGO" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IHEUR" 'constant) #x03)
(cl:export '#.(swig-lispify "GLP_IHEUR" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ICUTGEN" 'constant) #x04)
(cl:export '#.(swig-lispify "GLP_ICUTGEN" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IBRANCH" 'constant) #x05)
(cl:export '#.(swig-lispify "GLP_IBRANCH" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ISELECT" 'constant) #x06)
(cl:export '#.(swig-lispify "GLP_ISELECT" 'constant))
(cl:defconstant #.(swig-lispify "GLP_IPREPRO" 'constant) #x07)
(cl:export '#.(swig-lispify "GLP_IPREPRO" 'constant))
(cl:defconstant #.(swig-lispify "GLP_NO_BRNCH" 'constant) 0)
(cl:export '#.(swig-lispify "GLP_NO_BRNCH" 'constant))
(cl:defconstant #.(swig-lispify "GLP_DN_BRNCH" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_DN_BRNCH" 'constant))
(cl:defconstant #.(swig-lispify "GLP_UP_BRNCH" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_UP_BRNCH" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EBADB" 'constant) #x01)
(cl:export '#.(swig-lispify "GLP_EBADB" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ESING" 'constant) #x02)
(cl:export '#.(swig-lispify "GLP_ESING" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ECOND" 'constant) #x03)
(cl:export '#.(swig-lispify "GLP_ECOND" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EBOUND" 'constant) #x04)
(cl:export '#.(swig-lispify "GLP_EBOUND" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EFAIL" 'constant) #x05)
(cl:export '#.(swig-lispify "GLP_EFAIL" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EOBJLL" 'constant) #x06)
(cl:export '#.(swig-lispify "GLP_EOBJLL" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EOBJUL" 'constant) #x07)
(cl:export '#.(swig-lispify "GLP_EOBJUL" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EITLIM" 'constant) #x08)
(cl:export '#.(swig-lispify "GLP_EITLIM" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ETMLIM" 'constant) #x09)
(cl:export '#.(swig-lispify "GLP_ETMLIM" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ENOPFS" 'constant) #x0A)
(cl:export '#.(swig-lispify "GLP_ENOPFS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ENODFS" 'constant) #x0B)
(cl:export '#.(swig-lispify "GLP_ENODFS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EROOT" 'constant) #x0C)
(cl:export '#.(swig-lispify "GLP_EROOT" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ESTOP" 'constant) #x0D)
(cl:export '#.(swig-lispify "GLP_ESTOP" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EMIPGAP" 'constant) #x0E)
(cl:export '#.(swig-lispify "GLP_EMIPGAP" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ENOFEAS" 'constant) #x0F)
(cl:export '#.(swig-lispify "GLP_ENOFEAS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ENOCVG" 'constant) #x10)
(cl:export '#.(swig-lispify "GLP_ENOCVG" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EINSTAB" 'constant) #x11)
(cl:export '#.(swig-lispify "GLP_EINSTAB" 'constant))
(cl:defconstant #.(swig-lispify "GLP_EDATA" 'constant) #x12)
(cl:export '#.(swig-lispify "GLP_EDATA" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ERANGE" 'constant) #x13)
(cl:export '#.(swig-lispify "GLP_ERANGE" 'constant))
(cl:defconstant #.(swig-lispify "GLP_KKT_PE" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_KKT_PE" 'constant))
(cl:defconstant #.(swig-lispify "GLP_KKT_PB" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_KKT_PB" 'constant))
(cl:defconstant #.(swig-lispify "GLP_KKT_DE" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_KKT_DE" 'constant))
(cl:defconstant #.(swig-lispify "GLP_KKT_DB" 'constant) 4)
(cl:export '#.(swig-lispify "GLP_KKT_DB" 'constant))
(cl:defconstant #.(swig-lispify "GLP_KKT_CS" 'constant) 5)
(cl:export '#.(swig-lispify "GLP_KKT_CS" 'constant))
(cl:defconstant #.(swig-lispify "GLP_MPS_DECK" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_MPS_DECK" 'constant))
(cl:defconstant #.(swig-lispify "GLP_MPS_FILE" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_MPS_FILE" 'constant))
(cffi:defcstruct #.(swig-lispify "glp_mpscp" 'classname)
(#.(swig-lispify "blank" 'slotname) :int)
(#.(swig-lispify "obj_name" 'slotname) :string)
(#.(swig-lispify "tol_mps" 'slotname) :double)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_mpscp" 'classname))
(cl:export '#.(swig-lispify "blank" 'slotname))
(cl:export '#.(swig-lispify "obj_name" 'slotname))
(cl:export '#.(swig-lispify "tol_mps" 'slotname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_mpscp" 'typename) #.(swig-lispify "glp_mpscp" 'classname))
(cl:export '#.(swig-lispify "glp_mpscp" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_cpxcp" 'classname)
(#.(swig-lispify "foo_bar" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_cpxcp" 'classname))
(cl:export '#.(swig-lispify "foo_bar" 'slotname))
(cffi:defctype #.(swig-lispify "glp_cpxcp" 'typename) #.(swig-lispify "glp_cpxcp" 'classname))
(cl:export '#.(swig-lispify "glp_cpxcp" 'typename))
(cffi:defctype #.(swig-lispify "glp_tran" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_tran" 'typename))
(cffi:defcfun ("glp_create_prob" #.(swig-lispify "glp_create_prob" 'function)) :pointer)
(cl:export '#.(swig-lispify "glp_create_prob" 'function))
(cffi:defcfun ("glp_set_prob_name" #.(swig-lispify "glp_set_prob_name" 'function)) :void
(P :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_set_prob_name" 'function))
(cffi:defcfun ("glp_set_obj_name" #.(swig-lispify "glp_set_obj_name" 'function)) :void
(P :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_set_obj_name" 'function))
(cffi:defcfun ("glp_set_obj_dir" #.(swig-lispify "glp_set_obj_dir" 'function)) :void
(P :pointer)
(dir :int))
(cl:export '#.(swig-lispify "glp_set_obj_dir" 'function))
(cffi:defcfun ("glp_add_rows" #.(swig-lispify "glp_add_rows" 'function)) :int
(P :pointer)
(nrs :int))
(cl:export '#.(swig-lispify "glp_add_rows" 'function))
(cffi:defcfun ("glp_add_cols" #.(swig-lispify "glp_add_cols" 'function)) :int
(P :pointer)
(ncs :int))
(cl:export '#.(swig-lispify "glp_add_cols" 'function))
(cffi:defcfun ("glp_set_row_name" #.(swig-lispify "glp_set_row_name" 'function)) :void
(P :pointer)
(i :int)
(name :string))
(cl:export '#.(swig-lispify "glp_set_row_name" 'function))
(cffi:defcfun ("glp_set_col_name" #.(swig-lispify "glp_set_col_name" 'function)) :void
(P :pointer)
(j :int)
(name :string))
(cl:export '#.(swig-lispify "glp_set_col_name" 'function))
(cffi:defcfun ("glp_set_row_bnds" #.(swig-lispify "glp_set_row_bnds" 'function)) :void
(P :pointer)
(i :int)
(type :int)
(lb :double)
(ub :double))
(cl:export '#.(swig-lispify "glp_set_row_bnds" 'function))
(cffi:defcfun ("glp_set_col_bnds" #.(swig-lispify "glp_set_col_bnds" 'function)) :void
(P :pointer)
(j :int)
(type :int)
(lb :double)
(ub :double))
(cl:export '#.(swig-lispify "glp_set_col_bnds" 'function))
(cffi:defcfun ("glp_set_obj_coef" #.(swig-lispify "glp_set_obj_coef" 'function)) :void
(P :pointer)
(j :int)
(coef :double))
(cl:export '#.(swig-lispify "glp_set_obj_coef" 'function))
(cffi:defcfun ("glp_set_mat_row" #.(swig-lispify "glp_set_mat_row" 'function)) :void
(P :pointer)
(i :int)
(len :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_set_mat_row" 'function))
(cffi:defcfun ("glp_set_mat_col" #.(swig-lispify "glp_set_mat_col" 'function)) :void
(P :pointer)
(j :int)
(len :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_set_mat_col" 'function))
(cffi:defcfun ("glp_load_matrix" #.(swig-lispify "glp_load_matrix" 'function)) :void
(P :pointer)
(ne :int)
(ia :pointer)
(ja :pointer)
(ar :pointer))
(cl:export '#.(swig-lispify "glp_load_matrix" 'function))
(cffi:defcfun ("glp_check_dup" #.(swig-lispify "glp_check_dup" 'function)) :int
(m :int)
(n :int)
(ne :int)
(ia :pointer)
(ja :pointer))
(cl:export '#.(swig-lispify "glp_check_dup" 'function))
(cffi:defcfun ("glp_sort_matrix" #.(swig-lispify "glp_sort_matrix" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_sort_matrix" 'function))
(cffi:defcfun ("glp_del_rows" #.(swig-lispify "glp_del_rows" 'function)) :void
(P :pointer)
(nrs :int)
(num :pointer))
(cl:export '#.(swig-lispify "glp_del_rows" 'function))
(cffi:defcfun ("glp_del_cols" #.(swig-lispify "glp_del_cols" 'function)) :void
(P :pointer)
(ncs :int)
(num :pointer))
(cl:export '#.(swig-lispify "glp_del_cols" 'function))
(cffi:defcfun ("glp_copy_prob" #.(swig-lispify "glp_copy_prob" 'function)) :void
(dest :pointer)
(prob :pointer)
(names :int))
(cl:export '#.(swig-lispify "glp_copy_prob" 'function))
(cffi:defcfun ("glp_erase_prob" #.(swig-lispify "glp_erase_prob" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_erase_prob" 'function))
(cffi:defcfun ("glp_delete_prob" #.(swig-lispify "glp_delete_prob" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_delete_prob" 'function))
(cffi:defcfun ("glp_get_prob_name" #.(swig-lispify "glp_get_prob_name" 'function)) :string
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_prob_name" 'function))
(cffi:defcfun ("glp_get_obj_name" #.(swig-lispify "glp_get_obj_name" 'function)) :string
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_obj_name" 'function))
(cffi:defcfun ("glp_get_obj_dir" #.(swig-lispify "glp_get_obj_dir" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_obj_dir" 'function))
(cffi:defcfun ("glp_get_num_rows" #.(swig-lispify "glp_get_num_rows" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_num_rows" 'function))
(cffi:defcfun ("glp_get_num_cols" #.(swig-lispify "glp_get_num_cols" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_num_cols" 'function))
(cffi:defcfun ("glp_get_row_name" #.(swig-lispify "glp_get_row_name" 'function)) :string
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_name" 'function))
(cffi:defcfun ("glp_get_col_name" #.(swig-lispify "glp_get_col_name" 'function)) :string
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_name" 'function))
(cffi:defcfun ("glp_get_row_type" #.(swig-lispify "glp_get_row_type" 'function)) :int
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_type" 'function))
(cffi:defcfun ("glp_get_row_lb" #.(swig-lispify "glp_get_row_lb" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_lb" 'function))
(cffi:defcfun ("glp_get_row_ub" #.(swig-lispify "glp_get_row_ub" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_ub" 'function))
(cffi:defcfun ("glp_get_col_type" #.(swig-lispify "glp_get_col_type" 'function)) :int
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_type" 'function))
(cffi:defcfun ("glp_get_col_lb" #.(swig-lispify "glp_get_col_lb" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_lb" 'function))
(cffi:defcfun ("glp_get_col_ub" #.(swig-lispify "glp_get_col_ub" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_ub" 'function))
(cffi:defcfun ("glp_get_obj_coef" #.(swig-lispify "glp_get_obj_coef" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_obj_coef" 'function))
(cffi:defcfun ("glp_get_num_nz" #.(swig-lispify "glp_get_num_nz" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_num_nz" 'function))
(cffi:defcfun ("glp_get_mat_row" #.(swig-lispify "glp_get_mat_row" 'function)) :int
(P :pointer)
(i :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_get_mat_row" 'function))
(cffi:defcfun ("glp_get_mat_col" #.(swig-lispify "glp_get_mat_col" 'function)) :int
(P :pointer)
(j :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_get_mat_col" 'function))
(cffi:defcfun ("glp_create_index" #.(swig-lispify "glp_create_index" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_create_index" 'function))
(cffi:defcfun ("glp_find_row" #.(swig-lispify "glp_find_row" 'function)) :int
(P :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_find_row" 'function))
(cffi:defcfun ("glp_find_col" #.(swig-lispify "glp_find_col" 'function)) :int
(P :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_find_col" 'function))
(cffi:defcfun ("glp_delete_index" #.(swig-lispify "glp_delete_index" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_delete_index" 'function))
(cffi:defcfun ("glp_set_rii" #.(swig-lispify "glp_set_rii" 'function)) :void
(P :pointer)
(i :int)
(rii :double))
(cl:export '#.(swig-lispify "glp_set_rii" 'function))
(cffi:defcfun ("glp_set_sjj" #.(swig-lispify "glp_set_sjj" 'function)) :void
(P :pointer)
(j :int)
(sjj :double))
(cl:export '#.(swig-lispify "glp_set_sjj" 'function))
(cffi:defcfun ("glp_get_rii" #.(swig-lispify "glp_get_rii" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_rii" 'function))
(cffi:defcfun ("glp_get_sjj" #.(swig-lispify "glp_get_sjj" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_sjj" 'function))
(cffi:defcfun ("glp_scale_prob" #.(swig-lispify "glp_scale_prob" 'function)) :void
(P :pointer)
(flags :int))
(cl:export '#.(swig-lispify "glp_scale_prob" 'function))
(cffi:defcfun ("glp_unscale_prob" #.(swig-lispify "glp_unscale_prob" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_unscale_prob" 'function))
(cffi:defcfun ("glp_set_row_stat" #.(swig-lispify "glp_set_row_stat" 'function)) :void
(P :pointer)
(i :int)
(stat :int))
(cl:export '#.(swig-lispify "glp_set_row_stat" 'function))
(cffi:defcfun ("glp_set_col_stat" #.(swig-lispify "glp_set_col_stat" 'function)) :void
(P :pointer)
(j :int)
(stat :int))
(cl:export '#.(swig-lispify "glp_set_col_stat" 'function))
(cffi:defcfun ("glp_std_basis" #.(swig-lispify "glp_std_basis" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_std_basis" 'function))
(cffi:defcfun ("glp_adv_basis" #.(swig-lispify "glp_adv_basis" 'function)) :void
(P :pointer)
(flags :int))
(cl:export '#.(swig-lispify "glp_adv_basis" 'function))
(cffi:defcfun ("glp_cpx_basis" #.(swig-lispify "glp_cpx_basis" 'function)) :void
(P :pointer))
(cl:export '#.(swig-lispify "glp_cpx_basis" 'function))
(cffi:defcfun ("glp_simplex" #.(swig-lispify "glp_simplex" 'function)) :int
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_simplex" 'function))
(cffi:defcfun ("glp_exact" #.(swig-lispify "glp_exact" 'function)) :int
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_exact" 'function))
(cffi:defcfun ("glp_init_smcp" #.(swig-lispify "glp_init_smcp" 'function)) :void
(parm :pointer))
(cl:export '#.(swig-lispify "glp_init_smcp" 'function))
(cffi:defcfun ("glp_get_status" #.(swig-lispify "glp_get_status" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_status" 'function))
(cffi:defcfun ("glp_get_prim_stat" #.(swig-lispify "glp_get_prim_stat" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_prim_stat" 'function))
(cffi:defcfun ("glp_get_dual_stat" #.(swig-lispify "glp_get_dual_stat" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_dual_stat" 'function))
(cffi:defcfun ("glp_get_obj_val" #.(swig-lispify "glp_get_obj_val" 'function)) :double
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_obj_val" 'function))
(cffi:defcfun ("glp_get_row_stat" #.(swig-lispify "glp_get_row_stat" 'function)) :int
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_stat" 'function))
(cffi:defcfun ("glp_get_row_prim" #.(swig-lispify "glp_get_row_prim" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_prim" 'function))
(cffi:defcfun ("glp_get_row_dual" #.(swig-lispify "glp_get_row_dual" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_dual" 'function))
(cffi:defcfun ("glp_get_col_stat" #.(swig-lispify "glp_get_col_stat" 'function)) :int
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_stat" 'function))
(cffi:defcfun ("glp_get_col_prim" #.(swig-lispify "glp_get_col_prim" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_prim" 'function))
(cffi:defcfun ("glp_get_col_dual" #.(swig-lispify "glp_get_col_dual" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_dual" 'function))
(cffi:defcfun ("glp_get_unbnd_ray" #.(swig-lispify "glp_get_unbnd_ray" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_unbnd_ray" 'function))
(cffi:defcfun ("glp_interior" #.(swig-lispify "glp_interior" 'function)) :int
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_interior" 'function))
(cffi:defcfun ("glp_init_iptcp" #.(swig-lispify "glp_init_iptcp" 'function)) :void
(parm :pointer))
(cl:export '#.(swig-lispify "glp_init_iptcp" 'function))
(cffi:defcfun ("glp_ipt_status" #.(swig-lispify "glp_ipt_status" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_ipt_status" 'function))
(cffi:defcfun ("glp_ipt_obj_val" #.(swig-lispify "glp_ipt_obj_val" 'function)) :double
(P :pointer))
(cl:export '#.(swig-lispify "glp_ipt_obj_val" 'function))
(cffi:defcfun ("glp_ipt_row_prim" #.(swig-lispify "glp_ipt_row_prim" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_ipt_row_prim" 'function))
(cffi:defcfun ("glp_ipt_row_dual" #.(swig-lispify "glp_ipt_row_dual" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_ipt_row_dual" 'function))
(cffi:defcfun ("glp_ipt_col_prim" #.(swig-lispify "glp_ipt_col_prim" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_ipt_col_prim" 'function))
(cffi:defcfun ("glp_ipt_col_dual" #.(swig-lispify "glp_ipt_col_dual" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_ipt_col_dual" 'function))
(cffi:defcfun ("glp_set_col_kind" #.(swig-lispify "glp_set_col_kind" 'function)) :void
(P :pointer)
(j :int)
(kind :int))
(cl:export '#.(swig-lispify "glp_set_col_kind" 'function))
(cffi:defcfun ("glp_get_col_kind" #.(swig-lispify "glp_get_col_kind" 'function)) :int
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_kind" 'function))
(cffi:defcfun ("glp_get_num_int" #.(swig-lispify "glp_get_num_int" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_num_int" 'function))
(cffi:defcfun ("glp_get_num_bin" #.(swig-lispify "glp_get_num_bin" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_get_num_bin" 'function))
(cffi:defcfun ("glp_intopt" #.(swig-lispify "glp_intopt" 'function)) :int
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_intopt" 'function))
(cffi:defcfun ("glp_init_iocp" #.(swig-lispify "glp_init_iocp" 'function)) :void
(parm :pointer))
(cl:export '#.(swig-lispify "glp_init_iocp" 'function))
(cffi:defcfun ("glp_mip_status" #.(swig-lispify "glp_mip_status" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_mip_status" 'function))
(cffi:defcfun ("glp_mip_obj_val" #.(swig-lispify "glp_mip_obj_val" 'function)) :double
(P :pointer))
(cl:export '#.(swig-lispify "glp_mip_obj_val" 'function))
(cffi:defcfun ("glp_mip_row_val" #.(swig-lispify "glp_mip_row_val" 'function)) :double
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_mip_row_val" 'function))
(cffi:defcfun ("glp_mip_col_val" #.(swig-lispify "glp_mip_col_val" 'function)) :double
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_mip_col_val" 'function))
(cffi:defcfun ("glp_check_kkt" #.(swig-lispify "glp_check_kkt" 'function)) :void
(P :pointer)
(sol :int)
(cond :int)
(ae_max :pointer)
(ae_ind :pointer)
(re_max :pointer)
(re_ind :pointer))
(cl:export '#.(swig-lispify "glp_check_kkt" 'function))
(cffi:defcfun ("glp_print_sol" #.(swig-lispify "glp_print_sol" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_print_sol" 'function))
(cffi:defcfun ("glp_read_sol" #.(swig-lispify "glp_read_sol" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_sol" 'function))
(cffi:defcfun ("glp_write_sol" #.(swig-lispify "glp_write_sol" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_sol" 'function))
(cffi:defcfun ("glp_print_ranges" #.(swig-lispify "glp_print_ranges" 'function)) :int
(P :pointer)
(len :int)
(list :pointer)
(flags :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_print_ranges" 'function))
(cffi:defcfun ("glp_print_ipt" #.(swig-lispify "glp_print_ipt" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_print_ipt" 'function))
(cffi:defcfun ("glp_read_ipt" #.(swig-lispify "glp_read_ipt" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_ipt" 'function))
(cffi:defcfun ("glp_write_ipt" #.(swig-lispify "glp_write_ipt" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_ipt" 'function))
(cffi:defcfun ("glp_print_mip" #.(swig-lispify "glp_print_mip" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_print_mip" 'function))
(cffi:defcfun ("glp_read_mip" #.(swig-lispify "glp_read_mip" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_mip" 'function))
(cffi:defcfun ("glp_write_mip" #.(swig-lispify "glp_write_mip" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_mip" 'function))
(cffi:defcfun ("glp_bf_exists" #.(swig-lispify "glp_bf_exists" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_bf_exists" 'function))
(cffi:defcfun ("glp_factorize" #.(swig-lispify "glp_factorize" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_factorize" 'function))
(cffi:defcfun ("glp_bf_updated" #.(swig-lispify "glp_bf_updated" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_bf_updated" 'function))
(cffi:defcfun ("glp_get_bfcp" #.(swig-lispify "glp_get_bfcp" 'function)) :void
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_get_bfcp" 'function))
(cffi:defcfun ("glp_set_bfcp" #.(swig-lispify "glp_set_bfcp" 'function)) :void
(P :pointer)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_set_bfcp" 'function))
(cffi:defcfun ("glp_get_bhead" #.(swig-lispify "glp_get_bhead" 'function)) :int
(P :pointer)
(k :int))
(cl:export '#.(swig-lispify "glp_get_bhead" 'function))
(cffi:defcfun ("glp_get_row_bind" #.(swig-lispify "glp_get_row_bind" 'function)) :int
(P :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_get_row_bind" 'function))
(cffi:defcfun ("glp_get_col_bind" #.(swig-lispify "glp_get_col_bind" 'function)) :int
(P :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_get_col_bind" 'function))
(cffi:defcfun ("glp_ftran" #.(swig-lispify "glp_ftran" 'function)) :void
(P :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "glp_ftran" 'function))
(cffi:defcfun ("glp_btran" #.(swig-lispify "glp_btran" 'function)) :void
(P :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "glp_btran" 'function))
(cffi:defcfun ("glp_warm_up" #.(swig-lispify "glp_warm_up" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_warm_up" 'function))
(cffi:defcfun ("glp_eval_tab_row" #.(swig-lispify "glp_eval_tab_row" 'function)) :int
(P :pointer)
(k :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_eval_tab_row" 'function))
(cffi:defcfun ("glp_eval_tab_col" #.(swig-lispify "glp_eval_tab_col" 'function)) :int
(P :pointer)
(k :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_eval_tab_col" 'function))
(cffi:defcfun ("glp_transform_row" #.(swig-lispify "glp_transform_row" 'function)) :int
(P :pointer)
(len :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_transform_row" 'function))
(cffi:defcfun ("glp_transform_col" #.(swig-lispify "glp_transform_col" 'function)) :int
(P :pointer)
(len :int)
(ind :pointer)
(val :pointer))
(cl:export '#.(swig-lispify "glp_transform_col" 'function))
(cffi:defcfun ("glp_prim_rtest" #.(swig-lispify "glp_prim_rtest" 'function)) :int
(P :pointer)
(len :int)
(ind :pointer)
(val :pointer)
(dir :int)
(eps :double))
(cl:export '#.(swig-lispify "glp_prim_rtest" 'function))
(cffi:defcfun ("glp_dual_rtest" #.(swig-lispify "glp_dual_rtest" 'function)) :int
(P :pointer)
(len :int)
(ind :pointer)
(val :pointer)
(dir :int)
(eps :double))
(cl:export '#.(swig-lispify "glp_dual_rtest" 'function))
(cffi:defcfun ("glp_analyze_bound" #.(swig-lispify "glp_analyze_bound" 'function)) :void
(P :pointer)
(k :int)
(value1 :pointer)
(var1 :pointer)
(value2 :pointer)
(var2 :pointer))
(cl:export '#.(swig-lispify "glp_analyze_bound" 'function))
(cffi:defcfun ("glp_analyze_coef" #.(swig-lispify "glp_analyze_coef" 'function)) :void
(P :pointer)
(k :int)
(coef1 :pointer)
(var1 :pointer)
(value1 :pointer)
(coef2 :pointer)
(var2 :pointer)
(value2 :pointer))
(cl:export '#.(swig-lispify "glp_analyze_coef" 'function))
(cffi:defcfun ("glp_ios_reason" #.(swig-lispify "glp_ios_reason" 'function)) :int
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_reason" 'function))
(cffi:defcfun ("glp_ios_get_prob" #.(swig-lispify "glp_ios_get_prob" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_get_prob" 'function))
(cffi:defcfun ("glp_ios_tree_size" #.(swig-lispify "glp_ios_tree_size" 'function)) :void
(t_arg0 :pointer)
(a_cnt :pointer)
(n_cnt :pointer)
(t_cnt :pointer))
(cl:export '#.(swig-lispify "glp_ios_tree_size" 'function))
(cffi:defcfun ("glp_ios_curr_node" #.(swig-lispify "glp_ios_curr_node" 'function)) :int
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_curr_node" 'function))
(cffi:defcfun ("glp_ios_next_node" #.(swig-lispify "glp_ios_next_node" 'function)) :int
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_next_node" 'function))
(cffi:defcfun ("glp_ios_prev_node" #.(swig-lispify "glp_ios_prev_node" 'function)) :int
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_prev_node" 'function))
(cffi:defcfun ("glp_ios_up_node" #.(swig-lispify "glp_ios_up_node" 'function)) :int
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_up_node" 'function))
(cffi:defcfun ("glp_ios_node_level" #.(swig-lispify "glp_ios_node_level" 'function)) :int
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_node_level" 'function))
(cffi:defcfun ("glp_ios_node_bound" #.(swig-lispify "glp_ios_node_bound" 'function)) :double
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_node_bound" 'function))
(cffi:defcfun ("glp_ios_best_node" #.(swig-lispify "glp_ios_best_node" 'function)) :int
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_best_node" 'function))
(cffi:defcfun ("glp_ios_mip_gap" #.(swig-lispify "glp_ios_mip_gap" 'function)) :double
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_mip_gap" 'function))
(cffi:defcfun ("glp_ios_node_data" #.(swig-lispify "glp_ios_node_data" 'function)) :pointer
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_node_data" 'function))
(cffi:defcfun ("glp_ios_row_attr" #.(swig-lispify "glp_ios_row_attr" 'function)) :void
(t_arg0 :pointer)
(i :int)
(attr :pointer))
(cl:export '#.(swig-lispify "glp_ios_row_attr" 'function))
(cffi:defcfun ("glp_ios_pool_size" #.(swig-lispify "glp_ios_pool_size" 'function)) :int
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_pool_size" 'function))
(cffi:defcfun ("glp_ios_add_row" #.(swig-lispify "glp_ios_add_row" 'function)) :int
(t_arg0 :pointer)
(name :string)
(klass :int)
(flags :int)
(len :int)
(ind :pointer)
(val :pointer)
(type :int)
(rhs :double))
(cl:export '#.(swig-lispify "glp_ios_add_row" 'function))
(cffi:defcfun ("glp_ios_del_row" #.(swig-lispify "glp_ios_del_row" 'function)) :void
(t_arg0 :pointer)
(i :int))
(cl:export '#.(swig-lispify "glp_ios_del_row" 'function))
(cffi:defcfun ("glp_ios_clear_pool" #.(swig-lispify "glp_ios_clear_pool" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_clear_pool" 'function))
(cffi:defcfun ("glp_ios_can_branch" #.(swig-lispify "glp_ios_can_branch" 'function)) :int
(t_arg0 :pointer)
(j :int))
(cl:export '#.(swig-lispify "glp_ios_can_branch" 'function))
(cffi:defcfun ("glp_ios_branch_upon" #.(swig-lispify "glp_ios_branch_upon" 'function)) :void
(t_arg0 :pointer)
(j :int)
(sel :int))
(cl:export '#.(swig-lispify "glp_ios_branch_upon" 'function))
(cffi:defcfun ("glp_ios_select_node" #.(swig-lispify "glp_ios_select_node" 'function)) :void
(t_arg0 :pointer)
(p :int))
(cl:export '#.(swig-lispify "glp_ios_select_node" 'function))
(cffi:defcfun ("glp_ios_heur_sol" #.(swig-lispify "glp_ios_heur_sol" 'function)) :int
(t_arg0 :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "glp_ios_heur_sol" 'function))
(cffi:defcfun ("glp_ios_terminate" #.(swig-lispify "glp_ios_terminate" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "glp_ios_terminate" 'function))
(cffi:defcfun ("glp_init_mpscp" #.(swig-lispify "glp_init_mpscp" 'function)) :void
(parm :pointer))
(cl:export '#.(swig-lispify "glp_init_mpscp" 'function))
(cffi:defcfun ("glp_read_mps" #.(swig-lispify "glp_read_mps" 'function)) :int
(P :pointer)
(fmt :int)
(parm :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_mps" 'function))
(cffi:defcfun ("glp_write_mps" #.(swig-lispify "glp_write_mps" 'function)) :int
(P :pointer)
(fmt :int)
(parm :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_mps" 'function))
(cffi:defcfun ("glp_init_cpxcp" #.(swig-lispify "glp_init_cpxcp" 'function)) :void
(parm :pointer))
(cl:export '#.(swig-lispify "glp_init_cpxcp" 'function))
(cffi:defcfun ("glp_read_lp" #.(swig-lispify "glp_read_lp" 'function)) :int
(P :pointer)
(parm :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_lp" 'function))
(cffi:defcfun ("glp_write_lp" #.(swig-lispify "glp_write_lp" 'function)) :int
(P :pointer)
(parm :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_lp" 'function))
(cffi:defcfun ("glp_read_prob" #.(swig-lispify "glp_read_prob" 'function)) :int
(P :pointer)
(flags :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_prob" 'function))
(cffi:defcfun ("glp_write_prob" #.(swig-lispify "glp_write_prob" 'function)) :int
(P :pointer)
(flags :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_prob" 'function))
(cffi:defcfun ("glp_mpl_alloc_wksp" #.(swig-lispify "glp_mpl_alloc_wksp" 'function)) :pointer)
(cl:export '#.(swig-lispify "glp_mpl_alloc_wksp" 'function))
(cffi:defcfun ("glp_mpl_read_model" #.(swig-lispify "glp_mpl_read_model" 'function)) :int
(tran :pointer)
(fname :string)
(skip :int))
(cl:export '#.(swig-lispify "glp_mpl_read_model" 'function))
(cffi:defcfun ("glp_mpl_read_data" #.(swig-lispify "glp_mpl_read_data" 'function)) :int
(tran :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_mpl_read_data" 'function))
(cffi:defcfun ("glp_mpl_generate" #.(swig-lispify "glp_mpl_generate" 'function)) :int
(tran :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_mpl_generate" 'function))
(cffi:defcfun ("glp_mpl_build_prob" #.(swig-lispify "glp_mpl_build_prob" 'function)) :void
(tran :pointer)
(prob :pointer))
(cl:export '#.(swig-lispify "glp_mpl_build_prob" 'function))
(cffi:defcfun ("glp_mpl_postsolve" #.(swig-lispify "glp_mpl_postsolve" 'function)) :int
(tran :pointer)
(prob :pointer)
(sol :int))
(cl:export '#.(swig-lispify "glp_mpl_postsolve" 'function))
(cffi:defcfun ("glp_mpl_free_wksp" #.(swig-lispify "glp_mpl_free_wksp" 'function)) :void
(tran :pointer))
(cl:export '#.(swig-lispify "glp_mpl_free_wksp" 'function))
(cffi:defcfun ("glp_main" #.(swig-lispify "glp_main" 'function)) :int
(argc :int)
(argv :pointer))
(cl:export '#.(swig-lispify "glp_main" 'function))
(cffi:defcfun ("glp_read_cnfsat" #.(swig-lispify "glp_read_cnfsat" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_cnfsat" 'function))
(cffi:defcfun ("glp_check_cnfsat" #.(swig-lispify "glp_check_cnfsat" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_check_cnfsat" 'function))
(cffi:defcfun ("glp_write_cnfsat" #.(swig-lispify "glp_write_cnfsat" 'function)) :int
(P :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_cnfsat" 'function))
(cffi:defcfun ("glp_minisat1" #.(swig-lispify "glp_minisat1" 'function)) :int
(P :pointer))
(cl:export '#.(swig-lispify "glp_minisat1" 'function))
(cffi:defcfun ("glp_intfeas1" #.(swig-lispify "glp_intfeas1" 'function)) :int
(P :pointer)
(use_bound :int)
(obj_bound :int))
(cl:export '#.(swig-lispify "glp_intfeas1" 'function))
(cffi:defcfun ("glp_init_env" #.(swig-lispify "glp_init_env" 'function)) :int)
(cl:export '#.(swig-lispify "glp_init_env" 'function))
(cffi:defcfun ("glp_version" #.(swig-lispify "glp_version" 'function)) :string)
(cl:export '#.(swig-lispify "glp_version" 'function))
(cffi:defcfun ("glp_free_env" #.(swig-lispify "glp_free_env" 'function)) :int)
(cl:export '#.(swig-lispify "glp_free_env" 'function))
(cffi:defcfun ("glp_puts" #.(swig-lispify "glp_puts" 'function)) :void
(s :string))
(cl:export '#.(swig-lispify "glp_puts" 'function))
(cffi:defcfun ("glp_printf" #.(swig-lispify "glp_printf" 'function)) :void
(fmt :string)
&rest)
(cl:export '#.(swig-lispify "glp_printf" 'function))
(cffi:defcfun ("glp_vprintf" #.(swig-lispify "glp_vprintf" 'function)) :void
(fmt :string)
(arg :pointer))
(cl:export '#.(swig-lispify "glp_vprintf" 'function))
(cffi:defcfun ("glp_term_out" #.(swig-lispify "glp_term_out" 'function)) :int
(flag :int))
(cl:export '#.(swig-lispify "glp_term_out" 'function))
(cffi:defcfun ("glp_term_hook" #.(swig-lispify "glp_term_hook" 'function)) :void
(func :pointer)
(info :pointer))
(cl:export '#.(swig-lispify "glp_term_hook" 'function))
(cffi:defcfun ("glp_open_tee" #.(swig-lispify "glp_open_tee" 'function)) :int
(name :string))
(cl:export '#.(swig-lispify "glp_open_tee" 'function))
(cffi:defcfun ("glp_close_tee" #.(swig-lispify "glp_close_tee" 'function)) :int)
(cl:export '#.(swig-lispify "glp_close_tee" 'function))
(cffi:defctype #.(swig-lispify "glp_errfunc" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_errfunc" 'typename))
(cffi:defcfun ("glp_error_" #.(swig-lispify "glp_error_" 'function)) :pointer
(file :string)
(line :int))
(cl:export '#.(swig-lispify "glp_error_" 'function))
(cffi:defcfun ("glp_assert_" #.(swig-lispify "glp_assert_" 'function)) :void
(expr :string)
(file :string)
(line :int))
(cl:export '#.(swig-lispify "glp_assert_" 'function))
(cffi:defcfun ("glp_error_hook" #.(swig-lispify "glp_error_hook" 'function)) :void
(func :pointer)
(info :pointer))
(cl:export '#.(swig-lispify "glp_error_hook" 'function))
(cffi:defcfun ("glp_alloc" #.(swig-lispify "glp_alloc" 'function)) :pointer
(n :int)
(size :int))
(cl:export '#.(swig-lispify "glp_alloc" 'function))
(cffi:defcfun ("glp_realloc" #.(swig-lispify "glp_realloc" 'function)) :pointer
(ptr :pointer)
(n :int)
(size :int))
(cl:export '#.(swig-lispify "glp_realloc" 'function))
(cffi:defcfun ("glp_free" #.(swig-lispify "glp_free" 'function)) :void
(ptr :pointer))
(cl:export '#.(swig-lispify "glp_free" 'function))
(cffi:defcfun ("glp_mem_limit" #.(swig-lispify "glp_mem_limit" 'function)) :void
(limit :int))
(cl:export '#.(swig-lispify "glp_mem_limit" 'function))
(cffi:defcfun ("glp_mem_usage" #.(swig-lispify "glp_mem_usage" 'function)) :void
(count :pointer)
(cpeak :pointer)
(total :pointer)
(tpeak :pointer))
(cl:export '#.(swig-lispify "glp_mem_usage" 'function))
(cffi:defctype #.(swig-lispify "glp_graph" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_graph" 'typename))
(cffi:defctype #.(swig-lispify "glp_vertex" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_vertex" 'typename))
(cffi:defctype #.(swig-lispify "glp_arc" 'typename) :pointer)
(cl:export '#.(swig-lispify "glp_arc" 'typename))
(cffi:defcstruct #.(swig-lispify "glp_graph" 'classname)
(#.(swig-lispify "pool" 'slotname) :pointer)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "nv_max" 'slotname) :int)
(#.(swig-lispify "nv" 'slotname) :int)
(#.(swig-lispify "na" 'slotname) :int)
(#.(swig-lispify "v" 'slotname) :pointer)
(#.(swig-lispify "index" 'slotname) :pointer)
(#.(swig-lispify "v_size" 'slotname) :int)
(#.(swig-lispify "a_size" 'slotname) :int))
(cl:export '#.(swig-lispify "glp_graph" 'classname))
(cl:export '#.(swig-lispify "pool" 'slotname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "nv_max" 'slotname))
(cl:export '#.(swig-lispify "nv" 'slotname))
(cl:export '#.(swig-lispify "na" 'slotname))
(cl:export '#.(swig-lispify "v" 'slotname))
(cl:export '#.(swig-lispify "index" 'slotname))
(cl:export '#.(swig-lispify "v_size" 'slotname))
(cl:export '#.(swig-lispify "a_size" 'slotname))
(cffi:defcstruct #.(swig-lispify "glp_vertex" 'classname)
(#.(swig-lispify "i" 'slotname) :int)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "entry" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "temp" 'slotname) :pointer)
(#.(swig-lispify "in" 'slotname) :pointer)
(#.(swig-lispify "out" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_vertex" 'classname))
(cl:export '#.(swig-lispify "i" 'slotname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "entry" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "temp" 'slotname))
(cl:export '#.(swig-lispify "in" 'slotname))
(cl:export '#.(swig-lispify "out" 'slotname))
(cffi:defcstruct #.(swig-lispify "glp_arc" 'classname)
(#.(swig-lispify "tail" 'slotname) :pointer)
(#.(swig-lispify "head" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "temp" 'slotname) :pointer)
(#.(swig-lispify "t_prev" 'slotname) :pointer)
(#.(swig-lispify "t_next" 'slotname) :pointer)
(#.(swig-lispify "h_prev" 'slotname) :pointer)
(#.(swig-lispify "h_next" 'slotname) :pointer))
(cl:export '#.(swig-lispify "glp_arc" 'classname))
(cl:export '#.(swig-lispify "tail" 'slotname))
(cl:export '#.(swig-lispify "head" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "temp" 'slotname))
(cl:export '#.(swig-lispify "t_prev" 'slotname))
(cl:export '#.(swig-lispify "t_next" 'slotname))
(cl:export '#.(swig-lispify "h_prev" 'slotname))
(cl:export '#.(swig-lispify "h_next" 'slotname))
(cffi:defcfun ("glp_create_graph" #.(swig-lispify "glp_create_graph" 'function)) :pointer
(v_size :int)
(a_size :int))
(cl:export '#.(swig-lispify "glp_create_graph" 'function))
(cffi:defcfun ("glp_set_graph_name" #.(swig-lispify "glp_set_graph_name" 'function)) :void
(G :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_set_graph_name" 'function))
(cffi:defcfun ("glp_add_vertices" #.(swig-lispify "glp_add_vertices" 'function)) :int
(G :pointer)
(nadd :int))
(cl:export '#.(swig-lispify "glp_add_vertices" 'function))
(cffi:defcfun ("glp_set_vertex_name" #.(swig-lispify "glp_set_vertex_name" 'function)) :void
(G :pointer)
(i :int)
(name :string))
(cl:export '#.(swig-lispify "glp_set_vertex_name" 'function))
(cffi:defcfun ("glp_add_arc" #.(swig-lispify "glp_add_arc" 'function)) :pointer
(G :pointer)
(i :int)
(j :int))
(cl:export '#.(swig-lispify "glp_add_arc" 'function))
(cffi:defcfun ("glp_del_vertices" #.(swig-lispify "glp_del_vertices" 'function)) :void
(G :pointer)
(ndel :int)
(num :pointer))
(cl:export '#.(swig-lispify "glp_del_vertices" 'function))
(cffi:defcfun ("glp_del_arc" #.(swig-lispify "glp_del_arc" 'function)) :void
(G :pointer)
(a :pointer))
(cl:export '#.(swig-lispify "glp_del_arc" 'function))
(cffi:defcfun ("glp_erase_graph" #.(swig-lispify "glp_erase_graph" 'function)) :void
(G :pointer)
(v_size :int)
(a_size :int))
(cl:export '#.(swig-lispify "glp_erase_graph" 'function))
(cffi:defcfun ("glp_delete_graph" #.(swig-lispify "glp_delete_graph" 'function)) :void
(G :pointer))
(cl:export '#.(swig-lispify "glp_delete_graph" 'function))
(cffi:defcfun ("glp_create_v_index" #.(swig-lispify "glp_create_v_index" 'function)) :void
(G :pointer))
(cl:export '#.(swig-lispify "glp_create_v_index" 'function))
(cffi:defcfun ("glp_find_vertex" #.(swig-lispify "glp_find_vertex" 'function)) :int
(G :pointer)
(name :string))
(cl:export '#.(swig-lispify "glp_find_vertex" 'function))
(cffi:defcfun ("glp_delete_v_index" #.(swig-lispify "glp_delete_v_index" 'function)) :void
(G :pointer))
(cl:export '#.(swig-lispify "glp_delete_v_index" 'function))
(cffi:defcfun ("glp_read_graph" #.(swig-lispify "glp_read_graph" 'function)) :int
(G :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_graph" 'function))
(cffi:defcfun ("glp_write_graph" #.(swig-lispify "glp_write_graph" 'function)) :int
(G :pointer)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_graph" 'function))
(cffi:defcfun ("glp_mincost_lp" #.(swig-lispify "glp_mincost_lp" 'function)) :void
(P :pointer)
(G :pointer)
(names :int)
(v_rhs :int)
(a_low :int)
(a_cap :int)
(a_cost :int))
(cl:export '#.(swig-lispify "glp_mincost_lp" 'function))
(cffi:defcfun ("glp_mincost_okalg" #.(swig-lispify "glp_mincost_okalg" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_low :int)
(a_cap :int)
(a_cost :int)
(sol :pointer)
(a_x :int)
(v_pi :int))
(cl:export '#.(swig-lispify "glp_mincost_okalg" 'function))
(cffi:defcfun ("glp_mincost_relax4" #.(swig-lispify "glp_mincost_relax4" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_low :int)
(a_cap :int)
(a_cost :int)
(crash :int)
(sol :pointer)
(a_x :int)
(a_rc :int))
(cl:export '#.(swig-lispify "glp_mincost_relax4" 'function))
(cffi:defcfun ("glp_maxflow_lp" #.(swig-lispify "glp_maxflow_lp" 'function)) :void
(P :pointer)
(G :pointer)
(names :int)
(s :int)
(t_arg4 :int)
(a_cap :int))
(cl:export '#.(swig-lispify "glp_maxflow_lp" 'function))
(cffi:defcfun ("glp_maxflow_ffalg" #.(swig-lispify "glp_maxflow_ffalg" 'function)) :int
(G :pointer)
(s :int)
(t_arg2 :int)
(a_cap :int)
(sol :pointer)
(a_x :int)
(v_cut :int))
(cl:export '#.(swig-lispify "glp_maxflow_ffalg" 'function))
(cffi:defcfun ("glp_check_asnprob" #.(swig-lispify "glp_check_asnprob" 'function)) :int
(G :pointer)
(v_set :int))
(cl:export '#.(swig-lispify "glp_check_asnprob" 'function))
(cl:defconstant #.(swig-lispify "GLP_ASN_MIN" 'constant) 1)
(cl:export '#.(swig-lispify "GLP_ASN_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ASN_MAX" 'constant) 2)
(cl:export '#.(swig-lispify "GLP_ASN_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GLP_ASN_MMP" 'constant) 3)
(cl:export '#.(swig-lispify "GLP_ASN_MMP" 'constant))
(cffi:defcfun ("glp_asnprob_lp" #.(swig-lispify "glp_asnprob_lp" 'function)) :int
(P :pointer)
(form :int)
(G :pointer)
(names :int)
(v_set :int)
(a_cost :int))
(cl:export '#.(swig-lispify "glp_asnprob_lp" 'function))
(cffi:defcfun ("glp_asnprob_okalg" #.(swig-lispify "glp_asnprob_okalg" 'function)) :int
(form :int)
(G :pointer)
(v_set :int)
(a_cost :int)
(sol :pointer)
(a_x :int))
(cl:export '#.(swig-lispify "glp_asnprob_okalg" 'function))
(cffi:defcfun ("glp_asnprob_hall" #.(swig-lispify "glp_asnprob_hall" 'function)) :int
(G :pointer)
(v_set :int)
(a_x :int))
(cl:export '#.(swig-lispify "glp_asnprob_hall" 'function))
(cffi:defcfun ("glp_cpp" #.(swig-lispify "glp_cpp" 'function)) :double
(G :pointer)
(v_t :int)
(v_es :int)
(v_ls :int))
(cl:export '#.(swig-lispify "glp_cpp" 'function))
(cffi:defcfun ("glp_read_mincost" #.(swig-lispify "glp_read_mincost" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_low :int)
(a_cap :int)
(a_cost :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_mincost" 'function))
(cffi:defcfun ("glp_write_mincost" #.(swig-lispify "glp_write_mincost" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_low :int)
(a_cap :int)
(a_cost :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_mincost" 'function))
(cffi:defcfun ("glp_read_maxflow" #.(swig-lispify "glp_read_maxflow" 'function)) :int
(G :pointer)
(s :pointer)
(t_arg2 :pointer)
(a_cap :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_maxflow" 'function))
(cffi:defcfun ("glp_write_maxflow" #.(swig-lispify "glp_write_maxflow" 'function)) :int
(G :pointer)
(s :int)
(t_arg2 :int)
(a_cap :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_maxflow" 'function))
(cffi:defcfun ("glp_read_asnprob" #.(swig-lispify "glp_read_asnprob" 'function)) :int
(G :pointer)
(v_set :int)
(a_cost :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_asnprob" 'function))
(cffi:defcfun ("glp_write_asnprob" #.(swig-lispify "glp_write_asnprob" 'function)) :int
(G :pointer)
(v_set :int)
(a_cost :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_asnprob" 'function))
(cffi:defcfun ("glp_read_ccdata" #.(swig-lispify "glp_read_ccdata" 'function)) :int
(G :pointer)
(v_wgt :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_read_ccdata" 'function))
(cffi:defcfun ("glp_write_ccdata" #.(swig-lispify "glp_write_ccdata" 'function)) :int
(G :pointer)
(v_wgt :int)
(fname :string))
(cl:export '#.(swig-lispify "glp_write_ccdata" 'function))
(cffi:defcfun ("glp_netgen" #.(swig-lispify "glp_netgen" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_cap :int)
(a_cost :int)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_netgen" 'function))
(cffi:defcfun ("glp_netgen_prob" #.(swig-lispify "glp_netgen_prob" 'function)) :void
(nprob :int)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_netgen_prob" 'function))
(cffi:defcfun ("glp_gridgen" #.(swig-lispify "glp_gridgen" 'function)) :int
(G :pointer)
(v_rhs :int)
(a_cap :int)
(a_cost :int)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_gridgen" 'function))
(cffi:defcfun ("glp_rmfgen" #.(swig-lispify "glp_rmfgen" 'function)) :int
(G :pointer)
(s :pointer)
(t_arg2 :pointer)
(a_cap :int)
(parm :pointer))
(cl:export '#.(swig-lispify "glp_rmfgen" 'function))
(cffi:defcfun ("glp_weak_comp" #.(swig-lispify "glp_weak_comp" 'function)) :int
(G :pointer)
(v_num :int))
(cl:export '#.(swig-lispify "glp_weak_comp" 'function))
(cffi:defcfun ("glp_strong_comp" #.(swig-lispify "glp_strong_comp" 'function)) :int
(G :pointer)
(v_num :int))
(cl:export '#.(swig-lispify "glp_strong_comp" 'function))
(cffi:defcfun ("glp_top_sort" #.(swig-lispify "glp_top_sort" 'function)) :int
(G :pointer)
(v_num :int))
(cl:export '#.(swig-lispify "glp_top_sort" 'function))
(cffi:defcfun ("glp_wclique_exact" #.(swig-lispify "glp_wclique_exact" 'function)) :int
(G :pointer)
(v_wgt :int)
(sol :pointer)
(v_set :int))
(cl:export '#.(swig-lispify "glp_wclique_exact" 'function))
| 61,432 | Common Lisp | .lisp | 1,386 | 41.396825 | 94 | 0.66565 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | fc89f275efbb7ffc0e7eb99621f125286aa08dd4705f78985a9bd044629ea105 | 31,767 | [
-1
] |
31,768 | package.lisp | appleby_cl-opsresearch/subsystem/or-test/package.lisp | ;;;; package.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(defpackage #:or-test
(:use #:cl)
(:export
#:test-all
#:test-opsresearch
#:test-gsl
#:test-glpk
))
| 898 | Common Lisp | .lisp | 26 | 32.461538 | 74 | 0.678941 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 818310308fa3f2eafc59a4b74557a6b981ae4bf8b1ef76aa770417309cc5a4ef | 31,768 | [
-1
] |
31,769 | or-test.lisp | appleby_cl-opsresearch/subsystem/or-test/or-test.lisp | ;;;; or-test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
| 803 | Common Lisp | .lisp | 19 | 40.789474 | 74 | 0.692308 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 666f833d81def25a51b0dce2920fa690e7ee1a53668d946533dc48bed5cb7e3d | 31,769 | [
-1
] |
31,770 | test-gsl.lisp | appleby_cl-opsresearch/subsystem/or-test/tests/test-gsl.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
(defun test-gsl ()
(5am:explain! (5am:run 'test-gsl)))
(5am:test test-gsl
(5am:is ( equal (gsl:gsl-sf-bessel-j-0 0.5d0) 0.958851077208406d0 ))
(5am:is ( equal (gsl:gsl-sf-bessel-jj-0 0.5d0) 0.9384698072408129d0 ))) | 1,031 | Common Lisp | .lisp | 24 | 41.041667 | 78 | 0.682271 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 709ec21fb0a3bda6382de9f3d0913b0fc9a566587cdd5c1db186bb5b901c358a | 31,770 | [
-1
] |
31,771 | test-glpk.lisp | appleby_cl-opsresearch/subsystem/or-test/tests/test-glpk.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
(defun test-glpk ()
(5am:explain! (5am:run 'test-glpk)))
(5am:test test-glpk
(or-glpk:with-problem
(problem :name "test-name" )
(5am:is (equal (or-glpk:name problem) "test-name"))
(or-glpk:read-mps
problem
(merge-pathnames
(make-pathname :directory '(:relative "data") :name "test-1" :type "mps")
(asdf:system-source-directory :or-glpk)
))
(5am:is (equal (or-glpk:name problem) "TESTPROB"))
(or-glpk:write-cplex-lp problem #p"/tmp/cplex.lp")
(or-glpk:with-problem
(cplex-problem)
(or-glpk:read-cplex-lp cplex-problem #p"/tmp/cplex.lp")))) | 1,569 | Common Lisp | .lisp | 36 | 35.944444 | 89 | 0.613682 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | c8ec1b791076b23dd348ca00944bab5f6e15597a4b30ca46fe76314405210376 | 31,771 | [
-1
] |
31,772 | test-opsresearch.lisp | appleby_cl-opsresearch/subsystem/or-test/tests/test-opsresearch.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
(defun test-opsresearch ()
(5am:explain! (5am:run 'test-opsresearch)))
(5am:test test-opsresearch
(5am:is ( equal T T))) | 923 | Common Lisp | .lisp | 23 | 38.652174 | 74 | 0.694537 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 885348e5b078191bc4ae2221bcc2a772e48515a836dfea0c928e481e1cc3c958 | 31,772 | [
-1
] |
31,773 | test-fann.lisp | appleby_cl-opsresearch/subsystem/or-test/tests/test-fann.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
(defun test-fann ()
(5am:explain! (5am:run 'test-fann)))
(5am:test test-fann
(or-fann:with-network
(net :name "Standard" :layers '(5 4 5))
(or-fann:randomize-weights net 1.0D0 1.1D0)
(or-fann:run net '(1.1D0 2.2D0 3.3D0 4.4D0 5.5D0))
(5am:is (equal (or-fann:name net) "Standard"))
(5am:is (equal (or-fann:get-network-type net) :FANN-NETTYPE-LAYER)))
(or-fann:with-network
(net :name "Sparse" :net-type :SPARSE :connection-rate 0.5 :layers '(5 4 5))
(or-fann:randomize-weights net 1.0D0 1.1D0)
(or-fann:run net '(1.1D0 2.2D0 3.3D0 4.4D0 5.5D0))
(5am:is (equal (or-fann:name net) "Sparse"))
(5am:is (equal (or-fann:get-network-type net) :FANN-NETTYPE-LAYER)))
(or-fann:with-network
(net :name "Shortcut" :net-type :SHORTCUT :layers '(5 4 5))
(or-fann:randomize-weights net 1.0D0 1.1D0)
(or-fann:run net '(1.1D0 2.2D0 3.3D0 4.4D0 5.5D0))
(5am:is (equal (or-fann:name net) "Shortcut"))
(5am:is (equal (or-fann:get-network-type net) :FANN-NETTYPE-SHORTCUT))))
| 1,997 | Common Lisp | .lisp | 40 | 42.65 | 88 | 0.617418 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | d61d13cecce2d99c3d85929fe7b470e59e3a88a72420059f3eec736f060e9475 | 31,773 | [
-1
] |
31,774 | test.lisp | appleby_cl-opsresearch/subsystem/or-test/tests/test.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-test)
(defun test-all()
"Run unit tests for cl-opsresearch and subsystems."
(test-opsresearch)
(test-glpk)
(test-gsl)
(test-fann))
| 930 | Common Lisp | .lisp | 25 | 35.64 | 74 | 0.697339 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | e74671ac93396ddc855a6ceaf3405e50e9939e0f6afb7ee93745c28bfef2f3d5 | 31,774 | [
-1
] |
31,775 | package.lisp | appleby_cl-opsresearch/subsystem/or-gsl/package.lisp | ;;;; package.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(defpackage #:or-gsl
(:use #:cl)
(:export
#:start))
(defpackage #:gsl
(:use #:cl)) | 872 | Common Lisp | .lisp | 24 | 34.583333 | 74 | 0.679669 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | cb4359fa4b3051fe2d4e306a4e5c9ffcdc9a0a284e194fece7f30d7065519484 | 31,775 | [
-1
] |
31,776 | or-gsl.lisp | appleby_cl-opsresearch/subsystem/or-gsl/or-gsl.lisp | ;;;; or-gsl.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-gsl)
(defvar *lib-loaded* nil)
(cffi:define-foreign-library gsl
(t (:default "libgsl")))
(cffi:define-foreign-library gslcblas
(t (:default "libgslcblas")))
(defun start ()
(unless *lib-loaded*
(cffi:use-foreign-library gslcblas)
(cffi:use-foreign-library gsl))
(setf *lib-loaded* T))
(start) | 1,102 | Common Lisp | .lisp | 30 | 35 | 74 | 0.698874 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | f19c58a6920501e788d301e0cc02f739c4be5c43e4a066adecf04d78d75a5f6f | 31,776 | [
-1
] |
31,777 | gsl.lisp | appleby_cl-opsresearch/subsystem/or-gsl/swig/gsl.lisp | (in-package #:gsl)
;;; This file was automatically generated by SWIG (http://www.swig.org).
;;; Version 3.0.5
;;;
;;; Do not make changes to this file unless you know what you are doing--modify
;;; the SWIG interface file instead.
;;;SWIG wrapper code starts here
(cl:defmacro defanonenum (cl:&body enums)
"Converts anonymous enums to defconstants."
`(cl:progn ,@(cl:loop for value in enums
for index = 0 then (cl:1+ index)
when (cl:listp value) do (cl:setf index (cl:second value)
value (cl:first value))
collect `(cl:defconstant ,value ,index))))
(cl:eval-when (:compile-toplevel :load-toplevel)
(cl:unless (cl:fboundp 'swig-lispify)
(cl:defun swig-lispify (name flag cl:&optional (package cl:*package*))
(cl:labels ((helper (lst last rest cl:&aux (c (cl:car lst)))
(cl:cond
((cl:null lst)
rest)
((cl:upper-case-p c)
(helper (cl:cdr lst) 'upper
(cl:case last
((lower digit) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:lower-case-p c)
(helper (cl:cdr lst) 'lower (cl:cons (cl:char-upcase c) rest)))
((cl:digit-char-p c)
(helper (cl:cdr lst) 'digit
(cl:case last
((upper lower) (cl:list* c #\- rest))
(cl:t (cl:cons c rest)))))
((cl:char-equal c #\_)
(helper (cl:cdr lst) '_ (cl:cons #\- rest)))
(cl:t
(cl:error "Invalid character: ~A" c)))))
(cl:let ((fix (cl:case flag
((constant enumvalue) "+")
(variable "*")
(cl:t ""))))
(cl:intern
(cl:concatenate
'cl:string
fix
(cl:nreverse (helper (cl:concatenate 'cl:list name) cl:nil cl:nil))
fix)
package))))))
;;;SWIG wrapper code ends here
(defanonenum
(#.(swig-lispify "GSL_SUCCESS" 'enumvalue) #.0)
(#.(swig-lispify "GSL_FAILURE" 'enumvalue) #.-1)
(#.(swig-lispify "GSL_CONTINUE" 'enumvalue) #.-2)
(#.(swig-lispify "GSL_EDOM" 'enumvalue) #.1)
(#.(swig-lispify "GSL_ERANGE" 'enumvalue) #.2)
(#.(swig-lispify "GSL_EFAULT" 'enumvalue) #.3)
(#.(swig-lispify "GSL_EINVAL" 'enumvalue) #.4)
(#.(swig-lispify "GSL_EFAILED" 'enumvalue) #.5)
(#.(swig-lispify "GSL_EFACTOR" 'enumvalue) #.6)
(#.(swig-lispify "GSL_ESANITY" 'enumvalue) #.7)
(#.(swig-lispify "GSL_ENOMEM" 'enumvalue) #.8)
(#.(swig-lispify "GSL_EBADFUNC" 'enumvalue) #.9)
(#.(swig-lispify "GSL_ERUNAWAY" 'enumvalue) #.10)
(#.(swig-lispify "GSL_EMAXITER" 'enumvalue) #.11)
(#.(swig-lispify "GSL_EZERODIV" 'enumvalue) #.12)
(#.(swig-lispify "GSL_EBADTOL" 'enumvalue) #.13)
(#.(swig-lispify "GSL_ETOL" 'enumvalue) #.14)
(#.(swig-lispify "GSL_EUNDRFLW" 'enumvalue) #.15)
(#.(swig-lispify "GSL_EOVRFLW" 'enumvalue) #.16)
(#.(swig-lispify "GSL_ELOSS" 'enumvalue) #.17)
(#.(swig-lispify "GSL_EROUND" 'enumvalue) #.18)
(#.(swig-lispify "GSL_EBADLEN" 'enumvalue) #.19)
(#.(swig-lispify "GSL_ENOTSQR" 'enumvalue) #.20)
(#.(swig-lispify "GSL_ESING" 'enumvalue) #.21)
(#.(swig-lispify "GSL_EDIVERGE" 'enumvalue) #.22)
(#.(swig-lispify "GSL_EUNSUP" 'enumvalue) #.23)
(#.(swig-lispify "GSL_EUNIMPL" 'enumvalue) #.24)
(#.(swig-lispify "GSL_ECACHE" 'enumvalue) #.25)
(#.(swig-lispify "GSL_ETABLE" 'enumvalue) #.26)
(#.(swig-lispify "GSL_ENOPROG" 'enumvalue) #.27)
(#.(swig-lispify "GSL_ENOPROGJ" 'enumvalue) #.28)
(#.(swig-lispify "GSL_ETOLF" 'enumvalue) #.29)
(#.(swig-lispify "GSL_ETOLX" 'enumvalue) #.30)
(#.(swig-lispify "GSL_ETOLG" 'enumvalue) #.31)
(#.(swig-lispify "GSL_EOF" 'enumvalue) #.32))
(cl:export '#.(swig-lispify "GSL_SUCCESS" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_FAILURE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_CONTINUE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EDOM" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ERANGE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EFAULT" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EINVAL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EFAILED" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EFACTOR" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ESANITY" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ENOMEM" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EBADFUNC" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ERUNAWAY" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EMAXITER" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EZERODIV" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EBADTOL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ETOL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EUNDRFLW" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EOVRFLW" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ELOSS" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EROUND" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EBADLEN" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ENOTSQR" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ESING" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EDIVERGE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EUNSUP" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EUNIMPL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ECACHE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ETABLE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ENOPROG" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ENOPROGJ" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ETOLF" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ETOLX" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_ETOLG" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_EOF" 'enumvalue))
(cffi:defcfun ("gsl_error" #.(swig-lispify "gsl_error" 'function)) :void
(reason :string)
(file :string)
(line :int)
(gsl_errno :int))
(cl:export '#.(swig-lispify "gsl_error" 'function))
(cffi:defcfun ("gsl_stream_printf" #.(swig-lispify "gsl_stream_printf" 'function)) :void
(label :string)
(file :string)
(line :int)
(reason :string))
(cl:export '#.(swig-lispify "gsl_stream_printf" 'function))
(cffi:defcfun ("gsl_strerror" #.(swig-lispify "gsl_strerror" 'function)) :string
(gsl_errno :int))
(cl:export '#.(swig-lispify "gsl_strerror" 'function))
(cffi:defcfun ("gsl_set_error_handler" #.(swig-lispify "gsl_set_error_handler" 'function)) :pointer
(new_handler :pointer))
(cl:export '#.(swig-lispify "gsl_set_error_handler" 'function))
(cffi:defcfun ("gsl_set_error_handler_off" #.(swig-lispify "gsl_set_error_handler_off" 'function)) :pointer)
(cl:export '#.(swig-lispify "gsl_set_error_handler_off" 'function))
(cffi:defcfun ("gsl_set_stream_handler" #.(swig-lispify "gsl_set_stream_handler" 'function)) :pointer
(new_handler :pointer))
(cl:export '#.(swig-lispify "gsl_set_stream_handler" 'function))
(cffi:defcfun ("gsl_set_stream" #.(swig-lispify "gsl_set_stream" 'function)) :pointer
(new_stream :pointer))
(cl:export '#.(swig-lispify "gsl_set_stream" 'function))
(cffi:defcvar ("gsl_check_range" #.(swig-lispify "gsl_check_range" 'variable))
:int)
(cl:export '#.(swig-lispify "gsl_check_range" 'variable))
(cl:defconstant #.(swig-lispify "GSL_RANGE_CHECK" 'constant) 1)
(cl:export '#.(swig-lispify "GSL_RANGE_CHECK" 'constant))
(cffi:defcvar ("gsl_version" #.(swig-lispify "gsl_version" 'variable))
:string)
(cl:export '#.(swig-lispify "gsl_version" 'variable))
(cffi:defcfun ("gsl_message" #.(swig-lispify "gsl_message" 'function)) :void
(message :string)
(file :string)
(line :int)
(mask :unsigned-int))
(cl:export '#.(swig-lispify "gsl_message" 'function))
(cffi:defcvar ("gsl_message_mask" #.(swig-lispify "gsl_message_mask" 'variable))
:unsigned-int)
(cl:export '#.(swig-lispify "gsl_message_mask" 'variable))
(defanonenum
(#.(swig-lispify "GSL_MESSAGE_MASK_A" 'enumvalue) #.1)
(#.(swig-lispify "GSL_MESSAGE_MASK_B" 'enumvalue) #.2)
(#.(swig-lispify "GSL_MESSAGE_MASK_C" 'enumvalue) #.4)
(#.(swig-lispify "GSL_MESSAGE_MASK_D" 'enumvalue) #.8)
(#.(swig-lispify "GSL_MESSAGE_MASK_E" 'enumvalue) #.16)
(#.(swig-lispify "GSL_MESSAGE_MASK_F" 'enumvalue) #.32)
(#.(swig-lispify "GSL_MESSAGE_MASK_G" 'enumvalue) #.64)
(#.(swig-lispify "GSL_MESSAGE_MASK_H" 'enumvalue) #.128))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_A" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_B" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_C" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_D" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_E" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_F" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_G" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_MESSAGE_MASK_H" 'enumvalue))
(cffi:defcfun ("gsl_ran_bernoulli" #.(swig-lispify "gsl_ran_bernoulli" 'function)) :unsigned-int
(r :pointer)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_bernoulli" 'function))
(cffi:defcfun ("gsl_ran_bernoulli_pdf" #.(swig-lispify "gsl_ran_bernoulli_pdf" 'function)) :double
(k :unsigned-int)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_bernoulli_pdf" 'function))
(cffi:defcfun ("gsl_ran_beta" #.(swig-lispify "gsl_ran_beta" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_beta" 'function))
(cffi:defcfun ("gsl_ran_beta_pdf" #.(swig-lispify "gsl_ran_beta_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_beta_pdf" 'function))
(cffi:defcfun ("gsl_ran_binomial" #.(swig-lispify "gsl_ran_binomial" 'function)) :unsigned-int
(r :pointer)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_binomial" 'function))
(cffi:defcfun ("gsl_ran_binomial_knuth" #.(swig-lispify "gsl_ran_binomial_knuth" 'function)) :unsigned-int
(r :pointer)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_binomial_knuth" 'function))
(cffi:defcfun ("gsl_ran_binomial_tpe" #.(swig-lispify "gsl_ran_binomial_tpe" 'function)) :unsigned-int
(r :pointer)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_binomial_tpe" 'function))
(cffi:defcfun ("gsl_ran_binomial_pdf" #.(swig-lispify "gsl_ran_binomial_pdf" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_binomial_pdf" 'function))
(cffi:defcfun ("gsl_ran_exponential" #.(swig-lispify "gsl_ran_exponential" 'function)) :double
(r :pointer)
(mu :double))
(cl:export '#.(swig-lispify "gsl_ran_exponential" 'function))
(cffi:defcfun ("gsl_ran_exponential_pdf" #.(swig-lispify "gsl_ran_exponential_pdf" 'function)) :double
(x :double)
(mu :double))
(cl:export '#.(swig-lispify "gsl_ran_exponential_pdf" 'function))
(cffi:defcfun ("gsl_ran_exppow" #.(swig-lispify "gsl_ran_exppow" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_exppow" 'function))
(cffi:defcfun ("gsl_ran_exppow_pdf" #.(swig-lispify "gsl_ran_exppow_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_exppow_pdf" 'function))
(cffi:defcfun ("gsl_ran_cauchy" #.(swig-lispify "gsl_ran_cauchy" 'function)) :double
(r :pointer)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_cauchy" 'function))
(cffi:defcfun ("gsl_ran_cauchy_pdf" #.(swig-lispify "gsl_ran_cauchy_pdf" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_cauchy_pdf" 'function))
(cffi:defcfun ("gsl_ran_chisq" #.(swig-lispify "gsl_ran_chisq" 'function)) :double
(r :pointer)
(nu :double))
(cl:export '#.(swig-lispify "gsl_ran_chisq" 'function))
(cffi:defcfun ("gsl_ran_chisq_pdf" #.(swig-lispify "gsl_ran_chisq_pdf" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_ran_chisq_pdf" 'function))
(cffi:defcfun ("gsl_ran_dirichlet" #.(swig-lispify "gsl_ran_dirichlet" 'function)) :void
(r :pointer)
(K :pointer)
(alpha :pointer)
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dirichlet" 'function))
(cffi:defcfun ("gsl_ran_dirichlet_pdf" #.(swig-lispify "gsl_ran_dirichlet_pdf" 'function)) :double
(K :pointer)
(alpha :pointer)
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dirichlet_pdf" 'function))
(cffi:defcfun ("gsl_ran_dirichlet_lnpdf" #.(swig-lispify "gsl_ran_dirichlet_lnpdf" 'function)) :double
(K :pointer)
(alpha :pointer)
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dirichlet_lnpdf" 'function))
(cffi:defcfun ("gsl_ran_erlang" #.(swig-lispify "gsl_ran_erlang" 'function)) :double
(r :pointer)
(a :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_ran_erlang" 'function))
(cffi:defcfun ("gsl_ran_erlang_pdf" #.(swig-lispify "gsl_ran_erlang_pdf" 'function)) :double
(x :double)
(a :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_ran_erlang_pdf" 'function))
(cffi:defcfun ("gsl_ran_fdist" #.(swig-lispify "gsl_ran_fdist" 'function)) :double
(r :pointer)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_ran_fdist" 'function))
(cffi:defcfun ("gsl_ran_fdist_pdf" #.(swig-lispify "gsl_ran_fdist_pdf" 'function)) :double
(x :double)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_ran_fdist_pdf" 'function))
(cffi:defcfun ("gsl_ran_flat" #.(swig-lispify "gsl_ran_flat" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_flat" 'function))
(cffi:defcfun ("gsl_ran_flat_pdf" #.(swig-lispify "gsl_ran_flat_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_flat_pdf" 'function))
(cffi:defcfun ("gsl_ran_gamma" #.(swig-lispify "gsl_ran_gamma" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gamma" 'function))
(cffi:defcfun ("gsl_ran_gamma_int" #.(swig-lispify "gsl_ran_gamma_int" 'function)) :double
(r :pointer)
(a :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_gamma_int" 'function))
(cffi:defcfun ("gsl_ran_gamma_pdf" #.(swig-lispify "gsl_ran_gamma_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gamma_pdf" 'function))
(cffi:defcfun ("gsl_ran_gamma_mt" #.(swig-lispify "gsl_ran_gamma_mt" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gamma_mt" 'function))
(cffi:defcfun ("gsl_ran_gamma_knuth" #.(swig-lispify "gsl_ran_gamma_knuth" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gamma_knuth" 'function))
(cffi:defcfun ("gsl_ran_gaussian" #.(swig-lispify "gsl_ran_gaussian" 'function)) :double
(r :pointer)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian" 'function))
(cffi:defcfun ("gsl_ran_gaussian_ratio_method" #.(swig-lispify "gsl_ran_gaussian_ratio_method" 'function)) :double
(r :pointer)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian_ratio_method" 'function))
(cffi:defcfun ("gsl_ran_gaussian_ziggurat" #.(swig-lispify "gsl_ran_gaussian_ziggurat" 'function)) :double
(r :pointer)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian_ziggurat" 'function))
(cffi:defcfun ("gsl_ran_gaussian_pdf" #.(swig-lispify "gsl_ran_gaussian_pdf" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian_pdf" 'function))
(cffi:defcfun ("gsl_ran_ugaussian" #.(swig-lispify "gsl_ran_ugaussian" 'function)) :double
(r :pointer))
(cl:export '#.(swig-lispify "gsl_ran_ugaussian" 'function))
(cffi:defcfun ("gsl_ran_ugaussian_ratio_method" #.(swig-lispify "gsl_ran_ugaussian_ratio_method" 'function)) :double
(r :pointer))
(cl:export '#.(swig-lispify "gsl_ran_ugaussian_ratio_method" 'function))
(cffi:defcfun ("gsl_ran_ugaussian_pdf" #.(swig-lispify "gsl_ran_ugaussian_pdf" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_ran_ugaussian_pdf" 'function))
(cffi:defcfun ("gsl_ran_gaussian_tail" #.(swig-lispify "gsl_ran_gaussian_tail" 'function)) :double
(r :pointer)
(a :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian_tail" 'function))
(cffi:defcfun ("gsl_ran_gaussian_tail_pdf" #.(swig-lispify "gsl_ran_gaussian_tail_pdf" 'function)) :double
(x :double)
(a :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_gaussian_tail_pdf" 'function))
(cffi:defcfun ("gsl_ran_ugaussian_tail" #.(swig-lispify "gsl_ran_ugaussian_tail" 'function)) :double
(r :pointer)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_ugaussian_tail" 'function))
(cffi:defcfun ("gsl_ran_ugaussian_tail_pdf" #.(swig-lispify "gsl_ran_ugaussian_tail_pdf" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_ugaussian_tail_pdf" 'function))
(cffi:defcfun ("gsl_ran_bivariate_gaussian" #.(swig-lispify "gsl_ran_bivariate_gaussian" 'function)) :void
(r :pointer)
(sigma_x :double)
(sigma_y :double)
(rho :double)
(x :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_ran_bivariate_gaussian" 'function))
(cffi:defcfun ("gsl_ran_bivariate_gaussian_pdf" #.(swig-lispify "gsl_ran_bivariate_gaussian_pdf" 'function)) :double
(x :double)
(y :double)
(sigma_x :double)
(sigma_y :double)
(rho :double))
(cl:export '#.(swig-lispify "gsl_ran_bivariate_gaussian_pdf" 'function))
(cffi:defcfun ("gsl_ran_landau" #.(swig-lispify "gsl_ran_landau" 'function)) :double
(r :pointer))
(cl:export '#.(swig-lispify "gsl_ran_landau" 'function))
(cffi:defcfun ("gsl_ran_landau_pdf" #.(swig-lispify "gsl_ran_landau_pdf" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_ran_landau_pdf" 'function))
(cffi:defcfun ("gsl_ran_geometric" #.(swig-lispify "gsl_ran_geometric" 'function)) :unsigned-int
(r :pointer)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_geometric" 'function))
(cffi:defcfun ("gsl_ran_geometric_pdf" #.(swig-lispify "gsl_ran_geometric_pdf" 'function)) :double
(k :unsigned-int)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_geometric_pdf" 'function))
(cffi:defcfun ("gsl_ran_hypergeometric" #.(swig-lispify "gsl_ran_hypergeometric" 'function)) :unsigned-int
(r :pointer)
(n1 :unsigned-int)
(n2 :unsigned-int)
(t_arg3 :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_hypergeometric" 'function))
(cffi:defcfun ("gsl_ran_hypergeometric_pdf" #.(swig-lispify "gsl_ran_hypergeometric_pdf" 'function)) :double
(k :unsigned-int)
(n1 :unsigned-int)
(n2 :unsigned-int)
(t_arg3 :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_hypergeometric_pdf" 'function))
(cffi:defcfun ("gsl_ran_gumbel1" #.(swig-lispify "gsl_ran_gumbel1" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gumbel1" 'function))
(cffi:defcfun ("gsl_ran_gumbel1_pdf" #.(swig-lispify "gsl_ran_gumbel1_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gumbel1_pdf" 'function))
(cffi:defcfun ("gsl_ran_gumbel2" #.(swig-lispify "gsl_ran_gumbel2" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gumbel2" 'function))
(cffi:defcfun ("gsl_ran_gumbel2_pdf" #.(swig-lispify "gsl_ran_gumbel2_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_gumbel2_pdf" 'function))
(cffi:defcfun ("gsl_ran_logistic" #.(swig-lispify "gsl_ran_logistic" 'function)) :double
(r :pointer)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_logistic" 'function))
(cffi:defcfun ("gsl_ran_logistic_pdf" #.(swig-lispify "gsl_ran_logistic_pdf" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_logistic_pdf" 'function))
(cffi:defcfun ("gsl_ran_lognormal" #.(swig-lispify "gsl_ran_lognormal" 'function)) :double
(r :pointer)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_lognormal" 'function))
(cffi:defcfun ("gsl_ran_lognormal_pdf" #.(swig-lispify "gsl_ran_lognormal_pdf" 'function)) :double
(x :double)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_lognormal_pdf" 'function))
(cffi:defcfun ("gsl_ran_logarithmic" #.(swig-lispify "gsl_ran_logarithmic" 'function)) :unsigned-int
(r :pointer)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_logarithmic" 'function))
(cffi:defcfun ("gsl_ran_logarithmic_pdf" #.(swig-lispify "gsl_ran_logarithmic_pdf" 'function)) :double
(k :unsigned-int)
(p :double))
(cl:export '#.(swig-lispify "gsl_ran_logarithmic_pdf" 'function))
(cffi:defcfun ("gsl_ran_multinomial" #.(swig-lispify "gsl_ran_multinomial" 'function)) :void
(r :pointer)
(K :pointer)
(NN :unsigned-int)
(p :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_ran_multinomial" 'function))
(cffi:defcfun ("gsl_ran_multinomial_pdf" #.(swig-lispify "gsl_ran_multinomial_pdf" 'function)) :double
(K :pointer)
(p :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_ran_multinomial_pdf" 'function))
(cffi:defcfun ("gsl_ran_multinomial_lnpdf" #.(swig-lispify "gsl_ran_multinomial_lnpdf" 'function)) :double
(K :pointer)
(p :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_ran_multinomial_lnpdf" 'function))
(cffi:defcfun ("gsl_ran_negative_binomial" #.(swig-lispify "gsl_ran_negative_binomial" 'function)) :unsigned-int
(r :pointer)
(p :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_ran_negative_binomial" 'function))
(cffi:defcfun ("gsl_ran_negative_binomial_pdf" #.(swig-lispify "gsl_ran_negative_binomial_pdf" 'function)) :double
(k :unsigned-int)
(p :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_ran_negative_binomial_pdf" 'function))
(cffi:defcfun ("gsl_ran_pascal" #.(swig-lispify "gsl_ran_pascal" 'function)) :unsigned-int
(r :pointer)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_pascal" 'function))
(cffi:defcfun ("gsl_ran_pascal_pdf" #.(swig-lispify "gsl_ran_pascal_pdf" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_ran_pascal_pdf" 'function))
(cffi:defcfun ("gsl_ran_pareto" #.(swig-lispify "gsl_ran_pareto" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_pareto" 'function))
(cffi:defcfun ("gsl_ran_pareto_pdf" #.(swig-lispify "gsl_ran_pareto_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_pareto_pdf" 'function))
(cffi:defcfun ("gsl_ran_poisson" #.(swig-lispify "gsl_ran_poisson" 'function)) :unsigned-int
(r :pointer)
(mu :double))
(cl:export '#.(swig-lispify "gsl_ran_poisson" 'function))
(cffi:defcfun ("gsl_ran_poisson_array" #.(swig-lispify "gsl_ran_poisson_array" 'function)) :void
(r :pointer)
(n :pointer)
(array :pointer)
(mu :double))
(cl:export '#.(swig-lispify "gsl_ran_poisson_array" 'function))
(cffi:defcfun ("gsl_ran_poisson_pdf" #.(swig-lispify "gsl_ran_poisson_pdf" 'function)) :double
(k :unsigned-int)
(mu :double))
(cl:export '#.(swig-lispify "gsl_ran_poisson_pdf" 'function))
(cffi:defcfun ("gsl_ran_rayleigh" #.(swig-lispify "gsl_ran_rayleigh" 'function)) :double
(r :pointer)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_rayleigh" 'function))
(cffi:defcfun ("gsl_ran_rayleigh_pdf" #.(swig-lispify "gsl_ran_rayleigh_pdf" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_rayleigh_pdf" 'function))
(cffi:defcfun ("gsl_ran_rayleigh_tail" #.(swig-lispify "gsl_ran_rayleigh_tail" 'function)) :double
(r :pointer)
(a :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_rayleigh_tail" 'function))
(cffi:defcfun ("gsl_ran_rayleigh_tail_pdf" #.(swig-lispify "gsl_ran_rayleigh_tail_pdf" 'function)) :double
(x :double)
(a :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_ran_rayleigh_tail_pdf" 'function))
(cffi:defcfun ("gsl_ran_tdist" #.(swig-lispify "gsl_ran_tdist" 'function)) :double
(r :pointer)
(nu :double))
(cl:export '#.(swig-lispify "gsl_ran_tdist" 'function))
(cffi:defcfun ("gsl_ran_tdist_pdf" #.(swig-lispify "gsl_ran_tdist_pdf" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_ran_tdist_pdf" 'function))
(cffi:defcfun ("gsl_ran_laplace" #.(swig-lispify "gsl_ran_laplace" 'function)) :double
(r :pointer)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_laplace" 'function))
(cffi:defcfun ("gsl_ran_laplace_pdf" #.(swig-lispify "gsl_ran_laplace_pdf" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_ran_laplace_pdf" 'function))
(cffi:defcfun ("gsl_ran_levy" #.(swig-lispify "gsl_ran_levy" 'function)) :double
(r :pointer)
(c :double)
(alpha :double))
(cl:export '#.(swig-lispify "gsl_ran_levy" 'function))
(cffi:defcfun ("gsl_ran_levy_skew" #.(swig-lispify "gsl_ran_levy_skew" 'function)) :double
(r :pointer)
(c :double)
(alpha :double)
(beta :double))
(cl:export '#.(swig-lispify "gsl_ran_levy_skew" 'function))
(cffi:defcfun ("gsl_ran_weibull" #.(swig-lispify "gsl_ran_weibull" 'function)) :double
(r :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_weibull" 'function))
(cffi:defcfun ("gsl_ran_weibull_pdf" #.(swig-lispify "gsl_ran_weibull_pdf" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_ran_weibull_pdf" 'function))
(cffi:defcfun ("gsl_ran_dir_2d" #.(swig-lispify "gsl_ran_dir_2d" 'function)) :void
(r :pointer)
(x :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dir_2d" 'function))
(cffi:defcfun ("gsl_ran_dir_2d_trig_method" #.(swig-lispify "gsl_ran_dir_2d_trig_method" 'function)) :void
(r :pointer)
(x :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dir_2d_trig_method" 'function))
(cffi:defcfun ("gsl_ran_dir_3d" #.(swig-lispify "gsl_ran_dir_3d" 'function)) :void
(r :pointer)
(x :pointer)
(y :pointer)
(z :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dir_3d" 'function))
(cffi:defcfun ("gsl_ran_dir_nd" #.(swig-lispify "gsl_ran_dir_nd" 'function)) :void
(r :pointer)
(n :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_ran_dir_nd" 'function))
(cffi:defcfun ("gsl_ran_shuffle" #.(swig-lispify "gsl_ran_shuffle" 'function)) :void
(r :pointer)
(base :pointer)
(nmembm :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_ran_shuffle" 'function))
(cffi:defcfun ("gsl_ran_choose" #.(swig-lispify "gsl_ran_choose" 'function)) :int
(r :pointer)
(dest :pointer)
(k :pointer)
(src :pointer)
(n :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_ran_choose" 'function))
(cffi:defcfun ("gsl_ran_sample" #.(swig-lispify "gsl_ran_sample" 'function)) :void
(r :pointer)
(dest :pointer)
(k :pointer)
(src :pointer)
(n :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_ran_sample" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_ran_discrete_t" 'classname)
(#.(swig-lispify "K" 'slotname) :pointer)
(#.(swig-lispify "A" 'slotname) :pointer)
(#.(swig-lispify "F" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_ran_discrete_t" 'classname))
(cl:export '#.(swig-lispify "K" 'slotname))
(cl:export '#.(swig-lispify "A" 'slotname))
(cl:export '#.(swig-lispify "F" 'slotname))
(cffi:defcfun ("gsl_ran_discrete_preproc" #.(swig-lispify "gsl_ran_discrete_preproc" 'function)) :pointer
(K :pointer)
(P :pointer))
(cl:export '#.(swig-lispify "gsl_ran_discrete_preproc" 'function))
(cffi:defcfun ("gsl_ran_discrete_free" #.(swig-lispify "gsl_ran_discrete_free" 'function)) :void
(g :pointer))
(cl:export '#.(swig-lispify "gsl_ran_discrete_free" 'function))
(cffi:defcfun ("gsl_ran_discrete" #.(swig-lispify "gsl_ran_discrete" 'function)) :pointer
(r :pointer)
(g :pointer))
(cl:export '#.(swig-lispify "gsl_ran_discrete" 'function))
(cffi:defcfun ("gsl_ran_discrete_pdf" #.(swig-lispify "gsl_ran_discrete_pdf" 'function)) :double
(k :pointer)
(g :pointer))
(cl:export '#.(swig-lispify "gsl_ran_discrete_pdf" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_function_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_function_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcfun ("gsl_multiroot_fdjacobian" #.(swig-lispify "gsl_multiroot_fdjacobian" 'function)) :int
(FF :pointer)
(x :pointer)
(f :pointer)
(epsrel :double)
(jacobian :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdjacobian" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_fsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_fsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "dx" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "dx" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multiroot_fsolver_alloc" #.(swig-lispify "gsl_multiroot_fsolver_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_alloc" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_free" #.(swig-lispify "gsl_multiroot_fsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_free" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_set" #.(swig-lispify "gsl_multiroot_fsolver_set" 'function)) :int
(s :pointer)
(f :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_set" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_iterate" #.(swig-lispify "gsl_multiroot_fsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_iterate" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_name" #.(swig-lispify "gsl_multiroot_fsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_name" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_root" #.(swig-lispify "gsl_multiroot_fsolver_root" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_root" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_dx" #.(swig-lispify "gsl_multiroot_fsolver_dx" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_dx" 'function))
(cffi:defcfun ("gsl_multiroot_fsolver_f" #.(swig-lispify "gsl_multiroot_fsolver_f" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_f" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_function_fdf_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "df" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_function_fdf_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "df" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_fdfsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multiroot_fdfsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "J" 'slotname) :pointer)
(#.(swig-lispify "dx" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "J" 'slotname))
(cl:export '#.(swig-lispify "dx" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multiroot_fdfsolver_alloc" #.(swig-lispify "gsl_multiroot_fdfsolver_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_alloc" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_set" #.(swig-lispify "gsl_multiroot_fdfsolver_set" 'function)) :int
(s :pointer)
(fdf :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_set" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_iterate" #.(swig-lispify "gsl_multiroot_fdfsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_iterate" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_free" #.(swig-lispify "gsl_multiroot_fdfsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_free" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_name" #.(swig-lispify "gsl_multiroot_fdfsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_name" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_root" #.(swig-lispify "gsl_multiroot_fdfsolver_root" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_root" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_dx" #.(swig-lispify "gsl_multiroot_fdfsolver_dx" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_dx" 'function))
(cffi:defcfun ("gsl_multiroot_fdfsolver_f" #.(swig-lispify "gsl_multiroot_fdfsolver_f" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_f" 'function))
(cffi:defcfun ("gsl_multiroot_test_delta" #.(swig-lispify "gsl_multiroot_test_delta" 'function)) :int
(dx :pointer)
(x :pointer)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_multiroot_test_delta" 'function))
(cffi:defcfun ("gsl_multiroot_test_residual" #.(swig-lispify "gsl_multiroot_test_residual" 'function)) :int
(f :pointer)
(epsabs :double))
(cl:export '#.(swig-lispify "gsl_multiroot_test_residual" 'function))
(cffi:defcvar ("gsl_multiroot_fsolver_dnewton" #.(swig-lispify "gsl_multiroot_fsolver_dnewton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_dnewton" 'variable))
(cffi:defcvar ("gsl_multiroot_fsolver_broyden" #.(swig-lispify "gsl_multiroot_fsolver_broyden" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_broyden" 'variable))
(cffi:defcvar ("gsl_multiroot_fsolver_hybrid" #.(swig-lispify "gsl_multiroot_fsolver_hybrid" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_hybrid" 'variable))
(cffi:defcvar ("gsl_multiroot_fsolver_hybrids" #.(swig-lispify "gsl_multiroot_fsolver_hybrids" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fsolver_hybrids" 'variable))
(cffi:defcvar ("gsl_multiroot_fdfsolver_newton" #.(swig-lispify "gsl_multiroot_fdfsolver_newton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_newton" 'variable))
(cffi:defcvar ("gsl_multiroot_fdfsolver_gnewton" #.(swig-lispify "gsl_multiroot_fdfsolver_gnewton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_gnewton" 'variable))
(cffi:defcvar ("gsl_multiroot_fdfsolver_hybridj" #.(swig-lispify "gsl_multiroot_fdfsolver_hybridj" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_hybridj" 'variable))
(cffi:defcvar ("gsl_multiroot_fdfsolver_hybridsj" #.(swig-lispify "gsl_multiroot_fdfsolver_hybridsj" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multiroot_fdfsolver_hybridsj" 'variable))
(cffi:defcfun ("gsl_blas_sdsdot" #.(swig-lispify "gsl_blas_sdsdot" 'function)) :int
(alpha :float)
(X :pointer)
(Y :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sdsdot" 'function))
(cffi:defcfun ("gsl_blas_dsdot" #.(swig-lispify "gsl_blas_dsdot" 'function)) :int
(X :pointer)
(Y :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsdot" 'function))
(cffi:defcfun ("gsl_blas_sdot" #.(swig-lispify "gsl_blas_sdot" 'function)) :int
(X :pointer)
(Y :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sdot" 'function))
(cffi:defcfun ("gsl_blas_ddot" #.(swig-lispify "gsl_blas_ddot" 'function)) :int
(X :pointer)
(Y :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ddot" 'function))
(cffi:defcfun ("gsl_blas_cdotu" #.(swig-lispify "gsl_blas_cdotu" 'function)) :int
(X :pointer)
(Y :pointer)
(dotu :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cdotu" 'function))
(cffi:defcfun ("gsl_blas_cdotc" #.(swig-lispify "gsl_blas_cdotc" 'function)) :int
(X :pointer)
(Y :pointer)
(dotc :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cdotc" 'function))
(cffi:defcfun ("gsl_blas_zdotu" #.(swig-lispify "gsl_blas_zdotu" 'function)) :int
(X :pointer)
(Y :pointer)
(dotu :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zdotu" 'function))
(cffi:defcfun ("gsl_blas_zdotc" #.(swig-lispify "gsl_blas_zdotc" 'function)) :int
(X :pointer)
(Y :pointer)
(dotc :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zdotc" 'function))
(cffi:defcfun ("gsl_blas_snrm2" #.(swig-lispify "gsl_blas_snrm2" 'function)) :float
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_snrm2" 'function))
(cffi:defcfun ("gsl_blas_sasum" #.(swig-lispify "gsl_blas_sasum" 'function)) :float
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sasum" 'function))
(cffi:defcfun ("gsl_blas_dnrm2" #.(swig-lispify "gsl_blas_dnrm2" 'function)) :double
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dnrm2" 'function))
(cffi:defcfun ("gsl_blas_dasum" #.(swig-lispify "gsl_blas_dasum" 'function)) :double
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dasum" 'function))
(cffi:defcfun ("gsl_blas_scnrm2" #.(swig-lispify "gsl_blas_scnrm2" 'function)) :float
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_scnrm2" 'function))
(cffi:defcfun ("gsl_blas_scasum" #.(swig-lispify "gsl_blas_scasum" 'function)) :float
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_scasum" 'function))
(cffi:defcfun ("gsl_blas_dznrm2" #.(swig-lispify "gsl_blas_dznrm2" 'function)) :double
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dznrm2" 'function))
(cffi:defcfun ("gsl_blas_dzasum" #.(swig-lispify "gsl_blas_dzasum" 'function)) :double
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dzasum" 'function))
(cffi:defcfun ("gsl_blas_isamax" #.(swig-lispify "gsl_blas_isamax" 'function)) :pointer
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_isamax" 'function))
(cffi:defcfun ("gsl_blas_idamax" #.(swig-lispify "gsl_blas_idamax" 'function)) :pointer
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_idamax" 'function))
(cffi:defcfun ("gsl_blas_icamax" #.(swig-lispify "gsl_blas_icamax" 'function)) :pointer
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_icamax" 'function))
(cffi:defcfun ("gsl_blas_izamax" #.(swig-lispify "gsl_blas_izamax" 'function)) :pointer
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_izamax" 'function))
(cffi:defcfun ("gsl_blas_sswap" #.(swig-lispify "gsl_blas_sswap" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sswap" 'function))
(cffi:defcfun ("gsl_blas_scopy" #.(swig-lispify "gsl_blas_scopy" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_scopy" 'function))
(cffi:defcfun ("gsl_blas_saxpy" #.(swig-lispify "gsl_blas_saxpy" 'function)) :int
(alpha :float)
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_saxpy" 'function))
(cffi:defcfun ("gsl_blas_dswap" #.(swig-lispify "gsl_blas_dswap" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dswap" 'function))
(cffi:defcfun ("gsl_blas_dcopy" #.(swig-lispify "gsl_blas_dcopy" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dcopy" 'function))
(cffi:defcfun ("gsl_blas_daxpy" #.(swig-lispify "gsl_blas_daxpy" 'function)) :int
(alpha :double)
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_daxpy" 'function))
(cffi:defcfun ("gsl_blas_cswap" #.(swig-lispify "gsl_blas_cswap" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cswap" 'function))
(cffi:defcfun ("gsl_blas_ccopy" #.(swig-lispify "gsl_blas_ccopy" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ccopy" 'function))
(cffi:defcfun ("gsl_blas_caxpy" #.(swig-lispify "gsl_blas_caxpy" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_caxpy" 'function))
(cffi:defcfun ("gsl_blas_zswap" #.(swig-lispify "gsl_blas_zswap" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zswap" 'function))
(cffi:defcfun ("gsl_blas_zcopy" #.(swig-lispify "gsl_blas_zcopy" 'function)) :int
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zcopy" 'function))
(cffi:defcfun ("gsl_blas_zaxpy" #.(swig-lispify "gsl_blas_zaxpy" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zaxpy" 'function))
(cffi:defcfun ("gsl_blas_srotg" #.(swig-lispify "gsl_blas_srotg" 'function)) :int
(a :pointer)
(b :pointer)
(c :pointer)
(s :pointer))
(cl:export '#.(swig-lispify "gsl_blas_srotg" 'function))
(cffi:defcfun ("gsl_blas_srotmg" #.(swig-lispify "gsl_blas_srotmg" 'function)) :int
(d1 :pointer)
(d2 :pointer)
(b1 :pointer)
(b2 :float)
(P :pointer))
(cl:export '#.(swig-lispify "gsl_blas_srotmg" 'function))
(cffi:defcfun ("gsl_blas_srot" #.(swig-lispify "gsl_blas_srot" 'function)) :int
(X :pointer)
(Y :pointer)
(c :float)
(s :float))
(cl:export '#.(swig-lispify "gsl_blas_srot" 'function))
(cffi:defcfun ("gsl_blas_srotm" #.(swig-lispify "gsl_blas_srotm" 'function)) :int
(X :pointer)
(Y :pointer)
(P :pointer))
(cl:export '#.(swig-lispify "gsl_blas_srotm" 'function))
(cffi:defcfun ("gsl_blas_drotg" #.(swig-lispify "gsl_blas_drotg" 'function)) :int
(a :pointer)
(b :pointer)
(c :pointer)
(s :pointer))
(cl:export '#.(swig-lispify "gsl_blas_drotg" 'function))
(cffi:defcfun ("gsl_blas_drotmg" #.(swig-lispify "gsl_blas_drotmg" 'function)) :int
(d1 :pointer)
(d2 :pointer)
(b1 :pointer)
(b2 :double)
(P :pointer))
(cl:export '#.(swig-lispify "gsl_blas_drotmg" 'function))
(cffi:defcfun ("gsl_blas_drot" #.(swig-lispify "gsl_blas_drot" 'function)) :int
(X :pointer)
(Y :pointer)
(c :double)
(s :double))
(cl:export '#.(swig-lispify "gsl_blas_drot" 'function))
(cffi:defcfun ("gsl_blas_drotm" #.(swig-lispify "gsl_blas_drotm" 'function)) :int
(X :pointer)
(Y :pointer)
(P :pointer))
(cl:export '#.(swig-lispify "gsl_blas_drotm" 'function))
(cffi:defcfun ("gsl_blas_sscal" #.(swig-lispify "gsl_blas_sscal" 'function)) :void
(alpha :float)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sscal" 'function))
(cffi:defcfun ("gsl_blas_dscal" #.(swig-lispify "gsl_blas_dscal" 'function)) :void
(alpha :double)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dscal" 'function))
(cffi:defcfun ("gsl_blas_cscal" #.(swig-lispify "gsl_blas_cscal" 'function)) :void
(alpha :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cscal" 'function))
(cffi:defcfun ("gsl_blas_zscal" #.(swig-lispify "gsl_blas_zscal" 'function)) :void
(alpha :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zscal" 'function))
(cffi:defcfun ("gsl_blas_csscal" #.(swig-lispify "gsl_blas_csscal" 'function)) :void
(alpha :float)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_csscal" 'function))
(cffi:defcfun ("gsl_blas_zdscal" #.(swig-lispify "gsl_blas_zdscal" 'function)) :void
(alpha :double)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zdscal" 'function))
(cffi:defcfun ("gsl_blas_sgemv" #.(swig-lispify "gsl_blas_sgemv" 'function)) :int
(TransA :pointer)
(alpha :float)
(A :pointer)
(X :pointer)
(beta :float)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sgemv" 'function))
(cffi:defcfun ("gsl_blas_strmv" #.(swig-lispify "gsl_blas_strmv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_strmv" 'function))
(cffi:defcfun ("gsl_blas_strsv" #.(swig-lispify "gsl_blas_strsv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_strsv" 'function))
(cffi:defcfun ("gsl_blas_dgemv" #.(swig-lispify "gsl_blas_dgemv" 'function)) :int
(TransA :pointer)
(alpha :double)
(A :pointer)
(X :pointer)
(beta :double)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dgemv" 'function))
(cffi:defcfun ("gsl_blas_dtrmv" #.(swig-lispify "gsl_blas_dtrmv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dtrmv" 'function))
(cffi:defcfun ("gsl_blas_dtrsv" #.(swig-lispify "gsl_blas_dtrsv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dtrsv" 'function))
(cffi:defcfun ("gsl_blas_cgemv" #.(swig-lispify "gsl_blas_cgemv" 'function)) :int
(TransA :pointer)
(alpha :pointer)
(A :pointer)
(X :pointer)
(beta :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cgemv" 'function))
(cffi:defcfun ("gsl_blas_ctrmv" #.(swig-lispify "gsl_blas_ctrmv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ctrmv" 'function))
(cffi:defcfun ("gsl_blas_ctrsv" #.(swig-lispify "gsl_blas_ctrsv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ctrsv" 'function))
(cffi:defcfun ("gsl_blas_zgemv" #.(swig-lispify "gsl_blas_zgemv" 'function)) :int
(TransA :pointer)
(alpha :pointer)
(A :pointer)
(X :pointer)
(beta :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zgemv" 'function))
(cffi:defcfun ("gsl_blas_ztrmv" #.(swig-lispify "gsl_blas_ztrmv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ztrmv" 'function))
(cffi:defcfun ("gsl_blas_ztrsv" #.(swig-lispify "gsl_blas_ztrsv" 'function)) :int
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(A :pointer)
(X :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ztrsv" 'function))
(cffi:defcfun ("gsl_blas_ssymv" #.(swig-lispify "gsl_blas_ssymv" 'function)) :int
(Uplo :pointer)
(alpha :float)
(A :pointer)
(X :pointer)
(beta :float)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssymv" 'function))
(cffi:defcfun ("gsl_blas_sger" #.(swig-lispify "gsl_blas_sger" 'function)) :int
(alpha :float)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sger" 'function))
(cffi:defcfun ("gsl_blas_ssyr" #.(swig-lispify "gsl_blas_ssyr" 'function)) :int
(Uplo :pointer)
(alpha :float)
(X :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssyr" 'function))
(cffi:defcfun ("gsl_blas_ssyr2" #.(swig-lispify "gsl_blas_ssyr2" 'function)) :int
(Uplo :pointer)
(alpha :float)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssyr2" 'function))
(cffi:defcfun ("gsl_blas_dsymv" #.(swig-lispify "gsl_blas_dsymv" 'function)) :int
(Uplo :pointer)
(alpha :double)
(A :pointer)
(X :pointer)
(beta :double)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsymv" 'function))
(cffi:defcfun ("gsl_blas_dger" #.(swig-lispify "gsl_blas_dger" 'function)) :int
(alpha :double)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dger" 'function))
(cffi:defcfun ("gsl_blas_dsyr" #.(swig-lispify "gsl_blas_dsyr" 'function)) :int
(Uplo :pointer)
(alpha :double)
(X :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsyr" 'function))
(cffi:defcfun ("gsl_blas_dsyr2" #.(swig-lispify "gsl_blas_dsyr2" 'function)) :int
(Uplo :pointer)
(alpha :double)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsyr2" 'function))
(cffi:defcfun ("gsl_blas_chemv" #.(swig-lispify "gsl_blas_chemv" 'function)) :int
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(X :pointer)
(beta :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_chemv" 'function))
(cffi:defcfun ("gsl_blas_cgeru" #.(swig-lispify "gsl_blas_cgeru" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cgeru" 'function))
(cffi:defcfun ("gsl_blas_cgerc" #.(swig-lispify "gsl_blas_cgerc" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cgerc" 'function))
(cffi:defcfun ("gsl_blas_cher" #.(swig-lispify "gsl_blas_cher" 'function)) :int
(Uplo :pointer)
(alpha :float)
(X :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cher" 'function))
(cffi:defcfun ("gsl_blas_cher2" #.(swig-lispify "gsl_blas_cher2" 'function)) :int
(Uplo :pointer)
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cher2" 'function))
(cffi:defcfun ("gsl_blas_zhemv" #.(swig-lispify "gsl_blas_zhemv" 'function)) :int
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(X :pointer)
(beta :pointer)
(Y :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zhemv" 'function))
(cffi:defcfun ("gsl_blas_zgeru" #.(swig-lispify "gsl_blas_zgeru" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zgeru" 'function))
(cffi:defcfun ("gsl_blas_zgerc" #.(swig-lispify "gsl_blas_zgerc" 'function)) :int
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zgerc" 'function))
(cffi:defcfun ("gsl_blas_zher" #.(swig-lispify "gsl_blas_zher" 'function)) :int
(Uplo :pointer)
(alpha :double)
(X :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zher" 'function))
(cffi:defcfun ("gsl_blas_zher2" #.(swig-lispify "gsl_blas_zher2" 'function)) :int
(Uplo :pointer)
(alpha :pointer)
(X :pointer)
(Y :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zher2" 'function))
(cffi:defcfun ("gsl_blas_sgemm" #.(swig-lispify "gsl_blas_sgemm" 'function)) :int
(TransA :pointer)
(TransB :pointer)
(alpha :float)
(A :pointer)
(B :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_sgemm" 'function))
(cffi:defcfun ("gsl_blas_ssymm" #.(swig-lispify "gsl_blas_ssymm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :float)
(A :pointer)
(B :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssymm" 'function))
(cffi:defcfun ("gsl_blas_ssyrk" #.(swig-lispify "gsl_blas_ssyrk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :float)
(A :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssyrk" 'function))
(cffi:defcfun ("gsl_blas_ssyr2k" #.(swig-lispify "gsl_blas_ssyr2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :float)
(A :pointer)
(B :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ssyr2k" 'function))
(cffi:defcfun ("gsl_blas_strmm" #.(swig-lispify "gsl_blas_strmm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :float)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_strmm" 'function))
(cffi:defcfun ("gsl_blas_strsm" #.(swig-lispify "gsl_blas_strsm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :float)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_strsm" 'function))
(cffi:defcfun ("gsl_blas_dgemm" #.(swig-lispify "gsl_blas_dgemm" 'function)) :int
(TransA :pointer)
(TransB :pointer)
(alpha :double)
(A :pointer)
(B :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dgemm" 'function))
(cffi:defcfun ("gsl_blas_dsymm" #.(swig-lispify "gsl_blas_dsymm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :double)
(A :pointer)
(B :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsymm" 'function))
(cffi:defcfun ("gsl_blas_dsyrk" #.(swig-lispify "gsl_blas_dsyrk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :double)
(A :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsyrk" 'function))
(cffi:defcfun ("gsl_blas_dsyr2k" #.(swig-lispify "gsl_blas_dsyr2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :double)
(A :pointer)
(B :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dsyr2k" 'function))
(cffi:defcfun ("gsl_blas_dtrmm" #.(swig-lispify "gsl_blas_dtrmm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :double)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dtrmm" 'function))
(cffi:defcfun ("gsl_blas_dtrsm" #.(swig-lispify "gsl_blas_dtrsm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :double)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_dtrsm" 'function))
(cffi:defcfun ("gsl_blas_cgemm" #.(swig-lispify "gsl_blas_cgemm" 'function)) :int
(TransA :pointer)
(TransB :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cgemm" 'function))
(cffi:defcfun ("gsl_blas_csymm" #.(swig-lispify "gsl_blas_csymm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_csymm" 'function))
(cffi:defcfun ("gsl_blas_csyrk" #.(swig-lispify "gsl_blas_csyrk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_csyrk" 'function))
(cffi:defcfun ("gsl_blas_csyr2k" #.(swig-lispify "gsl_blas_csyr2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_csyr2k" 'function))
(cffi:defcfun ("gsl_blas_ctrmm" #.(swig-lispify "gsl_blas_ctrmm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ctrmm" 'function))
(cffi:defcfun ("gsl_blas_ctrsm" #.(swig-lispify "gsl_blas_ctrsm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ctrsm" 'function))
(cffi:defcfun ("gsl_blas_zgemm" #.(swig-lispify "gsl_blas_zgemm" 'function)) :int
(TransA :pointer)
(TransB :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zgemm" 'function))
(cffi:defcfun ("gsl_blas_zsymm" #.(swig-lispify "gsl_blas_zsymm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zsymm" 'function))
(cffi:defcfun ("gsl_blas_zsyrk" #.(swig-lispify "gsl_blas_zsyrk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zsyrk" 'function))
(cffi:defcfun ("gsl_blas_zsyr2k" #.(swig-lispify "gsl_blas_zsyr2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zsyr2k" 'function))
(cffi:defcfun ("gsl_blas_ztrmm" #.(swig-lispify "gsl_blas_ztrmm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ztrmm" 'function))
(cffi:defcfun ("gsl_blas_ztrsm" #.(swig-lispify "gsl_blas_ztrsm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(TransA :pointer)
(Diag :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_blas_ztrsm" 'function))
(cffi:defcfun ("gsl_blas_chemm" #.(swig-lispify "gsl_blas_chemm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_chemm" 'function))
(cffi:defcfun ("gsl_blas_cherk" #.(swig-lispify "gsl_blas_cherk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :float)
(A :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cherk" 'function))
(cffi:defcfun ("gsl_blas_cher2k" #.(swig-lispify "gsl_blas_cher2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :float)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_cher2k" 'function))
(cffi:defcfun ("gsl_blas_zhemm" #.(swig-lispify "gsl_blas_zhemm" 'function)) :int
(Side :pointer)
(Uplo :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zhemm" 'function))
(cffi:defcfun ("gsl_blas_zherk" #.(swig-lispify "gsl_blas_zherk" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :double)
(A :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zherk" 'function))
(cffi:defcfun ("gsl_blas_zher2k" #.(swig-lispify "gsl_blas_zher2k" 'function)) :int
(Uplo :pointer)
(Trans :pointer)
(alpha :pointer)
(A :pointer)
(B :pointer)
(beta :double)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_blas_zher2k" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_char_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :string))
(cl:export '#.(swig-lispify "gsl_block_char_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_char_alloc" #.(swig-lispify "gsl_block_char_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_alloc" 'function))
(cffi:defcfun ("gsl_block_char_calloc" #.(swig-lispify "gsl_block_char_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_calloc" 'function))
(cffi:defcfun ("gsl_block_char_free" #.(swig-lispify "gsl_block_char_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_free" 'function))
(cffi:defcfun ("gsl_block_char_fread" #.(swig-lispify "gsl_block_char_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_fread" 'function))
(cffi:defcfun ("gsl_block_char_fwrite" #.(swig-lispify "gsl_block_char_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_fwrite" 'function))
(cffi:defcfun ("gsl_block_char_fscanf" #.(swig-lispify "gsl_block_char_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_fscanf" 'function))
(cffi:defcfun ("gsl_block_char_fprintf" #.(swig-lispify "gsl_block_char_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_char_fprintf" 'function))
(cffi:defcfun ("gsl_block_char_raw_fread" #.(swig-lispify "gsl_block_char_raw_fread" 'function)) :int
(stream :pointer)
(b :string)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_raw_fread" 'function))
(cffi:defcfun ("gsl_block_char_raw_fwrite" #.(swig-lispify "gsl_block_char_raw_fwrite" 'function)) :int
(stream :pointer)
(b :string)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_char_raw_fscanf" #.(swig-lispify "gsl_block_char_raw_fscanf" 'function)) :int
(stream :pointer)
(b :string)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_char_raw_fprintf" #.(swig-lispify "gsl_block_char_raw_fprintf" 'function)) :int
(stream :pointer)
(b :string)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_char_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_char_size" #.(swig-lispify "gsl_block_char_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_size" 'function))
(cffi:defcfun ("gsl_block_char_data" #.(swig-lispify "gsl_block_char_data" 'function)) :string
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_char_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_complex_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_complex_alloc" #.(swig-lispify "gsl_block_complex_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_alloc" 'function))
(cffi:defcfun ("gsl_block_complex_calloc" #.(swig-lispify "gsl_block_complex_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_calloc" 'function))
(cffi:defcfun ("gsl_block_complex_free" #.(swig-lispify "gsl_block_complex_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_free" 'function))
(cffi:defcfun ("gsl_block_complex_fread" #.(swig-lispify "gsl_block_complex_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_fread" 'function))
(cffi:defcfun ("gsl_block_complex_fwrite" #.(swig-lispify "gsl_block_complex_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_fscanf" #.(swig-lispify "gsl_block_complex_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_fprintf" #.(swig-lispify "gsl_block_complex_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_raw_fread" #.(swig-lispify "gsl_block_complex_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_raw_fread" 'function))
(cffi:defcfun ("gsl_block_complex_raw_fwrite" #.(swig-lispify "gsl_block_complex_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_raw_fscanf" #.(swig-lispify "gsl_block_complex_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_raw_fprintf" #.(swig-lispify "gsl_block_complex_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_size" #.(swig-lispify "gsl_block_complex_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_size" 'function))
(cffi:defcfun ("gsl_block_complex_data" #.(swig-lispify "gsl_block_complex_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_complex_float_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_complex_float_alloc" #.(swig-lispify "gsl_block_complex_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_alloc" 'function))
(cffi:defcfun ("gsl_block_complex_float_calloc" #.(swig-lispify "gsl_block_complex_float_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_calloc" 'function))
(cffi:defcfun ("gsl_block_complex_float_free" #.(swig-lispify "gsl_block_complex_float_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_free" 'function))
(cffi:defcfun ("gsl_block_complex_float_fread" #.(swig-lispify "gsl_block_complex_float_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_fread" 'function))
(cffi:defcfun ("gsl_block_complex_float_fwrite" #.(swig-lispify "gsl_block_complex_float_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_float_fscanf" #.(swig-lispify "gsl_block_complex_float_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_float_fprintf" #.(swig-lispify "gsl_block_complex_float_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_float_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_float_raw_fread" #.(swig-lispify "gsl_block_complex_float_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_raw_fread" 'function))
(cffi:defcfun ("gsl_block_complex_float_raw_fwrite" #.(swig-lispify "gsl_block_complex_float_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_float_raw_fscanf" #.(swig-lispify "gsl_block_complex_float_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_float_raw_fprintf" #.(swig-lispify "gsl_block_complex_float_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_float_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_float_size" #.(swig-lispify "gsl_block_complex_float_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_size" 'function))
(cffi:defcfun ("gsl_block_complex_float_data" #.(swig-lispify "gsl_block_complex_float_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_float_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_complex_long_double_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_complex_long_double_alloc" #.(swig-lispify "gsl_block_complex_long_double_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_alloc" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_calloc" #.(swig-lispify "gsl_block_complex_long_double_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_calloc" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_free" #.(swig-lispify "gsl_block_complex_long_double_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_free" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_fread" #.(swig-lispify "gsl_block_complex_long_double_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_fread" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_fwrite" #.(swig-lispify "gsl_block_complex_long_double_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_fscanf" #.(swig-lispify "gsl_block_complex_long_double_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_fprintf" #.(swig-lispify "gsl_block_complex_long_double_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_raw_fread" #.(swig-lispify "gsl_block_complex_long_double_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_raw_fread" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_raw_fwrite" #.(swig-lispify "gsl_block_complex_long_double_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_raw_fscanf" #.(swig-lispify "gsl_block_complex_long_double_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_raw_fprintf" #.(swig-lispify "gsl_block_complex_long_double_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_size" #.(swig-lispify "gsl_block_complex_long_double_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_size" 'function))
(cffi:defcfun ("gsl_block_complex_long_double_data" #.(swig-lispify "gsl_block_complex_long_double_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_complex_long_double_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_alloc" #.(swig-lispify "gsl_block_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_alloc" 'function))
(cffi:defcfun ("gsl_block_calloc" #.(swig-lispify "gsl_block_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_calloc" 'function))
(cffi:defcfun ("gsl_block_free" #.(swig-lispify "gsl_block_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_free" 'function))
(cffi:defcfun ("gsl_block_fread" #.(swig-lispify "gsl_block_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_fread" 'function))
(cffi:defcfun ("gsl_block_fwrite" #.(swig-lispify "gsl_block_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_fwrite" 'function))
(cffi:defcfun ("gsl_block_fscanf" #.(swig-lispify "gsl_block_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_fscanf" 'function))
(cffi:defcfun ("gsl_block_fprintf" #.(swig-lispify "gsl_block_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_fprintf" 'function))
(cffi:defcfun ("gsl_block_raw_fread" #.(swig-lispify "gsl_block_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_raw_fread" 'function))
(cffi:defcfun ("gsl_block_raw_fwrite" #.(swig-lispify "gsl_block_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_raw_fscanf" #.(swig-lispify "gsl_block_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_raw_fprintf" #.(swig-lispify "gsl_block_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_size" #.(swig-lispify "gsl_block_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_size" 'function))
(cffi:defcfun ("gsl_block_data" #.(swig-lispify "gsl_block_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_float_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_float_alloc" #.(swig-lispify "gsl_block_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_alloc" 'function))
(cffi:defcfun ("gsl_block_float_calloc" #.(swig-lispify "gsl_block_float_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_calloc" 'function))
(cffi:defcfun ("gsl_block_float_free" #.(swig-lispify "gsl_block_float_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_free" 'function))
(cffi:defcfun ("gsl_block_float_fread" #.(swig-lispify "gsl_block_float_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_fread" 'function))
(cffi:defcfun ("gsl_block_float_fwrite" #.(swig-lispify "gsl_block_float_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_fwrite" 'function))
(cffi:defcfun ("gsl_block_float_fscanf" #.(swig-lispify "gsl_block_float_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_fscanf" 'function))
(cffi:defcfun ("gsl_block_float_fprintf" #.(swig-lispify "gsl_block_float_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_float_fprintf" 'function))
(cffi:defcfun ("gsl_block_float_raw_fread" #.(swig-lispify "gsl_block_float_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_raw_fread" 'function))
(cffi:defcfun ("gsl_block_float_raw_fwrite" #.(swig-lispify "gsl_block_float_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_float_raw_fscanf" #.(swig-lispify "gsl_block_float_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_float_raw_fprintf" #.(swig-lispify "gsl_block_float_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_float_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_float_size" #.(swig-lispify "gsl_block_float_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_size" 'function))
(cffi:defcfun ("gsl_block_float_data" #.(swig-lispify "gsl_block_float_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_float_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_int_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_int_alloc" #.(swig-lispify "gsl_block_int_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_alloc" 'function))
(cffi:defcfun ("gsl_block_int_calloc" #.(swig-lispify "gsl_block_int_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_calloc" 'function))
(cffi:defcfun ("gsl_block_int_free" #.(swig-lispify "gsl_block_int_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_free" 'function))
(cffi:defcfun ("gsl_block_int_fread" #.(swig-lispify "gsl_block_int_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_fread" 'function))
(cffi:defcfun ("gsl_block_int_fwrite" #.(swig-lispify "gsl_block_int_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_fwrite" 'function))
(cffi:defcfun ("gsl_block_int_fscanf" #.(swig-lispify "gsl_block_int_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_fscanf" 'function))
(cffi:defcfun ("gsl_block_int_fprintf" #.(swig-lispify "gsl_block_int_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_int_fprintf" 'function))
(cffi:defcfun ("gsl_block_int_raw_fread" #.(swig-lispify "gsl_block_int_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_raw_fread" 'function))
(cffi:defcfun ("gsl_block_int_raw_fwrite" #.(swig-lispify "gsl_block_int_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_int_raw_fscanf" #.(swig-lispify "gsl_block_int_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_int_raw_fprintf" #.(swig-lispify "gsl_block_int_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_int_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_int_size" #.(swig-lispify "gsl_block_int_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_size" 'function))
(cffi:defcfun ("gsl_block_int_data" #.(swig-lispify "gsl_block_int_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_int_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_long_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_long_alloc" #.(swig-lispify "gsl_block_long_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_alloc" 'function))
(cffi:defcfun ("gsl_block_long_calloc" #.(swig-lispify "gsl_block_long_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_calloc" 'function))
(cffi:defcfun ("gsl_block_long_free" #.(swig-lispify "gsl_block_long_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_free" 'function))
(cffi:defcfun ("gsl_block_long_fread" #.(swig-lispify "gsl_block_long_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_fread" 'function))
(cffi:defcfun ("gsl_block_long_fwrite" #.(swig-lispify "gsl_block_long_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_fwrite" 'function))
(cffi:defcfun ("gsl_block_long_fscanf" #.(swig-lispify "gsl_block_long_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_fscanf" 'function))
(cffi:defcfun ("gsl_block_long_fprintf" #.(swig-lispify "gsl_block_long_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_long_fprintf" 'function))
(cffi:defcfun ("gsl_block_long_raw_fread" #.(swig-lispify "gsl_block_long_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_raw_fread" 'function))
(cffi:defcfun ("gsl_block_long_raw_fwrite" #.(swig-lispify "gsl_block_long_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_long_raw_fscanf" #.(swig-lispify "gsl_block_long_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_long_raw_fprintf" #.(swig-lispify "gsl_block_long_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_long_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_long_size" #.(swig-lispify "gsl_block_long_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_size" 'function))
(cffi:defcfun ("gsl_block_long_data" #.(swig-lispify "gsl_block_long_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_long_double_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_long_double_alloc" #.(swig-lispify "gsl_block_long_double_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_alloc" 'function))
(cffi:defcfun ("gsl_block_long_double_calloc" #.(swig-lispify "gsl_block_long_double_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_calloc" 'function))
(cffi:defcfun ("gsl_block_long_double_free" #.(swig-lispify "gsl_block_long_double_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_free" 'function))
(cffi:defcfun ("gsl_block_long_double_fread" #.(swig-lispify "gsl_block_long_double_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_fread" 'function))
(cffi:defcfun ("gsl_block_long_double_fwrite" #.(swig-lispify "gsl_block_long_double_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_block_long_double_fscanf" #.(swig-lispify "gsl_block_long_double_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_block_long_double_fprintf" #.(swig-lispify "gsl_block_long_double_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_block_long_double_raw_fread" #.(swig-lispify "gsl_block_long_double_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_raw_fread" 'function))
(cffi:defcfun ("gsl_block_long_double_raw_fwrite" #.(swig-lispify "gsl_block_long_double_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_long_double_raw_fscanf" #.(swig-lispify "gsl_block_long_double_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_long_double_raw_fprintf" #.(swig-lispify "gsl_block_long_double_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_long_double_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_long_double_size" #.(swig-lispify "gsl_block_long_double_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_size" 'function))
(cffi:defcfun ("gsl_block_long_double_data" #.(swig-lispify "gsl_block_long_double_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_long_double_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_short_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_short_alloc" #.(swig-lispify "gsl_block_short_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_alloc" 'function))
(cffi:defcfun ("gsl_block_short_calloc" #.(swig-lispify "gsl_block_short_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_calloc" 'function))
(cffi:defcfun ("gsl_block_short_free" #.(swig-lispify "gsl_block_short_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_free" 'function))
(cffi:defcfun ("gsl_block_short_fread" #.(swig-lispify "gsl_block_short_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_fread" 'function))
(cffi:defcfun ("gsl_block_short_fwrite" #.(swig-lispify "gsl_block_short_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_fwrite" 'function))
(cffi:defcfun ("gsl_block_short_fscanf" #.(swig-lispify "gsl_block_short_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_fscanf" 'function))
(cffi:defcfun ("gsl_block_short_fprintf" #.(swig-lispify "gsl_block_short_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_short_fprintf" 'function))
(cffi:defcfun ("gsl_block_short_raw_fread" #.(swig-lispify "gsl_block_short_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_raw_fread" 'function))
(cffi:defcfun ("gsl_block_short_raw_fwrite" #.(swig-lispify "gsl_block_short_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_short_raw_fscanf" #.(swig-lispify "gsl_block_short_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_short_raw_fprintf" #.(swig-lispify "gsl_block_short_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_short_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_short_size" #.(swig-lispify "gsl_block_short_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_size" 'function))
(cffi:defcfun ("gsl_block_short_data" #.(swig-lispify "gsl_block_short_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_short_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_uchar_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_uchar_alloc" #.(swig-lispify "gsl_block_uchar_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_alloc" 'function))
(cffi:defcfun ("gsl_block_uchar_calloc" #.(swig-lispify "gsl_block_uchar_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_calloc" 'function))
(cffi:defcfun ("gsl_block_uchar_free" #.(swig-lispify "gsl_block_uchar_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_free" 'function))
(cffi:defcfun ("gsl_block_uchar_fread" #.(swig-lispify "gsl_block_uchar_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_fread" 'function))
(cffi:defcfun ("gsl_block_uchar_fwrite" #.(swig-lispify "gsl_block_uchar_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_fwrite" 'function))
(cffi:defcfun ("gsl_block_uchar_fscanf" #.(swig-lispify "gsl_block_uchar_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_fscanf" 'function))
(cffi:defcfun ("gsl_block_uchar_fprintf" #.(swig-lispify "gsl_block_uchar_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_uchar_fprintf" 'function))
(cffi:defcfun ("gsl_block_uchar_raw_fread" #.(swig-lispify "gsl_block_uchar_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_raw_fread" 'function))
(cffi:defcfun ("gsl_block_uchar_raw_fwrite" #.(swig-lispify "gsl_block_uchar_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_uchar_raw_fscanf" #.(swig-lispify "gsl_block_uchar_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_uchar_raw_fprintf" #.(swig-lispify "gsl_block_uchar_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_uchar_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_uchar_size" #.(swig-lispify "gsl_block_uchar_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_size" 'function))
(cffi:defcfun ("gsl_block_uchar_data" #.(swig-lispify "gsl_block_uchar_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uchar_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_uint_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_uint_alloc" #.(swig-lispify "gsl_block_uint_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_alloc" 'function))
(cffi:defcfun ("gsl_block_uint_calloc" #.(swig-lispify "gsl_block_uint_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_calloc" 'function))
(cffi:defcfun ("gsl_block_uint_free" #.(swig-lispify "gsl_block_uint_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_free" 'function))
(cffi:defcfun ("gsl_block_uint_fread" #.(swig-lispify "gsl_block_uint_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_fread" 'function))
(cffi:defcfun ("gsl_block_uint_fwrite" #.(swig-lispify "gsl_block_uint_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_fwrite" 'function))
(cffi:defcfun ("gsl_block_uint_fscanf" #.(swig-lispify "gsl_block_uint_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_fscanf" 'function))
(cffi:defcfun ("gsl_block_uint_fprintf" #.(swig-lispify "gsl_block_uint_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_uint_fprintf" 'function))
(cffi:defcfun ("gsl_block_uint_raw_fread" #.(swig-lispify "gsl_block_uint_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_raw_fread" 'function))
(cffi:defcfun ("gsl_block_uint_raw_fwrite" #.(swig-lispify "gsl_block_uint_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_uint_raw_fscanf" #.(swig-lispify "gsl_block_uint_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_uint_raw_fprintf" #.(swig-lispify "gsl_block_uint_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_uint_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_uint_size" #.(swig-lispify "gsl_block_uint_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_size" 'function))
(cffi:defcfun ("gsl_block_uint_data" #.(swig-lispify "gsl_block_uint_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_uint_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_ulong_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_ulong_alloc" #.(swig-lispify "gsl_block_ulong_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_alloc" 'function))
(cffi:defcfun ("gsl_block_ulong_calloc" #.(swig-lispify "gsl_block_ulong_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_calloc" 'function))
(cffi:defcfun ("gsl_block_ulong_free" #.(swig-lispify "gsl_block_ulong_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_free" 'function))
(cffi:defcfun ("gsl_block_ulong_fread" #.(swig-lispify "gsl_block_ulong_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_fread" 'function))
(cffi:defcfun ("gsl_block_ulong_fwrite" #.(swig-lispify "gsl_block_ulong_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_fwrite" 'function))
(cffi:defcfun ("gsl_block_ulong_fscanf" #.(swig-lispify "gsl_block_ulong_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_fscanf" 'function))
(cffi:defcfun ("gsl_block_ulong_fprintf" #.(swig-lispify "gsl_block_ulong_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_ulong_fprintf" 'function))
(cffi:defcfun ("gsl_block_ulong_raw_fread" #.(swig-lispify "gsl_block_ulong_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_raw_fread" 'function))
(cffi:defcfun ("gsl_block_ulong_raw_fwrite" #.(swig-lispify "gsl_block_ulong_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_ulong_raw_fscanf" #.(swig-lispify "gsl_block_ulong_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_ulong_raw_fprintf" #.(swig-lispify "gsl_block_ulong_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_ulong_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_ulong_size" #.(swig-lispify "gsl_block_ulong_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_size" 'function))
(cffi:defcfun ("gsl_block_ulong_data" #.(swig-lispify "gsl_block_ulong_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ulong_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_block_ushort_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_block_ushort_alloc" #.(swig-lispify "gsl_block_ushort_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_alloc" 'function))
(cffi:defcfun ("gsl_block_ushort_calloc" #.(swig-lispify "gsl_block_ushort_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_calloc" 'function))
(cffi:defcfun ("gsl_block_ushort_free" #.(swig-lispify "gsl_block_ushort_free" 'function)) :void
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_free" 'function))
(cffi:defcfun ("gsl_block_ushort_fread" #.(swig-lispify "gsl_block_ushort_fread" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_fread" 'function))
(cffi:defcfun ("gsl_block_ushort_fwrite" #.(swig-lispify "gsl_block_ushort_fwrite" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_fwrite" 'function))
(cffi:defcfun ("gsl_block_ushort_fscanf" #.(swig-lispify "gsl_block_ushort_fscanf" 'function)) :int
(stream :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_fscanf" 'function))
(cffi:defcfun ("gsl_block_ushort_fprintf" #.(swig-lispify "gsl_block_ushort_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_ushort_fprintf" 'function))
(cffi:defcfun ("gsl_block_ushort_raw_fread" #.(swig-lispify "gsl_block_ushort_raw_fread" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_raw_fread" 'function))
(cffi:defcfun ("gsl_block_ushort_raw_fwrite" #.(swig-lispify "gsl_block_ushort_raw_fwrite" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_raw_fwrite" 'function))
(cffi:defcfun ("gsl_block_ushort_raw_fscanf" #.(swig-lispify "gsl_block_ushort_raw_fscanf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_raw_fscanf" 'function))
(cffi:defcfun ("gsl_block_ushort_raw_fprintf" #.(swig-lispify "gsl_block_ushort_raw_fprintf" 'function)) :int
(stream :pointer)
(b :pointer)
(n :pointer)
(stride :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_block_ushort_raw_fprintf" 'function))
(cffi:defcfun ("gsl_block_ushort_size" #.(swig-lispify "gsl_block_ushort_size" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_size" 'function))
(cffi:defcfun ("gsl_block_ushort_data" #.(swig-lispify "gsl_block_ushort_data" 'function)) :pointer
(b :pointer))
(cl:export '#.(swig-lispify "gsl_block_ushort_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_bspline_workspace" 'classname)
(#.(swig-lispify "k" 'slotname) :pointer)
(#.(swig-lispify "km1" 'slotname) :pointer)
(#.(swig-lispify "l" 'slotname) :pointer)
(#.(swig-lispify "nbreak" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "knots" 'slotname) :pointer)
(#.(swig-lispify "deltal" 'slotname) :pointer)
(#.(swig-lispify "deltar" 'slotname) :pointer)
(#.(swig-lispify "B" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_workspace" 'classname))
(cl:export '#.(swig-lispify "k" 'slotname))
(cl:export '#.(swig-lispify "km1" 'slotname))
(cl:export '#.(swig-lispify "l" 'slotname))
(cl:export '#.(swig-lispify "nbreak" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "knots" 'slotname))
(cl:export '#.(swig-lispify "deltal" 'slotname))
(cl:export '#.(swig-lispify "deltar" 'slotname))
(cl:export '#.(swig-lispify "B" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_bspline_deriv_workspace" 'classname)
(#.(swig-lispify "k" 'slotname) :pointer)
(#.(swig-lispify "A" 'slotname) :pointer)
(#.(swig-lispify "dB" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_deriv_workspace" 'classname))
(cl:export '#.(swig-lispify "k" 'slotname))
(cl:export '#.(swig-lispify "A" 'slotname))
(cl:export '#.(swig-lispify "dB" 'slotname))
(cffi:defcfun ("gsl_bspline_alloc" #.(swig-lispify "gsl_bspline_alloc" 'function)) :pointer
(k :pointer)
(nbreak :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_alloc" 'function))
(cffi:defcfun ("gsl_bspline_free" #.(swig-lispify "gsl_bspline_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_free" 'function))
(cffi:defcfun ("gsl_bspline_ncoeffs" #.(swig-lispify "gsl_bspline_ncoeffs" 'function)) :pointer
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_ncoeffs" 'function))
(cffi:defcfun ("gsl_bspline_order" #.(swig-lispify "gsl_bspline_order" 'function)) :pointer
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_order" 'function))
(cffi:defcfun ("gsl_bspline_nbreak" #.(swig-lispify "gsl_bspline_nbreak" 'function)) :pointer
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_nbreak" 'function))
(cffi:defcfun ("gsl_bspline_breakpoint" #.(swig-lispify "gsl_bspline_breakpoint" 'function)) :double
(i :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_breakpoint" 'function))
(cffi:defcfun ("gsl_bspline_greville_abscissa" #.(swig-lispify "gsl_bspline_greville_abscissa" 'function)) :double
(i :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_greville_abscissa" 'function))
(cffi:defcfun ("gsl_bspline_knots" #.(swig-lispify "gsl_bspline_knots" 'function)) :int
(breakpts :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_knots" 'function))
(cffi:defcfun ("gsl_bspline_knots_uniform" #.(swig-lispify "gsl_bspline_knots_uniform" 'function)) :int
(a :double)
(b :double)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_knots_uniform" 'function))
(cffi:defcfun ("gsl_bspline_knots_greville" #.(swig-lispify "gsl_bspline_knots_greville" 'function)) :int
(abscissae :pointer)
(w :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_knots_greville" 'function))
(cffi:defcfun ("gsl_bspline_eval" #.(swig-lispify "gsl_bspline_eval" 'function)) :int
(x :double)
(B :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_eval" 'function))
(cffi:defcfun ("gsl_bspline_eval_nonzero" #.(swig-lispify "gsl_bspline_eval_nonzero" 'function)) :int
(x :double)
(Bk :pointer)
(istart :pointer)
(iend :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_eval_nonzero" 'function))
(cffi:defcfun ("gsl_bspline_deriv_alloc" #.(swig-lispify "gsl_bspline_deriv_alloc" 'function)) :pointer
(k :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_deriv_alloc" 'function))
(cffi:defcfun ("gsl_bspline_deriv_free" #.(swig-lispify "gsl_bspline_deriv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_deriv_free" 'function))
(cffi:defcfun ("gsl_bspline_deriv_eval" #.(swig-lispify "gsl_bspline_deriv_eval" 'function)) :int
(x :double)
(nderiv :pointer)
(dB :pointer)
(w :pointer)
(dw :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_deriv_eval" 'function))
(cffi:defcfun ("gsl_bspline_deriv_eval_nonzero" #.(swig-lispify "gsl_bspline_deriv_eval_nonzero" 'function)) :int
(x :double)
(nderiv :pointer)
(dB :pointer)
(istart :pointer)
(iend :pointer)
(w :pointer)
(dw :pointer))
(cl:export '#.(swig-lispify "gsl_bspline_deriv_eval_nonzero" 'function))
(cffi:defcenum #.(swig-lispify "CBLAS_ORDER" 'enumname)
(#.(swig-lispify "CblasRowMajor" 'enumvalue :keyword) #.101)
(#.(swig-lispify "CblasColMajor" 'enumvalue :keyword) #.102))
(cl:export '#.(swig-lispify "CBLAS_ORDER" 'enumname))
(cffi:defcenum #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname)
(#.(swig-lispify "CblasNoTrans" 'enumvalue :keyword) #.111)
(#.(swig-lispify "CblasTrans" 'enumvalue :keyword) #.112)
(#.(swig-lispify "CblasConjTrans" 'enumvalue :keyword) #.113))
(cl:export '#.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(cffi:defcenum #.(swig-lispify "CBLAS_UPLO" 'enumname)
(#.(swig-lispify "CblasUpper" 'enumvalue :keyword) #.121)
(#.(swig-lispify "CblasLower" 'enumvalue :keyword) #.122))
(cl:export '#.(swig-lispify "CBLAS_UPLO" 'enumname))
(cffi:defcenum #.(swig-lispify "CBLAS_DIAG" 'enumname)
(#.(swig-lispify "CblasNonUnit" 'enumvalue :keyword) #.131)
(#.(swig-lispify "CblasUnit" 'enumvalue :keyword) #.132))
(cl:export '#.(swig-lispify "CBLAS_DIAG" 'enumname))
(cffi:defcenum #.(swig-lispify "CBLAS_SIDE" 'enumname)
(#.(swig-lispify "CblasLeft" 'enumvalue :keyword) #.141)
(#.(swig-lispify "CblasRight" 'enumvalue :keyword) #.142))
(cl:export '#.(swig-lispify "CBLAS_SIDE" 'enumname))
(cffi:defcfun ("cblas_sdsdot" #.(swig-lispify "cblas_sdsdot" 'function)) :float
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sdsdot" 'function))
(cffi:defcfun ("cblas_dsdot" #.(swig-lispify "cblas_dsdot" 'function)) :double
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dsdot" 'function))
(cffi:defcfun ("cblas_sdot" #.(swig-lispify "cblas_sdot" 'function)) :float
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sdot" 'function))
(cffi:defcfun ("cblas_ddot" #.(swig-lispify "cblas_ddot" 'function)) :double
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_ddot" 'function))
(cffi:defcfun ("cblas_cdotu_sub" #.(swig-lispify "cblas_cdotu_sub" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(dotu :pointer))
(cl:export '#.(swig-lispify "cblas_cdotu_sub" 'function))
(cffi:defcfun ("cblas_cdotc_sub" #.(swig-lispify "cblas_cdotc_sub" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(dotc :pointer))
(cl:export '#.(swig-lispify "cblas_cdotc_sub" 'function))
(cffi:defcfun ("cblas_zdotu_sub" #.(swig-lispify "cblas_zdotu_sub" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(dotu :pointer))
(cl:export '#.(swig-lispify "cblas_zdotu_sub" 'function))
(cffi:defcfun ("cblas_zdotc_sub" #.(swig-lispify "cblas_zdotc_sub" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(dotc :pointer))
(cl:export '#.(swig-lispify "cblas_zdotc_sub" 'function))
(cffi:defcfun ("cblas_snrm2" #.(swig-lispify "cblas_snrm2" 'function)) :float
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_snrm2" 'function))
(cffi:defcfun ("cblas_sasum" #.(swig-lispify "cblas_sasum" 'function)) :float
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_sasum" 'function))
(cffi:defcfun ("cblas_dnrm2" #.(swig-lispify "cblas_dnrm2" 'function)) :double
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dnrm2" 'function))
(cffi:defcfun ("cblas_dasum" #.(swig-lispify "cblas_dasum" 'function)) :double
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dasum" 'function))
(cffi:defcfun ("cblas_scnrm2" #.(swig-lispify "cblas_scnrm2" 'function)) :float
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_scnrm2" 'function))
(cffi:defcfun ("cblas_scasum" #.(swig-lispify "cblas_scasum" 'function)) :float
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_scasum" 'function))
(cffi:defcfun ("cblas_dznrm2" #.(swig-lispify "cblas_dznrm2" 'function)) :double
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dznrm2" 'function))
(cffi:defcfun ("cblas_dzasum" #.(swig-lispify "cblas_dzasum" 'function)) :double
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dzasum" 'function))
(cffi:defcfun ("cblas_isamax" #.(swig-lispify "cblas_isamax" 'function)) :pointer
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_isamax" 'function))
(cffi:defcfun ("cblas_idamax" #.(swig-lispify "cblas_idamax" 'function)) :pointer
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_idamax" 'function))
(cffi:defcfun ("cblas_icamax" #.(swig-lispify "cblas_icamax" 'function)) :pointer
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_icamax" 'function))
(cffi:defcfun ("cblas_izamax" #.(swig-lispify "cblas_izamax" 'function)) :pointer
(N :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_izamax" 'function))
(cffi:defcfun ("cblas_sswap" #.(swig-lispify "cblas_sswap" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sswap" 'function))
(cffi:defcfun ("cblas_scopy" #.(swig-lispify "cblas_scopy" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_scopy" 'function))
(cffi:defcfun ("cblas_saxpy" #.(swig-lispify "cblas_saxpy" 'function)) :void
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_saxpy" 'function))
(cffi:defcfun ("cblas_dswap" #.(swig-lispify "cblas_dswap" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dswap" 'function))
(cffi:defcfun ("cblas_dcopy" #.(swig-lispify "cblas_dcopy" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dcopy" 'function))
(cffi:defcfun ("cblas_daxpy" #.(swig-lispify "cblas_daxpy" 'function)) :void
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_daxpy" 'function))
(cffi:defcfun ("cblas_cswap" #.(swig-lispify "cblas_cswap" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_cswap" 'function))
(cffi:defcfun ("cblas_ccopy" #.(swig-lispify "cblas_ccopy" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_ccopy" 'function))
(cffi:defcfun ("cblas_caxpy" #.(swig-lispify "cblas_caxpy" 'function)) :void
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_caxpy" 'function))
(cffi:defcfun ("cblas_zswap" #.(swig-lispify "cblas_zswap" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zswap" 'function))
(cffi:defcfun ("cblas_zcopy" #.(swig-lispify "cblas_zcopy" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zcopy" 'function))
(cffi:defcfun ("cblas_zaxpy" #.(swig-lispify "cblas_zaxpy" 'function)) :void
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zaxpy" 'function))
(cffi:defcfun ("cblas_srotg" #.(swig-lispify "cblas_srotg" 'function)) :void
(a :pointer)
(b :pointer)
(c :pointer)
(s :pointer))
(cl:export '#.(swig-lispify "cblas_srotg" 'function))
(cffi:defcfun ("cblas_srotmg" #.(swig-lispify "cblas_srotmg" 'function)) :void
(d1 :pointer)
(d2 :pointer)
(b1 :pointer)
(b2 :float)
(P :pointer))
(cl:export '#.(swig-lispify "cblas_srotmg" 'function))
(cffi:defcfun ("cblas_srot" #.(swig-lispify "cblas_srot" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(c :float)
(s :float))
(cl:export '#.(swig-lispify "cblas_srot" 'function))
(cffi:defcfun ("cblas_srotm" #.(swig-lispify "cblas_srotm" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(P :pointer))
(cl:export '#.(swig-lispify "cblas_srotm" 'function))
(cffi:defcfun ("cblas_drotg" #.(swig-lispify "cblas_drotg" 'function)) :void
(a :pointer)
(b :pointer)
(c :pointer)
(s :pointer))
(cl:export '#.(swig-lispify "cblas_drotg" 'function))
(cffi:defcfun ("cblas_drotmg" #.(swig-lispify "cblas_drotmg" 'function)) :void
(d1 :pointer)
(d2 :pointer)
(b1 :pointer)
(b2 :double)
(P :pointer))
(cl:export '#.(swig-lispify "cblas_drotmg" 'function))
(cffi:defcfun ("cblas_drot" #.(swig-lispify "cblas_drot" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(c :double)
(s :double))
(cl:export '#.(swig-lispify "cblas_drot" 'function))
(cffi:defcfun ("cblas_drotm" #.(swig-lispify "cblas_drotm" 'function)) :void
(N :int)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(P :pointer))
(cl:export '#.(swig-lispify "cblas_drotm" 'function))
(cffi:defcfun ("cblas_sscal" #.(swig-lispify "cblas_sscal" 'function)) :void
(N :int)
(alpha :float)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_sscal" 'function))
(cffi:defcfun ("cblas_dscal" #.(swig-lispify "cblas_dscal" 'function)) :void
(N :int)
(alpha :double)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dscal" 'function))
(cffi:defcfun ("cblas_cscal" #.(swig-lispify "cblas_cscal" 'function)) :void
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_cscal" 'function))
(cffi:defcfun ("cblas_zscal" #.(swig-lispify "cblas_zscal" 'function)) :void
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_zscal" 'function))
(cffi:defcfun ("cblas_csscal" #.(swig-lispify "cblas_csscal" 'function)) :void
(N :int)
(alpha :float)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_csscal" 'function))
(cffi:defcfun ("cblas_zdscal" #.(swig-lispify "cblas_zdscal" 'function)) :void
(N :int)
(alpha :double)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_zdscal" 'function))
(cffi:defcfun ("cblas_sgemv" #.(swig-lispify "cblas_sgemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(alpha :float)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :float)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sgemv" 'function))
(cffi:defcfun ("cblas_sgbmv" #.(swig-lispify "cblas_sgbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(KL :int)
(KU :int)
(alpha :float)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :float)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sgbmv" 'function))
(cffi:defcfun ("cblas_strmv" #.(swig-lispify "cblas_strmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_strmv" 'function))
(cffi:defcfun ("cblas_stbmv" #.(swig-lispify "cblas_stbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_stbmv" 'function))
(cffi:defcfun ("cblas_stpmv" #.(swig-lispify "cblas_stpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_stpmv" 'function))
(cffi:defcfun ("cblas_strsv" #.(swig-lispify "cblas_strsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_strsv" 'function))
(cffi:defcfun ("cblas_stbsv" #.(swig-lispify "cblas_stbsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_stbsv" 'function))
(cffi:defcfun ("cblas_stpsv" #.(swig-lispify "cblas_stpsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_stpsv" 'function))
(cffi:defcfun ("cblas_dgemv" #.(swig-lispify "cblas_dgemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(alpha :double)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :double)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dgemv" 'function))
(cffi:defcfun ("cblas_dgbmv" #.(swig-lispify "cblas_dgbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(KL :int)
(KU :int)
(alpha :double)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :double)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dgbmv" 'function))
(cffi:defcfun ("cblas_dtrmv" #.(swig-lispify "cblas_dtrmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtrmv" 'function))
(cffi:defcfun ("cblas_dtbmv" #.(swig-lispify "cblas_dtbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtbmv" 'function))
(cffi:defcfun ("cblas_dtpmv" #.(swig-lispify "cblas_dtpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtpmv" 'function))
(cffi:defcfun ("cblas_dtrsv" #.(swig-lispify "cblas_dtrsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtrsv" 'function))
(cffi:defcfun ("cblas_dtbsv" #.(swig-lispify "cblas_dtbsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtbsv" 'function))
(cffi:defcfun ("cblas_dtpsv" #.(swig-lispify "cblas_dtpsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_dtpsv" 'function))
(cffi:defcfun ("cblas_cgemv" #.(swig-lispify "cblas_cgemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_cgemv" 'function))
(cffi:defcfun ("cblas_cgbmv" #.(swig-lispify "cblas_cgbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(KL :int)
(KU :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_cgbmv" 'function))
(cffi:defcfun ("cblas_ctrmv" #.(swig-lispify "cblas_ctrmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctrmv" 'function))
(cffi:defcfun ("cblas_ctbmv" #.(swig-lispify "cblas_ctbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctbmv" 'function))
(cffi:defcfun ("cblas_ctpmv" #.(swig-lispify "cblas_ctpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctpmv" 'function))
(cffi:defcfun ("cblas_ctrsv" #.(swig-lispify "cblas_ctrsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctrsv" 'function))
(cffi:defcfun ("cblas_ctbsv" #.(swig-lispify "cblas_ctbsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctbsv" 'function))
(cffi:defcfun ("cblas_ctpsv" #.(swig-lispify "cblas_ctpsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ctpsv" 'function))
(cffi:defcfun ("cblas_zgemv" #.(swig-lispify "cblas_zgemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zgemv" 'function))
(cffi:defcfun ("cblas_zgbmv" #.(swig-lispify "cblas_zgbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(KL :int)
(KU :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zgbmv" 'function))
(cffi:defcfun ("cblas_ztrmv" #.(swig-lispify "cblas_ztrmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztrmv" 'function))
(cffi:defcfun ("cblas_ztbmv" #.(swig-lispify "cblas_ztbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztbmv" 'function))
(cffi:defcfun ("cblas_ztpmv" #.(swig-lispify "cblas_ztpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztpmv" 'function))
(cffi:defcfun ("cblas_ztrsv" #.(swig-lispify "cblas_ztrsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztrsv" 'function))
(cffi:defcfun ("cblas_ztbsv" #.(swig-lispify "cblas_ztbsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(K :int)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztbsv" 'function))
(cffi:defcfun ("cblas_ztpsv" #.(swig-lispify "cblas_ztpsv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(N :int)
(Ap :pointer)
(X :pointer)
(incX :int))
(cl:export '#.(swig-lispify "cblas_ztpsv" 'function))
(cffi:defcfun ("cblas_ssymv" #.(swig-lispify "cblas_ssymv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :float)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_ssymv" 'function))
(cffi:defcfun ("cblas_ssbmv" #.(swig-lispify "cblas_ssbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(K :int)
(alpha :float)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :float)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_ssbmv" 'function))
(cffi:defcfun ("cblas_sspmv" #.(swig-lispify "cblas_sspmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(Ap :pointer)
(X :pointer)
(incX :int)
(beta :float)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_sspmv" 'function))
(cffi:defcfun ("cblas_sger" #.(swig-lispify "cblas_sger" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_sger" 'function))
(cffi:defcfun ("cblas_ssyr" #.(swig-lispify "cblas_ssyr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_ssyr" 'function))
(cffi:defcfun ("cblas_sspr" #.(swig-lispify "cblas_sspr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Ap :pointer))
(cl:export '#.(swig-lispify "cblas_sspr" 'function))
(cffi:defcfun ("cblas_ssyr2" #.(swig-lispify "cblas_ssyr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_ssyr2" 'function))
(cffi:defcfun ("cblas_sspr2" #.(swig-lispify "cblas_sspr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer))
(cl:export '#.(swig-lispify "cblas_sspr2" 'function))
(cffi:defcfun ("cblas_dsymv" #.(swig-lispify "cblas_dsymv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :double)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dsymv" 'function))
(cffi:defcfun ("cblas_dsbmv" #.(swig-lispify "cblas_dsbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(K :int)
(alpha :double)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :double)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dsbmv" 'function))
(cffi:defcfun ("cblas_dspmv" #.(swig-lispify "cblas_dspmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(Ap :pointer)
(X :pointer)
(incX :int)
(beta :double)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_dspmv" 'function))
(cffi:defcfun ("cblas_dger" #.(swig-lispify "cblas_dger" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_dger" 'function))
(cffi:defcfun ("cblas_dsyr" #.(swig-lispify "cblas_dsyr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_dsyr" 'function))
(cffi:defcfun ("cblas_dspr" #.(swig-lispify "cblas_dspr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(Ap :pointer))
(cl:export '#.(swig-lispify "cblas_dspr" 'function))
(cffi:defcfun ("cblas_dsyr2" #.(swig-lispify "cblas_dsyr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_dsyr2" 'function))
(cffi:defcfun ("cblas_dspr2" #.(swig-lispify "cblas_dspr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer))
(cl:export '#.(swig-lispify "cblas_dspr2" 'function))
(cffi:defcfun ("cblas_chemv" #.(swig-lispify "cblas_chemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_chemv" 'function))
(cffi:defcfun ("cblas_chbmv" #.(swig-lispify "cblas_chbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_chbmv" 'function))
(cffi:defcfun ("cblas_chpmv" #.(swig-lispify "cblas_chpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(Ap :pointer)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_chpmv" 'function))
(cffi:defcfun ("cblas_cgeru" #.(swig-lispify "cblas_cgeru" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_cgeru" 'function))
(cffi:defcfun ("cblas_cgerc" #.(swig-lispify "cblas_cgerc" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_cgerc" 'function))
(cffi:defcfun ("cblas_cher" #.(swig-lispify "cblas_cher" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_cher" 'function))
(cffi:defcfun ("cblas_chpr" #.(swig-lispify "cblas_chpr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :float)
(X :pointer)
(incX :int)
(A :pointer))
(cl:export '#.(swig-lispify "cblas_chpr" 'function))
(cffi:defcfun ("cblas_cher2" #.(swig-lispify "cblas_cher2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_cher2" 'function))
(cffi:defcfun ("cblas_chpr2" #.(swig-lispify "cblas_chpr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(Ap :pointer))
(cl:export '#.(swig-lispify "cblas_chpr2" 'function))
(cffi:defcfun ("cblas_zhemv" #.(swig-lispify "cblas_zhemv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zhemv" 'function))
(cffi:defcfun ("cblas_zhbmv" #.(swig-lispify "cblas_zhbmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zhbmv" 'function))
(cffi:defcfun ("cblas_zhpmv" #.(swig-lispify "cblas_zhpmv" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(Ap :pointer)
(X :pointer)
(incX :int)
(beta :pointer)
(Y :pointer)
(incY :int))
(cl:export '#.(swig-lispify "cblas_zhpmv" 'function))
(cffi:defcfun ("cblas_zgeru" #.(swig-lispify "cblas_zgeru" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_zgeru" 'function))
(cffi:defcfun ("cblas_zgerc" #.(swig-lispify "cblas_zgerc" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_zgerc" 'function))
(cffi:defcfun ("cblas_zher" #.(swig-lispify "cblas_zher" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_zher" 'function))
(cffi:defcfun ("cblas_zhpr" #.(swig-lispify "cblas_zhpr" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :double)
(X :pointer)
(incX :int)
(A :pointer))
(cl:export '#.(swig-lispify "cblas_zhpr" 'function))
(cffi:defcfun ("cblas_zher2" #.(swig-lispify "cblas_zher2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(A :pointer)
(lda :int))
(cl:export '#.(swig-lispify "cblas_zher2" 'function))
(cffi:defcfun ("cblas_zhpr2" #.(swig-lispify "cblas_zhpr2" 'function)) :void
(order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(N :int)
(alpha :pointer)
(X :pointer)
(incX :int)
(Y :pointer)
(incY :int)
(Ap :pointer))
(cl:export '#.(swig-lispify "cblas_zhpr2" 'function))
(cffi:defcfun ("cblas_sgemm" #.(swig-lispify "cblas_sgemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(TransB #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(K :int)
(alpha :float)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_sgemm" 'function))
(cffi:defcfun ("cblas_ssymm" #.(swig-lispify "cblas_ssymm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :float)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_ssymm" 'function))
(cffi:defcfun ("cblas_ssyrk" #.(swig-lispify "cblas_ssyrk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :float)
(A :pointer)
(lda :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_ssyrk" 'function))
(cffi:defcfun ("cblas_ssyr2k" #.(swig-lispify "cblas_ssyr2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :float)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_ssyr2k" 'function))
(cffi:defcfun ("cblas_strmm" #.(swig-lispify "cblas_strmm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :float)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_strmm" 'function))
(cffi:defcfun ("cblas_strsm" #.(swig-lispify "cblas_strsm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :float)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_strsm" 'function))
(cffi:defcfun ("cblas_dgemm" #.(swig-lispify "cblas_dgemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(TransB #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(K :int)
(alpha :double)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_dgemm" 'function))
(cffi:defcfun ("cblas_dsymm" #.(swig-lispify "cblas_dsymm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :double)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_dsymm" 'function))
(cffi:defcfun ("cblas_dsyrk" #.(swig-lispify "cblas_dsyrk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :double)
(A :pointer)
(lda :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_dsyrk" 'function))
(cffi:defcfun ("cblas_dsyr2k" #.(swig-lispify "cblas_dsyr2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :double)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_dsyr2k" 'function))
(cffi:defcfun ("cblas_dtrmm" #.(swig-lispify "cblas_dtrmm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :double)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_dtrmm" 'function))
(cffi:defcfun ("cblas_dtrsm" #.(swig-lispify "cblas_dtrsm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :double)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_dtrsm" 'function))
(cffi:defcfun ("cblas_cgemm" #.(swig-lispify "cblas_cgemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(TransB #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_cgemm" 'function))
(cffi:defcfun ("cblas_csymm" #.(swig-lispify "cblas_csymm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_csymm" 'function))
(cffi:defcfun ("cblas_csyrk" #.(swig-lispify "cblas_csyrk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_csyrk" 'function))
(cffi:defcfun ("cblas_csyr2k" #.(swig-lispify "cblas_csyr2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_csyr2k" 'function))
(cffi:defcfun ("cblas_ctrmm" #.(swig-lispify "cblas_ctrmm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_ctrmm" 'function))
(cffi:defcfun ("cblas_ctrsm" #.(swig-lispify "cblas_ctrsm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_ctrsm" 'function))
(cffi:defcfun ("cblas_zgemm" #.(swig-lispify "cblas_zgemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(TransB #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(M :int)
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zgemm" 'function))
(cffi:defcfun ("cblas_zsymm" #.(swig-lispify "cblas_zsymm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zsymm" 'function))
(cffi:defcfun ("cblas_zsyrk" #.(swig-lispify "cblas_zsyrk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zsyrk" 'function))
(cffi:defcfun ("cblas_zsyr2k" #.(swig-lispify "cblas_zsyr2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zsyr2k" 'function))
(cffi:defcfun ("cblas_ztrmm" #.(swig-lispify "cblas_ztrmm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_ztrmm" 'function))
(cffi:defcfun ("cblas_ztrsm" #.(swig-lispify "cblas_ztrsm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(TransA #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(Diag #.(swig-lispify "CBLAS_DIAG" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int))
(cl:export '#.(swig-lispify "cblas_ztrsm" 'function))
(cffi:defcfun ("cblas_chemm" #.(swig-lispify "cblas_chemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_chemm" 'function))
(cffi:defcfun ("cblas_cherk" #.(swig-lispify "cblas_cherk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :float)
(A :pointer)
(lda :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_cherk" 'function))
(cffi:defcfun ("cblas_cher2k" #.(swig-lispify "cblas_cher2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :float)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_cher2k" 'function))
(cffi:defcfun ("cblas_zhemm" #.(swig-lispify "cblas_zhemm" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Side #.(swig-lispify "CBLAS_SIDE" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(M :int)
(N :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :pointer)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zhemm" 'function))
(cffi:defcfun ("cblas_zherk" #.(swig-lispify "cblas_zherk" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :double)
(A :pointer)
(lda :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zherk" 'function))
(cffi:defcfun ("cblas_zher2k" #.(swig-lispify "cblas_zher2k" 'function)) :void
(Order #.(swig-lispify "CBLAS_ORDER" 'enumname))
(Uplo #.(swig-lispify "CBLAS_UPLO" 'enumname))
(Trans #.(swig-lispify "CBLAS_TRANSPOSE" 'enumname))
(N :int)
(K :int)
(alpha :pointer)
(A :pointer)
(lda :int)
(B :pointer)
(ldb :int)
(beta :double)
(C :pointer)
(ldc :int))
(cl:export '#.(swig-lispify "cblas_zher2k" 'function))
(cffi:defcfun ("cblas_xerbla" #.(swig-lispify "cblas_xerbla" 'function)) :void
(p :int)
(rout :string)
(form :string)
&rest)
(cl:export '#.(swig-lispify "cblas_xerbla" 'function))
(cffi:defcfun ("gsl_cdf_ugaussian_P" #.(swig-lispify "gsl_cdf_ugaussian_P" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_cdf_ugaussian_P" 'function))
(cffi:defcfun ("gsl_cdf_ugaussian_Q" #.(swig-lispify "gsl_cdf_ugaussian_Q" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_cdf_ugaussian_Q" 'function))
(cffi:defcfun ("gsl_cdf_ugaussian_Pinv" #.(swig-lispify "gsl_cdf_ugaussian_Pinv" 'function)) :double
(P :double))
(cl:export '#.(swig-lispify "gsl_cdf_ugaussian_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_ugaussian_Qinv" #.(swig-lispify "gsl_cdf_ugaussian_Qinv" 'function)) :double
(Q :double))
(cl:export '#.(swig-lispify "gsl_cdf_ugaussian_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_gaussian_P" #.(swig-lispify "gsl_cdf_gaussian_P" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_gaussian_P" 'function))
(cffi:defcfun ("gsl_cdf_gaussian_Q" #.(swig-lispify "gsl_cdf_gaussian_Q" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_gaussian_Q" 'function))
(cffi:defcfun ("gsl_cdf_gaussian_Pinv" #.(swig-lispify "gsl_cdf_gaussian_Pinv" 'function)) :double
(P :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_gaussian_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_gaussian_Qinv" #.(swig-lispify "gsl_cdf_gaussian_Qinv" 'function)) :double
(Q :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_gaussian_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_gamma_P" #.(swig-lispify "gsl_cdf_gamma_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gamma_P" 'function))
(cffi:defcfun ("gsl_cdf_gamma_Q" #.(swig-lispify "gsl_cdf_gamma_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gamma_Q" 'function))
(cffi:defcfun ("gsl_cdf_gamma_Pinv" #.(swig-lispify "gsl_cdf_gamma_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gamma_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_gamma_Qinv" #.(swig-lispify "gsl_cdf_gamma_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gamma_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_cauchy_P" #.(swig-lispify "gsl_cdf_cauchy_P" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_cauchy_P" 'function))
(cffi:defcfun ("gsl_cdf_cauchy_Q" #.(swig-lispify "gsl_cdf_cauchy_Q" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_cauchy_Q" 'function))
(cffi:defcfun ("gsl_cdf_cauchy_Pinv" #.(swig-lispify "gsl_cdf_cauchy_Pinv" 'function)) :double
(P :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_cauchy_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_cauchy_Qinv" #.(swig-lispify "gsl_cdf_cauchy_Qinv" 'function)) :double
(Q :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_cauchy_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_laplace_P" #.(swig-lispify "gsl_cdf_laplace_P" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_laplace_P" 'function))
(cffi:defcfun ("gsl_cdf_laplace_Q" #.(swig-lispify "gsl_cdf_laplace_Q" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_laplace_Q" 'function))
(cffi:defcfun ("gsl_cdf_laplace_Pinv" #.(swig-lispify "gsl_cdf_laplace_Pinv" 'function)) :double
(P :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_laplace_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_laplace_Qinv" #.(swig-lispify "gsl_cdf_laplace_Qinv" 'function)) :double
(Q :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_laplace_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_rayleigh_P" #.(swig-lispify "gsl_cdf_rayleigh_P" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_rayleigh_P" 'function))
(cffi:defcfun ("gsl_cdf_rayleigh_Q" #.(swig-lispify "gsl_cdf_rayleigh_Q" 'function)) :double
(x :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_rayleigh_Q" 'function))
(cffi:defcfun ("gsl_cdf_rayleigh_Pinv" #.(swig-lispify "gsl_cdf_rayleigh_Pinv" 'function)) :double
(P :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_rayleigh_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_rayleigh_Qinv" #.(swig-lispify "gsl_cdf_rayleigh_Qinv" 'function)) :double
(Q :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_rayleigh_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_chisq_P" #.(swig-lispify "gsl_cdf_chisq_P" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_chisq_P" 'function))
(cffi:defcfun ("gsl_cdf_chisq_Q" #.(swig-lispify "gsl_cdf_chisq_Q" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_chisq_Q" 'function))
(cffi:defcfun ("gsl_cdf_chisq_Pinv" #.(swig-lispify "gsl_cdf_chisq_Pinv" 'function)) :double
(P :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_chisq_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_chisq_Qinv" #.(swig-lispify "gsl_cdf_chisq_Qinv" 'function)) :double
(Q :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_chisq_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_exponential_P" #.(swig-lispify "gsl_cdf_exponential_P" 'function)) :double
(x :double)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_exponential_P" 'function))
(cffi:defcfun ("gsl_cdf_exponential_Q" #.(swig-lispify "gsl_cdf_exponential_Q" 'function)) :double
(x :double)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_exponential_Q" 'function))
(cffi:defcfun ("gsl_cdf_exponential_Pinv" #.(swig-lispify "gsl_cdf_exponential_Pinv" 'function)) :double
(P :double)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_exponential_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_exponential_Qinv" #.(swig-lispify "gsl_cdf_exponential_Qinv" 'function)) :double
(Q :double)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_exponential_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_exppow_P" #.(swig-lispify "gsl_cdf_exppow_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_exppow_P" 'function))
(cffi:defcfun ("gsl_cdf_exppow_Q" #.(swig-lispify "gsl_cdf_exppow_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_exppow_Q" 'function))
(cffi:defcfun ("gsl_cdf_tdist_P" #.(swig-lispify "gsl_cdf_tdist_P" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_tdist_P" 'function))
(cffi:defcfun ("gsl_cdf_tdist_Q" #.(swig-lispify "gsl_cdf_tdist_Q" 'function)) :double
(x :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_tdist_Q" 'function))
(cffi:defcfun ("gsl_cdf_tdist_Pinv" #.(swig-lispify "gsl_cdf_tdist_Pinv" 'function)) :double
(P :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_tdist_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_tdist_Qinv" #.(swig-lispify "gsl_cdf_tdist_Qinv" 'function)) :double
(Q :double)
(nu :double))
(cl:export '#.(swig-lispify "gsl_cdf_tdist_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_fdist_P" #.(swig-lispify "gsl_cdf_fdist_P" 'function)) :double
(x :double)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_cdf_fdist_P" 'function))
(cffi:defcfun ("gsl_cdf_fdist_Q" #.(swig-lispify "gsl_cdf_fdist_Q" 'function)) :double
(x :double)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_cdf_fdist_Q" 'function))
(cffi:defcfun ("gsl_cdf_fdist_Pinv" #.(swig-lispify "gsl_cdf_fdist_Pinv" 'function)) :double
(P :double)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_cdf_fdist_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_fdist_Qinv" #.(swig-lispify "gsl_cdf_fdist_Qinv" 'function)) :double
(Q :double)
(nu1 :double)
(nu2 :double))
(cl:export '#.(swig-lispify "gsl_cdf_fdist_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_beta_P" #.(swig-lispify "gsl_cdf_beta_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_beta_P" 'function))
(cffi:defcfun ("gsl_cdf_beta_Q" #.(swig-lispify "gsl_cdf_beta_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_beta_Q" 'function))
(cffi:defcfun ("gsl_cdf_beta_Pinv" #.(swig-lispify "gsl_cdf_beta_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_beta_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_beta_Qinv" #.(swig-lispify "gsl_cdf_beta_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_beta_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_flat_P" #.(swig-lispify "gsl_cdf_flat_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_flat_P" 'function))
(cffi:defcfun ("gsl_cdf_flat_Q" #.(swig-lispify "gsl_cdf_flat_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_flat_Q" 'function))
(cffi:defcfun ("gsl_cdf_flat_Pinv" #.(swig-lispify "gsl_cdf_flat_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_flat_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_flat_Qinv" #.(swig-lispify "gsl_cdf_flat_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_flat_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_lognormal_P" #.(swig-lispify "gsl_cdf_lognormal_P" 'function)) :double
(x :double)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_lognormal_P" 'function))
(cffi:defcfun ("gsl_cdf_lognormal_Q" #.(swig-lispify "gsl_cdf_lognormal_Q" 'function)) :double
(x :double)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_lognormal_Q" 'function))
(cffi:defcfun ("gsl_cdf_lognormal_Pinv" #.(swig-lispify "gsl_cdf_lognormal_Pinv" 'function)) :double
(P :double)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_lognormal_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_lognormal_Qinv" #.(swig-lispify "gsl_cdf_lognormal_Qinv" 'function)) :double
(Q :double)
(zeta :double)
(sigma :double))
(cl:export '#.(swig-lispify "gsl_cdf_lognormal_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_gumbel1_P" #.(swig-lispify "gsl_cdf_gumbel1_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel1_P" 'function))
(cffi:defcfun ("gsl_cdf_gumbel1_Q" #.(swig-lispify "gsl_cdf_gumbel1_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel1_Q" 'function))
(cffi:defcfun ("gsl_cdf_gumbel1_Pinv" #.(swig-lispify "gsl_cdf_gumbel1_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel1_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_gumbel1_Qinv" #.(swig-lispify "gsl_cdf_gumbel1_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel1_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_gumbel2_P" #.(swig-lispify "gsl_cdf_gumbel2_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel2_P" 'function))
(cffi:defcfun ("gsl_cdf_gumbel2_Q" #.(swig-lispify "gsl_cdf_gumbel2_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel2_Q" 'function))
(cffi:defcfun ("gsl_cdf_gumbel2_Pinv" #.(swig-lispify "gsl_cdf_gumbel2_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel2_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_gumbel2_Qinv" #.(swig-lispify "gsl_cdf_gumbel2_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_gumbel2_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_weibull_P" #.(swig-lispify "gsl_cdf_weibull_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_weibull_P" 'function))
(cffi:defcfun ("gsl_cdf_weibull_Q" #.(swig-lispify "gsl_cdf_weibull_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_weibull_Q" 'function))
(cffi:defcfun ("gsl_cdf_weibull_Pinv" #.(swig-lispify "gsl_cdf_weibull_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_weibull_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_weibull_Qinv" #.(swig-lispify "gsl_cdf_weibull_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_weibull_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_pareto_P" #.(swig-lispify "gsl_cdf_pareto_P" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_pareto_P" 'function))
(cffi:defcfun ("gsl_cdf_pareto_Q" #.(swig-lispify "gsl_cdf_pareto_Q" 'function)) :double
(x :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_pareto_Q" 'function))
(cffi:defcfun ("gsl_cdf_pareto_Pinv" #.(swig-lispify "gsl_cdf_pareto_Pinv" 'function)) :double
(P :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_pareto_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_pareto_Qinv" #.(swig-lispify "gsl_cdf_pareto_Qinv" 'function)) :double
(Q :double)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cdf_pareto_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_logistic_P" #.(swig-lispify "gsl_cdf_logistic_P" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_logistic_P" 'function))
(cffi:defcfun ("gsl_cdf_logistic_Q" #.(swig-lispify "gsl_cdf_logistic_Q" 'function)) :double
(x :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_logistic_Q" 'function))
(cffi:defcfun ("gsl_cdf_logistic_Pinv" #.(swig-lispify "gsl_cdf_logistic_Pinv" 'function)) :double
(P :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_logistic_Pinv" 'function))
(cffi:defcfun ("gsl_cdf_logistic_Qinv" #.(swig-lispify "gsl_cdf_logistic_Qinv" 'function)) :double
(Q :double)
(a :double))
(cl:export '#.(swig-lispify "gsl_cdf_logistic_Qinv" 'function))
(cffi:defcfun ("gsl_cdf_binomial_P" #.(swig-lispify "gsl_cdf_binomial_P" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_binomial_P" 'function))
(cffi:defcfun ("gsl_cdf_binomial_Q" #.(swig-lispify "gsl_cdf_binomial_Q" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_binomial_Q" 'function))
(cffi:defcfun ("gsl_cdf_poisson_P" #.(swig-lispify "gsl_cdf_poisson_P" 'function)) :double
(k :unsigned-int)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_poisson_P" 'function))
(cffi:defcfun ("gsl_cdf_poisson_Q" #.(swig-lispify "gsl_cdf_poisson_Q" 'function)) :double
(k :unsigned-int)
(mu :double))
(cl:export '#.(swig-lispify "gsl_cdf_poisson_Q" 'function))
(cffi:defcfun ("gsl_cdf_geometric_P" #.(swig-lispify "gsl_cdf_geometric_P" 'function)) :double
(k :unsigned-int)
(p :double))
(cl:export '#.(swig-lispify "gsl_cdf_geometric_P" 'function))
(cffi:defcfun ("gsl_cdf_geometric_Q" #.(swig-lispify "gsl_cdf_geometric_Q" 'function)) :double
(k :unsigned-int)
(p :double))
(cl:export '#.(swig-lispify "gsl_cdf_geometric_Q" 'function))
(cffi:defcfun ("gsl_cdf_negative_binomial_P" #.(swig-lispify "gsl_cdf_negative_binomial_P" 'function)) :double
(k :unsigned-int)
(p :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_cdf_negative_binomial_P" 'function))
(cffi:defcfun ("gsl_cdf_negative_binomial_Q" #.(swig-lispify "gsl_cdf_negative_binomial_Q" 'function)) :double
(k :unsigned-int)
(p :double)
(n :double))
(cl:export '#.(swig-lispify "gsl_cdf_negative_binomial_Q" 'function))
(cffi:defcfun ("gsl_cdf_pascal_P" #.(swig-lispify "gsl_cdf_pascal_P" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_pascal_P" 'function))
(cffi:defcfun ("gsl_cdf_pascal_Q" #.(swig-lispify "gsl_cdf_pascal_Q" 'function)) :double
(k :unsigned-int)
(p :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_pascal_Q" 'function))
(cffi:defcfun ("gsl_cdf_hypergeometric_P" #.(swig-lispify "gsl_cdf_hypergeometric_P" 'function)) :double
(k :unsigned-int)
(n1 :unsigned-int)
(n2 :unsigned-int)
(t_arg3 :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_hypergeometric_P" 'function))
(cffi:defcfun ("gsl_cdf_hypergeometric_Q" #.(swig-lispify "gsl_cdf_hypergeometric_Q" 'function)) :double
(k :unsigned-int)
(n1 :unsigned-int)
(n2 :unsigned-int)
(t_arg3 :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cdf_hypergeometric_Q" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_cheb_series_struct" 'classname)
(#.(swig-lispify "c" 'slotname) :pointer)
(#.(swig-lispify "order" 'slotname) :pointer)
(#.(swig-lispify "a" 'slotname) :double)
(#.(swig-lispify "b" 'slotname) :double)
(#.(swig-lispify "order_sp" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_series_struct" 'classname))
(cl:export '#.(swig-lispify "c" 'slotname))
(cl:export '#.(swig-lispify "order" 'slotname))
(cl:export '#.(swig-lispify "a" 'slotname))
(cl:export '#.(swig-lispify "b" 'slotname))
(cl:export '#.(swig-lispify "order_sp" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cffi:defcfun ("gsl_cheb_alloc" #.(swig-lispify "gsl_cheb_alloc" 'function)) :pointer
(order :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_alloc" 'function))
(cffi:defcfun ("gsl_cheb_free" #.(swig-lispify "gsl_cheb_free" 'function)) :void
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_free" 'function))
(cffi:defcfun ("gsl_cheb_init" #.(swig-lispify "gsl_cheb_init" 'function)) :int
(cs :pointer)
(func :pointer)
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_cheb_init" 'function))
(cffi:defcfun ("gsl_cheb_order" #.(swig-lispify "gsl_cheb_order" 'function)) :pointer
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_order" 'function))
(cffi:defcfun ("gsl_cheb_size" #.(swig-lispify "gsl_cheb_size" 'function)) :pointer
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_size" 'function))
(cffi:defcfun ("gsl_cheb_coeffs" #.(swig-lispify "gsl_cheb_coeffs" 'function)) :pointer
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_coeffs" 'function))
(cffi:defcfun ("gsl_cheb_eval" #.(swig-lispify "gsl_cheb_eval" 'function)) :double
(cs :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_cheb_eval" 'function))
(cffi:defcfun ("gsl_cheb_eval_err" #.(swig-lispify "gsl_cheb_eval_err" 'function)) :int
(cs :pointer)
(x :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_eval_err" 'function))
(cffi:defcfun ("gsl_cheb_eval_n" #.(swig-lispify "gsl_cheb_eval_n" 'function)) :double
(cs :pointer)
(order :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_cheb_eval_n" 'function))
(cffi:defcfun ("gsl_cheb_eval_n_err" #.(swig-lispify "gsl_cheb_eval_n_err" 'function)) :int
(cs :pointer)
(order :pointer)
(x :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_eval_n_err" 'function))
(cffi:defcfun ("gsl_cheb_eval_mode" #.(swig-lispify "gsl_cheb_eval_mode" 'function)) :double
(cs :pointer)
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_cheb_eval_mode" 'function))
(cffi:defcfun ("gsl_cheb_eval_mode_e" #.(swig-lispify "gsl_cheb_eval_mode_e" 'function)) :int
(cs :pointer)
(x :double)
(mode :unsigned-int)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_eval_mode_e" 'function))
(cffi:defcfun ("gsl_cheb_calc_deriv" #.(swig-lispify "gsl_cheb_calc_deriv" 'function)) :int
(deriv :pointer)
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_calc_deriv" 'function))
(cffi:defcfun ("gsl_cheb_calc_integ" #.(swig-lispify "gsl_cheb_calc_integ" 'function)) :int
(integ :pointer)
(cs :pointer))
(cl:export '#.(swig-lispify "gsl_cheb_calc_integ" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_combination_struct" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "k" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_combination_struct" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "k" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_combination_alloc" #.(swig-lispify "gsl_combination_alloc" 'function)) :pointer
(n :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_combination_alloc" 'function))
(cffi:defcfun ("gsl_combination_calloc" #.(swig-lispify "gsl_combination_calloc" 'function)) :pointer
(n :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_combination_calloc" 'function))
(cffi:defcfun ("gsl_combination_init_first" #.(swig-lispify "gsl_combination_init_first" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_init_first" 'function))
(cffi:defcfun ("gsl_combination_init_last" #.(swig-lispify "gsl_combination_init_last" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_init_last" 'function))
(cffi:defcfun ("gsl_combination_free" #.(swig-lispify "gsl_combination_free" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_free" 'function))
(cffi:defcfun ("gsl_combination_memcpy" #.(swig-lispify "gsl_combination_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_combination_memcpy" 'function))
(cffi:defcfun ("gsl_combination_fread" #.(swig-lispify "gsl_combination_fread" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_fread" 'function))
(cffi:defcfun ("gsl_combination_fwrite" #.(swig-lispify "gsl_combination_fwrite" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_fwrite" 'function))
(cffi:defcfun ("gsl_combination_fscanf" #.(swig-lispify "gsl_combination_fscanf" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_fscanf" 'function))
(cffi:defcfun ("gsl_combination_fprintf" #.(swig-lispify "gsl_combination_fprintf" 'function)) :int
(stream :pointer)
(c :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_combination_fprintf" 'function))
(cffi:defcfun ("gsl_combination_n" #.(swig-lispify "gsl_combination_n" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_n" 'function))
(cffi:defcfun ("gsl_combination_k" #.(swig-lispify "gsl_combination_k" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_k" 'function))
(cffi:defcfun ("gsl_combination_data" #.(swig-lispify "gsl_combination_data" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_data" 'function))
(cffi:defcfun ("gsl_combination_valid" #.(swig-lispify "gsl_combination_valid" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_valid" 'function))
(cffi:defcfun ("gsl_combination_next" #.(swig-lispify "gsl_combination_next" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_next" 'function))
(cffi:defcfun ("gsl_combination_prev" #.(swig-lispify "gsl_combination_prev" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_combination_prev" 'function))
(cffi:defcfun ("gsl_combination_get" #.(swig-lispify "gsl_combination_get" 'function)) :pointer
(c :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_combination_get" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_complex_long_double" 'classname)
(#.(swig-lispify "dat" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_complex_long_double" 'classname))
(cl:export '#.(swig-lispify "dat" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_complex" 'classname)
(#.(swig-lispify "dat" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_complex" 'classname))
(cl:export '#.(swig-lispify "dat" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_complex_float" 'classname)
(#.(swig-lispify "dat" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_complex_float" 'classname))
(cl:export '#.(swig-lispify "dat" 'slotname))
(cffi:defcfun ("gsl_complex_polar" #.(swig-lispify "gsl_complex_polar" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(r :double)
(theta :double))
(cl:export '#.(swig-lispify "gsl_complex_polar" 'function))
(cffi:defcfun ("gsl_complex_rect" #.(swig-lispify "gsl_complex_rect" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_complex_rect" 'function))
(cffi:defcfun ("gsl_complex_arg" #.(swig-lispify "gsl_complex_arg" 'function)) :double
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arg" 'function))
(cffi:defcfun ("gsl_complex_abs" #.(swig-lispify "gsl_complex_abs" 'function)) :double
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_abs" 'function))
(cffi:defcfun ("gsl_complex_abs2" #.(swig-lispify "gsl_complex_abs2" 'function)) :double
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_abs2" 'function))
(cffi:defcfun ("gsl_complex_logabs" #.(swig-lispify "gsl_complex_logabs" 'function)) :double
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_logabs" 'function))
(cffi:defcfun ("gsl_complex_add" #.(swig-lispify "gsl_complex_add" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_add" 'function))
(cffi:defcfun ("gsl_complex_sub" #.(swig-lispify "gsl_complex_sub" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sub" 'function))
(cffi:defcfun ("gsl_complex_mul" #.(swig-lispify "gsl_complex_mul" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_mul" 'function))
(cffi:defcfun ("gsl_complex_div" #.(swig-lispify "gsl_complex_div" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_div" 'function))
(cffi:defcfun ("gsl_complex_add_real" #.(swig-lispify "gsl_complex_add_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(x :double))
(cl:export '#.(swig-lispify "gsl_complex_add_real" 'function))
(cffi:defcfun ("gsl_complex_sub_real" #.(swig-lispify "gsl_complex_sub_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(x :double))
(cl:export '#.(swig-lispify "gsl_complex_sub_real" 'function))
(cffi:defcfun ("gsl_complex_mul_real" #.(swig-lispify "gsl_complex_mul_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(x :double))
(cl:export '#.(swig-lispify "gsl_complex_mul_real" 'function))
(cffi:defcfun ("gsl_complex_div_real" #.(swig-lispify "gsl_complex_div_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(x :double))
(cl:export '#.(swig-lispify "gsl_complex_div_real" 'function))
(cffi:defcfun ("gsl_complex_add_imag" #.(swig-lispify "gsl_complex_add_imag" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(y :double))
(cl:export '#.(swig-lispify "gsl_complex_add_imag" 'function))
(cffi:defcfun ("gsl_complex_sub_imag" #.(swig-lispify "gsl_complex_sub_imag" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(y :double))
(cl:export '#.(swig-lispify "gsl_complex_sub_imag" 'function))
(cffi:defcfun ("gsl_complex_mul_imag" #.(swig-lispify "gsl_complex_mul_imag" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(y :double))
(cl:export '#.(swig-lispify "gsl_complex_mul_imag" 'function))
(cffi:defcfun ("gsl_complex_div_imag" #.(swig-lispify "gsl_complex_div_imag" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(y :double))
(cl:export '#.(swig-lispify "gsl_complex_div_imag" 'function))
(cffi:defcfun ("gsl_complex_conjugate" #.(swig-lispify "gsl_complex_conjugate" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_conjugate" 'function))
(cffi:defcfun ("gsl_complex_inverse" #.(swig-lispify "gsl_complex_inverse" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_inverse" 'function))
(cffi:defcfun ("gsl_complex_negative" #.(swig-lispify "gsl_complex_negative" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_negative" 'function))
(cffi:defcfun ("gsl_complex_sqrt" #.(swig-lispify "gsl_complex_sqrt" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sqrt" 'function))
(cffi:defcfun ("gsl_complex_sqrt_real" #.(swig-lispify "gsl_complex_sqrt_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(x :double))
(cl:export '#.(swig-lispify "gsl_complex_sqrt_real" 'function))
(cffi:defcfun ("gsl_complex_pow" #.(swig-lispify "gsl_complex_pow" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_pow" 'function))
(cffi:defcfun ("gsl_complex_pow_real" #.(swig-lispify "gsl_complex_pow_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b :double))
(cl:export '#.(swig-lispify "gsl_complex_pow_real" 'function))
(cffi:defcfun ("gsl_complex_exp" #.(swig-lispify "gsl_complex_exp" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_exp" 'function))
(cffi:defcfun ("gsl_complex_log" #.(swig-lispify "gsl_complex_log" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_log" 'function))
(cffi:defcfun ("gsl_complex_log10" #.(swig-lispify "gsl_complex_log10" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_log10" 'function))
(cffi:defcfun ("gsl_complex_log_b" #.(swig-lispify "gsl_complex_log_b" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname))
(b #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_log_b" 'function))
(cffi:defcfun ("gsl_complex_sin" #.(swig-lispify "gsl_complex_sin" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sin" 'function))
(cffi:defcfun ("gsl_complex_cos" #.(swig-lispify "gsl_complex_cos" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_cos" 'function))
(cffi:defcfun ("gsl_complex_sec" #.(swig-lispify "gsl_complex_sec" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sec" 'function))
(cffi:defcfun ("gsl_complex_csc" #.(swig-lispify "gsl_complex_csc" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_csc" 'function))
(cffi:defcfun ("gsl_complex_tan" #.(swig-lispify "gsl_complex_tan" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_tan" 'function))
(cffi:defcfun ("gsl_complex_cot" #.(swig-lispify "gsl_complex_cot" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_cot" 'function))
(cffi:defcfun ("gsl_complex_arcsin" #.(swig-lispify "gsl_complex_arcsin" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arcsin" 'function))
(cffi:defcfun ("gsl_complex_arcsin_real" #.(swig-lispify "gsl_complex_arcsin_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arcsin_real" 'function))
(cffi:defcfun ("gsl_complex_arccos" #.(swig-lispify "gsl_complex_arccos" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccos" 'function))
(cffi:defcfun ("gsl_complex_arccos_real" #.(swig-lispify "gsl_complex_arccos_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arccos_real" 'function))
(cffi:defcfun ("gsl_complex_arcsec" #.(swig-lispify "gsl_complex_arcsec" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arcsec" 'function))
(cffi:defcfun ("gsl_complex_arcsec_real" #.(swig-lispify "gsl_complex_arcsec_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arcsec_real" 'function))
(cffi:defcfun ("gsl_complex_arccsc" #.(swig-lispify "gsl_complex_arccsc" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccsc" 'function))
(cffi:defcfun ("gsl_complex_arccsc_real" #.(swig-lispify "gsl_complex_arccsc_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arccsc_real" 'function))
(cffi:defcfun ("gsl_complex_arctan" #.(swig-lispify "gsl_complex_arctan" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arctan" 'function))
(cffi:defcfun ("gsl_complex_arccot" #.(swig-lispify "gsl_complex_arccot" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccot" 'function))
(cffi:defcfun ("gsl_complex_sinh" #.(swig-lispify "gsl_complex_sinh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sinh" 'function))
(cffi:defcfun ("gsl_complex_cosh" #.(swig-lispify "gsl_complex_cosh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_cosh" 'function))
(cffi:defcfun ("gsl_complex_sech" #.(swig-lispify "gsl_complex_sech" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_sech" 'function))
(cffi:defcfun ("gsl_complex_csch" #.(swig-lispify "gsl_complex_csch" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_csch" 'function))
(cffi:defcfun ("gsl_complex_tanh" #.(swig-lispify "gsl_complex_tanh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_tanh" 'function))
(cffi:defcfun ("gsl_complex_coth" #.(swig-lispify "gsl_complex_coth" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_coth" 'function))
(cffi:defcfun ("gsl_complex_arcsinh" #.(swig-lispify "gsl_complex_arcsinh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arcsinh" 'function))
(cffi:defcfun ("gsl_complex_arccosh" #.(swig-lispify "gsl_complex_arccosh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccosh" 'function))
(cffi:defcfun ("gsl_complex_arccosh_real" #.(swig-lispify "gsl_complex_arccosh_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arccosh_real" 'function))
(cffi:defcfun ("gsl_complex_arcsech" #.(swig-lispify "gsl_complex_arcsech" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arcsech" 'function))
(cffi:defcfun ("gsl_complex_arccsch" #.(swig-lispify "gsl_complex_arccsch" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccsch" 'function))
(cffi:defcfun ("gsl_complex_arctanh" #.(swig-lispify "gsl_complex_arctanh" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arctanh" 'function))
(cffi:defcfun ("gsl_complex_arctanh_real" #.(swig-lispify "gsl_complex_arctanh_real" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a :double))
(cl:export '#.(swig-lispify "gsl_complex_arctanh_real" 'function))
(cffi:defcfun ("gsl_complex_arccoth" #.(swig-lispify "gsl_complex_arccoth" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(a #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_arccoth" 'function))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_SPEED_OF_LIGHT" 'constant) 2.99792458d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_SPEED_OF_LIGHT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_GRAVITATIONAL_CONSTANT" 'constant) 6.673d-8)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_GRAVITATIONAL_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PLANCKS_CONSTANT_H" 'constant) 6.62606896d-27)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PLANCKS_CONSTANT_H" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PLANCKS_CONSTANT_HBAR" 'constant) 1.05457162825d-27)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PLANCKS_CONSTANT_HBAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ASTRONOMICAL_UNIT" 'constant) 1.49597870691d13)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ASTRONOMICAL_UNIT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_LIGHT_YEAR" 'constant) 9.46053620707d17)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_LIGHT_YEAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PARSEC" 'constant) 3.08567758135d18)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PARSEC" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_GRAV_ACCEL" 'constant) 9.80665d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_GRAV_ACCEL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ELECTRON_VOLT" 'constant) 1.602176487d-12)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ELECTRON_VOLT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MASS_ELECTRON" 'constant) 9.10938188d-28)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MASS_ELECTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MASS_MUON" 'constant) 1.88353109d-25)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MASS_MUON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MASS_PROTON" 'constant) 1.67262158d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MASS_PROTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MASS_NEUTRON" 'constant) 1.67492716d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MASS_NEUTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_RYDBERG" 'constant) 2.17987196968d-11)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_RYDBERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_BOLTZMANN" 'constant) 1.3806504d-16)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_BOLTZMANN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MOLAR_GAS" 'constant) 8.314472d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MOLAR_GAS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_STANDARD_GAS_VOLUME" 'constant) 2.2710981d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_STANDARD_GAS_VOLUME" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MINUTE" 'constant) 6d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MINUTE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_HOUR" 'constant) 3.6d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_DAY" 'constant) 8.64d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_DAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_WEEK" 'constant) 6.048d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_WEEK" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_INCH" 'constant) 2.54d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_INCH" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_FOOT" 'constant) 3.048d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_FOOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_YARD" 'constant) 9.144d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_YARD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MILE" 'constant) 1.609344d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_NAUTICAL_MILE" 'constant) 1.852d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_NAUTICAL_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_FATHOM" 'constant) 1.8288d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_FATHOM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MIL" 'constant) 2.54d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MIL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_POINT" 'constant) 3.52777777778d-2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_POINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TEXPOINT" 'constant) 3.51459803515d-2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TEXPOINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MICRON" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MICRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ANGSTROM" 'constant) 1d-8)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ANGSTROM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_HECTARE" 'constant) 1d8)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_HECTARE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ACRE" 'constant) 4.04685642241d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ACRE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_BARN" 'constant) 1d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_BARN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_LITER" 'constant) 1d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_LITER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_US_GALLON" 'constant) 3.78541178402d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_US_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_QUART" 'constant) 9.46352946004d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_QUART" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PINT" 'constant) 4.73176473002d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_CUP" 'constant) 2.36588236501d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_CUP" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_FLUID_OUNCE" 'constant) 2.95735295626d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_FLUID_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TABLESPOON" 'constant) 1.47867647813d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TABLESPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TEASPOON" 'constant) 4.92892159375d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TEASPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_CANADIAN_GALLON" 'constant) 4.54609d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_CANADIAN_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_UK_GALLON" 'constant) 4.546092d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_UK_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_MILES_PER_HOUR" 'constant) 4.4704d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_MILES_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_KILOMETERS_PER_HOUR" 'constant) 2.77777777778d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_KILOMETERS_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_KNOT" 'constant) 5.14444444444d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_KNOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_POUND_MASS" 'constant) 4.5359237d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_POUND_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_OUNCE_MASS" 'constant) 2.8349523125d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_OUNCE_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TON" 'constant) 9.0718474d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_METRIC_TON" 'constant) 1d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_METRIC_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_UK_TON" 'constant) 1.0160469088d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_UK_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TROY_OUNCE" 'constant) 3.1103475d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TROY_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_CARAT" 'constant) 2d-1)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_CARAT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_UNIFIED_ATOMIC_MASS" 'constant) 1.660538782d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_UNIFIED_ATOMIC_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_GRAM_FORCE" 'constant) 9.80665d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_GRAM_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_POUND_FORCE" 'constant) 4.44822161526d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_POUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_KILOPOUND_FORCE" 'constant) 4.44822161526d8)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_KILOPOUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_POUNDAL" 'constant) 1.38255d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_POUNDAL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_CALORIE" 'constant) 4.1868d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_CALORIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_BTU" 'constant) 1.05505585262d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_BTU" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_THERM" 'constant) 1.05506d15)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_THERM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_HORSEPOWER" 'constant) 7.457d9)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_HORSEPOWER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_BAR" 'constant) 1d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_BAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_STD_ATMOSPHERE" 'constant) 1.01325d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_STD_ATMOSPHERE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_TORR" 'constant) 1.33322368421d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_TORR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_METER_OF_MERCURY" 'constant) 1.33322368421d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_METER_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_INCH_OF_MERCURY" 'constant) 3.38638815789d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_INCH_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_INCH_OF_WATER" 'constant) 2.490889d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_INCH_OF_WATER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PSI" 'constant) 6.89475729317d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PSI" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_POISE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_POISE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_STOKES" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_STOKES" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_STILB" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_STILB" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_LUMEN" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_LUMEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_LUX" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_LUX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_PHOT" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_PHOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_FOOTCANDLE" 'constant) 1.076d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_FOOTCANDLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_LAMBERT" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_LAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_FOOTLAMBERT" 'constant) 1.07639104d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_FOOTLAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_CURIE" 'constant) 3.7d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_CURIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ROENTGEN" 'constant) 2.58d-7)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ROENTGEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_RAD" 'constant) 1d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_RAD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_SOLAR_MASS" 'constant) 1.98892d33)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_SOLAR_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_BOHR_RADIUS" 'constant) 5.291772083d-9)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_BOHR_RADIUS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_NEWTON" 'constant) 1d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_NEWTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_DYNE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_DYNE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_JOULE" 'constant) 1d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_JOULE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_ERG" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_ERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_STEFAN_BOLTZMANN_CONSTANT" 'constant) 5.67040047374d-5)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_STEFAN_BOLTZMANN_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGS_THOMSON_CROSS_SECTION" 'constant) 6.65245893699d-25)
(cl:export '#.(swig-lispify "GSL_CONST_CGS_THOMSON_CROSS_SECTION" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_SPEED_OF_LIGHT" 'constant) 2.99792458d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_SPEED_OF_LIGHT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_GRAVITATIONAL_CONSTANT" 'constant) 6.673d-8)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_GRAVITATIONAL_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PLANCKS_CONSTANT_H" 'constant) 6.62606896d-27)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PLANCKS_CONSTANT_H" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PLANCKS_CONSTANT_HBAR" 'constant) 1.05457162825d-27)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PLANCKS_CONSTANT_HBAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ASTRONOMICAL_UNIT" 'constant) 1.49597870691d13)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ASTRONOMICAL_UNIT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_LIGHT_YEAR" 'constant) 9.46053620707d17)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_LIGHT_YEAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PARSEC" 'constant) 3.08567758135d18)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PARSEC" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_GRAV_ACCEL" 'constant) 9.80665d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_GRAV_ACCEL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ELECTRON_VOLT" 'constant) 1.602176487d-12)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ELECTRON_VOLT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MASS_ELECTRON" 'constant) 9.10938188d-28)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MASS_ELECTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MASS_MUON" 'constant) 1.88353109d-25)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MASS_MUON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MASS_PROTON" 'constant) 1.67262158d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MASS_PROTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MASS_NEUTRON" 'constant) 1.67492716d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MASS_NEUTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_RYDBERG" 'constant) 2.17987196968d-11)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_RYDBERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BOLTZMANN" 'constant) 1.3806504d-16)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BOLTZMANN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MOLAR_GAS" 'constant) 8.314472d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MOLAR_GAS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_STANDARD_GAS_VOLUME" 'constant) 2.2710981d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_STANDARD_GAS_VOLUME" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MINUTE" 'constant) 6d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MINUTE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_HOUR" 'constant) 3.6d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_DAY" 'constant) 8.64d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_DAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_WEEK" 'constant) 6.048d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_WEEK" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_INCH" 'constant) 2.54d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_INCH" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FOOT" 'constant) 3.048d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FOOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_YARD" 'constant) 9.144d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_YARD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MILE" 'constant) 1.609344d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_NAUTICAL_MILE" 'constant) 1.852d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_NAUTICAL_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FATHOM" 'constant) 1.8288d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FATHOM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MIL" 'constant) 2.54d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MIL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_POINT" 'constant) 3.52777777778d-2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_POINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TEXPOINT" 'constant) 3.51459803515d-2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TEXPOINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MICRON" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MICRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ANGSTROM" 'constant) 1d-8)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ANGSTROM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_HECTARE" 'constant) 1d8)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_HECTARE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ACRE" 'constant) 4.04685642241d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ACRE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BARN" 'constant) 1d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BARN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_LITER" 'constant) 1d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_LITER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_US_GALLON" 'constant) 3.78541178402d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_US_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_QUART" 'constant) 9.46352946004d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_QUART" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PINT" 'constant) 4.73176473002d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_CUP" 'constant) 2.36588236501d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_CUP" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FLUID_OUNCE" 'constant) 2.95735295626d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FLUID_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TABLESPOON" 'constant) 1.47867647813d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TABLESPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TEASPOON" 'constant) 4.92892159375d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TEASPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_CANADIAN_GALLON" 'constant) 4.54609d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_CANADIAN_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_UK_GALLON" 'constant) 4.546092d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_UK_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_MILES_PER_HOUR" 'constant) 4.4704d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_MILES_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_KILOMETERS_PER_HOUR" 'constant) 2.77777777778d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_KILOMETERS_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_KNOT" 'constant) 5.14444444444d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_KNOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_POUND_MASS" 'constant) 4.5359237d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_POUND_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_OUNCE_MASS" 'constant) 2.8349523125d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_OUNCE_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TON" 'constant) 9.0718474d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_METRIC_TON" 'constant) 1d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_METRIC_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_UK_TON" 'constant) 1.0160469088d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_UK_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TROY_OUNCE" 'constant) 3.1103475d1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TROY_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_CARAT" 'constant) 2d-1)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_CARAT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_UNIFIED_ATOMIC_MASS" 'constant) 1.660538782d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_UNIFIED_ATOMIC_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_GRAM_FORCE" 'constant) 9.80665d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_GRAM_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_POUND_FORCE" 'constant) 4.44822161526d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_POUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_KILOPOUND_FORCE" 'constant) 4.44822161526d8)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_KILOPOUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_POUNDAL" 'constant) 1.38255d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_POUNDAL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_CALORIE" 'constant) 4.1868d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_CALORIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BTU" 'constant) 1.05505585262d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BTU" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_THERM" 'constant) 1.05506d15)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_THERM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_HORSEPOWER" 'constant) 7.457d9)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_HORSEPOWER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BAR" 'constant) 1d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_STD_ATMOSPHERE" 'constant) 1.01325d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_STD_ATMOSPHERE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_TORR" 'constant) 1.33322368421d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_TORR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_METER_OF_MERCURY" 'constant) 1.33322368421d6)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_METER_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_INCH_OF_MERCURY" 'constant) 3.38638815789d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_INCH_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_INCH_OF_WATER" 'constant) 2.490889d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_INCH_OF_WATER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PSI" 'constant) 6.89475729317d4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PSI" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_POISE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_POISE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_STOKES" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_STOKES" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_STILB" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_STILB" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_LUMEN" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_LUMEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_LUX" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_LUX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PHOT" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PHOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FOOTCANDLE" 'constant) 1.076d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FOOTCANDLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_LAMBERT" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_LAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FOOTLAMBERT" 'constant) 1.07639104d-3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FOOTLAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_CURIE" 'constant) 3.7d10)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_CURIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ROENTGEN" 'constant) 2.58d-8)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ROENTGEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_RAD" 'constant) 1d2)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_RAD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_SOLAR_MASS" 'constant) 1.98892d33)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_SOLAR_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BOHR_RADIUS" 'constant) 5.291772083d-9)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BOHR_RADIUS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_NEWTON" 'constant) 1d5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_NEWTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_DYNE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_DYNE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_JOULE" 'constant) 1d7)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_JOULE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ERG" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_STEFAN_BOLTZMANN_CONSTANT" 'constant) 5.67040047374d-5)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_STEFAN_BOLTZMANN_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_THOMSON_CROSS_SECTION" 'constant) 6.65245893699d-25)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_THOMSON_CROSS_SECTION" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_BOHR_MAGNETON" 'constant) 9.27400899d-21)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_BOHR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_NUCLEAR_MAGNETON" 'constant) 5.05078317d-24)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_NUCLEAR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ELECTRON_MAGNETIC_MOMENT" 'constant) 9.28476362d-21)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ELECTRON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_PROTON_MAGNETIC_MOMENT" 'constant) 1.410606633d-23)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_PROTON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_FARADAY" 'constant) 9.64853429775d3)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_FARADAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_CGSM_ELECTRON_CHARGE" 'constant) 1.602176487d-20)
(cl:export '#.(swig-lispify "GSL_CONST_CGSM_ELECTRON_CHARGE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_SPEED_OF_LIGHT" 'constant) 2.99792458d8)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_SPEED_OF_LIGHT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_GRAVITATIONAL_CONSTANT" 'constant) 6.673d-11)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_GRAVITATIONAL_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PLANCKS_CONSTANT_H" 'constant) 6.62606896d-34)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PLANCKS_CONSTANT_H" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PLANCKS_CONSTANT_HBAR" 'constant) 1.05457162825d-34)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PLANCKS_CONSTANT_HBAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ASTRONOMICAL_UNIT" 'constant) 1.49597870691d11)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ASTRONOMICAL_UNIT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_LIGHT_YEAR" 'constant) 9.46053620707d15)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_LIGHT_YEAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PARSEC" 'constant) 3.08567758135d16)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PARSEC" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_GRAV_ACCEL" 'constant) 9.80665d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_GRAV_ACCEL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ELECTRON_VOLT" 'constant) 1.602176487d-19)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ELECTRON_VOLT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MASS_ELECTRON" 'constant) 9.10938188d-31)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MASS_ELECTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MASS_MUON" 'constant) 1.88353109d-28)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MASS_MUON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MASS_PROTON" 'constant) 1.67262158d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MASS_PROTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MASS_NEUTRON" 'constant) 1.67492716d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MASS_NEUTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_RYDBERG" 'constant) 2.17987196968d-18)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_RYDBERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BOLTZMANN" 'constant) 1.3806504d-23)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BOLTZMANN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MOLAR_GAS" 'constant) 8.314472d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MOLAR_GAS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_STANDARD_GAS_VOLUME" 'constant) 2.2710981d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_STANDARD_GAS_VOLUME" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MINUTE" 'constant) 6d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MINUTE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_HOUR" 'constant) 3.6d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_DAY" 'constant) 8.64d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_DAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_WEEK" 'constant) 6.048d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_WEEK" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_INCH" 'constant) 2.54d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_INCH" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FOOT" 'constant) 3.048d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FOOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_YARD" 'constant) 9.144d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_YARD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MILE" 'constant) 1.609344d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_NAUTICAL_MILE" 'constant) 1.852d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_NAUTICAL_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FATHOM" 'constant) 1.8288d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FATHOM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MIL" 'constant) 2.54d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MIL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_POINT" 'constant) 3.52777777778d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_POINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TEXPOINT" 'constant) 3.51459803515d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TEXPOINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MICRON" 'constant) 1d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MICRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ANGSTROM" 'constant) 1d-10)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ANGSTROM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_HECTARE" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_HECTARE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ACRE" 'constant) 4.04685642241d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ACRE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BARN" 'constant) 1d-28)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BARN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_LITER" 'constant) 1d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_LITER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_US_GALLON" 'constant) 3.78541178402d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_US_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_QUART" 'constant) 9.46352946004d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_QUART" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PINT" 'constant) 4.73176473002d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_CUP" 'constant) 2.36588236501d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_CUP" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FLUID_OUNCE" 'constant) 2.95735295626d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FLUID_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TABLESPOON" 'constant) 1.47867647813d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TABLESPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TEASPOON" 'constant) 4.92892159375d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TEASPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_CANADIAN_GALLON" 'constant) 4.54609d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_CANADIAN_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_UK_GALLON" 'constant) 4.546092d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_UK_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_MILES_PER_HOUR" 'constant) 4.4704d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_MILES_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_KILOMETERS_PER_HOUR" 'constant) 2.77777777778d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_KILOMETERS_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_KNOT" 'constant) 5.14444444444d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_KNOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_POUND_MASS" 'constant) 4.5359237d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_POUND_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_OUNCE_MASS" 'constant) 2.8349523125d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_OUNCE_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TON" 'constant) 9.0718474d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_METRIC_TON" 'constant) 1d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_METRIC_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_UK_TON" 'constant) 1.0160469088d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_UK_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TROY_OUNCE" 'constant) 3.1103475d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TROY_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_CARAT" 'constant) 2d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_CARAT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_UNIFIED_ATOMIC_MASS" 'constant) 1.660538782d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_UNIFIED_ATOMIC_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_GRAM_FORCE" 'constant) 9.80665d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_GRAM_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_POUND_FORCE" 'constant) 4.44822161526d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_POUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_KILOPOUND_FORCE" 'constant) 4.44822161526d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_KILOPOUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_POUNDAL" 'constant) 1.38255d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_POUNDAL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_CALORIE" 'constant) 4.1868d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_CALORIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BTU" 'constant) 1.05505585262d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BTU" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_THERM" 'constant) 1.05506d8)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_THERM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_HORSEPOWER" 'constant) 7.457d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_HORSEPOWER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BAR" 'constant) 1d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_STD_ATMOSPHERE" 'constant) 1.01325d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_STD_ATMOSPHERE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_TORR" 'constant) 1.33322368421d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_TORR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_METER_OF_MERCURY" 'constant) 1.33322368421d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_METER_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_INCH_OF_MERCURY" 'constant) 3.38638815789d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_INCH_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_INCH_OF_WATER" 'constant) 2.490889d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_INCH_OF_WATER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PSI" 'constant) 6.89475729317d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PSI" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_POISE" 'constant) 1d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_POISE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_STOKES" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_STOKES" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_STILB" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_STILB" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_LUMEN" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_LUMEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_LUX" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_LUX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PHOT" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PHOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FOOTCANDLE" 'constant) 1.076d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FOOTCANDLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_LAMBERT" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_LAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FOOTLAMBERT" 'constant) 1.07639104d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FOOTLAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_CURIE" 'constant) 3.7d10)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_CURIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ROENTGEN" 'constant) 2.58d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ROENTGEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_RAD" 'constant) 1d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_RAD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_SOLAR_MASS" 'constant) 1.98892d30)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_SOLAR_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BOHR_RADIUS" 'constant) 5.291772083d-11)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BOHR_RADIUS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_NEWTON" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_NEWTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_DYNE" 'constant) 1d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_DYNE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_JOULE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_JOULE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ERG" 'constant) 1d-7)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_STEFAN_BOLTZMANN_CONSTANT" 'constant) 5.67040047374d-8)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_STEFAN_BOLTZMANN_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_THOMSON_CROSS_SECTION" 'constant) 6.65245893699d-29)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_THOMSON_CROSS_SECTION" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_BOHR_MAGNETON" 'constant) 9.27400899d-24)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_BOHR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_NUCLEAR_MAGNETON" 'constant) 5.05078317d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_NUCLEAR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ELECTRON_MAGNETIC_MOMENT" 'constant) 9.28476362d-24)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ELECTRON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_PROTON_MAGNETIC_MOMENT" 'constant) 1.410606633d-26)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_PROTON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_FARADAY" 'constant) 9.64853429775d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_FARADAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_ELECTRON_CHARGE" 'constant) 1.602176487d-19)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_ELECTRON_CHARGE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_VACUUM_PERMITTIVITY" 'constant) 8.854187817d-12)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_VACUUM_PERMITTIVITY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_VACUUM_PERMEABILITY" 'constant) 1.25663706144d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_VACUUM_PERMEABILITY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_DEBYE" 'constant) 3.33564095198d-30)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_DEBYE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKS_GAUSS" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKS_GAUSS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_SPEED_OF_LIGHT" 'constant) 2.99792458d8)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_SPEED_OF_LIGHT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT" 'constant) 6.673d-11)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_GRAVITATIONAL_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PLANCKS_CONSTANT_H" 'constant) 6.62606896d-34)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PLANCKS_CONSTANT_H" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR" 'constant) 1.05457162825d-34)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PLANCKS_CONSTANT_HBAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ASTRONOMICAL_UNIT" 'constant) 1.49597870691d11)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ASTRONOMICAL_UNIT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_LIGHT_YEAR" 'constant) 9.46053620707d15)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_LIGHT_YEAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PARSEC" 'constant) 3.08567758135d16)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PARSEC" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_GRAV_ACCEL" 'constant) 9.80665d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_GRAV_ACCEL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ELECTRON_VOLT" 'constant) 1.602176487d-19)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ELECTRON_VOLT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MASS_ELECTRON" 'constant) 9.10938188d-31)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MASS_ELECTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MASS_MUON" 'constant) 1.88353109d-28)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MASS_MUON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MASS_PROTON" 'constant) 1.67262158d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MASS_PROTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MASS_NEUTRON" 'constant) 1.67492716d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MASS_NEUTRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_RYDBERG" 'constant) 2.17987196968d-18)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_RYDBERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BOLTZMANN" 'constant) 1.3806504d-23)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BOLTZMANN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MOLAR_GAS" 'constant) 8.314472d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MOLAR_GAS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_STANDARD_GAS_VOLUME" 'constant) 2.2710981d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_STANDARD_GAS_VOLUME" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MINUTE" 'constant) 6d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MINUTE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_HOUR" 'constant) 3.6d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_DAY" 'constant) 8.64d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_DAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_WEEK" 'constant) 6.048d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_WEEK" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_INCH" 'constant) 2.54d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_INCH" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FOOT" 'constant) 3.048d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FOOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_YARD" 'constant) 9.144d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_YARD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MILE" 'constant) 1.609344d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_NAUTICAL_MILE" 'constant) 1.852d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_NAUTICAL_MILE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FATHOM" 'constant) 1.8288d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FATHOM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MIL" 'constant) 2.54d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MIL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_POINT" 'constant) 3.52777777778d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_POINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TEXPOINT" 'constant) 3.51459803515d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TEXPOINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MICRON" 'constant) 1d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MICRON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ANGSTROM" 'constant) 1d-10)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ANGSTROM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_HECTARE" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_HECTARE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ACRE" 'constant) 4.04685642241d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ACRE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BARN" 'constant) 1d-28)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BARN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_LITER" 'constant) 1d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_LITER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_US_GALLON" 'constant) 3.78541178402d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_US_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_QUART" 'constant) 9.46352946004d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_QUART" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PINT" 'constant) 4.73176473002d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PINT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_CUP" 'constant) 2.36588236501d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_CUP" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FLUID_OUNCE" 'constant) 2.95735295626d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FLUID_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TABLESPOON" 'constant) 1.47867647813d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TABLESPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TEASPOON" 'constant) 4.92892159375d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TEASPOON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_CANADIAN_GALLON" 'constant) 4.54609d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_CANADIAN_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_UK_GALLON" 'constant) 4.546092d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_UK_GALLON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_MILES_PER_HOUR" 'constant) 4.4704d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_MILES_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_KILOMETERS_PER_HOUR" 'constant) 2.77777777778d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_KILOMETERS_PER_HOUR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_KNOT" 'constant) 5.14444444444d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_KNOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_POUND_MASS" 'constant) 4.5359237d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_POUND_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_OUNCE_MASS" 'constant) 2.8349523125d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_OUNCE_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TON" 'constant) 9.0718474d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_METRIC_TON" 'constant) 1d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_METRIC_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_UK_TON" 'constant) 1.0160469088d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_UK_TON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TROY_OUNCE" 'constant) 3.1103475d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TROY_OUNCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_CARAT" 'constant) 2d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_CARAT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS" 'constant) 1.660538782d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_UNIFIED_ATOMIC_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_GRAM_FORCE" 'constant) 9.80665d-3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_GRAM_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_POUND_FORCE" 'constant) 4.44822161526d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_POUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_KILOPOUND_FORCE" 'constant) 4.44822161526d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_KILOPOUND_FORCE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_POUNDAL" 'constant) 1.38255d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_POUNDAL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_CALORIE" 'constant) 4.1868d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_CALORIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BTU" 'constant) 1.05505585262d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BTU" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_THERM" 'constant) 1.05506d8)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_THERM" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_HORSEPOWER" 'constant) 7.457d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_HORSEPOWER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BAR" 'constant) 1d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BAR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_STD_ATMOSPHERE" 'constant) 1.01325d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_STD_ATMOSPHERE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_TORR" 'constant) 1.33322368421d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_TORR" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_METER_OF_MERCURY" 'constant) 1.33322368421d5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_METER_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_INCH_OF_MERCURY" 'constant) 3.38638815789d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_INCH_OF_MERCURY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_INCH_OF_WATER" 'constant) 2.490889d2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_INCH_OF_WATER" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PSI" 'constant) 6.89475729317d3)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PSI" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_POISE" 'constant) 1d-1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_POISE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_STOKES" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_STOKES" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_STILB" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_STILB" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_LUMEN" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_LUMEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_LUX" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_LUX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PHOT" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PHOT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FOOTCANDLE" 'constant) 1.076d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FOOTCANDLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_LAMBERT" 'constant) 1d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_LAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FOOTLAMBERT" 'constant) 1.07639104d1)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FOOTLAMBERT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_CURIE" 'constant) 3.7d10)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_CURIE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ROENTGEN" 'constant) 2.58d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ROENTGEN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_RAD" 'constant) 1d-2)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_RAD" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_SOLAR_MASS" 'constant) 1.98892d30)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_SOLAR_MASS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BOHR_RADIUS" 'constant) 5.291772083d-11)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BOHR_RADIUS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_NEWTON" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_NEWTON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_DYNE" 'constant) 1d-5)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_DYNE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_JOULE" 'constant) 1d0)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_JOULE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ERG" 'constant) 1d-7)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ERG" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT" 'constant) 5.67040047374d-8)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_STEFAN_BOLTZMANN_CONSTANT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_THOMSON_CROSS_SECTION" 'constant) 6.65245893699d-29)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_THOMSON_CROSS_SECTION" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_BOHR_MAGNETON" 'constant) 9.27400899d-24)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_BOHR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_NUCLEAR_MAGNETON" 'constant) 5.05078317d-27)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_NUCLEAR_MAGNETON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT" 'constant) 9.28476362d-24)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ELECTRON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT" 'constant) 1.410606633d-26)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_PROTON_MAGNETIC_MOMENT" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_FARADAY" 'constant) 9.64853429775d4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_FARADAY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_ELECTRON_CHARGE" 'constant) 1.602176487d-19)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_ELECTRON_CHARGE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_VACUUM_PERMITTIVITY" 'constant) 8.854187817d-12)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_VACUUM_PERMITTIVITY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_VACUUM_PERMEABILITY" 'constant) 1.25663706144d-6)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_VACUUM_PERMEABILITY" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_DEBYE" 'constant) 3.33564095198d-30)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_DEBYE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_MKSA_GAUSS" 'constant) 1d-4)
(cl:export '#.(swig-lispify "GSL_CONST_MKSA_GAUSS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_FINE_STRUCTURE" 'constant) 7.297352533d-3)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_FINE_STRUCTURE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_AVOGADRO" 'constant) 6.02214199d23)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_AVOGADRO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_YOTTA" 'constant) 1d24)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_YOTTA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_ZETTA" 'constant) 1d21)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_ZETTA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_EXA" 'constant) 1d18)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_EXA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_PETA" 'constant) 1d15)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_PETA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_TERA" 'constant) 1d12)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_TERA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_GIGA" 'constant) 1d9)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_GIGA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_MEGA" 'constant) 1d6)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_MEGA" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_KILO" 'constant) 1d3)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_KILO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_MILLI" 'constant) 1d-3)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_MILLI" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_MICRO" 'constant) 1d-6)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_MICRO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_NANO" 'constant) 1d-9)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_NANO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_PICO" 'constant) 1d-12)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_PICO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_FEMTO" 'constant) 1d-15)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_FEMTO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_ATTO" 'constant) 1d-18)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_ATTO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_ZEPTO" 'constant) 1d-21)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_ZEPTO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_CONST_NUM_YOCTO" 'constant) 1d-24)
(cl:export '#.(swig-lispify "GSL_CONST_NUM_YOCTO" 'constant))
(cffi:defcfun ("gsl_deriv_central" #.(swig-lispify "gsl_deriv_central" 'function)) :int
(f :pointer)
(x :double)
(h :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_deriv_central" 'function))
(cffi:defcfun ("gsl_deriv_backward" #.(swig-lispify "gsl_deriv_backward" 'function)) :int
(f :pointer)
(x :double)
(h :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_deriv_backward" 'function))
(cffi:defcfun ("gsl_deriv_forward" #.(swig-lispify "gsl_deriv_forward" 'function)) :int
(f :pointer)
(x :double)
(h :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_deriv_forward" 'function))
(cffi:defcfun ("gsl_dft_complex_forward" #.(swig-lispify "gsl_dft_complex_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_forward" 'function))
(cffi:defcfun ("gsl_dft_complex_backward" #.(swig-lispify "gsl_dft_complex_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_backward" 'function))
(cffi:defcfun ("gsl_dft_complex_inverse" #.(swig-lispify "gsl_dft_complex_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_inverse" 'function))
(cffi:defcfun ("gsl_dft_complex_transform" #.(swig-lispify "gsl_dft_complex_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer)
(sign :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_transform" 'function))
(cffi:defcfun ("gsl_dft_complex_float_forward" #.(swig-lispify "gsl_dft_complex_float_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_float_forward" 'function))
(cffi:defcfun ("gsl_dft_complex_float_backward" #.(swig-lispify "gsl_dft_complex_float_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_float_backward" 'function))
(cffi:defcfun ("gsl_dft_complex_float_inverse" #.(swig-lispify "gsl_dft_complex_float_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_float_inverse" 'function))
(cffi:defcfun ("gsl_dft_complex_float_transform" #.(swig-lispify "gsl_dft_complex_float_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(result :pointer)
(sign :pointer))
(cl:export '#.(swig-lispify "gsl_dft_complex_float_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_dht_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "nu" 'slotname) :double)
(#.(swig-lispify "xmax" 'slotname) :double)
(#.(swig-lispify "kmax" 'slotname) :double)
(#.(swig-lispify "j" 'slotname) :pointer)
(#.(swig-lispify "Jjj" 'slotname) :pointer)
(#.(swig-lispify "J2" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_dht_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "nu" 'slotname))
(cl:export '#.(swig-lispify "xmax" 'slotname))
(cl:export '#.(swig-lispify "kmax" 'slotname))
(cl:export '#.(swig-lispify "j" 'slotname))
(cl:export '#.(swig-lispify "Jjj" 'slotname))
(cl:export '#.(swig-lispify "J2" 'slotname))
(cffi:defcfun ("gsl_dht_alloc" #.(swig-lispify "gsl_dht_alloc" 'function)) :pointer
(size :pointer))
(cl:export '#.(swig-lispify "gsl_dht_alloc" 'function))
(cffi:defcfun ("gsl_dht_new" #.(swig-lispify "gsl_dht_new" 'function)) :pointer
(size :pointer)
(nu :double)
(xmax :double))
(cl:export '#.(swig-lispify "gsl_dht_new" 'function))
(cffi:defcfun ("gsl_dht_init" #.(swig-lispify "gsl_dht_init" 'function)) :int
(t_arg0 :pointer)
(nu :double)
(xmax :double))
(cl:export '#.(swig-lispify "gsl_dht_init" 'function))
(cffi:defcfun ("gsl_dht_x_sample" #.(swig-lispify "gsl_dht_x_sample" 'function)) :double
(t_arg0 :pointer)
(n :int))
(cl:export '#.(swig-lispify "gsl_dht_x_sample" 'function))
(cffi:defcfun ("gsl_dht_k_sample" #.(swig-lispify "gsl_dht_k_sample" 'function)) :double
(t_arg0 :pointer)
(n :int))
(cl:export '#.(swig-lispify "gsl_dht_k_sample" 'function))
(cffi:defcfun ("gsl_dht_free" #.(swig-lispify "gsl_dht_free" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_dht_free" 'function))
(cffi:defcfun ("gsl_dht_apply" #.(swig-lispify "gsl_dht_apply" 'function)) :int
(t_arg0 :pointer)
(f_in :pointer)
(f_out :pointer))
(cl:export '#.(swig-lispify "gsl_dht_apply" 'function))
(cffi:defcfun ("gsl_diff_central" #.(swig-lispify "gsl_diff_central" 'function)) :int
(f :pointer)
(x :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_diff_central" 'function))
(cffi:defcfun ("gsl_diff_backward" #.(swig-lispify "gsl_diff_backward" 'function)) :int
(f :pointer)
(x :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_diff_backward" 'function))
(cffi:defcfun ("gsl_diff_forward" #.(swig-lispify "gsl_diff_forward" 'function)) :int
(f :pointer)
(x :double)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_diff_forward" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_symm_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "d" 'slotname) :pointer)
(#.(swig-lispify "sd" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symm_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "d" 'slotname))
(cl:export '#.(swig-lispify "sd" 'slotname))
(cffi:defcfun ("gsl_eigen_symm_alloc" #.(swig-lispify "gsl_eigen_symm_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symm_alloc" 'function))
(cffi:defcfun ("gsl_eigen_symm_free" #.(swig-lispify "gsl_eigen_symm_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symm_free" 'function))
(cffi:defcfun ("gsl_eigen_symm" #.(swig-lispify "gsl_eigen_symm" 'function)) :int
(A :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symm" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_symmv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "d" 'slotname) :pointer)
(#.(swig-lispify "sd" 'slotname) :pointer)
(#.(swig-lispify "gc" 'slotname) :pointer)
(#.(swig-lispify "gs" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symmv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "d" 'slotname))
(cl:export '#.(swig-lispify "sd" 'slotname))
(cl:export '#.(swig-lispify "gc" 'slotname))
(cl:export '#.(swig-lispify "gs" 'slotname))
(cffi:defcfun ("gsl_eigen_symmv_alloc" #.(swig-lispify "gsl_eigen_symmv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symmv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_symmv_free" #.(swig-lispify "gsl_eigen_symmv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symmv_free" 'function))
(cffi:defcfun ("gsl_eigen_symmv" #.(swig-lispify "gsl_eigen_symmv" 'function)) :int
(A :pointer)
(eval :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_symmv" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_herm_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "d" 'slotname) :pointer)
(#.(swig-lispify "sd" 'slotname) :pointer)
(#.(swig-lispify "tau" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_herm_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "d" 'slotname))
(cl:export '#.(swig-lispify "sd" 'slotname))
(cl:export '#.(swig-lispify "tau" 'slotname))
(cffi:defcfun ("gsl_eigen_herm_alloc" #.(swig-lispify "gsl_eigen_herm_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_herm_alloc" 'function))
(cffi:defcfun ("gsl_eigen_herm_free" #.(swig-lispify "gsl_eigen_herm_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_herm_free" 'function))
(cffi:defcfun ("gsl_eigen_herm" #.(swig-lispify "gsl_eigen_herm" 'function)) :int
(A :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_herm" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_hermv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "d" 'slotname) :pointer)
(#.(swig-lispify "sd" 'slotname) :pointer)
(#.(swig-lispify "tau" 'slotname) :pointer)
(#.(swig-lispify "gc" 'slotname) :pointer)
(#.(swig-lispify "gs" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_hermv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "d" 'slotname))
(cl:export '#.(swig-lispify "sd" 'slotname))
(cl:export '#.(swig-lispify "tau" 'slotname))
(cl:export '#.(swig-lispify "gc" 'slotname))
(cl:export '#.(swig-lispify "gs" 'slotname))
(cffi:defcfun ("gsl_eigen_hermv_alloc" #.(swig-lispify "gsl_eigen_hermv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_hermv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_hermv_free" #.(swig-lispify "gsl_eigen_hermv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_hermv_free" 'function))
(cffi:defcfun ("gsl_eigen_hermv" #.(swig-lispify "gsl_eigen_hermv" 'function)) :int
(A :pointer)
(eval :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_hermv" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_francis_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "max_iterations" 'slotname) :pointer)
(#.(swig-lispify "n_iter" 'slotname) :pointer)
(#.(swig-lispify "n_evals" 'slotname) :pointer)
(#.(swig-lispify "compute_t" 'slotname) :int)
(#.(swig-lispify "H" 'slotname) :pointer)
(#.(swig-lispify "Z" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_francis_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "max_iterations" 'slotname))
(cl:export '#.(swig-lispify "n_iter" 'slotname))
(cl:export '#.(swig-lispify "n_evals" 'slotname))
(cl:export '#.(swig-lispify "compute_t" 'slotname))
(cl:export '#.(swig-lispify "H" 'slotname))
(cl:export '#.(swig-lispify "Z" 'slotname))
(cffi:defcfun ("gsl_eigen_francis_alloc" #.(swig-lispify "gsl_eigen_francis_alloc" 'function)) :pointer)
(cl:export '#.(swig-lispify "gsl_eigen_francis_alloc" 'function))
(cffi:defcfun ("gsl_eigen_francis_free" #.(swig-lispify "gsl_eigen_francis_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_francis_free" 'function))
(cffi:defcfun ("gsl_eigen_francis_T" #.(swig-lispify "gsl_eigen_francis_T" 'function)) :void
(compute_t :int)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_francis_T" 'function))
(cffi:defcfun ("gsl_eigen_francis" #.(swig-lispify "gsl_eigen_francis" 'function)) :int
(H :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_francis" 'function))
(cffi:defcfun ("gsl_eigen_francis_Z" #.(swig-lispify "gsl_eigen_francis_Z" 'function)) :int
(H :pointer)
(eval :pointer)
(Z :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_francis_Z" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_nonsymm_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "diag" 'slotname) :pointer)
(#.(swig-lispify "tau" 'slotname) :pointer)
(#.(swig-lispify "Z" 'slotname) :pointer)
(#.(swig-lispify "do_balance" 'slotname) :int)
(#.(swig-lispify "n_evals" 'slotname) :pointer)
(#.(swig-lispify "francis_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "diag" 'slotname))
(cl:export '#.(swig-lispify "tau" 'slotname))
(cl:export '#.(swig-lispify "Z" 'slotname))
(cl:export '#.(swig-lispify "do_balance" 'slotname))
(cl:export '#.(swig-lispify "n_evals" 'slotname))
(cl:export '#.(swig-lispify "francis_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_nonsymm_alloc" #.(swig-lispify "gsl_eigen_nonsymm_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm_alloc" 'function))
(cffi:defcfun ("gsl_eigen_nonsymm_free" #.(swig-lispify "gsl_eigen_nonsymm_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm_free" 'function))
(cffi:defcfun ("gsl_eigen_nonsymm_params" #.(swig-lispify "gsl_eigen_nonsymm_params" 'function)) :void
(compute_t :int)
(balance :int)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm_params" 'function))
(cffi:defcfun ("gsl_eigen_nonsymm" #.(swig-lispify "gsl_eigen_nonsymm" 'function)) :int
(A :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm" 'function))
(cffi:defcfun ("gsl_eigen_nonsymm_Z" #.(swig-lispify "gsl_eigen_nonsymm_Z" 'function)) :int
(A :pointer)
(eval :pointer)
(Z :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymm_Z" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_nonsymmv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "work" 'slotname) :pointer)
(#.(swig-lispify "work2" 'slotname) :pointer)
(#.(swig-lispify "work3" 'slotname) :pointer)
(#.(swig-lispify "Z" 'slotname) :pointer)
(#.(swig-lispify "nonsymm_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "work" 'slotname))
(cl:export '#.(swig-lispify "work2" 'slotname))
(cl:export '#.(swig-lispify "work3" 'slotname))
(cl:export '#.(swig-lispify "Z" 'slotname))
(cl:export '#.(swig-lispify "nonsymm_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_nonsymmv_alloc" #.(swig-lispify "gsl_eigen_nonsymmv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_nonsymmv_free" #.(swig-lispify "gsl_eigen_nonsymmv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_free" 'function))
(cffi:defcfun ("gsl_eigen_nonsymmv_params" #.(swig-lispify "gsl_eigen_nonsymmv_params" 'function)) :void
(balance :int)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_params" 'function))
(cffi:defcfun ("gsl_eigen_nonsymmv" #.(swig-lispify "gsl_eigen_nonsymmv" 'function)) :int
(A :pointer)
(eval :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv" 'function))
(cffi:defcfun ("gsl_eigen_nonsymmv_Z" #.(swig-lispify "gsl_eigen_nonsymmv_Z" 'function)) :int
(A :pointer)
(eval :pointer)
(evec :pointer)
(Z :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_Z" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_gensymm_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "symm_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymm_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "symm_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_gensymm_alloc" #.(swig-lispify "gsl_eigen_gensymm_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymm_alloc" 'function))
(cffi:defcfun ("gsl_eigen_gensymm_free" #.(swig-lispify "gsl_eigen_gensymm_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymm_free" 'function))
(cffi:defcfun ("gsl_eigen_gensymm" #.(swig-lispify "gsl_eigen_gensymm" 'function)) :int
(A :pointer)
(B :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymm" 'function))
(cffi:defcfun ("gsl_eigen_gensymm_standardize" #.(swig-lispify "gsl_eigen_gensymm_standardize" 'function)) :int
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymm_standardize" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_gensymmv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "symmv_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymmv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "symmv_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_gensymmv_alloc" #.(swig-lispify "gsl_eigen_gensymmv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymmv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_gensymmv_free" #.(swig-lispify "gsl_eigen_gensymmv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymmv_free" 'function))
(cffi:defcfun ("gsl_eigen_gensymmv" #.(swig-lispify "gsl_eigen_gensymmv" 'function)) :int
(A :pointer)
(B :pointer)
(eval :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gensymmv" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_genherm_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "herm_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genherm_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "herm_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_genherm_alloc" #.(swig-lispify "gsl_eigen_genherm_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genherm_alloc" 'function))
(cffi:defcfun ("gsl_eigen_genherm_free" #.(swig-lispify "gsl_eigen_genherm_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genherm_free" 'function))
(cffi:defcfun ("gsl_eigen_genherm" #.(swig-lispify "gsl_eigen_genherm" 'function)) :int
(A :pointer)
(B :pointer)
(eval :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genherm" 'function))
(cffi:defcfun ("gsl_eigen_genherm_standardize" #.(swig-lispify "gsl_eigen_genherm_standardize" 'function)) :int
(A :pointer)
(B :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genherm_standardize" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_genhermv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "hermv_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genhermv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "hermv_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_genhermv_alloc" #.(swig-lispify "gsl_eigen_genhermv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genhermv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_genhermv_free" #.(swig-lispify "gsl_eigen_genhermv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genhermv_free" 'function))
(cffi:defcfun ("gsl_eigen_genhermv" #.(swig-lispify "gsl_eigen_genhermv" 'function)) :int
(A :pointer)
(B :pointer)
(eval :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genhermv" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_gen_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "work" 'slotname) :pointer)
(#.(swig-lispify "n_evals" 'slotname) :pointer)
(#.(swig-lispify "max_iterations" 'slotname) :pointer)
(#.(swig-lispify "n_iter" 'slotname) :pointer)
(#.(swig-lispify "eshift" 'slotname) :double)
(#.(swig-lispify "needtop" 'slotname) :int)
(#.(swig-lispify "atol" 'slotname) :double)
(#.(swig-lispify "btol" 'slotname) :double)
(#.(swig-lispify "ascale" 'slotname) :double)
(#.(swig-lispify "bscale" 'slotname) :double)
(#.(swig-lispify "H" 'slotname) :pointer)
(#.(swig-lispify "R" 'slotname) :pointer)
(#.(swig-lispify "compute_s" 'slotname) :int)
(#.(swig-lispify "compute_t" 'slotname) :int)
(#.(swig-lispify "Q" 'slotname) :pointer)
(#.(swig-lispify "Z" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "work" 'slotname))
(cl:export '#.(swig-lispify "n_evals" 'slotname))
(cl:export '#.(swig-lispify "max_iterations" 'slotname))
(cl:export '#.(swig-lispify "n_iter" 'slotname))
(cl:export '#.(swig-lispify "eshift" 'slotname))
(cl:export '#.(swig-lispify "needtop" 'slotname))
(cl:export '#.(swig-lispify "atol" 'slotname))
(cl:export '#.(swig-lispify "btol" 'slotname))
(cl:export '#.(swig-lispify "ascale" 'slotname))
(cl:export '#.(swig-lispify "bscale" 'slotname))
(cl:export '#.(swig-lispify "H" 'slotname))
(cl:export '#.(swig-lispify "R" 'slotname))
(cl:export '#.(swig-lispify "compute_s" 'slotname))
(cl:export '#.(swig-lispify "compute_t" 'slotname))
(cl:export '#.(swig-lispify "Q" 'slotname))
(cl:export '#.(swig-lispify "Z" 'slotname))
(cffi:defcfun ("gsl_eigen_gen_alloc" #.(swig-lispify "gsl_eigen_gen_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen_alloc" 'function))
(cffi:defcfun ("gsl_eigen_gen_free" #.(swig-lispify "gsl_eigen_gen_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen_free" 'function))
(cffi:defcfun ("gsl_eigen_gen_params" #.(swig-lispify "gsl_eigen_gen_params" 'function)) :void
(compute_s :int)
(compute_t :int)
(balance :int)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen_params" 'function))
(cffi:defcfun ("gsl_eigen_gen" #.(swig-lispify "gsl_eigen_gen" 'function)) :int
(A :pointer)
(B :pointer)
(alpha :pointer)
(beta :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen" 'function))
(cffi:defcfun ("gsl_eigen_gen_QZ" #.(swig-lispify "gsl_eigen_gen_QZ" 'function)) :int
(A :pointer)
(B :pointer)
(alpha :pointer)
(beta :pointer)
(Q :pointer)
(Z :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_gen_QZ" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_eigen_genv_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "work1" 'slotname) :pointer)
(#.(swig-lispify "work2" 'slotname) :pointer)
(#.(swig-lispify "work3" 'slotname) :pointer)
(#.(swig-lispify "work4" 'slotname) :pointer)
(#.(swig-lispify "work5" 'slotname) :pointer)
(#.(swig-lispify "work6" 'slotname) :pointer)
(#.(swig-lispify "Q" 'slotname) :pointer)
(#.(swig-lispify "Z" 'slotname) :pointer)
(#.(swig-lispify "gen_workspace_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genv_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "work1" 'slotname))
(cl:export '#.(swig-lispify "work2" 'slotname))
(cl:export '#.(swig-lispify "work3" 'slotname))
(cl:export '#.(swig-lispify "work4" 'slotname))
(cl:export '#.(swig-lispify "work5" 'slotname))
(cl:export '#.(swig-lispify "work6" 'slotname))
(cl:export '#.(swig-lispify "Q" 'slotname))
(cl:export '#.(swig-lispify "Z" 'slotname))
(cl:export '#.(swig-lispify "gen_workspace_p" 'slotname))
(cffi:defcfun ("gsl_eigen_genv_alloc" #.(swig-lispify "gsl_eigen_genv_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genv_alloc" 'function))
(cffi:defcfun ("gsl_eigen_genv_free" #.(swig-lispify "gsl_eigen_genv_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genv_free" 'function))
(cffi:defcfun ("gsl_eigen_genv" #.(swig-lispify "gsl_eigen_genv" 'function)) :int
(A :pointer)
(B :pointer)
(alpha :pointer)
(beta :pointer)
(evec :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genv" 'function))
(cffi:defcfun ("gsl_eigen_genv_QZ" #.(swig-lispify "gsl_eigen_genv_QZ" 'function)) :int
(A :pointer)
(B :pointer)
(alpha :pointer)
(beta :pointer)
(evec :pointer)
(Q :pointer)
(Z :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_genv_QZ" 'function))
(cffi:defcenum #.(swig-lispify "gsl_eigen_sort_t" 'enumname)
#.(swig-lispify "GSL_EIGEN_SORT_VAL_ASC" 'enumvalue :keyword)
#.(swig-lispify "GSL_EIGEN_SORT_VAL_DESC" 'enumvalue :keyword)
#.(swig-lispify "GSL_EIGEN_SORT_ABS_ASC" 'enumvalue :keyword)
#.(swig-lispify "GSL_EIGEN_SORT_ABS_DESC" 'enumvalue :keyword))
(cl:export '#.(swig-lispify "gsl_eigen_sort_t" 'enumname))
(cffi:defcfun ("gsl_eigen_symmv_sort" #.(swig-lispify "gsl_eigen_symmv_sort" 'function)) :int
(eval :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_symmv_sort" 'function))
(cffi:defcfun ("gsl_eigen_hermv_sort" #.(swig-lispify "gsl_eigen_hermv_sort" 'function)) :int
(eval :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_hermv_sort" 'function))
(cffi:defcfun ("gsl_eigen_nonsymmv_sort" #.(swig-lispify "gsl_eigen_nonsymmv_sort" 'function)) :int
(eval :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_nonsymmv_sort" 'function))
(cffi:defcfun ("gsl_eigen_gensymmv_sort" #.(swig-lispify "gsl_eigen_gensymmv_sort" 'function)) :int
(eval :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_gensymmv_sort" 'function))
(cffi:defcfun ("gsl_eigen_genhermv_sort" #.(swig-lispify "gsl_eigen_genhermv_sort" 'function)) :int
(eval :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_genhermv_sort" 'function))
(cffi:defcfun ("gsl_eigen_genv_sort" #.(swig-lispify "gsl_eigen_genv_sort" 'function)) :int
(alpha :pointer)
(beta :pointer)
(evec :pointer)
(sort_type #.(swig-lispify "gsl_eigen_sort_t" 'enumname)))
(cl:export '#.(swig-lispify "gsl_eigen_genv_sort" 'function))
(cffi:defcfun ("gsl_schur_gen_eigvals" #.(swig-lispify "gsl_schur_gen_eigvals" 'function)) :int
(A :pointer)
(B :pointer)
(wr1 :pointer)
(wr2 :pointer)
(wi :pointer)
(scale1 :pointer)
(scale2 :pointer))
(cl:export '#.(swig-lispify "gsl_schur_gen_eigvals" 'function))
(cffi:defcfun ("gsl_schur_solve_equation" #.(swig-lispify "gsl_schur_solve_equation" 'function)) :int
(ca :double)
(A :pointer)
(z :double)
(d1 :double)
(d2 :double)
(b :pointer)
(x :pointer)
(s :pointer)
(xnorm :pointer)
(smin :double))
(cl:export '#.(swig-lispify "gsl_schur_solve_equation" 'function))
(cffi:defcfun ("gsl_schur_solve_equation_z" #.(swig-lispify "gsl_schur_solve_equation_z" 'function)) :int
(ca :double)
(A :pointer)
(z :pointer)
(d1 :double)
(d2 :double)
(b :pointer)
(x :pointer)
(s :pointer)
(xnorm :pointer)
(smin :double))
(cl:export '#.(swig-lispify "gsl_schur_solve_equation_z" 'function))
(cffi:defcfun ("gsl_eigen_jacobi" #.(swig-lispify "gsl_eigen_jacobi" 'function)) :int
(matrix :pointer)
(eval :pointer)
(evec :pointer)
(max_rot :unsigned-int)
(nrot :pointer))
(cl:export '#.(swig-lispify "gsl_eigen_jacobi" 'function))
(cffi:defcfun ("gsl_eigen_invert_jacobi" #.(swig-lispify "gsl_eigen_invert_jacobi" 'function)) :int
(matrix :pointer)
(ainv :pointer)
(max_rot :unsigned-int))
(cl:export '#.(swig-lispify "gsl_eigen_invert_jacobi" 'function))
(cffi:defcenum #.(swig-lispify "gsl_fft_direction" 'enumname)
(#.(swig-lispify "gsl_fft_forward" 'enumvalue :keyword) #.-1)
(#.(swig-lispify "gsl_fft_backward" 'enumvalue :keyword) #.+1))
(cl:export '#.(swig-lispify "gsl_fft_direction" 'enumname))
(cffi:defcfun ("gsl_fft_complex_radix2_forward" #.(swig-lispify "gsl_fft_complex_radix2_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_backward" #.(swig-lispify "gsl_fft_complex_radix2_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_inverse" #.(swig-lispify "gsl_fft_complex_radix2_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_transform" #.(swig-lispify "gsl_fft_complex_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_transform" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_dif_forward" #.(swig-lispify "gsl_fft_complex_radix2_dif_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_dif_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_dif_backward" #.(swig-lispify "gsl_fft_complex_radix2_dif_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_dif_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_dif_inverse" #.(swig-lispify "gsl_fft_complex_radix2_dif_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_dif_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_radix2_dif_transform" #.(swig-lispify "gsl_fft_complex_radix2_dif_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_radix2_dif_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_complex_wavetable" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_fft_complex_workspace" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "scratch" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "scratch" 'slotname))
(cffi:defcfun ("gsl_fft_complex_wavetable_alloc" #.(swig-lispify "gsl_fft_complex_wavetable_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable_alloc" 'function))
(cffi:defcfun ("gsl_fft_complex_wavetable_free" #.(swig-lispify "gsl_fft_complex_wavetable_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable_free" 'function))
(cffi:defcfun ("gsl_fft_complex_workspace_alloc" #.(swig-lispify "gsl_fft_complex_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace_alloc" 'function))
(cffi:defcfun ("gsl_fft_complex_workspace_free" #.(swig-lispify "gsl_fft_complex_workspace_free" 'function)) :void
(workspace :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace_free" 'function))
(cffi:defcfun ("gsl_fft_complex_memcpy" #.(swig-lispify "gsl_fft_complex_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_memcpy" 'function))
(cffi:defcfun ("gsl_fft_complex_forward" #.(swig-lispify "gsl_fft_complex_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_backward" #.(swig-lispify "gsl_fft_complex_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_inverse" #.(swig-lispify "gsl_fft_complex_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_transform" #.(swig-lispify "gsl_fft_complex_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_transform" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_forward" #.(swig-lispify "gsl_fft_complex_float_radix2_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_backward" #.(swig-lispify "gsl_fft_complex_float_radix2_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_inverse" #.(swig-lispify "gsl_fft_complex_float_radix2_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_transform" #.(swig-lispify "gsl_fft_complex_float_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_transform" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_dif_forward" #.(swig-lispify "gsl_fft_complex_float_radix2_dif_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_dif_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_dif_backward" #.(swig-lispify "gsl_fft_complex_float_radix2_dif_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_dif_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_dif_inverse" #.(swig-lispify "gsl_fft_complex_float_radix2_dif_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_dif_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_float_radix2_dif_transform" #.(swig-lispify "gsl_fft_complex_float_radix2_dif_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_radix2_dif_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_complex_wavetable_float" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable_float" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_fft_complex_workspace_float" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "scratch" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace_float" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "scratch" 'slotname))
(cffi:defcfun ("gsl_fft_complex_wavetable_float_alloc" #.(swig-lispify "gsl_fft_complex_wavetable_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable_float_alloc" 'function))
(cffi:defcfun ("gsl_fft_complex_wavetable_float_free" #.(swig-lispify "gsl_fft_complex_wavetable_float_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_wavetable_float_free" 'function))
(cffi:defcfun ("gsl_fft_complex_workspace_float_alloc" #.(swig-lispify "gsl_fft_complex_workspace_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace_float_alloc" 'function))
(cffi:defcfun ("gsl_fft_complex_workspace_float_free" #.(swig-lispify "gsl_fft_complex_workspace_float_free" 'function)) :void
(workspace :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_workspace_float_free" 'function))
(cffi:defcfun ("gsl_fft_complex_float_memcpy" #.(swig-lispify "gsl_fft_complex_float_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_memcpy" 'function))
(cffi:defcfun ("gsl_fft_complex_float_forward" #.(swig-lispify "gsl_fft_complex_float_forward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_forward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_backward" #.(swig-lispify "gsl_fft_complex_float_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_backward" 'function))
(cffi:defcfun ("gsl_fft_complex_float_inverse" #.(swig-lispify "gsl_fft_complex_float_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_inverse" 'function))
(cffi:defcfun ("gsl_fft_complex_float_transform" #.(swig-lispify "gsl_fft_complex_float_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer)
(sign #.(swig-lispify "gsl_fft_direction" 'enumname)))
(cl:export '#.(swig-lispify "gsl_fft_complex_float_transform" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_radix2_backward" #.(swig-lispify "gsl_fft_halfcomplex_radix2_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_radix2_backward" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_radix2_inverse" #.(swig-lispify "gsl_fft_halfcomplex_radix2_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_radix2_inverse" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_radix2_transform" #.(swig-lispify "gsl_fft_halfcomplex_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_radix2_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_halfcomplex_wavetable" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcfun ("gsl_fft_halfcomplex_wavetable_alloc" #.(swig-lispify "gsl_fft_halfcomplex_wavetable_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable_alloc" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_wavetable_free" #.(swig-lispify "gsl_fft_halfcomplex_wavetable_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable_free" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_backward" #.(swig-lispify "gsl_fft_halfcomplex_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_backward" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_inverse" #.(swig-lispify "gsl_fft_halfcomplex_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_inverse" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_transform" #.(swig-lispify "gsl_fft_halfcomplex_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_transform" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_unpack" #.(swig-lispify "gsl_fft_halfcomplex_unpack" 'function)) :int
(halfcomplex_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_unpack" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_radix2_unpack" #.(swig-lispify "gsl_fft_halfcomplex_radix2_unpack" 'function)) :int
(halfcomplex_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_radix2_unpack" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_radix2_backward" #.(swig-lispify "gsl_fft_halfcomplex_float_radix2_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_radix2_backward" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_radix2_inverse" #.(swig-lispify "gsl_fft_halfcomplex_float_radix2_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_radix2_inverse" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_radix2_transform" #.(swig-lispify "gsl_fft_halfcomplex_float_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_radix2_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_halfcomplex_wavetable_float" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable_float" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcfun ("gsl_fft_halfcomplex_wavetable_float_alloc" #.(swig-lispify "gsl_fft_halfcomplex_wavetable_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable_float_alloc" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_wavetable_float_free" #.(swig-lispify "gsl_fft_halfcomplex_wavetable_float_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_wavetable_float_free" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_backward" #.(swig-lispify "gsl_fft_halfcomplex_float_backward" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_backward" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_inverse" #.(swig-lispify "gsl_fft_halfcomplex_float_inverse" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_inverse" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_transform" #.(swig-lispify "gsl_fft_halfcomplex_float_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_transform" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_unpack" #.(swig-lispify "gsl_fft_halfcomplex_float_unpack" 'function)) :int
(halfcomplex_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_unpack" 'function))
(cffi:defcfun ("gsl_fft_halfcomplex_float_radix2_unpack" #.(swig-lispify "gsl_fft_halfcomplex_float_radix2_unpack" 'function)) :int
(halfcomplex_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_halfcomplex_float_radix2_unpack" 'function))
(cffi:defcfun ("gsl_fft_real_radix2_transform" #.(swig-lispify "gsl_fft_real_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_radix2_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_real_wavetable" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_fft_real_workspace" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "scratch" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "scratch" 'slotname))
(cffi:defcfun ("gsl_fft_real_wavetable_alloc" #.(swig-lispify "gsl_fft_real_wavetable_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable_alloc" 'function))
(cffi:defcfun ("gsl_fft_real_wavetable_free" #.(swig-lispify "gsl_fft_real_wavetable_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable_free" 'function))
(cffi:defcfun ("gsl_fft_real_workspace_alloc" #.(swig-lispify "gsl_fft_real_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace_alloc" 'function))
(cffi:defcfun ("gsl_fft_real_workspace_free" #.(swig-lispify "gsl_fft_real_workspace_free" 'function)) :void
(workspace :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace_free" 'function))
(cffi:defcfun ("gsl_fft_real_transform" #.(swig-lispify "gsl_fft_real_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_transform" 'function))
(cffi:defcfun ("gsl_fft_real_unpack" #.(swig-lispify "gsl_fft_real_unpack" 'function)) :int
(real_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_unpack" 'function))
(cffi:defcfun ("gsl_fft_real_float_radix2_transform" #.(swig-lispify "gsl_fft_real_float_radix2_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_float_radix2_transform" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_fft_real_wavetable_float" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "nf" 'slotname) :pointer)
(#.(swig-lispify "factor" 'slotname) :pointer)
(#.(swig-lispify "twiddle" 'slotname) :pointer)
(#.(swig-lispify "trig" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable_float" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nf" 'slotname))
(cl:export '#.(swig-lispify "factor" 'slotname))
(cl:export '#.(swig-lispify "twiddle" 'slotname))
(cl:export '#.(swig-lispify "trig" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_fft_real_workspace_float" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "scratch" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace_float" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "scratch" 'slotname))
(cffi:defcfun ("gsl_fft_real_wavetable_float_alloc" #.(swig-lispify "gsl_fft_real_wavetable_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable_float_alloc" 'function))
(cffi:defcfun ("gsl_fft_real_wavetable_float_free" #.(swig-lispify "gsl_fft_real_wavetable_float_free" 'function)) :void
(wavetable :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_wavetable_float_free" 'function))
(cffi:defcfun ("gsl_fft_real_workspace_float_alloc" #.(swig-lispify "gsl_fft_real_workspace_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace_float_alloc" 'function))
(cffi:defcfun ("gsl_fft_real_workspace_float_free" #.(swig-lispify "gsl_fft_real_workspace_float_free" 'function)) :void
(workspace :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_workspace_float_free" 'function))
(cffi:defcfun ("gsl_fft_real_float_transform" #.(swig-lispify "gsl_fft_real_float_transform" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer)
(wavetable :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_float_transform" 'function))
(cffi:defcfun ("gsl_fft_real_float_unpack" #.(swig-lispify "gsl_fft_real_float_unpack" 'function)) :int
(real_float_coefficient :pointer)
(complex_coefficient :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_fft_real_float_unpack" 'function))
(cffi:defcfun ("gsl_fit_linear" #.(swig-lispify "gsl_fit_linear" 'function)) :int
(x :pointer)
(xstride :pointer)
(y :pointer)
(ystride :pointer)
(n :pointer)
(c0 :pointer)
(c1 :pointer)
(cov00 :pointer)
(cov01 :pointer)
(cov11 :pointer)
(sumsq :pointer))
(cl:export '#.(swig-lispify "gsl_fit_linear" 'function))
(cffi:defcfun ("gsl_fit_wlinear" #.(swig-lispify "gsl_fit_wlinear" 'function)) :int
(x :pointer)
(xstride :pointer)
(w :pointer)
(wstride :pointer)
(y :pointer)
(ystride :pointer)
(n :pointer)
(c0 :pointer)
(c1 :pointer)
(cov00 :pointer)
(cov01 :pointer)
(cov11 :pointer)
(chisq :pointer))
(cl:export '#.(swig-lispify "gsl_fit_wlinear" 'function))
(cffi:defcfun ("gsl_fit_linear_est" #.(swig-lispify "gsl_fit_linear_est" 'function)) :int
(x :double)
(c0 :double)
(c1 :double)
(cov00 :double)
(cov01 :double)
(cov11 :double)
(y :pointer)
(y_err :pointer))
(cl:export '#.(swig-lispify "gsl_fit_linear_est" 'function))
(cffi:defcfun ("gsl_fit_mul" #.(swig-lispify "gsl_fit_mul" 'function)) :int
(x :pointer)
(xstride :pointer)
(y :pointer)
(ystride :pointer)
(n :pointer)
(c1 :pointer)
(cov11 :pointer)
(sumsq :pointer))
(cl:export '#.(swig-lispify "gsl_fit_mul" 'function))
(cffi:defcfun ("gsl_fit_wmul" #.(swig-lispify "gsl_fit_wmul" 'function)) :int
(x :pointer)
(xstride :pointer)
(w :pointer)
(wstride :pointer)
(y :pointer)
(ystride :pointer)
(n :pointer)
(c1 :pointer)
(cov11 :pointer)
(sumsq :pointer))
(cl:export '#.(swig-lispify "gsl_fit_wmul" 'function))
(cffi:defcfun ("gsl_fit_mul_est" #.(swig-lispify "gsl_fit_mul_est" 'function)) :int
(x :double)
(c1 :double)
(cov11 :double)
(y :pointer)
(y_err :pointer))
(cl:export '#.(swig-lispify "gsl_fit_mul_est" 'function))
(cffi:defcfun ("gsl_heapsort" #.(swig-lispify "gsl_heapsort" 'function)) :void
(array :pointer)
(count :pointer)
(size :pointer)
(compare :pointer))
(cl:export '#.(swig-lispify "gsl_heapsort" 'function))
(cffi:defcfun ("gsl_heapsort_index" #.(swig-lispify "gsl_heapsort_index" 'function)) :int
(p :pointer)
(array :pointer)
(count :pointer)
(size :pointer)
(compare :pointer))
(cl:export '#.(swig-lispify "gsl_heapsort_index" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_histogram" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "range" 'slotname) :pointer)
(#.(swig-lispify "bin" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_histogram" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "range" 'slotname))
(cl:export '#.(swig-lispify "bin" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_histogram_pdf" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "range" 'slotname) :pointer)
(#.(swig-lispify "sum" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_pdf" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "range" 'slotname))
(cl:export '#.(swig-lispify "sum" 'slotname))
(cffi:defcfun ("gsl_histogram_alloc" #.(swig-lispify "gsl_histogram_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_alloc" 'function))
(cffi:defcfun ("gsl_histogram_calloc" #.(swig-lispify "gsl_histogram_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_calloc" 'function))
(cffi:defcfun ("gsl_histogram_calloc_uniform" #.(swig-lispify "gsl_histogram_calloc_uniform" 'function)) :pointer
(n :pointer)
(xmin :double)
(xmax :double))
(cl:export '#.(swig-lispify "gsl_histogram_calloc_uniform" 'function))
(cffi:defcfun ("gsl_histogram_free" #.(swig-lispify "gsl_histogram_free" 'function)) :void
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_free" 'function))
(cffi:defcfun ("gsl_histogram_increment" #.(swig-lispify "gsl_histogram_increment" 'function)) :int
(h :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_histogram_increment" 'function))
(cffi:defcfun ("gsl_histogram_accumulate" #.(swig-lispify "gsl_histogram_accumulate" 'function)) :int
(h :pointer)
(x :double)
(weight :double))
(cl:export '#.(swig-lispify "gsl_histogram_accumulate" 'function))
(cffi:defcfun ("gsl_histogram_find" #.(swig-lispify "gsl_histogram_find" 'function)) :int
(h :pointer)
(x :double)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_find" 'function))
(cffi:defcfun ("gsl_histogram_get" #.(swig-lispify "gsl_histogram_get" 'function)) :double
(h :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_get" 'function))
(cffi:defcfun ("gsl_histogram_get_range" #.(swig-lispify "gsl_histogram_get_range" 'function)) :int
(h :pointer)
(i :pointer)
(lower :pointer)
(upper :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_get_range" 'function))
(cffi:defcfun ("gsl_histogram_max" #.(swig-lispify "gsl_histogram_max" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_max" 'function))
(cffi:defcfun ("gsl_histogram_min" #.(swig-lispify "gsl_histogram_min" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_min" 'function))
(cffi:defcfun ("gsl_histogram_bins" #.(swig-lispify "gsl_histogram_bins" 'function)) :pointer
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_bins" 'function))
(cffi:defcfun ("gsl_histogram_reset" #.(swig-lispify "gsl_histogram_reset" 'function)) :void
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_reset" 'function))
(cffi:defcfun ("gsl_histogram_calloc_range" #.(swig-lispify "gsl_histogram_calloc_range" 'function)) :pointer
(n :pointer)
(range :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_calloc_range" 'function))
(cffi:defcfun ("gsl_histogram_set_ranges" #.(swig-lispify "gsl_histogram_set_ranges" 'function)) :int
(h :pointer)
(range :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_set_ranges" 'function))
(cffi:defcfun ("gsl_histogram_set_ranges_uniform" #.(swig-lispify "gsl_histogram_set_ranges_uniform" 'function)) :int
(h :pointer)
(xmin :double)
(xmax :double))
(cl:export '#.(swig-lispify "gsl_histogram_set_ranges_uniform" 'function))
(cffi:defcfun ("gsl_histogram_memcpy" #.(swig-lispify "gsl_histogram_memcpy" 'function)) :int
(dest :pointer)
(source :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_memcpy" 'function))
(cffi:defcfun ("gsl_histogram_clone" #.(swig-lispify "gsl_histogram_clone" 'function)) :pointer
(source :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_clone" 'function))
(cffi:defcfun ("gsl_histogram_max_val" #.(swig-lispify "gsl_histogram_max_val" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_max_val" 'function))
(cffi:defcfun ("gsl_histogram_max_bin" #.(swig-lispify "gsl_histogram_max_bin" 'function)) :pointer
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_max_bin" 'function))
(cffi:defcfun ("gsl_histogram_min_val" #.(swig-lispify "gsl_histogram_min_val" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_min_val" 'function))
(cffi:defcfun ("gsl_histogram_min_bin" #.(swig-lispify "gsl_histogram_min_bin" 'function)) :pointer
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_min_bin" 'function))
(cffi:defcfun ("gsl_histogram_equal_bins_p" #.(swig-lispify "gsl_histogram_equal_bins_p" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_equal_bins_p" 'function))
(cffi:defcfun ("gsl_histogram_add" #.(swig-lispify "gsl_histogram_add" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_add" 'function))
(cffi:defcfun ("gsl_histogram_sub" #.(swig-lispify "gsl_histogram_sub" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_sub" 'function))
(cffi:defcfun ("gsl_histogram_mul" #.(swig-lispify "gsl_histogram_mul" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_mul" 'function))
(cffi:defcfun ("gsl_histogram_div" #.(swig-lispify "gsl_histogram_div" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_div" 'function))
(cffi:defcfun ("gsl_histogram_scale" #.(swig-lispify "gsl_histogram_scale" 'function)) :int
(h :pointer)
(scale :double))
(cl:export '#.(swig-lispify "gsl_histogram_scale" 'function))
(cffi:defcfun ("gsl_histogram_shift" #.(swig-lispify "gsl_histogram_shift" 'function)) :int
(h :pointer)
(shift :double))
(cl:export '#.(swig-lispify "gsl_histogram_shift" 'function))
(cffi:defcfun ("gsl_histogram_sigma" #.(swig-lispify "gsl_histogram_sigma" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_sigma" 'function))
(cffi:defcfun ("gsl_histogram_mean" #.(swig-lispify "gsl_histogram_mean" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_mean" 'function))
(cffi:defcfun ("gsl_histogram_sum" #.(swig-lispify "gsl_histogram_sum" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_sum" 'function))
(cffi:defcfun ("gsl_histogram_fwrite" #.(swig-lispify "gsl_histogram_fwrite" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_fwrite" 'function))
(cffi:defcfun ("gsl_histogram_fread" #.(swig-lispify "gsl_histogram_fread" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_fread" 'function))
(cffi:defcfun ("gsl_histogram_fprintf" #.(swig-lispify "gsl_histogram_fprintf" 'function)) :int
(stream :pointer)
(h :pointer)
(range_format :string)
(bin_format :string))
(cl:export '#.(swig-lispify "gsl_histogram_fprintf" 'function))
(cffi:defcfun ("gsl_histogram_fscanf" #.(swig-lispify "gsl_histogram_fscanf" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_fscanf" 'function))
(cffi:defcfun ("gsl_histogram_pdf_alloc" #.(swig-lispify "gsl_histogram_pdf_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_pdf_alloc" 'function))
(cffi:defcfun ("gsl_histogram_pdf_init" #.(swig-lispify "gsl_histogram_pdf_init" 'function)) :int
(p :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_pdf_init" 'function))
(cffi:defcfun ("gsl_histogram_pdf_free" #.(swig-lispify "gsl_histogram_pdf_free" 'function)) :void
(p :pointer))
(cl:export '#.(swig-lispify "gsl_histogram_pdf_free" 'function))
(cffi:defcfun ("gsl_histogram_pdf_sample" #.(swig-lispify "gsl_histogram_pdf_sample" 'function)) :double
(p :pointer)
(r :double))
(cl:export '#.(swig-lispify "gsl_histogram_pdf_sample" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_histogram2d" 'classname)
(#.(swig-lispify "nx" 'slotname) :pointer)
(#.(swig-lispify "ny" 'slotname) :pointer)
(#.(swig-lispify "xrange" 'slotname) :pointer)
(#.(swig-lispify "yrange" 'slotname) :pointer)
(#.(swig-lispify "bin" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d" 'classname))
(cl:export '#.(swig-lispify "nx" 'slotname))
(cl:export '#.(swig-lispify "ny" 'slotname))
(cl:export '#.(swig-lispify "xrange" 'slotname))
(cl:export '#.(swig-lispify "yrange" 'slotname))
(cl:export '#.(swig-lispify "bin" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_histogram2d_pdf" 'classname)
(#.(swig-lispify "nx" 'slotname) :pointer)
(#.(swig-lispify "ny" 'slotname) :pointer)
(#.(swig-lispify "xrange" 'slotname) :pointer)
(#.(swig-lispify "yrange" 'slotname) :pointer)
(#.(swig-lispify "sum" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_pdf" 'classname))
(cl:export '#.(swig-lispify "nx" 'slotname))
(cl:export '#.(swig-lispify "ny" 'slotname))
(cl:export '#.(swig-lispify "xrange" 'slotname))
(cl:export '#.(swig-lispify "yrange" 'slotname))
(cl:export '#.(swig-lispify "sum" 'slotname))
(cffi:defcfun ("gsl_histogram2d_alloc" #.(swig-lispify "gsl_histogram2d_alloc" 'function)) :pointer
(nx :pointer)
(ny :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_alloc" 'function))
(cffi:defcfun ("gsl_histogram2d_calloc" #.(swig-lispify "gsl_histogram2d_calloc" 'function)) :pointer
(nx :pointer)
(ny :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_calloc" 'function))
(cffi:defcfun ("gsl_histogram2d_calloc_uniform" #.(swig-lispify "gsl_histogram2d_calloc_uniform" 'function)) :pointer
(nx :pointer)
(ny :pointer)
(xmin :double)
(xmax :double)
(ymin :double)
(ymax :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_calloc_uniform" 'function))
(cffi:defcfun ("gsl_histogram2d_free" #.(swig-lispify "gsl_histogram2d_free" 'function)) :void
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_free" 'function))
(cffi:defcfun ("gsl_histogram2d_increment" #.(swig-lispify "gsl_histogram2d_increment" 'function)) :int
(h :pointer)
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_increment" 'function))
(cffi:defcfun ("gsl_histogram2d_accumulate" #.(swig-lispify "gsl_histogram2d_accumulate" 'function)) :int
(h :pointer)
(x :double)
(y :double)
(weight :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_accumulate" 'function))
(cffi:defcfun ("gsl_histogram2d_find" #.(swig-lispify "gsl_histogram2d_find" 'function)) :int
(h :pointer)
(x :double)
(y :double)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_find" 'function))
(cffi:defcfun ("gsl_histogram2d_get" #.(swig-lispify "gsl_histogram2d_get" 'function)) :double
(h :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_get" 'function))
(cffi:defcfun ("gsl_histogram2d_get_xrange" #.(swig-lispify "gsl_histogram2d_get_xrange" 'function)) :int
(h :pointer)
(i :pointer)
(xlower :pointer)
(xupper :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_get_xrange" 'function))
(cffi:defcfun ("gsl_histogram2d_get_yrange" #.(swig-lispify "gsl_histogram2d_get_yrange" 'function)) :int
(h :pointer)
(j :pointer)
(ylower :pointer)
(yupper :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_get_yrange" 'function))
(cffi:defcfun ("gsl_histogram2d_xmax" #.(swig-lispify "gsl_histogram2d_xmax" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_xmax" 'function))
(cffi:defcfun ("gsl_histogram2d_xmin" #.(swig-lispify "gsl_histogram2d_xmin" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_xmin" 'function))
(cffi:defcfun ("gsl_histogram2d_nx" #.(swig-lispify "gsl_histogram2d_nx" 'function)) :pointer
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_nx" 'function))
(cffi:defcfun ("gsl_histogram2d_ymax" #.(swig-lispify "gsl_histogram2d_ymax" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_ymax" 'function))
(cffi:defcfun ("gsl_histogram2d_ymin" #.(swig-lispify "gsl_histogram2d_ymin" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_ymin" 'function))
(cffi:defcfun ("gsl_histogram2d_ny" #.(swig-lispify "gsl_histogram2d_ny" 'function)) :pointer
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_ny" 'function))
(cffi:defcfun ("gsl_histogram2d_reset" #.(swig-lispify "gsl_histogram2d_reset" 'function)) :void
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_reset" 'function))
(cffi:defcfun ("gsl_histogram2d_calloc_range" #.(swig-lispify "gsl_histogram2d_calloc_range" 'function)) :pointer
(nx :pointer)
(ny :pointer)
(xrange :pointer)
(yrange :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_calloc_range" 'function))
(cffi:defcfun ("gsl_histogram2d_set_ranges_uniform" #.(swig-lispify "gsl_histogram2d_set_ranges_uniform" 'function)) :int
(h :pointer)
(xmin :double)
(xmax :double)
(ymin :double)
(ymax :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_set_ranges_uniform" 'function))
(cffi:defcfun ("gsl_histogram2d_set_ranges" #.(swig-lispify "gsl_histogram2d_set_ranges" 'function)) :int
(h :pointer)
(xrange :pointer)
(xsize :pointer)
(yrange :pointer)
(ysize :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_set_ranges" 'function))
(cffi:defcfun ("gsl_histogram2d_memcpy" #.(swig-lispify "gsl_histogram2d_memcpy" 'function)) :int
(dest :pointer)
(source :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_memcpy" 'function))
(cffi:defcfun ("gsl_histogram2d_clone" #.(swig-lispify "gsl_histogram2d_clone" 'function)) :pointer
(source :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_clone" 'function))
(cffi:defcfun ("gsl_histogram2d_max_val" #.(swig-lispify "gsl_histogram2d_max_val" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_max_val" 'function))
(cffi:defcfun ("gsl_histogram2d_max_bin" #.(swig-lispify "gsl_histogram2d_max_bin" 'function)) :void
(h :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_max_bin" 'function))
(cffi:defcfun ("gsl_histogram2d_min_val" #.(swig-lispify "gsl_histogram2d_min_val" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_min_val" 'function))
(cffi:defcfun ("gsl_histogram2d_min_bin" #.(swig-lispify "gsl_histogram2d_min_bin" 'function)) :void
(h :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_min_bin" 'function))
(cffi:defcfun ("gsl_histogram2d_xmean" #.(swig-lispify "gsl_histogram2d_xmean" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_xmean" 'function))
(cffi:defcfun ("gsl_histogram2d_ymean" #.(swig-lispify "gsl_histogram2d_ymean" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_ymean" 'function))
(cffi:defcfun ("gsl_histogram2d_xsigma" #.(swig-lispify "gsl_histogram2d_xsigma" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_xsigma" 'function))
(cffi:defcfun ("gsl_histogram2d_ysigma" #.(swig-lispify "gsl_histogram2d_ysigma" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_ysigma" 'function))
(cffi:defcfun ("gsl_histogram2d_cov" #.(swig-lispify "gsl_histogram2d_cov" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_cov" 'function))
(cffi:defcfun ("gsl_histogram2d_sum" #.(swig-lispify "gsl_histogram2d_sum" 'function)) :double
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_sum" 'function))
(cffi:defcfun ("gsl_histogram2d_equal_bins_p" #.(swig-lispify "gsl_histogram2d_equal_bins_p" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_equal_bins_p" 'function))
(cffi:defcfun ("gsl_histogram2d_add" #.(swig-lispify "gsl_histogram2d_add" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_add" 'function))
(cffi:defcfun ("gsl_histogram2d_sub" #.(swig-lispify "gsl_histogram2d_sub" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_sub" 'function))
(cffi:defcfun ("gsl_histogram2d_mul" #.(swig-lispify "gsl_histogram2d_mul" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_mul" 'function))
(cffi:defcfun ("gsl_histogram2d_div" #.(swig-lispify "gsl_histogram2d_div" 'function)) :int
(h1 :pointer)
(h2 :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_div" 'function))
(cffi:defcfun ("gsl_histogram2d_scale" #.(swig-lispify "gsl_histogram2d_scale" 'function)) :int
(h :pointer)
(scale :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_scale" 'function))
(cffi:defcfun ("gsl_histogram2d_shift" #.(swig-lispify "gsl_histogram2d_shift" 'function)) :int
(h :pointer)
(shift :double))
(cl:export '#.(swig-lispify "gsl_histogram2d_shift" 'function))
(cffi:defcfun ("gsl_histogram2d_fwrite" #.(swig-lispify "gsl_histogram2d_fwrite" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_fwrite" 'function))
(cffi:defcfun ("gsl_histogram2d_fread" #.(swig-lispify "gsl_histogram2d_fread" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_fread" 'function))
(cffi:defcfun ("gsl_histogram2d_fprintf" #.(swig-lispify "gsl_histogram2d_fprintf" 'function)) :int
(stream :pointer)
(h :pointer)
(range_format :string)
(bin_format :string))
(cl:export '#.(swig-lispify "gsl_histogram2d_fprintf" 'function))
(cffi:defcfun ("gsl_histogram2d_fscanf" #.(swig-lispify "gsl_histogram2d_fscanf" 'function)) :int
(stream :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_fscanf" 'function))
(cffi:defcfun ("gsl_histogram2d_pdf_alloc" #.(swig-lispify "gsl_histogram2d_pdf_alloc" 'function)) :pointer
(nx :pointer)
(ny :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_pdf_alloc" 'function))
(cffi:defcfun ("gsl_histogram2d_pdf_init" #.(swig-lispify "gsl_histogram2d_pdf_init" 'function)) :int
(p :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_pdf_init" 'function))
(cffi:defcfun ("gsl_histogram2d_pdf_free" #.(swig-lispify "gsl_histogram2d_pdf_free" 'function)) :void
(p :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_pdf_free" 'function))
(cffi:defcfun ("gsl_histogram2d_pdf_sample" #.(swig-lispify "gsl_histogram2d_pdf_sample" 'function)) :int
(p :pointer)
(r1 :double)
(r2 :double)
(x :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_histogram2d_pdf_sample" 'function))
(defanonenum
(#.(swig-lispify "GSL_IEEE_TYPE_NAN" 'enumvalue) #.1)
(#.(swig-lispify "GSL_IEEE_TYPE_INF" 'enumvalue) #.2)
(#.(swig-lispify "GSL_IEEE_TYPE_NORMAL" 'enumvalue) #.3)
(#.(swig-lispify "GSL_IEEE_TYPE_DENORMAL" 'enumvalue) #.4)
(#.(swig-lispify "GSL_IEEE_TYPE_ZERO" 'enumvalue) #.5))
(cl:export '#.(swig-lispify "GSL_IEEE_TYPE_NAN" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_TYPE_INF" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_TYPE_NORMAL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_TYPE_DENORMAL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_TYPE_ZERO" 'enumvalue))
(cffi:defcstruct #.(swig-lispify "gsl_ieee_float_rep" 'classname)
(#.(swig-lispify "sign" 'slotname) :int)
(#.(swig-lispify "mantissa" 'slotname) :pointer)
(#.(swig-lispify "exponent" 'slotname) :int)
(#.(swig-lispify "type" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_ieee_float_rep" 'classname))
(cl:export '#.(swig-lispify "sign" 'slotname))
(cl:export '#.(swig-lispify "mantissa" 'slotname))
(cl:export '#.(swig-lispify "exponent" 'slotname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_ieee_double_rep" 'classname)
(#.(swig-lispify "sign" 'slotname) :int)
(#.(swig-lispify "mantissa" 'slotname) :pointer)
(#.(swig-lispify "exponent" 'slotname) :int)
(#.(swig-lispify "type" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_ieee_double_rep" 'classname))
(cl:export '#.(swig-lispify "sign" 'slotname))
(cl:export '#.(swig-lispify "mantissa" 'slotname))
(cl:export '#.(swig-lispify "exponent" 'slotname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cffi:defcfun ("gsl_ieee_printf_float" #.(swig-lispify "gsl_ieee_printf_float" 'function)) :void
(x :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_printf_float" 'function))
(cffi:defcfun ("gsl_ieee_printf_double" #.(swig-lispify "gsl_ieee_printf_double" 'function)) :void
(x :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_printf_double" 'function))
(cffi:defcfun ("gsl_ieee_fprintf_float" #.(swig-lispify "gsl_ieee_fprintf_float" 'function)) :void
(stream :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_fprintf_float" 'function))
(cffi:defcfun ("gsl_ieee_fprintf_double" #.(swig-lispify "gsl_ieee_fprintf_double" 'function)) :void
(stream :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_fprintf_double" 'function))
(cffi:defcfun ("gsl_ieee_float_to_rep" #.(swig-lispify "gsl_ieee_float_to_rep" 'function)) :void
(x :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_float_to_rep" 'function))
(cffi:defcfun ("gsl_ieee_double_to_rep" #.(swig-lispify "gsl_ieee_double_to_rep" 'function)) :void
(x :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_double_to_rep" 'function))
(defanonenum
(#.(swig-lispify "GSL_IEEE_SINGLE_PRECISION" 'enumvalue) #.1)
(#.(swig-lispify "GSL_IEEE_DOUBLE_PRECISION" 'enumvalue) #.2)
(#.(swig-lispify "GSL_IEEE_EXTENDED_PRECISION" 'enumvalue) #.3))
(cl:export '#.(swig-lispify "GSL_IEEE_SINGLE_PRECISION" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_DOUBLE_PRECISION" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_EXTENDED_PRECISION" 'enumvalue))
(defanonenum
(#.(swig-lispify "GSL_IEEE_ROUND_TO_NEAREST" 'enumvalue) #.1)
(#.(swig-lispify "GSL_IEEE_ROUND_DOWN" 'enumvalue) #.2)
(#.(swig-lispify "GSL_IEEE_ROUND_UP" 'enumvalue) #.3)
(#.(swig-lispify "GSL_IEEE_ROUND_TO_ZERO" 'enumvalue) #.4))
(cl:export '#.(swig-lispify "GSL_IEEE_ROUND_TO_NEAREST" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_ROUND_DOWN" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_ROUND_UP" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_ROUND_TO_ZERO" 'enumvalue))
(defanonenum
(#.(swig-lispify "GSL_IEEE_MASK_INVALID" 'enumvalue) #.1)
(#.(swig-lispify "GSL_IEEE_MASK_DENORMALIZED" 'enumvalue) #.2)
(#.(swig-lispify "GSL_IEEE_MASK_DIVISION_BY_ZERO" 'enumvalue) #.4)
(#.(swig-lispify "GSL_IEEE_MASK_OVERFLOW" 'enumvalue) #.8)
(#.(swig-lispify "GSL_IEEE_MASK_UNDERFLOW" 'enumvalue) #.16)
(#.(swig-lispify "GSL_IEEE_MASK_ALL" 'enumvalue) #.31)
(#.(swig-lispify "GSL_IEEE_TRAP_INEXACT" 'enumvalue) #.32))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_INVALID" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_DENORMALIZED" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_DIVISION_BY_ZERO" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_OVERFLOW" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_UNDERFLOW" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_MASK_ALL" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_IEEE_TRAP_INEXACT" 'enumvalue))
(cffi:defcfun ("gsl_ieee_env_setup" #.(swig-lispify "gsl_ieee_env_setup" 'function)) :void)
(cl:export '#.(swig-lispify "gsl_ieee_env_setup" 'function))
(cffi:defcfun ("gsl_ieee_read_mode_string" #.(swig-lispify "gsl_ieee_read_mode_string" 'function)) :int
(description :string)
(precision :pointer)
(rounding :pointer)
(exception_mask :pointer))
(cl:export '#.(swig-lispify "gsl_ieee_read_mode_string" 'function))
(cffi:defcfun ("gsl_ieee_set_mode" #.(swig-lispify "gsl_ieee_set_mode" 'function)) :int
(precision :int)
(rounding :int)
(exception_mask :int))
(cl:export '#.(swig-lispify "gsl_ieee_set_mode" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_integration_workspace" 'classname)
(#.(swig-lispify "limit" 'slotname) :pointer)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "nrmax" 'slotname) :pointer)
(#.(swig-lispify "i" 'slotname) :pointer)
(#.(swig-lispify "maximum_level" 'slotname) :pointer)
(#.(swig-lispify "alist" 'slotname) :pointer)
(#.(swig-lispify "blist" 'slotname) :pointer)
(#.(swig-lispify "rlist" 'slotname) :pointer)
(#.(swig-lispify "elist" 'slotname) :pointer)
(#.(swig-lispify "order" 'slotname) :pointer)
(#.(swig-lispify "level" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_integration_workspace" 'classname))
(cl:export '#.(swig-lispify "limit" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "nrmax" 'slotname))
(cl:export '#.(swig-lispify "i" 'slotname))
(cl:export '#.(swig-lispify "maximum_level" 'slotname))
(cl:export '#.(swig-lispify "alist" 'slotname))
(cl:export '#.(swig-lispify "blist" 'slotname))
(cl:export '#.(swig-lispify "rlist" 'slotname))
(cl:export '#.(swig-lispify "elist" 'slotname))
(cl:export '#.(swig-lispify "order" 'slotname))
(cl:export '#.(swig-lispify "level" 'slotname))
(cffi:defcfun ("gsl_integration_workspace_alloc" #.(swig-lispify "gsl_integration_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_integration_workspace_alloc" 'function))
(cffi:defcfun ("gsl_integration_workspace_free" #.(swig-lispify "gsl_integration_workspace_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_integration_workspace_free" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_integration_qaws_table" 'classname)
(#.(swig-lispify "alpha" 'slotname) :double)
(#.(swig-lispify "beta" 'slotname) :double)
(#.(swig-lispify "mu" 'slotname) :int)
(#.(swig-lispify "nu" 'slotname) :int)
(#.(swig-lispify "ri" 'slotname) :pointer)
(#.(swig-lispify "rj" 'slotname) :pointer)
(#.(swig-lispify "rg" 'slotname) :pointer)
(#.(swig-lispify "rh" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qaws_table" 'classname))
(cl:export '#.(swig-lispify "alpha" 'slotname))
(cl:export '#.(swig-lispify "beta" 'slotname))
(cl:export '#.(swig-lispify "mu" 'slotname))
(cl:export '#.(swig-lispify "nu" 'slotname))
(cl:export '#.(swig-lispify "ri" 'slotname))
(cl:export '#.(swig-lispify "rj" 'slotname))
(cl:export '#.(swig-lispify "rg" 'slotname))
(cl:export '#.(swig-lispify "rh" 'slotname))
(cffi:defcfun ("gsl_integration_qaws_table_alloc" #.(swig-lispify "gsl_integration_qaws_table_alloc" 'function)) :pointer
(alpha :double)
(beta :double)
(mu :int)
(nu :int))
(cl:export '#.(swig-lispify "gsl_integration_qaws_table_alloc" 'function))
(cffi:defcfun ("gsl_integration_qaws_table_set" #.(swig-lispify "gsl_integration_qaws_table_set" 'function)) :int
(t_arg0 :pointer)
(alpha :double)
(beta :double)
(mu :int)
(nu :int))
(cl:export '#.(swig-lispify "gsl_integration_qaws_table_set" 'function))
(cffi:defcfun ("gsl_integration_qaws_table_free" #.(swig-lispify "gsl_integration_qaws_table_free" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qaws_table_free" 'function))
(cffi:defcenum #.(swig-lispify "gsl_integration_qawo_enum" 'enumname)
#.(swig-lispify "GSL_INTEG_COSINE" 'enumvalue :keyword)
#.(swig-lispify "GSL_INTEG_SINE" 'enumvalue :keyword))
(cl:export '#.(swig-lispify "gsl_integration_qawo_enum" 'enumname))
(cffi:defcstruct #.(swig-lispify "gsl_integration_qawo_table" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "omega" 'slotname) :double)
(#.(swig-lispify "L" 'slotname) :double)
(#.(swig-lispify "par" 'slotname) :double)
(#.(swig-lispify "sine" 'slotname) #.(swig-lispify "gsl_integration_qawo_enum" 'enumname))
(#.(swig-lispify "chebmo" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawo_table" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "omega" 'slotname))
(cl:export '#.(swig-lispify "L" 'slotname))
(cl:export '#.(swig-lispify "par" 'slotname))
(cl:export '#.(swig-lispify "sine" 'slotname))
(cl:export '#.(swig-lispify "chebmo" 'slotname))
(cffi:defcfun ("gsl_integration_qawo_table_alloc" #.(swig-lispify "gsl_integration_qawo_table_alloc" 'function)) :pointer
(omega :double)
(L :double)
(sine #.(swig-lispify "gsl_integration_qawo_enum" 'enumname))
(n :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawo_table_alloc" 'function))
(cffi:defcfun ("gsl_integration_qawo_table_set" #.(swig-lispify "gsl_integration_qawo_table_set" 'function)) :int
(t_arg0 :pointer)
(omega :double)
(L :double)
(sine #.(swig-lispify "gsl_integration_qawo_enum" 'enumname)))
(cl:export '#.(swig-lispify "gsl_integration_qawo_table_set" 'function))
(cffi:defcfun ("gsl_integration_qawo_table_set_length" #.(swig-lispify "gsl_integration_qawo_table_set_length" 'function)) :int
(t_arg0 :pointer)
(L :double))
(cl:export '#.(swig-lispify "gsl_integration_qawo_table_set_length" 'function))
(cffi:defcfun ("gsl_integration_qawo_table_free" #.(swig-lispify "gsl_integration_qawo_table_free" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawo_table_free" 'function))
(cffi:defcfun ("gsl_integration_qk15" #.(swig-lispify "gsl_integration_qk15" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk15" 'function))
(cffi:defcfun ("gsl_integration_qk21" #.(swig-lispify "gsl_integration_qk21" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk21" 'function))
(cffi:defcfun ("gsl_integration_qk31" #.(swig-lispify "gsl_integration_qk31" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk31" 'function))
(cffi:defcfun ("gsl_integration_qk41" #.(swig-lispify "gsl_integration_qk41" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk41" 'function))
(cffi:defcfun ("gsl_integration_qk51" #.(swig-lispify "gsl_integration_qk51" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk51" 'function))
(cffi:defcfun ("gsl_integration_qk61" #.(swig-lispify "gsl_integration_qk61" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk61" 'function))
(cffi:defcfun ("gsl_integration_qcheb" #.(swig-lispify "gsl_integration_qcheb" 'function)) :void
(f :pointer)
(a :double)
(b :double)
(cheb12 :pointer)
(cheb24 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qcheb" 'function))
(defanonenum
(#.(swig-lispify "GSL_INTEG_GAUSS15" 'enumvalue) #.1)
(#.(swig-lispify "GSL_INTEG_GAUSS21" 'enumvalue) #.2)
(#.(swig-lispify "GSL_INTEG_GAUSS31" 'enumvalue) #.3)
(#.(swig-lispify "GSL_INTEG_GAUSS41" 'enumvalue) #.4)
(#.(swig-lispify "GSL_INTEG_GAUSS51" 'enumvalue) #.5)
(#.(swig-lispify "GSL_INTEG_GAUSS61" 'enumvalue) #.6))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS15" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS21" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS31" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS41" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS51" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_INTEG_GAUSS61" 'enumvalue))
(cffi:defcfun ("gsl_integration_qk" #.(swig-lispify "gsl_integration_qk" 'function)) :void
(n :int)
(xgk :pointer)
(wg :pointer)
(wgk :pointer)
(fv1 :pointer)
(fv2 :pointer)
(f :pointer)
(a :double)
(b :double)
(result :pointer)
(abserr :pointer)
(resabs :pointer)
(resasc :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qk" 'function))
(cffi:defcfun ("gsl_integration_qng" #.(swig-lispify "gsl_integration_qng" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(epsabs :double)
(epsrel :double)
(result :pointer)
(abserr :pointer)
(neval :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qng" 'function))
(cffi:defcfun ("gsl_integration_qag" #.(swig-lispify "gsl_integration_qag" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(key :int)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qag" 'function))
(cffi:defcfun ("gsl_integration_qagi" #.(swig-lispify "gsl_integration_qagi" 'function)) :int
(f :pointer)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qagi" 'function))
(cffi:defcfun ("gsl_integration_qagiu" #.(swig-lispify "gsl_integration_qagiu" 'function)) :int
(f :pointer)
(a :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qagiu" 'function))
(cffi:defcfun ("gsl_integration_qagil" #.(swig-lispify "gsl_integration_qagil" 'function)) :int
(f :pointer)
(b :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qagil" 'function))
(cffi:defcfun ("gsl_integration_qags" #.(swig-lispify "gsl_integration_qags" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qags" 'function))
(cffi:defcfun ("gsl_integration_qagp" #.(swig-lispify "gsl_integration_qagp" 'function)) :int
(f :pointer)
(pts :pointer)
(npts :pointer)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qagp" 'function))
(cffi:defcfun ("gsl_integration_qawc" #.(swig-lispify "gsl_integration_qawc" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(c :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawc" 'function))
(cffi:defcfun ("gsl_integration_qaws" #.(swig-lispify "gsl_integration_qaws" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(t_arg3 :pointer)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qaws" 'function))
(cffi:defcfun ("gsl_integration_qawo" #.(swig-lispify "gsl_integration_qawo" 'function)) :int
(f :pointer)
(a :double)
(epsabs :double)
(epsrel :double)
(limit :pointer)
(workspace :pointer)
(wf :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawo" 'function))
(cffi:defcfun ("gsl_integration_qawf" #.(swig-lispify "gsl_integration_qawf" 'function)) :int
(f :pointer)
(a :double)
(epsabs :double)
(limit :pointer)
(workspace :pointer)
(cycle_workspace :pointer)
(wf :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_integration_qawf" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_integration_glfixed_table" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "w" 'slotname) :pointer)
(#.(swig-lispify "precomputed" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_integration_glfixed_table" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "w" 'slotname))
(cl:export '#.(swig-lispify "precomputed" 'slotname))
(cffi:defcfun ("gsl_integration_glfixed_table_alloc" #.(swig-lispify "gsl_integration_glfixed_table_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_integration_glfixed_table_alloc" 'function))
(cffi:defcfun ("gsl_integration_glfixed_table_free" #.(swig-lispify "gsl_integration_glfixed_table_free" 'function)) :void
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_glfixed_table_free" 'function))
(cffi:defcfun ("gsl_integration_glfixed" #.(swig-lispify "gsl_integration_glfixed" 'function)) :double
(f :pointer)
(a :double)
(b :double)
(t_arg3 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_glfixed" 'function))
(cffi:defcfun ("gsl_integration_glfixed_point" #.(swig-lispify "gsl_integration_glfixed_point" 'function)) :int
(a :double)
(b :double)
(i :pointer)
(xi :pointer)
(wi :pointer)
(t_arg5 :pointer))
(cl:export '#.(swig-lispify "gsl_integration_glfixed_point" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_integration_cquad_ival" 'classname)
(#.(swig-lispify "a" 'slotname) :double)
(#.(swig-lispify "b" 'slotname) :double)
(#.(swig-lispify "c" 'slotname) :pointer)
(#.(swig-lispify "fx" 'slotname) :pointer)
(#.(swig-lispify "igral" 'slotname) :double)
(#.(swig-lispify "err" 'slotname) :double)
(#.(swig-lispify "depth" 'slotname) :int)
(#.(swig-lispify "rdepth" 'slotname) :int)
(#.(swig-lispify "ndiv" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_integration_cquad_ival" 'classname))
(cl:export '#.(swig-lispify "a" 'slotname))
(cl:export '#.(swig-lispify "b" 'slotname))
(cl:export '#.(swig-lispify "c" 'slotname))
(cl:export '#.(swig-lispify "fx" 'slotname))
(cl:export '#.(swig-lispify "igral" 'slotname))
(cl:export '#.(swig-lispify "err" 'slotname))
(cl:export '#.(swig-lispify "depth" 'slotname))
(cl:export '#.(swig-lispify "rdepth" 'slotname))
(cl:export '#.(swig-lispify "ndiv" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_integration_cquad_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "ivals" 'slotname) :pointer)
(#.(swig-lispify "heap" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_integration_cquad_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "ivals" 'slotname))
(cl:export '#.(swig-lispify "heap" 'slotname))
(cffi:defcfun ("gsl_integration_cquad_workspace_alloc" #.(swig-lispify "gsl_integration_cquad_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_integration_cquad_workspace_alloc" 'function))
(cffi:defcfun ("gsl_integration_cquad_workspace_free" #.(swig-lispify "gsl_integration_cquad_workspace_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_integration_cquad_workspace_free" 'function))
(cffi:defcfun ("gsl_integration_cquad" #.(swig-lispify "gsl_integration_cquad" 'function)) :int
(f :pointer)
(a :double)
(b :double)
(epsabs :double)
(epsrel :double)
(ws :pointer)
(result :pointer)
(abserr :pointer)
(nevals :pointer))
(cl:export '#.(swig-lispify "gsl_integration_cquad" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_interp_accel" 'classname)
(#.(swig-lispify "cache" 'slotname) :pointer)
(#.(swig-lispify "miss_count" 'slotname) :pointer)
(#.(swig-lispify "hit_count" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_interp_accel" 'classname))
(cl:export '#.(swig-lispify "cache" 'slotname))
(cl:export '#.(swig-lispify "miss_count" 'slotname))
(cl:export '#.(swig-lispify "hit_count" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_interp_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "min_size" 'slotname) :unsigned-int)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "init" 'slotname) :pointer)
(#.(swig-lispify "eval" 'slotname) :pointer)
(#.(swig-lispify "eval_deriv" 'slotname) :pointer)
(#.(swig-lispify "eval_deriv2" 'slotname) :pointer)
(#.(swig-lispify "eval_integ" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_interp_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "min_size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "init" 'slotname))
(cl:export '#.(swig-lispify "eval" 'slotname))
(cl:export '#.(swig-lispify "eval_deriv" 'slotname))
(cl:export '#.(swig-lispify "eval_deriv2" 'slotname))
(cl:export '#.(swig-lispify "eval_integ" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_interp" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "xmin" 'slotname) :double)
(#.(swig-lispify "xmax" 'slotname) :double)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_interp" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "xmin" 'slotname))
(cl:export '#.(swig-lispify "xmax" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcvar ("gsl_interp_linear" #.(swig-lispify "gsl_interp_linear" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_linear" 'variable))
(cffi:defcvar ("gsl_interp_polynomial" #.(swig-lispify "gsl_interp_polynomial" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_polynomial" 'variable))
(cffi:defcvar ("gsl_interp_cspline" #.(swig-lispify "gsl_interp_cspline" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_cspline" 'variable))
(cffi:defcvar ("gsl_interp_cspline_periodic" #.(swig-lispify "gsl_interp_cspline_periodic" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_cspline_periodic" 'variable))
(cffi:defcvar ("gsl_interp_akima" #.(swig-lispify "gsl_interp_akima" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_akima" 'variable))
(cffi:defcvar ("gsl_interp_akima_periodic" #.(swig-lispify "gsl_interp_akima_periodic" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_interp_akima_periodic" 'variable))
(cffi:defcfun ("gsl_interp_accel_alloc" #.(swig-lispify "gsl_interp_accel_alloc" 'function)) :pointer)
(cl:export '#.(swig-lispify "gsl_interp_accel_alloc" 'function))
(cffi:defcfun ("gsl_interp_accel_reset" #.(swig-lispify "gsl_interp_accel_reset" 'function)) :int
(a :pointer))
(cl:export '#.(swig-lispify "gsl_interp_accel_reset" 'function))
(cffi:defcfun ("gsl_interp_accel_free" #.(swig-lispify "gsl_interp_accel_free" 'function)) :void
(a :pointer))
(cl:export '#.(swig-lispify "gsl_interp_accel_free" 'function))
(cffi:defcfun ("gsl_interp_alloc" #.(swig-lispify "gsl_interp_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_interp_alloc" 'function))
(cffi:defcfun ("gsl_interp_init" #.(swig-lispify "gsl_interp_init" 'function)) :int
(obj :pointer)
(xa :pointer)
(ya :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_interp_init" 'function))
(cffi:defcfun ("gsl_interp_name" #.(swig-lispify "gsl_interp_name" 'function)) :string
(interp :pointer))
(cl:export '#.(swig-lispify "gsl_interp_name" 'function))
(cffi:defcfun ("gsl_interp_min_size" #.(swig-lispify "gsl_interp_min_size" 'function)) :unsigned-int
(interp :pointer))
(cl:export '#.(swig-lispify "gsl_interp_min_size" 'function))
(cffi:defcfun ("gsl_interp_type_min_size" #.(swig-lispify "gsl_interp_type_min_size" 'function)) :unsigned-int
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_interp_type_min_size" 'function))
(cffi:defcfun ("gsl_interp_eval_e" #.(swig-lispify "gsl_interp_eval_e" 'function)) :int
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_e" 'function))
(cffi:defcfun ("gsl_interp_eval" #.(swig-lispify "gsl_interp_eval" 'function)) :double
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval" 'function))
(cffi:defcfun ("gsl_interp_eval_deriv_e" #.(swig-lispify "gsl_interp_eval_deriv_e" 'function)) :int
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer)
(d :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_deriv_e" 'function))
(cffi:defcfun ("gsl_interp_eval_deriv" #.(swig-lispify "gsl_interp_eval_deriv" 'function)) :double
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_deriv" 'function))
(cffi:defcfun ("gsl_interp_eval_deriv2_e" #.(swig-lispify "gsl_interp_eval_deriv2_e" 'function)) :int
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_deriv2_e" 'function))
(cffi:defcfun ("gsl_interp_eval_deriv2" #.(swig-lispify "gsl_interp_eval_deriv2" 'function)) :double
(obj :pointer)
(xa :pointer)
(ya :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_deriv2" 'function))
(cffi:defcfun ("gsl_interp_eval_integ_e" #.(swig-lispify "gsl_interp_eval_integ_e" 'function)) :int
(obj :pointer)
(xa :pointer)
(ya :pointer)
(a :double)
(b :double)
(acc :pointer)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_integ_e" 'function))
(cffi:defcfun ("gsl_interp_eval_integ" #.(swig-lispify "gsl_interp_eval_integ" 'function)) :double
(obj :pointer)
(xa :pointer)
(ya :pointer)
(a :double)
(b :double)
(acc :pointer))
(cl:export '#.(swig-lispify "gsl_interp_eval_integ" 'function))
(cffi:defcfun ("gsl_interp_free" #.(swig-lispify "gsl_interp_free" 'function)) :void
(interp :pointer))
(cl:export '#.(swig-lispify "gsl_interp_free" 'function))
(cffi:defcfun ("gsl_interp_bsearch" #.(swig-lispify "gsl_interp_bsearch" 'function)) :pointer
(x_array :pointer)
(x :double)
(index_lo :pointer)
(index_hi :pointer))
(cl:export '#.(swig-lispify "gsl_interp_bsearch" 'function))
(cffi:defcfun ("gsl_interp_accel_find" #.(swig-lispify "gsl_interp_accel_find" 'function)) :pointer
(a :pointer)
(x_array :pointer)
(size :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_interp_accel_find" 'function))
(cffi:defcenum #.(swig-lispify "gsl_linalg_matrix_mod_t" 'enumname)
(#.(swig-lispify "GSL_LINALG_MOD_NONE" 'enumvalue :keyword) #.0)
(#.(swig-lispify "GSL_LINALG_MOD_TRANSPOSE" 'enumvalue :keyword) #.1)
(#.(swig-lispify "GSL_LINALG_MOD_CONJUGATE" 'enumvalue :keyword) #.2))
(cl:export '#.(swig-lispify "gsl_linalg_matrix_mod_t" 'enumname))
(cffi:defcfun ("gsl_linalg_matmult" #.(swig-lispify "gsl_linalg_matmult" 'function)) :int
(A :pointer)
(B :pointer)
(C :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_matmult" 'function))
(cffi:defcfun ("gsl_linalg_matmult_mod" #.(swig-lispify "gsl_linalg_matmult_mod" 'function)) :int
(A :pointer)
(modA #.(swig-lispify "gsl_linalg_matrix_mod_t" 'enumname))
(B :pointer)
(modB #.(swig-lispify "gsl_linalg_matrix_mod_t" 'enumname))
(C :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_matmult_mod" 'function))
(cffi:defcfun ("gsl_linalg_exponential_ss" #.(swig-lispify "gsl_linalg_exponential_ss" 'function)) :int
(A :pointer)
(eA :pointer)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_linalg_exponential_ss" 'function))
(cffi:defcfun ("gsl_linalg_householder_transform" #.(swig-lispify "gsl_linalg_householder_transform" 'function)) :double
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_householder_transform" 'function))
(cffi:defcfun ("gsl_linalg_complex_householder_transform" #.(swig-lispify "gsl_linalg_complex_householder_transform" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_householder_transform" 'function))
(cffi:defcfun ("gsl_linalg_householder_hm" #.(swig-lispify "gsl_linalg_householder_hm" 'function)) :int
(tau :double)
(v :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_householder_hm" 'function))
(cffi:defcfun ("gsl_linalg_householder_mh" #.(swig-lispify "gsl_linalg_householder_mh" 'function)) :int
(tau :double)
(v :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_householder_mh" 'function))
(cffi:defcfun ("gsl_linalg_householder_hv" #.(swig-lispify "gsl_linalg_householder_hv" 'function)) :int
(tau :double)
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_householder_hv" 'function))
(cffi:defcfun ("gsl_linalg_householder_hm1" #.(swig-lispify "gsl_linalg_householder_hm1" 'function)) :int
(tau :double)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_householder_hm1" 'function))
(cffi:defcfun ("gsl_linalg_complex_householder_hm" #.(swig-lispify "gsl_linalg_complex_householder_hm" 'function)) :int
(tau #.(swig-lispify "gsl_complex" 'classname))
(v :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_householder_hm" 'function))
(cffi:defcfun ("gsl_linalg_complex_householder_mh" #.(swig-lispify "gsl_linalg_complex_householder_mh" 'function)) :int
(tau #.(swig-lispify "gsl_complex" 'classname))
(v :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_householder_mh" 'function))
(cffi:defcfun ("gsl_linalg_complex_householder_hv" #.(swig-lispify "gsl_linalg_complex_householder_hv" 'function)) :int
(tau #.(swig-lispify "gsl_complex" 'classname))
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_householder_hv" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg_decomp" #.(swig-lispify "gsl_linalg_hessenberg_decomp" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg_decomp" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg_unpack" #.(swig-lispify "gsl_linalg_hessenberg_unpack" 'function)) :int
(H :pointer)
(tau :pointer)
(U :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg_unpack" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg_unpack_accum" #.(swig-lispify "gsl_linalg_hessenberg_unpack_accum" 'function)) :int
(H :pointer)
(tau :pointer)
(U :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg_unpack_accum" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg_set_zero" #.(swig-lispify "gsl_linalg_hessenberg_set_zero" 'function)) :int
(H :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg_set_zero" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg_submatrix" #.(swig-lispify "gsl_linalg_hessenberg_submatrix" 'function)) :int
(M :pointer)
(A :pointer)
(top :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg_submatrix" 'function))
(cffi:defcfun ("gsl_linalg_hessenberg" #.(swig-lispify "gsl_linalg_hessenberg" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hessenberg" 'function))
(cffi:defcfun ("gsl_linalg_hesstri_decomp" #.(swig-lispify "gsl_linalg_hesstri_decomp" 'function)) :int
(A :pointer)
(B :pointer)
(U :pointer)
(V :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hesstri_decomp" 'function))
(cffi:defcfun ("gsl_linalg_SV_decomp" #.(swig-lispify "gsl_linalg_SV_decomp" 'function)) :int
(A :pointer)
(V :pointer)
(S :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_SV_decomp" 'function))
(cffi:defcfun ("gsl_linalg_SV_decomp_mod" #.(swig-lispify "gsl_linalg_SV_decomp_mod" 'function)) :int
(A :pointer)
(X :pointer)
(V :pointer)
(S :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_SV_decomp_mod" 'function))
(cffi:defcfun ("gsl_linalg_SV_decomp_jacobi" #.(swig-lispify "gsl_linalg_SV_decomp_jacobi" 'function)) :int
(A :pointer)
(Q :pointer)
(S :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_SV_decomp_jacobi" 'function))
(cffi:defcfun ("gsl_linalg_SV_solve" #.(swig-lispify "gsl_linalg_SV_solve" 'function)) :int
(U :pointer)
(Q :pointer)
(S :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_SV_solve" 'function))
(cffi:defcfun ("gsl_linalg_SV_leverage" #.(swig-lispify "gsl_linalg_SV_leverage" 'function)) :int
(U :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_SV_leverage" 'function))
(cffi:defcfun ("gsl_linalg_LU_decomp" #.(swig-lispify "gsl_linalg_LU_decomp" 'function)) :int
(A :pointer)
(p :pointer)
(signum :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_decomp" 'function))
(cffi:defcfun ("gsl_linalg_LU_solve" #.(swig-lispify "gsl_linalg_LU_solve" 'function)) :int
(LU :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_solve" 'function))
(cffi:defcfun ("gsl_linalg_LU_svx" #.(swig-lispify "gsl_linalg_LU_svx" 'function)) :int
(LU :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_svx" 'function))
(cffi:defcfun ("gsl_linalg_LU_refine" #.(swig-lispify "gsl_linalg_LU_refine" 'function)) :int
(A :pointer)
(LU :pointer)
(p :pointer)
(b :pointer)
(x :pointer)
(residual :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_refine" 'function))
(cffi:defcfun ("gsl_linalg_LU_invert" #.(swig-lispify "gsl_linalg_LU_invert" 'function)) :int
(LU :pointer)
(p :pointer)
(inverse :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_invert" 'function))
(cffi:defcfun ("gsl_linalg_LU_det" #.(swig-lispify "gsl_linalg_LU_det" 'function)) :double
(LU :pointer)
(signum :int))
(cl:export '#.(swig-lispify "gsl_linalg_LU_det" 'function))
(cffi:defcfun ("gsl_linalg_LU_lndet" #.(swig-lispify "gsl_linalg_LU_lndet" 'function)) :double
(LU :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LU_lndet" 'function))
(cffi:defcfun ("gsl_linalg_LU_sgndet" #.(swig-lispify "gsl_linalg_LU_sgndet" 'function)) :int
(lu :pointer)
(signum :int))
(cl:export '#.(swig-lispify "gsl_linalg_LU_sgndet" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_decomp" #.(swig-lispify "gsl_linalg_complex_LU_decomp" 'function)) :int
(A :pointer)
(p :pointer)
(signum :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_decomp" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_solve" #.(swig-lispify "gsl_linalg_complex_LU_solve" 'function)) :int
(LU :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_solve" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_svx" #.(swig-lispify "gsl_linalg_complex_LU_svx" 'function)) :int
(LU :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_svx" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_refine" #.(swig-lispify "gsl_linalg_complex_LU_refine" 'function)) :int
(A :pointer)
(LU :pointer)
(p :pointer)
(b :pointer)
(x :pointer)
(residual :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_refine" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_invert" #.(swig-lispify "gsl_linalg_complex_LU_invert" 'function)) :int
(LU :pointer)
(p :pointer)
(inverse :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_invert" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_det" #.(swig-lispify "gsl_linalg_complex_LU_det" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(LU :pointer)
(signum :int))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_det" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_lndet" #.(swig-lispify "gsl_linalg_complex_LU_lndet" 'function)) :double
(LU :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_lndet" 'function))
(cffi:defcfun ("gsl_linalg_complex_LU_sgndet" #.(swig-lispify "gsl_linalg_complex_LU_sgndet" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(LU :pointer)
(signum :int))
(cl:export '#.(swig-lispify "gsl_linalg_complex_LU_sgndet" 'function))
(cffi:defcfun ("gsl_linalg_QR_decomp" #.(swig-lispify "gsl_linalg_QR_decomp" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_decomp" 'function))
(cffi:defcfun ("gsl_linalg_QR_solve" #.(swig-lispify "gsl_linalg_QR_solve" 'function)) :int
(QR :pointer)
(tau :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_solve" 'function))
(cffi:defcfun ("gsl_linalg_QR_svx" #.(swig-lispify "gsl_linalg_QR_svx" 'function)) :int
(QR :pointer)
(tau :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_svx" 'function))
(cffi:defcfun ("gsl_linalg_QR_lssolve" #.(swig-lispify "gsl_linalg_QR_lssolve" 'function)) :int
(QR :pointer)
(tau :pointer)
(b :pointer)
(x :pointer)
(residual :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_lssolve" 'function))
(cffi:defcfun ("gsl_linalg_QR_QRsolve" #.(swig-lispify "gsl_linalg_QR_QRsolve" 'function)) :int
(Q :pointer)
(R :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_QRsolve" 'function))
(cffi:defcfun ("gsl_linalg_QR_Rsolve" #.(swig-lispify "gsl_linalg_QR_Rsolve" 'function)) :int
(QR :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_Rsolve" 'function))
(cffi:defcfun ("gsl_linalg_QR_Rsvx" #.(swig-lispify "gsl_linalg_QR_Rsvx" 'function)) :int
(QR :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_Rsvx" 'function))
(cffi:defcfun ("gsl_linalg_QR_update" #.(swig-lispify "gsl_linalg_QR_update" 'function)) :int
(Q :pointer)
(R :pointer)
(w :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_update" 'function))
(cffi:defcfun ("gsl_linalg_QR_QTvec" #.(swig-lispify "gsl_linalg_QR_QTvec" 'function)) :int
(QR :pointer)
(tau :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_QTvec" 'function))
(cffi:defcfun ("gsl_linalg_QR_Qvec" #.(swig-lispify "gsl_linalg_QR_Qvec" 'function)) :int
(QR :pointer)
(tau :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_Qvec" 'function))
(cffi:defcfun ("gsl_linalg_QR_QTmat" #.(swig-lispify "gsl_linalg_QR_QTmat" 'function)) :int
(QR :pointer)
(tau :pointer)
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_QTmat" 'function))
(cffi:defcfun ("gsl_linalg_QR_unpack" #.(swig-lispify "gsl_linalg_QR_unpack" 'function)) :int
(QR :pointer)
(tau :pointer)
(Q :pointer)
(R :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QR_unpack" 'function))
(cffi:defcfun ("gsl_linalg_R_solve" #.(swig-lispify "gsl_linalg_R_solve" 'function)) :int
(R :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_R_solve" 'function))
(cffi:defcfun ("gsl_linalg_R_svx" #.(swig-lispify "gsl_linalg_R_svx" 'function)) :int
(R :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_R_svx" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_decomp" #.(swig-lispify "gsl_linalg_QRPT_decomp" 'function)) :int
(A :pointer)
(tau :pointer)
(p :pointer)
(signum :pointer)
(norm :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_decomp" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_decomp2" #.(swig-lispify "gsl_linalg_QRPT_decomp2" 'function)) :int
(A :pointer)
(q :pointer)
(r :pointer)
(tau :pointer)
(p :pointer)
(signum :pointer)
(norm :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_decomp2" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_solve" #.(swig-lispify "gsl_linalg_QRPT_solve" 'function)) :int
(QR :pointer)
(tau :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_solve" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_svx" #.(swig-lispify "gsl_linalg_QRPT_svx" 'function)) :int
(QR :pointer)
(tau :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_svx" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_QRsolve" #.(swig-lispify "gsl_linalg_QRPT_QRsolve" 'function)) :int
(Q :pointer)
(R :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_QRsolve" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_Rsolve" #.(swig-lispify "gsl_linalg_QRPT_Rsolve" 'function)) :int
(QR :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_Rsolve" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_Rsvx" #.(swig-lispify "gsl_linalg_QRPT_Rsvx" 'function)) :int
(QR :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_Rsvx" 'function))
(cffi:defcfun ("gsl_linalg_QRPT_update" #.(swig-lispify "gsl_linalg_QRPT_update" 'function)) :int
(Q :pointer)
(R :pointer)
(p :pointer)
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_QRPT_update" 'function))
(cffi:defcfun ("gsl_linalg_LQ_decomp" #.(swig-lispify "gsl_linalg_LQ_decomp" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_decomp" 'function))
(cffi:defcfun ("gsl_linalg_LQ_solve_T" #.(swig-lispify "gsl_linalg_LQ_solve_T" 'function)) :int
(LQ :pointer)
(tau :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_solve_T" 'function))
(cffi:defcfun ("gsl_linalg_LQ_svx_T" #.(swig-lispify "gsl_linalg_LQ_svx_T" 'function)) :int
(LQ :pointer)
(tau :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_svx_T" 'function))
(cffi:defcfun ("gsl_linalg_LQ_lssolve_T" #.(swig-lispify "gsl_linalg_LQ_lssolve_T" 'function)) :int
(LQ :pointer)
(tau :pointer)
(b :pointer)
(x :pointer)
(residual :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_lssolve_T" 'function))
(cffi:defcfun ("gsl_linalg_LQ_Lsolve_T" #.(swig-lispify "gsl_linalg_LQ_Lsolve_T" 'function)) :int
(LQ :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_Lsolve_T" 'function))
(cffi:defcfun ("gsl_linalg_LQ_Lsvx_T" #.(swig-lispify "gsl_linalg_LQ_Lsvx_T" 'function)) :int
(LQ :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_Lsvx_T" 'function))
(cffi:defcfun ("gsl_linalg_L_solve_T" #.(swig-lispify "gsl_linalg_L_solve_T" 'function)) :int
(L :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_L_solve_T" 'function))
(cffi:defcfun ("gsl_linalg_LQ_vecQ" #.(swig-lispify "gsl_linalg_LQ_vecQ" 'function)) :int
(LQ :pointer)
(tau :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_vecQ" 'function))
(cffi:defcfun ("gsl_linalg_LQ_vecQT" #.(swig-lispify "gsl_linalg_LQ_vecQT" 'function)) :int
(LQ :pointer)
(tau :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_vecQT" 'function))
(cffi:defcfun ("gsl_linalg_LQ_unpack" #.(swig-lispify "gsl_linalg_LQ_unpack" 'function)) :int
(LQ :pointer)
(tau :pointer)
(Q :pointer)
(L :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_unpack" 'function))
(cffi:defcfun ("gsl_linalg_LQ_update" #.(swig-lispify "gsl_linalg_LQ_update" 'function)) :int
(Q :pointer)
(R :pointer)
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_update" 'function))
(cffi:defcfun ("gsl_linalg_LQ_LQsolve" #.(swig-lispify "gsl_linalg_LQ_LQsolve" 'function)) :int
(Q :pointer)
(L :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_LQ_LQsolve" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_decomp" #.(swig-lispify "gsl_linalg_PTLQ_decomp" 'function)) :int
(A :pointer)
(tau :pointer)
(p :pointer)
(signum :pointer)
(norm :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_decomp" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_decomp2" #.(swig-lispify "gsl_linalg_PTLQ_decomp2" 'function)) :int
(A :pointer)
(q :pointer)
(r :pointer)
(tau :pointer)
(p :pointer)
(signum :pointer)
(norm :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_decomp2" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_solve_T" #.(swig-lispify "gsl_linalg_PTLQ_solve_T" 'function)) :int
(QR :pointer)
(tau :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_solve_T" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_svx_T" #.(swig-lispify "gsl_linalg_PTLQ_svx_T" 'function)) :int
(LQ :pointer)
(tau :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_svx_T" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_LQsolve_T" #.(swig-lispify "gsl_linalg_PTLQ_LQsolve_T" 'function)) :int
(Q :pointer)
(L :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_LQsolve_T" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_Lsolve_T" #.(swig-lispify "gsl_linalg_PTLQ_Lsolve_T" 'function)) :int
(LQ :pointer)
(p :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_Lsolve_T" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_Lsvx_T" #.(swig-lispify "gsl_linalg_PTLQ_Lsvx_T" 'function)) :int
(LQ :pointer)
(p :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_Lsvx_T" 'function))
(cffi:defcfun ("gsl_linalg_PTLQ_update" #.(swig-lispify "gsl_linalg_PTLQ_update" 'function)) :int
(Q :pointer)
(L :pointer)
(p :pointer)
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_PTLQ_update" 'function))
(cffi:defcfun ("gsl_linalg_cholesky_decomp" #.(swig-lispify "gsl_linalg_cholesky_decomp" 'function)) :int
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_cholesky_decomp" 'function))
(cffi:defcfun ("gsl_linalg_cholesky_solve" #.(swig-lispify "gsl_linalg_cholesky_solve" 'function)) :int
(cholesky :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_cholesky_solve" 'function))
(cffi:defcfun ("gsl_linalg_cholesky_svx" #.(swig-lispify "gsl_linalg_cholesky_svx" 'function)) :int
(cholesky :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_cholesky_svx" 'function))
(cffi:defcfun ("gsl_linalg_cholesky_invert" #.(swig-lispify "gsl_linalg_cholesky_invert" 'function)) :int
(cholesky :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_cholesky_invert" 'function))
(cffi:defcfun ("gsl_linalg_cholesky_decomp_unit" #.(swig-lispify "gsl_linalg_cholesky_decomp_unit" 'function)) :int
(A :pointer)
(D :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_cholesky_decomp_unit" 'function))
(cffi:defcfun ("gsl_linalg_complex_cholesky_decomp" #.(swig-lispify "gsl_linalg_complex_cholesky_decomp" 'function)) :int
(A :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_cholesky_decomp" 'function))
(cffi:defcfun ("gsl_linalg_complex_cholesky_solve" #.(swig-lispify "gsl_linalg_complex_cholesky_solve" 'function)) :int
(cholesky :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_cholesky_solve" 'function))
(cffi:defcfun ("gsl_linalg_complex_cholesky_svx" #.(swig-lispify "gsl_linalg_complex_cholesky_svx" 'function)) :int
(cholesky :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_cholesky_svx" 'function))
(cffi:defcfun ("gsl_linalg_complex_cholesky_invert" #.(swig-lispify "gsl_linalg_complex_cholesky_invert" 'function)) :int
(cholesky :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_complex_cholesky_invert" 'function))
(cffi:defcfun ("gsl_linalg_symmtd_decomp" #.(swig-lispify "gsl_linalg_symmtd_decomp" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_symmtd_decomp" 'function))
(cffi:defcfun ("gsl_linalg_symmtd_unpack" #.(swig-lispify "gsl_linalg_symmtd_unpack" 'function)) :int
(A :pointer)
(tau :pointer)
(Q :pointer)
(diag :pointer)
(subdiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_symmtd_unpack" 'function))
(cffi:defcfun ("gsl_linalg_symmtd_unpack_T" #.(swig-lispify "gsl_linalg_symmtd_unpack_T" 'function)) :int
(A :pointer)
(diag :pointer)
(subdiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_symmtd_unpack_T" 'function))
(cffi:defcfun ("gsl_linalg_hermtd_decomp" #.(swig-lispify "gsl_linalg_hermtd_decomp" 'function)) :int
(A :pointer)
(tau :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hermtd_decomp" 'function))
(cffi:defcfun ("gsl_linalg_hermtd_unpack" #.(swig-lispify "gsl_linalg_hermtd_unpack" 'function)) :int
(A :pointer)
(tau :pointer)
(U :pointer)
(diag :pointer)
(sudiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hermtd_unpack" 'function))
(cffi:defcfun ("gsl_linalg_hermtd_unpack_T" #.(swig-lispify "gsl_linalg_hermtd_unpack_T" 'function)) :int
(A :pointer)
(diag :pointer)
(subdiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_hermtd_unpack_T" 'function))
(cffi:defcfun ("gsl_linalg_HH_solve" #.(swig-lispify "gsl_linalg_HH_solve" 'function)) :int
(A :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_HH_solve" 'function))
(cffi:defcfun ("gsl_linalg_HH_svx" #.(swig-lispify "gsl_linalg_HH_svx" 'function)) :int
(A :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_HH_svx" 'function))
(cffi:defcfun ("gsl_linalg_solve_symm_tridiag" #.(swig-lispify "gsl_linalg_solve_symm_tridiag" 'function)) :int
(diag :pointer)
(offdiag :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_solve_symm_tridiag" 'function))
(cffi:defcfun ("gsl_linalg_solve_tridiag" #.(swig-lispify "gsl_linalg_solve_tridiag" 'function)) :int
(diag :pointer)
(abovediag :pointer)
(belowdiag :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_solve_tridiag" 'function))
(cffi:defcfun ("gsl_linalg_solve_symm_cyc_tridiag" #.(swig-lispify "gsl_linalg_solve_symm_cyc_tridiag" 'function)) :int
(diag :pointer)
(offdiag :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_solve_symm_cyc_tridiag" 'function))
(cffi:defcfun ("gsl_linalg_solve_cyc_tridiag" #.(swig-lispify "gsl_linalg_solve_cyc_tridiag" 'function)) :int
(diag :pointer)
(abovediag :pointer)
(belowdiag :pointer)
(b :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_solve_cyc_tridiag" 'function))
(cffi:defcfun ("gsl_linalg_bidiag_decomp" #.(swig-lispify "gsl_linalg_bidiag_decomp" 'function)) :int
(A :pointer)
(tau_U :pointer)
(tau_V :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_bidiag_decomp" 'function))
(cffi:defcfun ("gsl_linalg_bidiag_unpack" #.(swig-lispify "gsl_linalg_bidiag_unpack" 'function)) :int
(A :pointer)
(tau_U :pointer)
(U :pointer)
(tau_V :pointer)
(V :pointer)
(diag :pointer)
(superdiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_bidiag_unpack" 'function))
(cffi:defcfun ("gsl_linalg_bidiag_unpack2" #.(swig-lispify "gsl_linalg_bidiag_unpack2" 'function)) :int
(A :pointer)
(tau_U :pointer)
(tau_V :pointer)
(V :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_bidiag_unpack2" 'function))
(cffi:defcfun ("gsl_linalg_bidiag_unpack_B" #.(swig-lispify "gsl_linalg_bidiag_unpack_B" 'function)) :int
(A :pointer)
(diag :pointer)
(superdiag :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_bidiag_unpack_B" 'function))
(cffi:defcfun ("gsl_linalg_balance_matrix" #.(swig-lispify "gsl_linalg_balance_matrix" 'function)) :int
(A :pointer)
(D :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_balance_matrix" 'function))
(cffi:defcfun ("gsl_linalg_balance_accum" #.(swig-lispify "gsl_linalg_balance_accum" 'function)) :int
(A :pointer)
(D :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_balance_accum" 'function))
(cffi:defcfun ("gsl_linalg_balance_columns" #.(swig-lispify "gsl_linalg_balance_columns" 'function)) :int
(A :pointer)
(D :pointer))
(cl:export '#.(swig-lispify "gsl_linalg_balance_columns" 'function))
(cl:defconstant #.(swig-lispify "GSL_DBL_EPSILON" 'constant) 2.2204460492503131d-16)
(cl:export '#.(swig-lispify "GSL_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_DBL_EPSILON" 'constant) 1.4901161193847656d-08)
(cl:export '#.(swig-lispify "GSL_SQRT_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_DBL_EPSILON" 'constant) 6.0554544523933429d-06)
(cl:export '#.(swig-lispify "GSL_ROOT3_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_DBL_EPSILON" 'constant) 1.2207031250000000d-04)
(cl:export '#.(swig-lispify "GSL_ROOT4_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_DBL_EPSILON" 'constant) 7.4009597974140505d-04)
(cl:export '#.(swig-lispify "GSL_ROOT5_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_DBL_EPSILON" 'constant) 2.4607833005759251d-03)
(cl:export '#.(swig-lispify "GSL_ROOT6_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_DBL_EPSILON" 'constant) -3.6043653389117154d+01)
(cl:export '#.(swig-lispify "GSL_LOG_DBL_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_DBL_MIN" 'constant) 2.2250738585072014d-308)
(cl:export '#.(swig-lispify "GSL_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_DBL_MIN" 'constant) 1.4916681462400413d-154)
(cl:export '#.(swig-lispify "GSL_SQRT_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_DBL_MIN" 'constant) 2.8126442852362996d-103)
(cl:export '#.(swig-lispify "GSL_ROOT3_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_DBL_MIN" 'constant) 1.2213386697554620d-77)
(cl:export '#.(swig-lispify "GSL_ROOT4_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_DBL_MIN" 'constant) 2.9476022969691763d-62)
(cl:export '#.(swig-lispify "GSL_ROOT5_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_DBL_MIN" 'constant) 5.3034368905798218d-52)
(cl:export '#.(swig-lispify "GSL_ROOT6_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_DBL_MIN" 'constant) -7.0839641853226408d+02)
(cl:export '#.(swig-lispify "GSL_LOG_DBL_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_DBL_MAX" 'constant) 1.7976931348623157d+308)
(cl:export '#.(swig-lispify "GSL_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_DBL_MAX" 'constant) 1.3407807929942596d+154)
(cl:export '#.(swig-lispify "GSL_SQRT_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_DBL_MAX" 'constant) 5.6438030941222897d+102)
(cl:export '#.(swig-lispify "GSL_ROOT3_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_DBL_MAX" 'constant) 1.1579208923731620d+77)
(cl:export '#.(swig-lispify "GSL_ROOT4_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_DBL_MAX" 'constant) 4.4765466227572707d+61)
(cl:export '#.(swig-lispify "GSL_ROOT5_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_DBL_MAX" 'constant) 2.3756689782295612d+51)
(cl:export '#.(swig-lispify "GSL_ROOT6_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_DBL_MAX" 'constant) 7.0978271289338397d+02)
(cl:export '#.(swig-lispify "GSL_LOG_DBL_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_FLT_EPSILON" 'constant) 1.1920928955078125d-07)
(cl:export '#.(swig-lispify "GSL_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_FLT_EPSILON" 'constant) 3.4526698300124393d-04)
(cl:export '#.(swig-lispify "GSL_SQRT_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_FLT_EPSILON" 'constant) 4.9215666011518501d-03)
(cl:export '#.(swig-lispify "GSL_ROOT3_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_FLT_EPSILON" 'constant) 1.8581361171917516d-02)
(cl:export '#.(swig-lispify "GSL_ROOT4_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_FLT_EPSILON" 'constant) 4.1234622211652937d-02)
(cl:export '#.(swig-lispify "GSL_ROOT5_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_FLT_EPSILON" 'constant) 7.0153878019335827d-02)
(cl:export '#.(swig-lispify "GSL_ROOT6_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_FLT_EPSILON" 'constant) -1.5942385152878742d+01)
(cl:export '#.(swig-lispify "GSL_LOG_FLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_FLT_MIN" 'constant) 1.1754943508222875d-38)
(cl:export '#.(swig-lispify "GSL_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_FLT_MIN" 'constant) 1.0842021724855044d-19)
(cl:export '#.(swig-lispify "GSL_SQRT_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_FLT_MIN" 'constant) 2.2737367544323241d-13)
(cl:export '#.(swig-lispify "GSL_ROOT3_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_FLT_MIN" 'constant) 3.2927225399135965d-10)
(cl:export '#.(swig-lispify "GSL_ROOT4_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_FLT_MIN" 'constant) 2.5944428542140822d-08)
(cl:export '#.(swig-lispify "GSL_ROOT5_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_FLT_MIN" 'constant) 4.7683715820312542d-07)
(cl:export '#.(swig-lispify "GSL_ROOT6_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_FLT_MIN" 'constant) -8.7336544750553102d+01)
(cl:export '#.(swig-lispify "GSL_LOG_FLT_MIN" 'constant))
(cl:defconstant #.(swig-lispify "GSL_FLT_MAX" 'constant) 3.4028234663852886d+38)
(cl:export '#.(swig-lispify "GSL_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_FLT_MAX" 'constant) 1.8446743523953730d+19)
(cl:export '#.(swig-lispify "GSL_SQRT_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_FLT_MAX" 'constant) 6.9814635196223242d+12)
(cl:export '#.(swig-lispify "GSL_ROOT3_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_FLT_MAX" 'constant) 4.2949672319999986d+09)
(cl:export '#.(swig-lispify "GSL_ROOT4_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_FLT_MAX" 'constant) 5.0859007855960041d+07)
(cl:export '#.(swig-lispify "GSL_ROOT5_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_FLT_MAX" 'constant) 2.6422459233807749d+06)
(cl:export '#.(swig-lispify "GSL_ROOT6_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_FLT_MAX" 'constant) 8.8722839052068352d+01)
(cl:export '#.(swig-lispify "GSL_LOG_FLT_MAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SFLT_EPSILON" 'constant) 4.8828125000000000d-04)
(cl:export '#.(swig-lispify "GSL_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_SFLT_EPSILON" 'constant) 2.2097086912079612d-02)
(cl:export '#.(swig-lispify "GSL_SQRT_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_SFLT_EPSILON" 'constant) 7.8745065618429588d-02)
(cl:export '#.(swig-lispify "GSL_ROOT3_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_SFLT_EPSILON" 'constant) 1.4865088937534013d-01)
(cl:export '#.(swig-lispify "GSL_ROOT4_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_SFLT_EPSILON" 'constant) 2.1763764082403100d-01)
(cl:export '#.(swig-lispify "GSL_ROOT5_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_SFLT_EPSILON" 'constant) 2.8061551207734325d-01)
(cl:export '#.(swig-lispify "GSL_ROOT6_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_SFLT_EPSILON" 'constant) -7.6246189861593985d+00)
(cl:export '#.(swig-lispify "GSL_LOG_SFLT_EPSILON" 'constant))
(cl:defconstant #.(swig-lispify "GSL_MACH_EPS" 'constant) 2.2204460492503131d-16)
(cl:export '#.(swig-lispify "GSL_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SQRT_MACH_EPS" 'constant) 3.2d-08)
(cl:export '#.(swig-lispify "GSL_SQRT_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT3_MACH_EPS" 'constant) 1.0d-05)
(cl:export '#.(swig-lispify "GSL_ROOT3_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT4_MACH_EPS" 'constant) 0.000178d0)
(cl:export '#.(swig-lispify "GSL_ROOT4_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT5_MACH_EPS" 'constant) 0.00100d0)
(cl:export '#.(swig-lispify "GSL_ROOT5_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ROOT6_MACH_EPS" 'constant) 0.00316d0)
(cl:export '#.(swig-lispify "GSL_ROOT6_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "GSL_LOG_MACH_EPS" 'constant) -34.54d0)
(cl:export '#.(swig-lispify "GSL_LOG_MACH_EPS" 'constant))
(cl:defconstant #.(swig-lispify "M_E" 'constant) 2.71828182845904523536028747135d0)
(cl:export '#.(swig-lispify "M_E" 'constant))
(cl:defconstant #.(swig-lispify "M_LOG2E" 'constant) 1.44269504088896340735992468100d0)
(cl:export '#.(swig-lispify "M_LOG2E" 'constant))
(cl:defconstant #.(swig-lispify "M_LOG10E" 'constant) 0.43429448190325182765112891892d0)
(cl:export '#.(swig-lispify "M_LOG10E" 'constant))
(cl:defconstant #.(swig-lispify "M_SQRT2" 'constant) 1.41421356237309504880168872421d0)
(cl:export '#.(swig-lispify "M_SQRT2" 'constant))
(cl:defconstant #.(swig-lispify "M_SQRT1_2" 'constant) 0.70710678118654752440084436210d0)
(cl:export '#.(swig-lispify "M_SQRT1_2" 'constant))
(cl:defconstant #.(swig-lispify "M_SQRT3" 'constant) 1.73205080756887729352744634151d0)
(cl:export '#.(swig-lispify "M_SQRT3" 'constant))
(cl:defconstant #.(swig-lispify "M_PI" 'constant) 3.14159265358979323846264338328d0)
(cl:export '#.(swig-lispify "M_PI" 'constant))
(cl:defconstant #.(swig-lispify "M_PI_2" 'constant) 1.57079632679489661923132169164d0)
(cl:export '#.(swig-lispify "M_PI_2" 'constant))
(cl:defconstant #.(swig-lispify "M_PI_4" 'constant) 0.78539816339744830961566084582d0)
(cl:export '#.(swig-lispify "M_PI_4" 'constant))
(cl:defconstant #.(swig-lispify "M_SQRTPI" 'constant) 1.77245385090551602729816748334d0)
(cl:export '#.(swig-lispify "M_SQRTPI" 'constant))
(cl:defconstant #.(swig-lispify "M_2_SQRTPI" 'constant) 1.12837916709551257389615890312d0)
(cl:export '#.(swig-lispify "M_2_SQRTPI" 'constant))
(cl:defconstant #.(swig-lispify "M_1_PI" 'constant) 0.31830988618379067153776752675d0)
(cl:export '#.(swig-lispify "M_1_PI" 'constant))
(cl:defconstant #.(swig-lispify "M_2_PI" 'constant) 0.63661977236758134307553505349d0)
(cl:export '#.(swig-lispify "M_2_PI" 'constant))
(cl:defconstant #.(swig-lispify "M_LN10" 'constant) 2.30258509299404568401799145468d0)
(cl:export '#.(swig-lispify "M_LN10" 'constant))
(cl:defconstant #.(swig-lispify "M_LN2" 'constant) 0.69314718055994530941723212146d0)
(cl:export '#.(swig-lispify "M_LN2" 'constant))
(cl:defconstant #.(swig-lispify "M_LNPI" 'constant) 1.14472988584940017414342735135d0)
(cl:export '#.(swig-lispify "M_LNPI" 'constant))
(cl:defconstant #.(swig-lispify "M_EULER" 'constant) 0.57721566490153286060651209008d0)
(cl:export '#.(swig-lispify "M_EULER" 'constant))
(cffi:defcstruct #.(swig-lispify "gsl_function_struct" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_function_struct" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_function_fdf_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "df" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_function_fdf_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "df" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_function_vec_struct" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_function_vec_struct" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_char" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :string)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_char" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_char" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_char_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_char" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_char_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_char_alloc" #.(swig-lispify "gsl_matrix_char_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_alloc" 'function))
(cffi:defcfun ("gsl_matrix_char_calloc" #.(swig-lispify "gsl_matrix_char_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_calloc" 'function))
(cffi:defcfun ("gsl_matrix_char_alloc_from_block" #.(swig-lispify "gsl_matrix_char_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_char_alloc_from_matrix" #.(swig-lispify "gsl_matrix_char_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_char_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_char_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_char_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_char_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_char_free" #.(swig-lispify "gsl_matrix_char_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_free" 'function))
(cffi:defcfun ("gsl_matrix_char_submatrix" #.(swig-lispify "gsl_matrix_char_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_char_row" #.(swig-lispify "gsl_matrix_char_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_row" 'function))
(cffi:defcfun ("gsl_matrix_char_column" #.(swig-lispify "gsl_matrix_char_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_column" 'function))
(cffi:defcfun ("gsl_matrix_char_diagonal" #.(swig-lispify "gsl_matrix_char_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_subdiagonal" #.(swig-lispify "gsl_matrix_char_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_superdiagonal" #.(swig-lispify "gsl_matrix_char_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_subrow" #.(swig-lispify "gsl_matrix_char_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_subrow" 'function))
(cffi:defcfun ("gsl_matrix_char_subcolumn" #.(swig-lispify "gsl_matrix_char_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_char_view_array" #.(swig-lispify "gsl_matrix_char_view_array" 'function)) #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(base :string)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_view_array" 'function))
(cffi:defcfun ("gsl_matrix_char_view_array_with_tda" #.(swig-lispify "gsl_matrix_char_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(base :string)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_char_view_vector" #.(swig-lispify "gsl_matrix_char_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_char_view_vector_with_tda" #.(swig-lispify "gsl_matrix_char_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_char_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_char_const_submatrix" #.(swig-lispify "gsl_matrix_char_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_char_const_row" #.(swig-lispify "gsl_matrix_char_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_row" 'function))
(cffi:defcfun ("gsl_matrix_char_const_column" #.(swig-lispify "gsl_matrix_char_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_column" 'function))
(cffi:defcfun ("gsl_matrix_char_const_diagonal" #.(swig-lispify "gsl_matrix_char_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_const_subdiagonal" #.(swig-lispify "gsl_matrix_char_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_const_superdiagonal" #.(swig-lispify "gsl_matrix_char_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_const_subrow" #.(swig-lispify "gsl_matrix_char_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_char_const_subcolumn" #.(swig-lispify "gsl_matrix_char_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_char_const_view_array" #.(swig-lispify "gsl_matrix_char_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(base :string)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_char_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_char_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(base :string)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_char_const_view_vector" #.(swig-lispify "gsl_matrix_char_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_char_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_char_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_char_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_char_set_zero" #.(swig-lispify "gsl_matrix_char_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_char_set_identity" #.(swig-lispify "gsl_matrix_char_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_char_set_all" #.(swig-lispify "gsl_matrix_char_set_all" 'function)) :void
(m :pointer)
(x :char))
(cl:export '#.(swig-lispify "gsl_matrix_char_set_all" 'function))
(cffi:defcfun ("gsl_matrix_char_fread" #.(swig-lispify "gsl_matrix_char_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_fread" 'function))
(cffi:defcfun ("gsl_matrix_char_fwrite" #.(swig-lispify "gsl_matrix_char_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_char_fscanf" #.(swig-lispify "gsl_matrix_char_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_char_fprintf" #.(swig-lispify "gsl_matrix_char_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_char_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_char_memcpy" #.(swig-lispify "gsl_matrix_char_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_char_swap" #.(swig-lispify "gsl_matrix_char_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_swap" 'function))
(cffi:defcfun ("gsl_matrix_char_swap_rows" #.(swig-lispify "gsl_matrix_char_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_char_swap_columns" #.(swig-lispify "gsl_matrix_char_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_char_swap_rowcol" #.(swig-lispify "gsl_matrix_char_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_char_transpose" #.(swig-lispify "gsl_matrix_char_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_transpose" 'function))
(cffi:defcfun ("gsl_matrix_char_transpose_memcpy" #.(swig-lispify "gsl_matrix_char_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_char_max" #.(swig-lispify "gsl_matrix_char_max" 'function)) :char
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_max" 'function))
(cffi:defcfun ("gsl_matrix_char_min" #.(swig-lispify "gsl_matrix_char_min" 'function)) :char
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_min" 'function))
(cffi:defcfun ("gsl_matrix_char_minmax" #.(swig-lispify "gsl_matrix_char_minmax" 'function)) :void
(m :pointer)
(min_out :string)
(max_out :string))
(cl:export '#.(swig-lispify "gsl_matrix_char_minmax" 'function))
(cffi:defcfun ("gsl_matrix_char_max_index" #.(swig-lispify "gsl_matrix_char_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_max_index" 'function))
(cffi:defcfun ("gsl_matrix_char_min_index" #.(swig-lispify "gsl_matrix_char_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_min_index" 'function))
(cffi:defcfun ("gsl_matrix_char_minmax_index" #.(swig-lispify "gsl_matrix_char_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_char_equal" #.(swig-lispify "gsl_matrix_char_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_equal" 'function))
(cffi:defcfun ("gsl_matrix_char_isnull" #.(swig-lispify "gsl_matrix_char_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_isnull" 'function))
(cffi:defcfun ("gsl_matrix_char_ispos" #.(swig-lispify "gsl_matrix_char_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_ispos" 'function))
(cffi:defcfun ("gsl_matrix_char_isneg" #.(swig-lispify "gsl_matrix_char_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_isneg" 'function))
(cffi:defcfun ("gsl_matrix_char_isnonneg" #.(swig-lispify "gsl_matrix_char_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_char_add" #.(swig-lispify "gsl_matrix_char_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_add" 'function))
(cffi:defcfun ("gsl_matrix_char_sub" #.(swig-lispify "gsl_matrix_char_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_sub" 'function))
(cffi:defcfun ("gsl_matrix_char_mul_elements" #.(swig-lispify "gsl_matrix_char_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_char_div_elements" #.(swig-lispify "gsl_matrix_char_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_char_scale" #.(swig-lispify "gsl_matrix_char_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_char_scale" 'function))
(cffi:defcfun ("gsl_matrix_char_add_constant" #.(swig-lispify "gsl_matrix_char_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_char_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_char_add_diagonal" #.(swig-lispify "gsl_matrix_char_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_char_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_char_get_row" #.(swig-lispify "gsl_matrix_char_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_get_row" 'function))
(cffi:defcfun ("gsl_matrix_char_get_col" #.(swig-lispify "gsl_matrix_char_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_get_col" 'function))
(cffi:defcfun ("gsl_matrix_char_set_row" #.(swig-lispify "gsl_matrix_char_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_set_row" 'function))
(cffi:defcfun ("gsl_matrix_char_set_col" #.(swig-lispify "gsl_matrix_char_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_set_col" 'function))
(cffi:defcfun ("gsl_matrix_char_get" #.(swig-lispify "gsl_matrix_char_get" 'function)) :char
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_get" 'function))
(cffi:defcfun ("gsl_matrix_char_set" #.(swig-lispify "gsl_matrix_char_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :char))
(cl:export '#.(swig-lispify "gsl_matrix_char_set" 'function))
(cffi:defcfun ("gsl_matrix_char_ptr" #.(swig-lispify "gsl_matrix_char_ptr" 'function)) :string
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_ptr" 'function))
(cffi:defcfun ("gsl_matrix_char_const_ptr" #.(swig-lispify "gsl_matrix_char_const_ptr" 'function)) :string
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_char_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_complex" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_complex" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_complex_alloc" #.(swig-lispify "gsl_matrix_complex_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_alloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_calloc" #.(swig-lispify "gsl_matrix_complex_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_calloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_alloc_from_block" #.(swig-lispify "gsl_matrix_complex_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_complex_alloc_from_matrix" #.(swig-lispify "gsl_matrix_complex_alloc_from_matrix" 'function)) :pointer
(b :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_complex_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_complex_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_free" #.(swig-lispify "gsl_matrix_complex_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_free" 'function))
(cffi:defcfun ("gsl_matrix_complex_submatrix" #.(swig-lispify "gsl_matrix_complex_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_row" #.(swig-lispify "gsl_matrix_complex_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_column" #.(swig-lispify "gsl_matrix_complex_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_diagonal" #.(swig-lispify "gsl_matrix_complex_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_subdiagonal" #.(swig-lispify "gsl_matrix_complex_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_superdiagonal" #.(swig-lispify "gsl_matrix_complex_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_subrow" #.(swig-lispify "gsl_matrix_complex_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_subcolumn" #.(swig-lispify "gsl_matrix_complex_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_view_array" #.(swig-lispify "gsl_matrix_complex_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_view_vector" #.(swig-lispify "gsl_matrix_complex_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_submatrix" #.(swig-lispify "gsl_matrix_complex_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_row" #.(swig-lispify "gsl_matrix_complex_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_column" #.(swig-lispify "gsl_matrix_complex_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_diagonal" #.(swig-lispify "gsl_matrix_complex_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_subdiagonal" #.(swig-lispify "gsl_matrix_complex_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_superdiagonal" #.(swig-lispify "gsl_matrix_complex_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_subrow" #.(swig-lispify "gsl_matrix_complex_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_subcolumn" #.(swig-lispify "gsl_matrix_complex_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_view_array" #.(swig-lispify "gsl_matrix_complex_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_view_vector" #.(swig-lispify "gsl_matrix_complex_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_set_zero" #.(swig-lispify "gsl_matrix_complex_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_complex_set_identity" #.(swig-lispify "gsl_matrix_complex_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_complex_set_all" #.(swig-lispify "gsl_matrix_complex_set_all" 'function)) :void
(m :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set_all" 'function))
(cffi:defcfun ("gsl_matrix_complex_fread" #.(swig-lispify "gsl_matrix_complex_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_fread" 'function))
(cffi:defcfun ("gsl_matrix_complex_fwrite" #.(swig-lispify "gsl_matrix_complex_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_complex_fscanf" #.(swig-lispify "gsl_matrix_complex_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_complex_fprintf" #.(swig-lispify "gsl_matrix_complex_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_complex_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_complex_memcpy" #.(swig-lispify "gsl_matrix_complex_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_swap" #.(swig-lispify "gsl_matrix_complex_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_swap" 'function))
(cffi:defcfun ("gsl_matrix_complex_swap_rows" #.(swig-lispify "gsl_matrix_complex_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_complex_swap_columns" #.(swig-lispify "gsl_matrix_complex_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_complex_swap_rowcol" #.(swig-lispify "gsl_matrix_complex_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_complex_transpose" #.(swig-lispify "gsl_matrix_complex_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_transpose" 'function))
(cffi:defcfun ("gsl_matrix_complex_transpose_memcpy" #.(swig-lispify "gsl_matrix_complex_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_equal" #.(swig-lispify "gsl_matrix_complex_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_equal" 'function))
(cffi:defcfun ("gsl_matrix_complex_isnull" #.(swig-lispify "gsl_matrix_complex_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_isnull" 'function))
(cffi:defcfun ("gsl_matrix_complex_ispos" #.(swig-lispify "gsl_matrix_complex_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_ispos" 'function))
(cffi:defcfun ("gsl_matrix_complex_isneg" #.(swig-lispify "gsl_matrix_complex_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_isneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_isnonneg" #.(swig-lispify "gsl_matrix_complex_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_add" #.(swig-lispify "gsl_matrix_complex_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_add" 'function))
(cffi:defcfun ("gsl_matrix_complex_sub" #.(swig-lispify "gsl_matrix_complex_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_sub" 'function))
(cffi:defcfun ("gsl_matrix_complex_mul_elements" #.(swig-lispify "gsl_matrix_complex_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_div_elements" #.(swig-lispify "gsl_matrix_complex_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_scale" #.(swig-lispify "gsl_matrix_complex_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_scale" 'function))
(cffi:defcfun ("gsl_matrix_complex_add_constant" #.(swig-lispify "gsl_matrix_complex_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_complex_add_diagonal" #.(swig-lispify "gsl_matrix_complex_add_diagonal" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_get_row" #.(swig-lispify "gsl_matrix_complex_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_get_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_get_col" #.(swig-lispify "gsl_matrix_complex_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_get_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_set_row" #.(swig-lispify "gsl_matrix_complex_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_set_col" #.(swig-lispify "gsl_matrix_complex_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_get" #.(swig-lispify "gsl_matrix_complex_get" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_get" 'function))
(cffi:defcfun ("gsl_matrix_complex_set" #.(swig-lispify "gsl_matrix_complex_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_set" 'function))
(cffi:defcfun ("gsl_matrix_complex_ptr" #.(swig-lispify "gsl_matrix_complex_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_ptr" 'function))
(cffi:defcfun ("gsl_matrix_complex_const_ptr" #.(swig-lispify "gsl_matrix_complex_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_complex_float" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_float_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_complex_float_alloc" #.(swig-lispify "gsl_matrix_complex_float_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_alloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_calloc" #.(swig-lispify "gsl_matrix_complex_float_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_calloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_alloc_from_block" #.(swig-lispify "gsl_matrix_complex_float_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_alloc_from_matrix" #.(swig-lispify "gsl_matrix_complex_float_alloc_from_matrix" 'function)) :pointer
(b :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_float_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_complex_float_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_float_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_complex_float_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_free" #.(swig-lispify "gsl_matrix_complex_float_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_free" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_submatrix" #.(swig-lispify "gsl_matrix_complex_float_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_row" #.(swig-lispify "gsl_matrix_complex_float_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_column" #.(swig-lispify "gsl_matrix_complex_float_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_diagonal" #.(swig-lispify "gsl_matrix_complex_float_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_subdiagonal" #.(swig-lispify "gsl_matrix_complex_float_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_superdiagonal" #.(swig-lispify "gsl_matrix_complex_float_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_subrow" #.(swig-lispify "gsl_matrix_complex_float_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_subcolumn" #.(swig-lispify "gsl_matrix_complex_float_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_view_array" #.(swig-lispify "gsl_matrix_complex_float_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_float_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_view_vector" #.(swig-lispify "gsl_matrix_complex_float_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_float_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_submatrix" #.(swig-lispify "gsl_matrix_complex_float_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_row" #.(swig-lispify "gsl_matrix_complex_float_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_column" #.(swig-lispify "gsl_matrix_complex_float_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_diagonal" #.(swig-lispify "gsl_matrix_complex_float_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_subdiagonal" #.(swig-lispify "gsl_matrix_complex_float_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_superdiagonal" #.(swig-lispify "gsl_matrix_complex_float_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_subrow" #.(swig-lispify "gsl_matrix_complex_float_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_subcolumn" #.(swig-lispify "gsl_matrix_complex_float_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_view_array" #.(swig-lispify "gsl_matrix_complex_float_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_float_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_view_vector" #.(swig-lispify "gsl_matrix_complex_float_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_float_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_float_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set_zero" #.(swig-lispify "gsl_matrix_complex_float_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set_identity" #.(swig-lispify "gsl_matrix_complex_float_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set_all" #.(swig-lispify "gsl_matrix_complex_float_set_all" 'function)) :void
(m :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set_all" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_fread" #.(swig-lispify "gsl_matrix_complex_float_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_fread" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_fwrite" #.(swig-lispify "gsl_matrix_complex_float_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_fscanf" #.(swig-lispify "gsl_matrix_complex_float_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_fprintf" #.(swig-lispify "gsl_matrix_complex_float_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_memcpy" #.(swig-lispify "gsl_matrix_complex_float_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_swap" #.(swig-lispify "gsl_matrix_complex_float_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_swap" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_swap_rows" #.(swig-lispify "gsl_matrix_complex_float_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_swap_columns" #.(swig-lispify "gsl_matrix_complex_float_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_swap_rowcol" #.(swig-lispify "gsl_matrix_complex_float_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_transpose" #.(swig-lispify "gsl_matrix_complex_float_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_transpose" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_transpose_memcpy" #.(swig-lispify "gsl_matrix_complex_float_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_equal" #.(swig-lispify "gsl_matrix_complex_float_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_equal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_isnull" #.(swig-lispify "gsl_matrix_complex_float_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_isnull" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_ispos" #.(swig-lispify "gsl_matrix_complex_float_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_ispos" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_isneg" #.(swig-lispify "gsl_matrix_complex_float_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_isneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_isnonneg" #.(swig-lispify "gsl_matrix_complex_float_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_add" #.(swig-lispify "gsl_matrix_complex_float_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_add" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_sub" #.(swig-lispify "gsl_matrix_complex_float_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_sub" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_mul_elements" #.(swig-lispify "gsl_matrix_complex_float_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_div_elements" #.(swig-lispify "gsl_matrix_complex_float_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_scale" #.(swig-lispify "gsl_matrix_complex_float_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_scale" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_add_constant" #.(swig-lispify "gsl_matrix_complex_float_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_add_diagonal" #.(swig-lispify "gsl_matrix_complex_float_add_diagonal" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_get_row" #.(swig-lispify "gsl_matrix_complex_float_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_get_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_get_col" #.(swig-lispify "gsl_matrix_complex_float_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_get_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set_row" #.(swig-lispify "gsl_matrix_complex_float_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set_col" #.(swig-lispify "gsl_matrix_complex_float_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_get" #.(swig-lispify "gsl_matrix_complex_float_get" 'function)) #.(swig-lispify "gsl_complex_float" 'classname)
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_get" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_set" #.(swig-lispify "gsl_matrix_complex_float_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_set" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_ptr" #.(swig-lispify "gsl_matrix_complex_float_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_ptr" 'function))
(cffi:defcfun ("gsl_matrix_complex_float_const_ptr" #.(swig-lispify "gsl_matrix_complex_float_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_float_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_complex_long_double" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_complex_long_double_alloc" #.(swig-lispify "gsl_matrix_complex_long_double_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_alloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_calloc" #.(swig-lispify "gsl_matrix_complex_long_double_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_calloc" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_alloc_from_block" #.(swig-lispify "gsl_matrix_complex_long_double_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_alloc_from_matrix" #.(swig-lispify "gsl_matrix_complex_long_double_alloc_from_matrix" 'function)) :pointer
(b :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_complex_long_double_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_complex_long_double_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_free" #.(swig-lispify "gsl_matrix_complex_long_double_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_free" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_submatrix" #.(swig-lispify "gsl_matrix_complex_long_double_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_row" #.(swig-lispify "gsl_matrix_complex_long_double_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_column" #.(swig-lispify "gsl_matrix_complex_long_double_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_diagonal" #.(swig-lispify "gsl_matrix_complex_long_double_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_subdiagonal" #.(swig-lispify "gsl_matrix_complex_long_double_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_superdiagonal" #.(swig-lispify "gsl_matrix_complex_long_double_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_subrow" #.(swig-lispify "gsl_matrix_complex_long_double_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_subcolumn" #.(swig-lispify "gsl_matrix_complex_long_double_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_view_array" #.(swig-lispify "gsl_matrix_complex_long_double_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_long_double_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_view_vector" #.(swig-lispify "gsl_matrix_complex_long_double_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_long_double_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_submatrix" #.(swig-lispify "gsl_matrix_complex_long_double_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_row" #.(swig-lispify "gsl_matrix_complex_long_double_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_column" #.(swig-lispify "gsl_matrix_complex_long_double_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_column" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_diagonal" #.(swig-lispify "gsl_matrix_complex_long_double_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_subdiagonal" #.(swig-lispify "gsl_matrix_complex_long_double_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_superdiagonal" #.(swig-lispify "gsl_matrix_complex_long_double_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_subrow" #.(swig-lispify "gsl_matrix_complex_long_double_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_subcolumn" #.(swig-lispify "gsl_matrix_complex_long_double_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_view_array" #.(swig-lispify "gsl_matrix_complex_long_double_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_complex_long_double_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_view_vector" #.(swig-lispify "gsl_matrix_complex_long_double_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_complex_long_double_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_complex_long_double_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set_zero" #.(swig-lispify "gsl_matrix_complex_long_double_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set_identity" #.(swig-lispify "gsl_matrix_complex_long_double_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set_all" #.(swig-lispify "gsl_matrix_complex_long_double_set_all" 'function)) :void
(m :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set_all" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_fread" #.(swig-lispify "gsl_matrix_complex_long_double_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_fread" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_fwrite" #.(swig-lispify "gsl_matrix_complex_long_double_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_fscanf" #.(swig-lispify "gsl_matrix_complex_long_double_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_fprintf" #.(swig-lispify "gsl_matrix_complex_long_double_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_memcpy" #.(swig-lispify "gsl_matrix_complex_long_double_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_swap" #.(swig-lispify "gsl_matrix_complex_long_double_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_swap" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_swap_rows" #.(swig-lispify "gsl_matrix_complex_long_double_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_swap_columns" #.(swig-lispify "gsl_matrix_complex_long_double_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_swap_rowcol" #.(swig-lispify "gsl_matrix_complex_long_double_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_transpose" #.(swig-lispify "gsl_matrix_complex_long_double_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_transpose" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_transpose_memcpy" #.(swig-lispify "gsl_matrix_complex_long_double_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_equal" #.(swig-lispify "gsl_matrix_complex_long_double_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_equal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_isnull" #.(swig-lispify "gsl_matrix_complex_long_double_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_isnull" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_ispos" #.(swig-lispify "gsl_matrix_complex_long_double_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_ispos" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_isneg" #.(swig-lispify "gsl_matrix_complex_long_double_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_isneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_isnonneg" #.(swig-lispify "gsl_matrix_complex_long_double_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_add" #.(swig-lispify "gsl_matrix_complex_long_double_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_add" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_sub" #.(swig-lispify "gsl_matrix_complex_long_double_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_sub" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_mul_elements" #.(swig-lispify "gsl_matrix_complex_long_double_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_div_elements" #.(swig-lispify "gsl_matrix_complex_long_double_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_scale" #.(swig-lispify "gsl_matrix_complex_long_double_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_scale" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_add_constant" #.(swig-lispify "gsl_matrix_complex_long_double_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_add_diagonal" #.(swig-lispify "gsl_matrix_complex_long_double_add_diagonal" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_get_row" #.(swig-lispify "gsl_matrix_complex_long_double_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_get_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_get_col" #.(swig-lispify "gsl_matrix_complex_long_double_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_get_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set_row" #.(swig-lispify "gsl_matrix_complex_long_double_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set_row" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set_col" #.(swig-lispify "gsl_matrix_complex_long_double_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set_col" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_get" #.(swig-lispify "gsl_matrix_complex_long_double_get" 'function)) #.(swig-lispify "gsl_complex_long_double" 'classname)
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_get" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_set" #.(swig-lispify "gsl_matrix_complex_long_double_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_set" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_ptr" #.(swig-lispify "gsl_matrix_complex_long_double_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_ptr" 'function))
(cffi:defcfun ("gsl_matrix_complex_long_double_const_ptr" #.(swig-lispify "gsl_matrix_complex_long_double_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_complex_long_double_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_alloc" #.(swig-lispify "gsl_matrix_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_alloc" 'function))
(cffi:defcfun ("gsl_matrix_calloc" #.(swig-lispify "gsl_matrix_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_calloc" 'function))
(cffi:defcfun ("gsl_matrix_alloc_from_block" #.(swig-lispify "gsl_matrix_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_alloc_from_matrix" #.(swig-lispify "gsl_matrix_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_free" #.(swig-lispify "gsl_matrix_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_free" 'function))
(cffi:defcfun ("gsl_matrix_submatrix" #.(swig-lispify "gsl_matrix_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_row" #.(swig-lispify "gsl_matrix_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_row" 'function))
(cffi:defcfun ("gsl_matrix_column" #.(swig-lispify "gsl_matrix_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_column" 'function))
(cffi:defcfun ("gsl_matrix_diagonal" #.(swig-lispify "gsl_matrix_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_subdiagonal" #.(swig-lispify "gsl_matrix_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_superdiagonal" #.(swig-lispify "gsl_matrix_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_subrow" #.(swig-lispify "gsl_matrix_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_subrow" 'function))
(cffi:defcfun ("gsl_matrix_subcolumn" #.(swig-lispify "gsl_matrix_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_view_array" #.(swig-lispify "gsl_matrix_view_array" 'function)) #.(swig-lispify "_gsl_matrix_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_view_array" 'function))
(cffi:defcfun ("gsl_matrix_view_array_with_tda" #.(swig-lispify "gsl_matrix_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_view_vector" #.(swig-lispify "gsl_matrix_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_view_vector_with_tda" #.(swig-lispify "gsl_matrix_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_const_submatrix" #.(swig-lispify "gsl_matrix_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_const_row" #.(swig-lispify "gsl_matrix_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_row" 'function))
(cffi:defcfun ("gsl_matrix_const_column" #.(swig-lispify "gsl_matrix_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_column" 'function))
(cffi:defcfun ("gsl_matrix_const_diagonal" #.(swig-lispify "gsl_matrix_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_const_subdiagonal" #.(swig-lispify "gsl_matrix_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_const_superdiagonal" #.(swig-lispify "gsl_matrix_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_const_subrow" #.(swig-lispify "gsl_matrix_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_const_subcolumn" #.(swig-lispify "gsl_matrix_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_const_view_array" #.(swig-lispify "gsl_matrix_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_const_view_vector" #.(swig-lispify "gsl_matrix_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_set_zero" #.(swig-lispify "gsl_matrix_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_set_identity" #.(swig-lispify "gsl_matrix_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_set_all" #.(swig-lispify "gsl_matrix_set_all" 'function)) :void
(m :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_set_all" 'function))
(cffi:defcfun ("gsl_matrix_fread" #.(swig-lispify "gsl_matrix_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_fread" 'function))
(cffi:defcfun ("gsl_matrix_fwrite" #.(swig-lispify "gsl_matrix_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_fscanf" #.(swig-lispify "gsl_matrix_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_fprintf" #.(swig-lispify "gsl_matrix_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_memcpy" #.(swig-lispify "gsl_matrix_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_swap" #.(swig-lispify "gsl_matrix_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_swap" 'function))
(cffi:defcfun ("gsl_matrix_swap_rows" #.(swig-lispify "gsl_matrix_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_swap_columns" #.(swig-lispify "gsl_matrix_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_swap_rowcol" #.(swig-lispify "gsl_matrix_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_transpose" #.(swig-lispify "gsl_matrix_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_transpose" 'function))
(cffi:defcfun ("gsl_matrix_transpose_memcpy" #.(swig-lispify "gsl_matrix_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_max" #.(swig-lispify "gsl_matrix_max" 'function)) :double
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_max" 'function))
(cffi:defcfun ("gsl_matrix_min" #.(swig-lispify "gsl_matrix_min" 'function)) :double
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_min" 'function))
(cffi:defcfun ("gsl_matrix_minmax" #.(swig-lispify "gsl_matrix_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_minmax" 'function))
(cffi:defcfun ("gsl_matrix_max_index" #.(swig-lispify "gsl_matrix_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_max_index" 'function))
(cffi:defcfun ("gsl_matrix_min_index" #.(swig-lispify "gsl_matrix_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_min_index" 'function))
(cffi:defcfun ("gsl_matrix_minmax_index" #.(swig-lispify "gsl_matrix_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_equal" #.(swig-lispify "gsl_matrix_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_equal" 'function))
(cffi:defcfun ("gsl_matrix_isnull" #.(swig-lispify "gsl_matrix_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_isnull" 'function))
(cffi:defcfun ("gsl_matrix_ispos" #.(swig-lispify "gsl_matrix_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ispos" 'function))
(cffi:defcfun ("gsl_matrix_isneg" #.(swig-lispify "gsl_matrix_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_isneg" 'function))
(cffi:defcfun ("gsl_matrix_isnonneg" #.(swig-lispify "gsl_matrix_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_add" #.(swig-lispify "gsl_matrix_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_add" 'function))
(cffi:defcfun ("gsl_matrix_sub" #.(swig-lispify "gsl_matrix_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_sub" 'function))
(cffi:defcfun ("gsl_matrix_mul_elements" #.(swig-lispify "gsl_matrix_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_div_elements" #.(swig-lispify "gsl_matrix_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_scale" #.(swig-lispify "gsl_matrix_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_scale" 'function))
(cffi:defcfun ("gsl_matrix_add_constant" #.(swig-lispify "gsl_matrix_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_add_diagonal" #.(swig-lispify "gsl_matrix_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_get_row" #.(swig-lispify "gsl_matrix_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_get_row" 'function))
(cffi:defcfun ("gsl_matrix_get_col" #.(swig-lispify "gsl_matrix_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_get_col" 'function))
(cffi:defcfun ("gsl_matrix_set_row" #.(swig-lispify "gsl_matrix_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_set_row" 'function))
(cffi:defcfun ("gsl_matrix_set_col" #.(swig-lispify "gsl_matrix_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_set_col" 'function))
(cffi:defcfun ("gsl_matrix_get" #.(swig-lispify "gsl_matrix_get" 'function)) :double
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_get" 'function))
(cffi:defcfun ("gsl_matrix_set" #.(swig-lispify "gsl_matrix_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_set" 'function))
(cffi:defcfun ("gsl_matrix_ptr" #.(swig-lispify "gsl_matrix_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ptr" 'function))
(cffi:defcfun ("gsl_matrix_const_ptr" #.(swig-lispify "gsl_matrix_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_float" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_float" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_float_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_float_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_float_alloc" #.(swig-lispify "gsl_matrix_float_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_alloc" 'function))
(cffi:defcfun ("gsl_matrix_float_calloc" #.(swig-lispify "gsl_matrix_float_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_calloc" 'function))
(cffi:defcfun ("gsl_matrix_float_alloc_from_block" #.(swig-lispify "gsl_matrix_float_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_float_alloc_from_matrix" #.(swig-lispify "gsl_matrix_float_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_float_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_float_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_float_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_float_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_float_free" #.(swig-lispify "gsl_matrix_float_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_free" 'function))
(cffi:defcfun ("gsl_matrix_float_submatrix" #.(swig-lispify "gsl_matrix_float_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_float_row" #.(swig-lispify "gsl_matrix_float_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_row" 'function))
(cffi:defcfun ("gsl_matrix_float_column" #.(swig-lispify "gsl_matrix_float_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_column" 'function))
(cffi:defcfun ("gsl_matrix_float_diagonal" #.(swig-lispify "gsl_matrix_float_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_subdiagonal" #.(swig-lispify "gsl_matrix_float_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_superdiagonal" #.(swig-lispify "gsl_matrix_float_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_subrow" #.(swig-lispify "gsl_matrix_float_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_subrow" 'function))
(cffi:defcfun ("gsl_matrix_float_subcolumn" #.(swig-lispify "gsl_matrix_float_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_float_view_array" #.(swig-lispify "gsl_matrix_float_view_array" 'function)) #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_view_array" 'function))
(cffi:defcfun ("gsl_matrix_float_view_array_with_tda" #.(swig-lispify "gsl_matrix_float_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_float_view_vector" #.(swig-lispify "gsl_matrix_float_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_float_view_vector_with_tda" #.(swig-lispify "gsl_matrix_float_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_float_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_float_const_submatrix" #.(swig-lispify "gsl_matrix_float_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_float_const_row" #.(swig-lispify "gsl_matrix_float_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_row" 'function))
(cffi:defcfun ("gsl_matrix_float_const_column" #.(swig-lispify "gsl_matrix_float_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_column" 'function))
(cffi:defcfun ("gsl_matrix_float_const_diagonal" #.(swig-lispify "gsl_matrix_float_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_const_subdiagonal" #.(swig-lispify "gsl_matrix_float_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_const_superdiagonal" #.(swig-lispify "gsl_matrix_float_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_const_subrow" #.(swig-lispify "gsl_matrix_float_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_float_const_subcolumn" #.(swig-lispify "gsl_matrix_float_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_float_const_view_array" #.(swig-lispify "gsl_matrix_float_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_float_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_float_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_float_const_view_vector" #.(swig-lispify "gsl_matrix_float_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_float_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_float_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_float_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_float_set_zero" #.(swig-lispify "gsl_matrix_float_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_float_set_identity" #.(swig-lispify "gsl_matrix_float_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_float_set_all" #.(swig-lispify "gsl_matrix_float_set_all" 'function)) :void
(m :pointer)
(x :float))
(cl:export '#.(swig-lispify "gsl_matrix_float_set_all" 'function))
(cffi:defcfun ("gsl_matrix_float_fread" #.(swig-lispify "gsl_matrix_float_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_fread" 'function))
(cffi:defcfun ("gsl_matrix_float_fwrite" #.(swig-lispify "gsl_matrix_float_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_float_fscanf" #.(swig-lispify "gsl_matrix_float_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_float_fprintf" #.(swig-lispify "gsl_matrix_float_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_float_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_float_memcpy" #.(swig-lispify "gsl_matrix_float_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_float_swap" #.(swig-lispify "gsl_matrix_float_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_swap" 'function))
(cffi:defcfun ("gsl_matrix_float_swap_rows" #.(swig-lispify "gsl_matrix_float_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_float_swap_columns" #.(swig-lispify "gsl_matrix_float_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_float_swap_rowcol" #.(swig-lispify "gsl_matrix_float_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_float_transpose" #.(swig-lispify "gsl_matrix_float_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_transpose" 'function))
(cffi:defcfun ("gsl_matrix_float_transpose_memcpy" #.(swig-lispify "gsl_matrix_float_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_float_max" #.(swig-lispify "gsl_matrix_float_max" 'function)) :float
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_max" 'function))
(cffi:defcfun ("gsl_matrix_float_min" #.(swig-lispify "gsl_matrix_float_min" 'function)) :float
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_min" 'function))
(cffi:defcfun ("gsl_matrix_float_minmax" #.(swig-lispify "gsl_matrix_float_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_minmax" 'function))
(cffi:defcfun ("gsl_matrix_float_max_index" #.(swig-lispify "gsl_matrix_float_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_max_index" 'function))
(cffi:defcfun ("gsl_matrix_float_min_index" #.(swig-lispify "gsl_matrix_float_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_min_index" 'function))
(cffi:defcfun ("gsl_matrix_float_minmax_index" #.(swig-lispify "gsl_matrix_float_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_float_equal" #.(swig-lispify "gsl_matrix_float_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_equal" 'function))
(cffi:defcfun ("gsl_matrix_float_isnull" #.(swig-lispify "gsl_matrix_float_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_isnull" 'function))
(cffi:defcfun ("gsl_matrix_float_ispos" #.(swig-lispify "gsl_matrix_float_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_ispos" 'function))
(cffi:defcfun ("gsl_matrix_float_isneg" #.(swig-lispify "gsl_matrix_float_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_isneg" 'function))
(cffi:defcfun ("gsl_matrix_float_isnonneg" #.(swig-lispify "gsl_matrix_float_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_float_add" #.(swig-lispify "gsl_matrix_float_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_add" 'function))
(cffi:defcfun ("gsl_matrix_float_sub" #.(swig-lispify "gsl_matrix_float_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_sub" 'function))
(cffi:defcfun ("gsl_matrix_float_mul_elements" #.(swig-lispify "gsl_matrix_float_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_float_div_elements" #.(swig-lispify "gsl_matrix_float_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_float_scale" #.(swig-lispify "gsl_matrix_float_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_float_scale" 'function))
(cffi:defcfun ("gsl_matrix_float_add_constant" #.(swig-lispify "gsl_matrix_float_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_float_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_float_add_diagonal" #.(swig-lispify "gsl_matrix_float_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_float_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_float_get_row" #.(swig-lispify "gsl_matrix_float_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_get_row" 'function))
(cffi:defcfun ("gsl_matrix_float_get_col" #.(swig-lispify "gsl_matrix_float_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_get_col" 'function))
(cffi:defcfun ("gsl_matrix_float_set_row" #.(swig-lispify "gsl_matrix_float_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_set_row" 'function))
(cffi:defcfun ("gsl_matrix_float_set_col" #.(swig-lispify "gsl_matrix_float_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_set_col" 'function))
(cffi:defcfun ("gsl_matrix_float_get" #.(swig-lispify "gsl_matrix_float_get" 'function)) :float
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_get" 'function))
(cffi:defcfun ("gsl_matrix_float_set" #.(swig-lispify "gsl_matrix_float_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :float))
(cl:export '#.(swig-lispify "gsl_matrix_float_set" 'function))
(cffi:defcfun ("gsl_matrix_float_ptr" #.(swig-lispify "gsl_matrix_float_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_ptr" 'function))
(cffi:defcfun ("gsl_matrix_float_const_ptr" #.(swig-lispify "gsl_matrix_float_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_float_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_int" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_int" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_int" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_int_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_int" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_int_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_int_alloc" #.(swig-lispify "gsl_matrix_int_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_alloc" 'function))
(cffi:defcfun ("gsl_matrix_int_calloc" #.(swig-lispify "gsl_matrix_int_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_calloc" 'function))
(cffi:defcfun ("gsl_matrix_int_alloc_from_block" #.(swig-lispify "gsl_matrix_int_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_int_alloc_from_matrix" #.(swig-lispify "gsl_matrix_int_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_int_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_int_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_int_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_int_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_int_free" #.(swig-lispify "gsl_matrix_int_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_free" 'function))
(cffi:defcfun ("gsl_matrix_int_submatrix" #.(swig-lispify "gsl_matrix_int_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_int_row" #.(swig-lispify "gsl_matrix_int_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_row" 'function))
(cffi:defcfun ("gsl_matrix_int_column" #.(swig-lispify "gsl_matrix_int_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_column" 'function))
(cffi:defcfun ("gsl_matrix_int_diagonal" #.(swig-lispify "gsl_matrix_int_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_subdiagonal" #.(swig-lispify "gsl_matrix_int_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_superdiagonal" #.(swig-lispify "gsl_matrix_int_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_subrow" #.(swig-lispify "gsl_matrix_int_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_subrow" 'function))
(cffi:defcfun ("gsl_matrix_int_subcolumn" #.(swig-lispify "gsl_matrix_int_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_int_view_array" #.(swig-lispify "gsl_matrix_int_view_array" 'function)) #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_view_array" 'function))
(cffi:defcfun ("gsl_matrix_int_view_array_with_tda" #.(swig-lispify "gsl_matrix_int_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_int_view_vector" #.(swig-lispify "gsl_matrix_int_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_int_view_vector_with_tda" #.(swig-lispify "gsl_matrix_int_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_int_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_int_const_submatrix" #.(swig-lispify "gsl_matrix_int_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_int_const_row" #.(swig-lispify "gsl_matrix_int_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_row" 'function))
(cffi:defcfun ("gsl_matrix_int_const_column" #.(swig-lispify "gsl_matrix_int_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_column" 'function))
(cffi:defcfun ("gsl_matrix_int_const_diagonal" #.(swig-lispify "gsl_matrix_int_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_const_subdiagonal" #.(swig-lispify "gsl_matrix_int_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_const_superdiagonal" #.(swig-lispify "gsl_matrix_int_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_const_subrow" #.(swig-lispify "gsl_matrix_int_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_int_const_subcolumn" #.(swig-lispify "gsl_matrix_int_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_int_const_view_array" #.(swig-lispify "gsl_matrix_int_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_int_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_int_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_int_const_view_vector" #.(swig-lispify "gsl_matrix_int_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_int_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_int_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_int_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_int_set_zero" #.(swig-lispify "gsl_matrix_int_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_int_set_identity" #.(swig-lispify "gsl_matrix_int_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_int_set_all" #.(swig-lispify "gsl_matrix_int_set_all" 'function)) :void
(m :pointer)
(x :int))
(cl:export '#.(swig-lispify "gsl_matrix_int_set_all" 'function))
(cffi:defcfun ("gsl_matrix_int_fread" #.(swig-lispify "gsl_matrix_int_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_fread" 'function))
(cffi:defcfun ("gsl_matrix_int_fwrite" #.(swig-lispify "gsl_matrix_int_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_int_fscanf" #.(swig-lispify "gsl_matrix_int_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_int_fprintf" #.(swig-lispify "gsl_matrix_int_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_int_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_int_memcpy" #.(swig-lispify "gsl_matrix_int_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_int_swap" #.(swig-lispify "gsl_matrix_int_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_swap" 'function))
(cffi:defcfun ("gsl_matrix_int_swap_rows" #.(swig-lispify "gsl_matrix_int_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_int_swap_columns" #.(swig-lispify "gsl_matrix_int_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_int_swap_rowcol" #.(swig-lispify "gsl_matrix_int_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_int_transpose" #.(swig-lispify "gsl_matrix_int_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_transpose" 'function))
(cffi:defcfun ("gsl_matrix_int_transpose_memcpy" #.(swig-lispify "gsl_matrix_int_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_int_max" #.(swig-lispify "gsl_matrix_int_max" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_max" 'function))
(cffi:defcfun ("gsl_matrix_int_min" #.(swig-lispify "gsl_matrix_int_min" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_min" 'function))
(cffi:defcfun ("gsl_matrix_int_minmax" #.(swig-lispify "gsl_matrix_int_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_minmax" 'function))
(cffi:defcfun ("gsl_matrix_int_max_index" #.(swig-lispify "gsl_matrix_int_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_max_index" 'function))
(cffi:defcfun ("gsl_matrix_int_min_index" #.(swig-lispify "gsl_matrix_int_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_min_index" 'function))
(cffi:defcfun ("gsl_matrix_int_minmax_index" #.(swig-lispify "gsl_matrix_int_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_int_equal" #.(swig-lispify "gsl_matrix_int_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_equal" 'function))
(cffi:defcfun ("gsl_matrix_int_isnull" #.(swig-lispify "gsl_matrix_int_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_isnull" 'function))
(cffi:defcfun ("gsl_matrix_int_ispos" #.(swig-lispify "gsl_matrix_int_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_ispos" 'function))
(cffi:defcfun ("gsl_matrix_int_isneg" #.(swig-lispify "gsl_matrix_int_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_isneg" 'function))
(cffi:defcfun ("gsl_matrix_int_isnonneg" #.(swig-lispify "gsl_matrix_int_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_int_add" #.(swig-lispify "gsl_matrix_int_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_add" 'function))
(cffi:defcfun ("gsl_matrix_int_sub" #.(swig-lispify "gsl_matrix_int_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_sub" 'function))
(cffi:defcfun ("gsl_matrix_int_mul_elements" #.(swig-lispify "gsl_matrix_int_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_int_div_elements" #.(swig-lispify "gsl_matrix_int_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_int_scale" #.(swig-lispify "gsl_matrix_int_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_int_scale" 'function))
(cffi:defcfun ("gsl_matrix_int_add_constant" #.(swig-lispify "gsl_matrix_int_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_int_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_int_add_diagonal" #.(swig-lispify "gsl_matrix_int_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_int_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_int_get_row" #.(swig-lispify "gsl_matrix_int_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_get_row" 'function))
(cffi:defcfun ("gsl_matrix_int_get_col" #.(swig-lispify "gsl_matrix_int_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_get_col" 'function))
(cffi:defcfun ("gsl_matrix_int_set_row" #.(swig-lispify "gsl_matrix_int_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_set_row" 'function))
(cffi:defcfun ("gsl_matrix_int_set_col" #.(swig-lispify "gsl_matrix_int_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_set_col" 'function))
(cffi:defcfun ("gsl_matrix_int_get" #.(swig-lispify "gsl_matrix_int_get" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_get" 'function))
(cffi:defcfun ("gsl_matrix_int_set" #.(swig-lispify "gsl_matrix_int_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :int))
(cl:export '#.(swig-lispify "gsl_matrix_int_set" 'function))
(cffi:defcfun ("gsl_matrix_int_ptr" #.(swig-lispify "gsl_matrix_int_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_ptr" 'function))
(cffi:defcfun ("gsl_matrix_int_const_ptr" #.(swig-lispify "gsl_matrix_int_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_int_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_long" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_long" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_long" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_long_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_long" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_long_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_long_alloc" #.(swig-lispify "gsl_matrix_long_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_alloc" 'function))
(cffi:defcfun ("gsl_matrix_long_calloc" #.(swig-lispify "gsl_matrix_long_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_calloc" 'function))
(cffi:defcfun ("gsl_matrix_long_alloc_from_block" #.(swig-lispify "gsl_matrix_long_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_long_alloc_from_matrix" #.(swig-lispify "gsl_matrix_long_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_long_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_long_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_long_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_long_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_long_free" #.(swig-lispify "gsl_matrix_long_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_free" 'function))
(cffi:defcfun ("gsl_matrix_long_submatrix" #.(swig-lispify "gsl_matrix_long_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_long_row" #.(swig-lispify "gsl_matrix_long_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_row" 'function))
(cffi:defcfun ("gsl_matrix_long_column" #.(swig-lispify "gsl_matrix_long_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_column" 'function))
(cffi:defcfun ("gsl_matrix_long_diagonal" #.(swig-lispify "gsl_matrix_long_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_subdiagonal" #.(swig-lispify "gsl_matrix_long_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_superdiagonal" #.(swig-lispify "gsl_matrix_long_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_subrow" #.(swig-lispify "gsl_matrix_long_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_subrow" 'function))
(cffi:defcfun ("gsl_matrix_long_subcolumn" #.(swig-lispify "gsl_matrix_long_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_long_view_array" #.(swig-lispify "gsl_matrix_long_view_array" 'function)) #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_view_array" 'function))
(cffi:defcfun ("gsl_matrix_long_view_array_with_tda" #.(swig-lispify "gsl_matrix_long_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_view_vector" #.(swig-lispify "gsl_matrix_long_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_long_view_vector_with_tda" #.(swig-lispify "gsl_matrix_long_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_const_submatrix" #.(swig-lispify "gsl_matrix_long_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_long_const_row" #.(swig-lispify "gsl_matrix_long_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_row" 'function))
(cffi:defcfun ("gsl_matrix_long_const_column" #.(swig-lispify "gsl_matrix_long_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_column" 'function))
(cffi:defcfun ("gsl_matrix_long_const_diagonal" #.(swig-lispify "gsl_matrix_long_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_const_subdiagonal" #.(swig-lispify "gsl_matrix_long_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_const_superdiagonal" #.(swig-lispify "gsl_matrix_long_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_const_subrow" #.(swig-lispify "gsl_matrix_long_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_long_const_subcolumn" #.(swig-lispify "gsl_matrix_long_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_long_const_view_array" #.(swig-lispify "gsl_matrix_long_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_long_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_long_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_const_view_vector" #.(swig-lispify "gsl_matrix_long_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_long_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_long_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_set_zero" #.(swig-lispify "gsl_matrix_long_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_long_set_identity" #.(swig-lispify "gsl_matrix_long_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_long_set_all" #.(swig-lispify "gsl_matrix_long_set_all" 'function)) :void
(m :pointer)
(x :long))
(cl:export '#.(swig-lispify "gsl_matrix_long_set_all" 'function))
(cffi:defcfun ("gsl_matrix_long_fread" #.(swig-lispify "gsl_matrix_long_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_fread" 'function))
(cffi:defcfun ("gsl_matrix_long_fwrite" #.(swig-lispify "gsl_matrix_long_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_long_fscanf" #.(swig-lispify "gsl_matrix_long_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_long_fprintf" #.(swig-lispify "gsl_matrix_long_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_long_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_long_memcpy" #.(swig-lispify "gsl_matrix_long_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_long_swap" #.(swig-lispify "gsl_matrix_long_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_swap" 'function))
(cffi:defcfun ("gsl_matrix_long_swap_rows" #.(swig-lispify "gsl_matrix_long_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_long_swap_columns" #.(swig-lispify "gsl_matrix_long_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_long_swap_rowcol" #.(swig-lispify "gsl_matrix_long_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_long_transpose" #.(swig-lispify "gsl_matrix_long_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_transpose" 'function))
(cffi:defcfun ("gsl_matrix_long_transpose_memcpy" #.(swig-lispify "gsl_matrix_long_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_long_max" #.(swig-lispify "gsl_matrix_long_max" 'function)) :long
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_max" 'function))
(cffi:defcfun ("gsl_matrix_long_min" #.(swig-lispify "gsl_matrix_long_min" 'function)) :long
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_min" 'function))
(cffi:defcfun ("gsl_matrix_long_minmax" #.(swig-lispify "gsl_matrix_long_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_minmax" 'function))
(cffi:defcfun ("gsl_matrix_long_max_index" #.(swig-lispify "gsl_matrix_long_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_max_index" 'function))
(cffi:defcfun ("gsl_matrix_long_min_index" #.(swig-lispify "gsl_matrix_long_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_min_index" 'function))
(cffi:defcfun ("gsl_matrix_long_minmax_index" #.(swig-lispify "gsl_matrix_long_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_long_equal" #.(swig-lispify "gsl_matrix_long_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_equal" 'function))
(cffi:defcfun ("gsl_matrix_long_isnull" #.(swig-lispify "gsl_matrix_long_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_isnull" 'function))
(cffi:defcfun ("gsl_matrix_long_ispos" #.(swig-lispify "gsl_matrix_long_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_ispos" 'function))
(cffi:defcfun ("gsl_matrix_long_isneg" #.(swig-lispify "gsl_matrix_long_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_isneg" 'function))
(cffi:defcfun ("gsl_matrix_long_isnonneg" #.(swig-lispify "gsl_matrix_long_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_long_add" #.(swig-lispify "gsl_matrix_long_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_add" 'function))
(cffi:defcfun ("gsl_matrix_long_sub" #.(swig-lispify "gsl_matrix_long_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_sub" 'function))
(cffi:defcfun ("gsl_matrix_long_mul_elements" #.(swig-lispify "gsl_matrix_long_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_long_div_elements" #.(swig-lispify "gsl_matrix_long_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_long_scale" #.(swig-lispify "gsl_matrix_long_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_scale" 'function))
(cffi:defcfun ("gsl_matrix_long_add_constant" #.(swig-lispify "gsl_matrix_long_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_long_add_diagonal" #.(swig-lispify "gsl_matrix_long_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_get_row" #.(swig-lispify "gsl_matrix_long_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_get_row" 'function))
(cffi:defcfun ("gsl_matrix_long_get_col" #.(swig-lispify "gsl_matrix_long_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_get_col" 'function))
(cffi:defcfun ("gsl_matrix_long_set_row" #.(swig-lispify "gsl_matrix_long_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_set_row" 'function))
(cffi:defcfun ("gsl_matrix_long_set_col" #.(swig-lispify "gsl_matrix_long_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_set_col" 'function))
(cffi:defcfun ("gsl_matrix_long_get" #.(swig-lispify "gsl_matrix_long_get" 'function)) :long
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_get" 'function))
(cffi:defcfun ("gsl_matrix_long_set" #.(swig-lispify "gsl_matrix_long_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :long))
(cl:export '#.(swig-lispify "gsl_matrix_long_set" 'function))
(cffi:defcfun ("gsl_matrix_long_ptr" #.(swig-lispify "gsl_matrix_long_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_ptr" 'function))
(cffi:defcfun ("gsl_matrix_long_const_ptr" #.(swig-lispify "gsl_matrix_long_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_long_double" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_long_double" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_long_double_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_long_double_alloc" #.(swig-lispify "gsl_matrix_long_double_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_alloc" 'function))
(cffi:defcfun ("gsl_matrix_long_double_calloc" #.(swig-lispify "gsl_matrix_long_double_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_calloc" 'function))
(cffi:defcfun ("gsl_matrix_long_double_alloc_from_block" #.(swig-lispify "gsl_matrix_long_double_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_long_double_alloc_from_matrix" #.(swig-lispify "gsl_matrix_long_double_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_long_double_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_long_double_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_long_double_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_long_double_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_long_double_free" #.(swig-lispify "gsl_matrix_long_double_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_free" 'function))
(cffi:defcfun ("gsl_matrix_long_double_submatrix" #.(swig-lispify "gsl_matrix_long_double_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_long_double_row" #.(swig-lispify "gsl_matrix_long_double_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_row" 'function))
(cffi:defcfun ("gsl_matrix_long_double_column" #.(swig-lispify "gsl_matrix_long_double_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_column" 'function))
(cffi:defcfun ("gsl_matrix_long_double_diagonal" #.(swig-lispify "gsl_matrix_long_double_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_subdiagonal" #.(swig-lispify "gsl_matrix_long_double_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_superdiagonal" #.(swig-lispify "gsl_matrix_long_double_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_subrow" #.(swig-lispify "gsl_matrix_long_double_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_subrow" 'function))
(cffi:defcfun ("gsl_matrix_long_double_subcolumn" #.(swig-lispify "gsl_matrix_long_double_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_long_double_view_array" #.(swig-lispify "gsl_matrix_long_double_view_array" 'function)) #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_view_array" 'function))
(cffi:defcfun ("gsl_matrix_long_double_view_array_with_tda" #.(swig-lispify "gsl_matrix_long_double_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_double_view_vector" #.(swig-lispify "gsl_matrix_long_double_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_long_double_view_vector_with_tda" #.(swig-lispify "gsl_matrix_long_double_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_double_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_submatrix" #.(swig-lispify "gsl_matrix_long_double_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_row" #.(swig-lispify "gsl_matrix_long_double_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_row" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_column" #.(swig-lispify "gsl_matrix_long_double_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_column" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_diagonal" #.(swig-lispify "gsl_matrix_long_double_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_subdiagonal" #.(swig-lispify "gsl_matrix_long_double_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_superdiagonal" #.(swig-lispify "gsl_matrix_long_double_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_subrow" #.(swig-lispify "gsl_matrix_long_double_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_subcolumn" #.(swig-lispify "gsl_matrix_long_double_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_view_array" #.(swig-lispify "gsl_matrix_long_double_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_long_double_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_view_vector" #.(swig-lispify "gsl_matrix_long_double_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_long_double_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_long_double_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set_zero" #.(swig-lispify "gsl_matrix_long_double_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set_identity" #.(swig-lispify "gsl_matrix_long_double_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set_all" #.(swig-lispify "gsl_matrix_long_double_set_all" 'function)) :void
(m :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set_all" 'function))
(cffi:defcfun ("gsl_matrix_long_double_fread" #.(swig-lispify "gsl_matrix_long_double_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_fread" 'function))
(cffi:defcfun ("gsl_matrix_long_double_fwrite" #.(swig-lispify "gsl_matrix_long_double_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_long_double_fscanf" #.(swig-lispify "gsl_matrix_long_double_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_long_double_fprintf" #.(swig-lispify "gsl_matrix_long_double_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_long_double_memcpy" #.(swig-lispify "gsl_matrix_long_double_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_long_double_swap" #.(swig-lispify "gsl_matrix_long_double_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_swap" 'function))
(cffi:defcfun ("gsl_matrix_long_double_swap_rows" #.(swig-lispify "gsl_matrix_long_double_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_long_double_swap_columns" #.(swig-lispify "gsl_matrix_long_double_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_long_double_swap_rowcol" #.(swig-lispify "gsl_matrix_long_double_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_long_double_transpose" #.(swig-lispify "gsl_matrix_long_double_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_transpose" 'function))
(cffi:defcfun ("gsl_matrix_long_double_transpose_memcpy" #.(swig-lispify "gsl_matrix_long_double_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_long_double_max" #.(swig-lispify "gsl_matrix_long_double_max" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_max" 'function))
(cffi:defcfun ("gsl_matrix_long_double_min" #.(swig-lispify "gsl_matrix_long_double_min" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_min" 'function))
(cffi:defcfun ("gsl_matrix_long_double_minmax" #.(swig-lispify "gsl_matrix_long_double_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_minmax" 'function))
(cffi:defcfun ("gsl_matrix_long_double_max_index" #.(swig-lispify "gsl_matrix_long_double_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_max_index" 'function))
(cffi:defcfun ("gsl_matrix_long_double_min_index" #.(swig-lispify "gsl_matrix_long_double_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_min_index" 'function))
(cffi:defcfun ("gsl_matrix_long_double_minmax_index" #.(swig-lispify "gsl_matrix_long_double_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_long_double_equal" #.(swig-lispify "gsl_matrix_long_double_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_equal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_isnull" #.(swig-lispify "gsl_matrix_long_double_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_isnull" 'function))
(cffi:defcfun ("gsl_matrix_long_double_ispos" #.(swig-lispify "gsl_matrix_long_double_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_ispos" 'function))
(cffi:defcfun ("gsl_matrix_long_double_isneg" #.(swig-lispify "gsl_matrix_long_double_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_isneg" 'function))
(cffi:defcfun ("gsl_matrix_long_double_isnonneg" #.(swig-lispify "gsl_matrix_long_double_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_long_double_add" #.(swig-lispify "gsl_matrix_long_double_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_add" 'function))
(cffi:defcfun ("gsl_matrix_long_double_sub" #.(swig-lispify "gsl_matrix_long_double_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_sub" 'function))
(cffi:defcfun ("gsl_matrix_long_double_mul_elements" #.(swig-lispify "gsl_matrix_long_double_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_long_double_div_elements" #.(swig-lispify "gsl_matrix_long_double_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_long_double_scale" #.(swig-lispify "gsl_matrix_long_double_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_scale" 'function))
(cffi:defcfun ("gsl_matrix_long_double_add_constant" #.(swig-lispify "gsl_matrix_long_double_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_long_double_add_diagonal" #.(swig-lispify "gsl_matrix_long_double_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_long_double_get_row" #.(swig-lispify "gsl_matrix_long_double_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_get_row" 'function))
(cffi:defcfun ("gsl_matrix_long_double_get_col" #.(swig-lispify "gsl_matrix_long_double_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_get_col" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set_row" #.(swig-lispify "gsl_matrix_long_double_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set_row" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set_col" #.(swig-lispify "gsl_matrix_long_double_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set_col" 'function))
(cffi:defcfun ("gsl_matrix_long_double_get" #.(swig-lispify "gsl_matrix_long_double_get" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_get" 'function))
(cffi:defcfun ("gsl_matrix_long_double_set" #.(swig-lispify "gsl_matrix_long_double_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_set" 'function))
(cffi:defcfun ("gsl_matrix_long_double_ptr" #.(swig-lispify "gsl_matrix_long_double_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_ptr" 'function))
(cffi:defcfun ("gsl_matrix_long_double_const_ptr" #.(swig-lispify "gsl_matrix_long_double_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_long_double_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_short" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_short" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_short" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_short_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_short" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_short_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_short_alloc" #.(swig-lispify "gsl_matrix_short_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_alloc" 'function))
(cffi:defcfun ("gsl_matrix_short_calloc" #.(swig-lispify "gsl_matrix_short_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_calloc" 'function))
(cffi:defcfun ("gsl_matrix_short_alloc_from_block" #.(swig-lispify "gsl_matrix_short_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_short_alloc_from_matrix" #.(swig-lispify "gsl_matrix_short_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_short_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_short_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_short_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_short_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_short_free" #.(swig-lispify "gsl_matrix_short_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_free" 'function))
(cffi:defcfun ("gsl_matrix_short_submatrix" #.(swig-lispify "gsl_matrix_short_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_short_row" #.(swig-lispify "gsl_matrix_short_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_row" 'function))
(cffi:defcfun ("gsl_matrix_short_column" #.(swig-lispify "gsl_matrix_short_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_column" 'function))
(cffi:defcfun ("gsl_matrix_short_diagonal" #.(swig-lispify "gsl_matrix_short_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_subdiagonal" #.(swig-lispify "gsl_matrix_short_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_superdiagonal" #.(swig-lispify "gsl_matrix_short_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_subrow" #.(swig-lispify "gsl_matrix_short_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_subrow" 'function))
(cffi:defcfun ("gsl_matrix_short_subcolumn" #.(swig-lispify "gsl_matrix_short_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_short_view_array" #.(swig-lispify "gsl_matrix_short_view_array" 'function)) #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_view_array" 'function))
(cffi:defcfun ("gsl_matrix_short_view_array_with_tda" #.(swig-lispify "gsl_matrix_short_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_short_view_vector" #.(swig-lispify "gsl_matrix_short_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_short_view_vector_with_tda" #.(swig-lispify "gsl_matrix_short_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_short_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_short_const_submatrix" #.(swig-lispify "gsl_matrix_short_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_short_const_row" #.(swig-lispify "gsl_matrix_short_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_row" 'function))
(cffi:defcfun ("gsl_matrix_short_const_column" #.(swig-lispify "gsl_matrix_short_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_column" 'function))
(cffi:defcfun ("gsl_matrix_short_const_diagonal" #.(swig-lispify "gsl_matrix_short_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_const_subdiagonal" #.(swig-lispify "gsl_matrix_short_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_const_superdiagonal" #.(swig-lispify "gsl_matrix_short_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_const_subrow" #.(swig-lispify "gsl_matrix_short_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_short_const_subcolumn" #.(swig-lispify "gsl_matrix_short_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_short_const_view_array" #.(swig-lispify "gsl_matrix_short_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_short_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_short_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_short_const_view_vector" #.(swig-lispify "gsl_matrix_short_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_short_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_short_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_short_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_short_set_zero" #.(swig-lispify "gsl_matrix_short_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_short_set_identity" #.(swig-lispify "gsl_matrix_short_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_short_set_all" #.(swig-lispify "gsl_matrix_short_set_all" 'function)) :void
(m :pointer)
(x :short))
(cl:export '#.(swig-lispify "gsl_matrix_short_set_all" 'function))
(cffi:defcfun ("gsl_matrix_short_fread" #.(swig-lispify "gsl_matrix_short_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_fread" 'function))
(cffi:defcfun ("gsl_matrix_short_fwrite" #.(swig-lispify "gsl_matrix_short_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_short_fscanf" #.(swig-lispify "gsl_matrix_short_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_short_fprintf" #.(swig-lispify "gsl_matrix_short_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_short_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_short_memcpy" #.(swig-lispify "gsl_matrix_short_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_short_swap" #.(swig-lispify "gsl_matrix_short_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_swap" 'function))
(cffi:defcfun ("gsl_matrix_short_swap_rows" #.(swig-lispify "gsl_matrix_short_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_short_swap_columns" #.(swig-lispify "gsl_matrix_short_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_short_swap_rowcol" #.(swig-lispify "gsl_matrix_short_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_short_transpose" #.(swig-lispify "gsl_matrix_short_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_transpose" 'function))
(cffi:defcfun ("gsl_matrix_short_transpose_memcpy" #.(swig-lispify "gsl_matrix_short_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_short_max" #.(swig-lispify "gsl_matrix_short_max" 'function)) :short
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_max" 'function))
(cffi:defcfun ("gsl_matrix_short_min" #.(swig-lispify "gsl_matrix_short_min" 'function)) :short
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_min" 'function))
(cffi:defcfun ("gsl_matrix_short_minmax" #.(swig-lispify "gsl_matrix_short_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_minmax" 'function))
(cffi:defcfun ("gsl_matrix_short_max_index" #.(swig-lispify "gsl_matrix_short_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_max_index" 'function))
(cffi:defcfun ("gsl_matrix_short_min_index" #.(swig-lispify "gsl_matrix_short_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_min_index" 'function))
(cffi:defcfun ("gsl_matrix_short_minmax_index" #.(swig-lispify "gsl_matrix_short_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_short_equal" #.(swig-lispify "gsl_matrix_short_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_equal" 'function))
(cffi:defcfun ("gsl_matrix_short_isnull" #.(swig-lispify "gsl_matrix_short_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_isnull" 'function))
(cffi:defcfun ("gsl_matrix_short_ispos" #.(swig-lispify "gsl_matrix_short_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_ispos" 'function))
(cffi:defcfun ("gsl_matrix_short_isneg" #.(swig-lispify "gsl_matrix_short_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_isneg" 'function))
(cffi:defcfun ("gsl_matrix_short_isnonneg" #.(swig-lispify "gsl_matrix_short_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_short_add" #.(swig-lispify "gsl_matrix_short_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_add" 'function))
(cffi:defcfun ("gsl_matrix_short_sub" #.(swig-lispify "gsl_matrix_short_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_sub" 'function))
(cffi:defcfun ("gsl_matrix_short_mul_elements" #.(swig-lispify "gsl_matrix_short_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_short_div_elements" #.(swig-lispify "gsl_matrix_short_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_short_scale" #.(swig-lispify "gsl_matrix_short_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_short_scale" 'function))
(cffi:defcfun ("gsl_matrix_short_add_constant" #.(swig-lispify "gsl_matrix_short_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_short_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_short_add_diagonal" #.(swig-lispify "gsl_matrix_short_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_short_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_short_get_row" #.(swig-lispify "gsl_matrix_short_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_get_row" 'function))
(cffi:defcfun ("gsl_matrix_short_get_col" #.(swig-lispify "gsl_matrix_short_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_get_col" 'function))
(cffi:defcfun ("gsl_matrix_short_set_row" #.(swig-lispify "gsl_matrix_short_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_set_row" 'function))
(cffi:defcfun ("gsl_matrix_short_set_col" #.(swig-lispify "gsl_matrix_short_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_set_col" 'function))
(cffi:defcfun ("gsl_matrix_short_get" #.(swig-lispify "gsl_matrix_short_get" 'function)) :short
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_get" 'function))
(cffi:defcfun ("gsl_matrix_short_set" #.(swig-lispify "gsl_matrix_short_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :short))
(cl:export '#.(swig-lispify "gsl_matrix_short_set" 'function))
(cffi:defcfun ("gsl_matrix_short_ptr" #.(swig-lispify "gsl_matrix_short_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_ptr" 'function))
(cffi:defcfun ("gsl_matrix_short_const_ptr" #.(swig-lispify "gsl_matrix_short_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_short_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_uchar" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_uchar" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_uchar" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_uchar_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_uchar" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_uchar_alloc" #.(swig-lispify "gsl_matrix_uchar_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_alloc" 'function))
(cffi:defcfun ("gsl_matrix_uchar_calloc" #.(swig-lispify "gsl_matrix_uchar_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_calloc" 'function))
(cffi:defcfun ("gsl_matrix_uchar_alloc_from_block" #.(swig-lispify "gsl_matrix_uchar_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_uchar_alloc_from_matrix" #.(swig-lispify "gsl_matrix_uchar_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_uchar_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_uchar_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_uchar_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_uchar_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_uchar_free" #.(swig-lispify "gsl_matrix_uchar_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_free" 'function))
(cffi:defcfun ("gsl_matrix_uchar_submatrix" #.(swig-lispify "gsl_matrix_uchar_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_uchar_row" #.(swig-lispify "gsl_matrix_uchar_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_row" 'function))
(cffi:defcfun ("gsl_matrix_uchar_column" #.(swig-lispify "gsl_matrix_uchar_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_column" 'function))
(cffi:defcfun ("gsl_matrix_uchar_diagonal" #.(swig-lispify "gsl_matrix_uchar_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_subdiagonal" #.(swig-lispify "gsl_matrix_uchar_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_superdiagonal" #.(swig-lispify "gsl_matrix_uchar_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_subrow" #.(swig-lispify "gsl_matrix_uchar_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_subrow" 'function))
(cffi:defcfun ("gsl_matrix_uchar_subcolumn" #.(swig-lispify "gsl_matrix_uchar_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_uchar_view_array" #.(swig-lispify "gsl_matrix_uchar_view_array" 'function)) #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_view_array" 'function))
(cffi:defcfun ("gsl_matrix_uchar_view_array_with_tda" #.(swig-lispify "gsl_matrix_uchar_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uchar_view_vector" #.(swig-lispify "gsl_matrix_uchar_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_uchar_view_vector_with_tda" #.(swig-lispify "gsl_matrix_uchar_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uchar_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_submatrix" #.(swig-lispify "gsl_matrix_uchar_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_row" #.(swig-lispify "gsl_matrix_uchar_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_row" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_column" #.(swig-lispify "gsl_matrix_uchar_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_column" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_diagonal" #.(swig-lispify "gsl_matrix_uchar_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_subdiagonal" #.(swig-lispify "gsl_matrix_uchar_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_superdiagonal" #.(swig-lispify "gsl_matrix_uchar_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_subrow" #.(swig-lispify "gsl_matrix_uchar_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_subcolumn" #.(swig-lispify "gsl_matrix_uchar_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_view_array" #.(swig-lispify "gsl_matrix_uchar_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_uchar_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_view_vector" #.(swig-lispify "gsl_matrix_uchar_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_uchar_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uchar_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set_zero" #.(swig-lispify "gsl_matrix_uchar_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set_identity" #.(swig-lispify "gsl_matrix_uchar_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set_all" #.(swig-lispify "gsl_matrix_uchar_set_all" 'function)) :void
(m :pointer)
(x :unsigned-char))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set_all" 'function))
(cffi:defcfun ("gsl_matrix_uchar_fread" #.(swig-lispify "gsl_matrix_uchar_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_fread" 'function))
(cffi:defcfun ("gsl_matrix_uchar_fwrite" #.(swig-lispify "gsl_matrix_uchar_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_uchar_fscanf" #.(swig-lispify "gsl_matrix_uchar_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_uchar_fprintf" #.(swig-lispify "gsl_matrix_uchar_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_uchar_memcpy" #.(swig-lispify "gsl_matrix_uchar_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_uchar_swap" #.(swig-lispify "gsl_matrix_uchar_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_swap" 'function))
(cffi:defcfun ("gsl_matrix_uchar_swap_rows" #.(swig-lispify "gsl_matrix_uchar_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_uchar_swap_columns" #.(swig-lispify "gsl_matrix_uchar_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_uchar_swap_rowcol" #.(swig-lispify "gsl_matrix_uchar_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_uchar_transpose" #.(swig-lispify "gsl_matrix_uchar_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_transpose" 'function))
(cffi:defcfun ("gsl_matrix_uchar_transpose_memcpy" #.(swig-lispify "gsl_matrix_uchar_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_uchar_max" #.(swig-lispify "gsl_matrix_uchar_max" 'function)) :unsigned-char
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_max" 'function))
(cffi:defcfun ("gsl_matrix_uchar_min" #.(swig-lispify "gsl_matrix_uchar_min" 'function)) :unsigned-char
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_min" 'function))
(cffi:defcfun ("gsl_matrix_uchar_minmax" #.(swig-lispify "gsl_matrix_uchar_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_minmax" 'function))
(cffi:defcfun ("gsl_matrix_uchar_max_index" #.(swig-lispify "gsl_matrix_uchar_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_max_index" 'function))
(cffi:defcfun ("gsl_matrix_uchar_min_index" #.(swig-lispify "gsl_matrix_uchar_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_min_index" 'function))
(cffi:defcfun ("gsl_matrix_uchar_minmax_index" #.(swig-lispify "gsl_matrix_uchar_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_uchar_equal" #.(swig-lispify "gsl_matrix_uchar_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_equal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_isnull" #.(swig-lispify "gsl_matrix_uchar_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_isnull" 'function))
(cffi:defcfun ("gsl_matrix_uchar_ispos" #.(swig-lispify "gsl_matrix_uchar_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_ispos" 'function))
(cffi:defcfun ("gsl_matrix_uchar_isneg" #.(swig-lispify "gsl_matrix_uchar_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_isneg" 'function))
(cffi:defcfun ("gsl_matrix_uchar_isnonneg" #.(swig-lispify "gsl_matrix_uchar_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_uchar_add" #.(swig-lispify "gsl_matrix_uchar_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_add" 'function))
(cffi:defcfun ("gsl_matrix_uchar_sub" #.(swig-lispify "gsl_matrix_uchar_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_sub" 'function))
(cffi:defcfun ("gsl_matrix_uchar_mul_elements" #.(swig-lispify "gsl_matrix_uchar_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_uchar_div_elements" #.(swig-lispify "gsl_matrix_uchar_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_uchar_scale" #.(swig-lispify "gsl_matrix_uchar_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_scale" 'function))
(cffi:defcfun ("gsl_matrix_uchar_add_constant" #.(swig-lispify "gsl_matrix_uchar_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_uchar_add_diagonal" #.(swig-lispify "gsl_matrix_uchar_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uchar_get_row" #.(swig-lispify "gsl_matrix_uchar_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_get_row" 'function))
(cffi:defcfun ("gsl_matrix_uchar_get_col" #.(swig-lispify "gsl_matrix_uchar_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_get_col" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set_row" #.(swig-lispify "gsl_matrix_uchar_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set_row" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set_col" #.(swig-lispify "gsl_matrix_uchar_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set_col" 'function))
(cffi:defcfun ("gsl_matrix_uchar_get" #.(swig-lispify "gsl_matrix_uchar_get" 'function)) :unsigned-char
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_get" 'function))
(cffi:defcfun ("gsl_matrix_uchar_set" #.(swig-lispify "gsl_matrix_uchar_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :unsigned-char))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_set" 'function))
(cffi:defcfun ("gsl_matrix_uchar_ptr" #.(swig-lispify "gsl_matrix_uchar_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_ptr" 'function))
(cffi:defcfun ("gsl_matrix_uchar_const_ptr" #.(swig-lispify "gsl_matrix_uchar_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uchar_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_uint" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_uint" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_uint" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_uint_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_uint" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_uint_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_uint_alloc" #.(swig-lispify "gsl_matrix_uint_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_alloc" 'function))
(cffi:defcfun ("gsl_matrix_uint_calloc" #.(swig-lispify "gsl_matrix_uint_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_calloc" 'function))
(cffi:defcfun ("gsl_matrix_uint_alloc_from_block" #.(swig-lispify "gsl_matrix_uint_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_uint_alloc_from_matrix" #.(swig-lispify "gsl_matrix_uint_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_uint_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_uint_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_uint_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_uint_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_uint_free" #.(swig-lispify "gsl_matrix_uint_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_free" 'function))
(cffi:defcfun ("gsl_matrix_uint_submatrix" #.(swig-lispify "gsl_matrix_uint_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_uint_row" #.(swig-lispify "gsl_matrix_uint_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_row" 'function))
(cffi:defcfun ("gsl_matrix_uint_column" #.(swig-lispify "gsl_matrix_uint_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_column" 'function))
(cffi:defcfun ("gsl_matrix_uint_diagonal" #.(swig-lispify "gsl_matrix_uint_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_subdiagonal" #.(swig-lispify "gsl_matrix_uint_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_superdiagonal" #.(swig-lispify "gsl_matrix_uint_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_subrow" #.(swig-lispify "gsl_matrix_uint_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_subrow" 'function))
(cffi:defcfun ("gsl_matrix_uint_subcolumn" #.(swig-lispify "gsl_matrix_uint_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_uint_view_array" #.(swig-lispify "gsl_matrix_uint_view_array" 'function)) #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_view_array" 'function))
(cffi:defcfun ("gsl_matrix_uint_view_array_with_tda" #.(swig-lispify "gsl_matrix_uint_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uint_view_vector" #.(swig-lispify "gsl_matrix_uint_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_uint_view_vector_with_tda" #.(swig-lispify "gsl_matrix_uint_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uint_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_submatrix" #.(swig-lispify "gsl_matrix_uint_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_row" #.(swig-lispify "gsl_matrix_uint_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_row" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_column" #.(swig-lispify "gsl_matrix_uint_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_column" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_diagonal" #.(swig-lispify "gsl_matrix_uint_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_subdiagonal" #.(swig-lispify "gsl_matrix_uint_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_superdiagonal" #.(swig-lispify "gsl_matrix_uint_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_subrow" #.(swig-lispify "gsl_matrix_uint_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_subcolumn" #.(swig-lispify "gsl_matrix_uint_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_view_array" #.(swig-lispify "gsl_matrix_uint_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_uint_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_view_vector" #.(swig-lispify "gsl_matrix_uint_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_uint_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_uint_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_uint_set_zero" #.(swig-lispify "gsl_matrix_uint_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_uint_set_identity" #.(swig-lispify "gsl_matrix_uint_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_uint_set_all" #.(swig-lispify "gsl_matrix_uint_set_all" 'function)) :void
(m :pointer)
(x :unsigned-int))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set_all" 'function))
(cffi:defcfun ("gsl_matrix_uint_fread" #.(swig-lispify "gsl_matrix_uint_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_fread" 'function))
(cffi:defcfun ("gsl_matrix_uint_fwrite" #.(swig-lispify "gsl_matrix_uint_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_uint_fscanf" #.(swig-lispify "gsl_matrix_uint_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_uint_fprintf" #.(swig-lispify "gsl_matrix_uint_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_uint_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_uint_memcpy" #.(swig-lispify "gsl_matrix_uint_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_uint_swap" #.(swig-lispify "gsl_matrix_uint_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_swap" 'function))
(cffi:defcfun ("gsl_matrix_uint_swap_rows" #.(swig-lispify "gsl_matrix_uint_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_uint_swap_columns" #.(swig-lispify "gsl_matrix_uint_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_uint_swap_rowcol" #.(swig-lispify "gsl_matrix_uint_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_uint_transpose" #.(swig-lispify "gsl_matrix_uint_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_transpose" 'function))
(cffi:defcfun ("gsl_matrix_uint_transpose_memcpy" #.(swig-lispify "gsl_matrix_uint_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_uint_max" #.(swig-lispify "gsl_matrix_uint_max" 'function)) :unsigned-int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_max" 'function))
(cffi:defcfun ("gsl_matrix_uint_min" #.(swig-lispify "gsl_matrix_uint_min" 'function)) :unsigned-int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_min" 'function))
(cffi:defcfun ("gsl_matrix_uint_minmax" #.(swig-lispify "gsl_matrix_uint_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_minmax" 'function))
(cffi:defcfun ("gsl_matrix_uint_max_index" #.(swig-lispify "gsl_matrix_uint_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_max_index" 'function))
(cffi:defcfun ("gsl_matrix_uint_min_index" #.(swig-lispify "gsl_matrix_uint_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_min_index" 'function))
(cffi:defcfun ("gsl_matrix_uint_minmax_index" #.(swig-lispify "gsl_matrix_uint_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_uint_equal" #.(swig-lispify "gsl_matrix_uint_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_equal" 'function))
(cffi:defcfun ("gsl_matrix_uint_isnull" #.(swig-lispify "gsl_matrix_uint_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_isnull" 'function))
(cffi:defcfun ("gsl_matrix_uint_ispos" #.(swig-lispify "gsl_matrix_uint_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_ispos" 'function))
(cffi:defcfun ("gsl_matrix_uint_isneg" #.(swig-lispify "gsl_matrix_uint_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_isneg" 'function))
(cffi:defcfun ("gsl_matrix_uint_isnonneg" #.(swig-lispify "gsl_matrix_uint_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_uint_add" #.(swig-lispify "gsl_matrix_uint_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_add" 'function))
(cffi:defcfun ("gsl_matrix_uint_sub" #.(swig-lispify "gsl_matrix_uint_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_sub" 'function))
(cffi:defcfun ("gsl_matrix_uint_mul_elements" #.(swig-lispify "gsl_matrix_uint_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_uint_div_elements" #.(swig-lispify "gsl_matrix_uint_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_uint_scale" #.(swig-lispify "gsl_matrix_uint_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uint_scale" 'function))
(cffi:defcfun ("gsl_matrix_uint_add_constant" #.(swig-lispify "gsl_matrix_uint_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uint_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_uint_add_diagonal" #.(swig-lispify "gsl_matrix_uint_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_uint_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_uint_get_row" #.(swig-lispify "gsl_matrix_uint_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_get_row" 'function))
(cffi:defcfun ("gsl_matrix_uint_get_col" #.(swig-lispify "gsl_matrix_uint_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_get_col" 'function))
(cffi:defcfun ("gsl_matrix_uint_set_row" #.(swig-lispify "gsl_matrix_uint_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set_row" 'function))
(cffi:defcfun ("gsl_matrix_uint_set_col" #.(swig-lispify "gsl_matrix_uint_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set_col" 'function))
(cffi:defcfun ("gsl_matrix_uint_get" #.(swig-lispify "gsl_matrix_uint_get" 'function)) :unsigned-int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_get" 'function))
(cffi:defcfun ("gsl_matrix_uint_set" #.(swig-lispify "gsl_matrix_uint_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :unsigned-int))
(cl:export '#.(swig-lispify "gsl_matrix_uint_set" 'function))
(cffi:defcfun ("gsl_matrix_uint_ptr" #.(swig-lispify "gsl_matrix_uint_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_ptr" 'function))
(cffi:defcfun ("gsl_matrix_uint_const_ptr" #.(swig-lispify "gsl_matrix_uint_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_uint_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_ulong" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_ulong" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_ulong" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_ulong_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_ulong" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_ulong_alloc" #.(swig-lispify "gsl_matrix_ulong_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_alloc" 'function))
(cffi:defcfun ("gsl_matrix_ulong_calloc" #.(swig-lispify "gsl_matrix_ulong_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_calloc" 'function))
(cffi:defcfun ("gsl_matrix_ulong_alloc_from_block" #.(swig-lispify "gsl_matrix_ulong_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_ulong_alloc_from_matrix" #.(swig-lispify "gsl_matrix_ulong_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_ulong_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_ulong_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_ulong_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_ulong_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_ulong_free" #.(swig-lispify "gsl_matrix_ulong_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_free" 'function))
(cffi:defcfun ("gsl_matrix_ulong_submatrix" #.(swig-lispify "gsl_matrix_ulong_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_ulong_row" #.(swig-lispify "gsl_matrix_ulong_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_row" 'function))
(cffi:defcfun ("gsl_matrix_ulong_column" #.(swig-lispify "gsl_matrix_ulong_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_column" 'function))
(cffi:defcfun ("gsl_matrix_ulong_diagonal" #.(swig-lispify "gsl_matrix_ulong_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_subdiagonal" #.(swig-lispify "gsl_matrix_ulong_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_superdiagonal" #.(swig-lispify "gsl_matrix_ulong_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_subrow" #.(swig-lispify "gsl_matrix_ulong_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_subrow" 'function))
(cffi:defcfun ("gsl_matrix_ulong_subcolumn" #.(swig-lispify "gsl_matrix_ulong_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_ulong_view_array" #.(swig-lispify "gsl_matrix_ulong_view_array" 'function)) #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_view_array" 'function))
(cffi:defcfun ("gsl_matrix_ulong_view_array_with_tda" #.(swig-lispify "gsl_matrix_ulong_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ulong_view_vector" #.(swig-lispify "gsl_matrix_ulong_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_ulong_view_vector_with_tda" #.(swig-lispify "gsl_matrix_ulong_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ulong_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_submatrix" #.(swig-lispify "gsl_matrix_ulong_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_row" #.(swig-lispify "gsl_matrix_ulong_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_row" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_column" #.(swig-lispify "gsl_matrix_ulong_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_column" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_diagonal" #.(swig-lispify "gsl_matrix_ulong_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_subdiagonal" #.(swig-lispify "gsl_matrix_ulong_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_superdiagonal" #.(swig-lispify "gsl_matrix_ulong_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_subrow" #.(swig-lispify "gsl_matrix_ulong_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_subcolumn" #.(swig-lispify "gsl_matrix_ulong_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_view_array" #.(swig-lispify "gsl_matrix_ulong_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_ulong_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_view_vector" #.(swig-lispify "gsl_matrix_ulong_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_ulong_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ulong_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set_zero" #.(swig-lispify "gsl_matrix_ulong_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set_identity" #.(swig-lispify "gsl_matrix_ulong_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set_all" #.(swig-lispify "gsl_matrix_ulong_set_all" 'function)) :void
(m :pointer)
(x :unsigned-long))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set_all" 'function))
(cffi:defcfun ("gsl_matrix_ulong_fread" #.(swig-lispify "gsl_matrix_ulong_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_fread" 'function))
(cffi:defcfun ("gsl_matrix_ulong_fwrite" #.(swig-lispify "gsl_matrix_ulong_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_ulong_fscanf" #.(swig-lispify "gsl_matrix_ulong_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_ulong_fprintf" #.(swig-lispify "gsl_matrix_ulong_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_ulong_memcpy" #.(swig-lispify "gsl_matrix_ulong_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_ulong_swap" #.(swig-lispify "gsl_matrix_ulong_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_swap" 'function))
(cffi:defcfun ("gsl_matrix_ulong_swap_rows" #.(swig-lispify "gsl_matrix_ulong_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_ulong_swap_columns" #.(swig-lispify "gsl_matrix_ulong_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_ulong_swap_rowcol" #.(swig-lispify "gsl_matrix_ulong_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_ulong_transpose" #.(swig-lispify "gsl_matrix_ulong_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_transpose" 'function))
(cffi:defcfun ("gsl_matrix_ulong_transpose_memcpy" #.(swig-lispify "gsl_matrix_ulong_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_ulong_max" #.(swig-lispify "gsl_matrix_ulong_max" 'function)) :unsigned-long
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_max" 'function))
(cffi:defcfun ("gsl_matrix_ulong_min" #.(swig-lispify "gsl_matrix_ulong_min" 'function)) :unsigned-long
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_min" 'function))
(cffi:defcfun ("gsl_matrix_ulong_minmax" #.(swig-lispify "gsl_matrix_ulong_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_minmax" 'function))
(cffi:defcfun ("gsl_matrix_ulong_max_index" #.(swig-lispify "gsl_matrix_ulong_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_max_index" 'function))
(cffi:defcfun ("gsl_matrix_ulong_min_index" #.(swig-lispify "gsl_matrix_ulong_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_min_index" 'function))
(cffi:defcfun ("gsl_matrix_ulong_minmax_index" #.(swig-lispify "gsl_matrix_ulong_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_ulong_equal" #.(swig-lispify "gsl_matrix_ulong_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_equal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_isnull" #.(swig-lispify "gsl_matrix_ulong_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_isnull" 'function))
(cffi:defcfun ("gsl_matrix_ulong_ispos" #.(swig-lispify "gsl_matrix_ulong_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_ispos" 'function))
(cffi:defcfun ("gsl_matrix_ulong_isneg" #.(swig-lispify "gsl_matrix_ulong_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_isneg" 'function))
(cffi:defcfun ("gsl_matrix_ulong_isnonneg" #.(swig-lispify "gsl_matrix_ulong_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_ulong_add" #.(swig-lispify "gsl_matrix_ulong_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_add" 'function))
(cffi:defcfun ("gsl_matrix_ulong_sub" #.(swig-lispify "gsl_matrix_ulong_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_sub" 'function))
(cffi:defcfun ("gsl_matrix_ulong_mul_elements" #.(swig-lispify "gsl_matrix_ulong_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_ulong_div_elements" #.(swig-lispify "gsl_matrix_ulong_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_ulong_scale" #.(swig-lispify "gsl_matrix_ulong_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_scale" 'function))
(cffi:defcfun ("gsl_matrix_ulong_add_constant" #.(swig-lispify "gsl_matrix_ulong_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_ulong_add_diagonal" #.(swig-lispify "gsl_matrix_ulong_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ulong_get_row" #.(swig-lispify "gsl_matrix_ulong_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_get_row" 'function))
(cffi:defcfun ("gsl_matrix_ulong_get_col" #.(swig-lispify "gsl_matrix_ulong_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_get_col" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set_row" #.(swig-lispify "gsl_matrix_ulong_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set_row" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set_col" #.(swig-lispify "gsl_matrix_ulong_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set_col" 'function))
(cffi:defcfun ("gsl_matrix_ulong_get" #.(swig-lispify "gsl_matrix_ulong_get" 'function)) :unsigned-long
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_get" 'function))
(cffi:defcfun ("gsl_matrix_ulong_set" #.(swig-lispify "gsl_matrix_ulong_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :unsigned-long))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_set" 'function))
(cffi:defcfun ("gsl_matrix_ulong_ptr" #.(swig-lispify "gsl_matrix_ulong_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_ptr" 'function))
(cffi:defcfun ("gsl_matrix_ulong_const_ptr" #.(swig-lispify "gsl_matrix_ulong_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ulong_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_matrix_ushort" 'classname)
(#.(swig-lispify "size1" 'slotname) :pointer)
(#.(swig-lispify "size2" 'slotname) :pointer)
(#.(swig-lispify "tda" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_matrix_ushort" 'classname))
(cl:export '#.(swig-lispify "size1" 'slotname))
(cl:export '#.(swig-lispify "size2" 'slotname))
(cl:export '#.(swig-lispify "tda" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_ushort" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_ushort_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(#.(swig-lispify "matrix" 'slotname) #.(swig-lispify "gsl_matrix_ushort" 'classname)))
(cl:export '#.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_matrix_ushort_alloc" #.(swig-lispify "gsl_matrix_ushort_alloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_alloc" 'function))
(cffi:defcfun ("gsl_matrix_ushort_calloc" #.(swig-lispify "gsl_matrix_ushort_calloc" 'function)) :pointer
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_calloc" 'function))
(cffi:defcfun ("gsl_matrix_ushort_alloc_from_block" #.(swig-lispify "gsl_matrix_ushort_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n1 :pointer)
(n2 :pointer)
(d2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_alloc_from_block" 'function))
(cffi:defcfun ("gsl_matrix_ushort_alloc_from_matrix" #.(swig-lispify "gsl_matrix_ushort_alloc_from_matrix" 'function)) :pointer
(m :pointer)
(k1 :pointer)
(k2 :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_alloc_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_ushort_alloc_row_from_matrix" #.(swig-lispify "gsl_vector_ushort_alloc_row_from_matrix" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_alloc_row_from_matrix" 'function))
(cffi:defcfun ("gsl_vector_ushort_alloc_col_from_matrix" #.(swig-lispify "gsl_vector_ushort_alloc_col_from_matrix" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_alloc_col_from_matrix" 'function))
(cffi:defcfun ("gsl_matrix_ushort_free" #.(swig-lispify "gsl_matrix_ushort_free" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_free" 'function))
(cffi:defcfun ("gsl_matrix_ushort_submatrix" #.(swig-lispify "gsl_matrix_ushort_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_ushort_row" #.(swig-lispify "gsl_matrix_ushort_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_row" 'function))
(cffi:defcfun ("gsl_matrix_ushort_column" #.(swig-lispify "gsl_matrix_ushort_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_column" 'function))
(cffi:defcfun ("gsl_matrix_ushort_diagonal" #.(swig-lispify "gsl_matrix_ushort_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_subdiagonal" #.(swig-lispify "gsl_matrix_ushort_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_superdiagonal" #.(swig-lispify "gsl_matrix_ushort_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_subrow" #.(swig-lispify "gsl_matrix_ushort_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_subrow" 'function))
(cffi:defcfun ("gsl_matrix_ushort_subcolumn" #.(swig-lispify "gsl_matrix_ushort_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_ushort_view_array" #.(swig-lispify "gsl_matrix_ushort_view_array" 'function)) #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_view_array" 'function))
(cffi:defcfun ("gsl_matrix_ushort_view_array_with_tda" #.(swig-lispify "gsl_matrix_ushort_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ushort_view_vector" #.(swig-lispify "gsl_matrix_ushort_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_ushort_view_vector_with_tda" #.(swig-lispify "gsl_matrix_ushort_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ushort_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_submatrix" #.(swig-lispify "gsl_matrix_ushort_const_submatrix" 'function)) #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(m :pointer)
(i :pointer)
(j :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_submatrix" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_row" #.(swig-lispify "gsl_matrix_ushort_const_row" 'function)) :pointer
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_row" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_column" #.(swig-lispify "gsl_matrix_ushort_const_column" 'function)) :pointer
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_column" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_diagonal" #.(swig-lispify "gsl_matrix_ushort_const_diagonal" 'function)) :pointer
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_subdiagonal" #.(swig-lispify "gsl_matrix_ushort_const_subdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_subdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_superdiagonal" #.(swig-lispify "gsl_matrix_ushort_const_superdiagonal" 'function)) :pointer
(m :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_superdiagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_subrow" #.(swig-lispify "gsl_matrix_ushort_const_subrow" 'function)) :pointer
(m :pointer)
(i :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_subrow" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_subcolumn" #.(swig-lispify "gsl_matrix_ushort_const_subcolumn" 'function)) :pointer
(m :pointer)
(j :pointer)
(offset :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_subcolumn" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_view_array" #.(swig-lispify "gsl_matrix_ushort_const_view_array" 'function)) #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_view_array" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_view_array_with_tda" #.(swig-lispify "gsl_matrix_ushort_const_view_array_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(base :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_view_array_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_view_vector" #.(swig-lispify "gsl_matrix_ushort_const_view_vector" 'function)) #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_view_vector" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_view_vector_with_tda" #.(swig-lispify "gsl_matrix_ushort_const_view_vector_with_tda" 'function)) #.(swig-lispify "_gsl_matrix_ushort_const_view" 'classname)
(v :pointer)
(n1 :pointer)
(n2 :pointer)
(tda :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_view_vector_with_tda" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set_zero" #.(swig-lispify "gsl_matrix_ushort_set_zero" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set_zero" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set_identity" #.(swig-lispify "gsl_matrix_ushort_set_identity" 'function)) :void
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set_identity" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set_all" #.(swig-lispify "gsl_matrix_ushort_set_all" 'function)) :void
(m :pointer)
(x :unsigned-short))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set_all" 'function))
(cffi:defcfun ("gsl_matrix_ushort_fread" #.(swig-lispify "gsl_matrix_ushort_fread" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_fread" 'function))
(cffi:defcfun ("gsl_matrix_ushort_fwrite" #.(swig-lispify "gsl_matrix_ushort_fwrite" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_fwrite" 'function))
(cffi:defcfun ("gsl_matrix_ushort_fscanf" #.(swig-lispify "gsl_matrix_ushort_fscanf" 'function)) :int
(stream :pointer)
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_fscanf" 'function))
(cffi:defcfun ("gsl_matrix_ushort_fprintf" #.(swig-lispify "gsl_matrix_ushort_fprintf" 'function)) :int
(stream :pointer)
(m :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_fprintf" 'function))
(cffi:defcfun ("gsl_matrix_ushort_memcpy" #.(swig-lispify "gsl_matrix_ushort_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_ushort_swap" #.(swig-lispify "gsl_matrix_ushort_swap" 'function)) :int
(m1 :pointer)
(m2 :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_swap" 'function))
(cffi:defcfun ("gsl_matrix_ushort_swap_rows" #.(swig-lispify "gsl_matrix_ushort_swap_rows" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_swap_rows" 'function))
(cffi:defcfun ("gsl_matrix_ushort_swap_columns" #.(swig-lispify "gsl_matrix_ushort_swap_columns" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_swap_columns" 'function))
(cffi:defcfun ("gsl_matrix_ushort_swap_rowcol" #.(swig-lispify "gsl_matrix_ushort_swap_rowcol" 'function)) :int
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_swap_rowcol" 'function))
(cffi:defcfun ("gsl_matrix_ushort_transpose" #.(swig-lispify "gsl_matrix_ushort_transpose" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_transpose" 'function))
(cffi:defcfun ("gsl_matrix_ushort_transpose_memcpy" #.(swig-lispify "gsl_matrix_ushort_transpose_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_transpose_memcpy" 'function))
(cffi:defcfun ("gsl_matrix_ushort_max" #.(swig-lispify "gsl_matrix_ushort_max" 'function)) :unsigned-short
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_max" 'function))
(cffi:defcfun ("gsl_matrix_ushort_min" #.(swig-lispify "gsl_matrix_ushort_min" 'function)) :unsigned-short
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_min" 'function))
(cffi:defcfun ("gsl_matrix_ushort_minmax" #.(swig-lispify "gsl_matrix_ushort_minmax" 'function)) :void
(m :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_minmax" 'function))
(cffi:defcfun ("gsl_matrix_ushort_max_index" #.(swig-lispify "gsl_matrix_ushort_max_index" 'function)) :void
(m :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_max_index" 'function))
(cffi:defcfun ("gsl_matrix_ushort_min_index" #.(swig-lispify "gsl_matrix_ushort_min_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_min_index" 'function))
(cffi:defcfun ("gsl_matrix_ushort_minmax_index" #.(swig-lispify "gsl_matrix_ushort_minmax_index" 'function)) :void
(m :pointer)
(imin :pointer)
(jmin :pointer)
(imax :pointer)
(jmax :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_minmax_index" 'function))
(cffi:defcfun ("gsl_matrix_ushort_equal" #.(swig-lispify "gsl_matrix_ushort_equal" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_equal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_isnull" #.(swig-lispify "gsl_matrix_ushort_isnull" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_isnull" 'function))
(cffi:defcfun ("gsl_matrix_ushort_ispos" #.(swig-lispify "gsl_matrix_ushort_ispos" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_ispos" 'function))
(cffi:defcfun ("gsl_matrix_ushort_isneg" #.(swig-lispify "gsl_matrix_ushort_isneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_isneg" 'function))
(cffi:defcfun ("gsl_matrix_ushort_isnonneg" #.(swig-lispify "gsl_matrix_ushort_isnonneg" 'function)) :int
(m :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_isnonneg" 'function))
(cffi:defcfun ("gsl_matrix_ushort_add" #.(swig-lispify "gsl_matrix_ushort_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_add" 'function))
(cffi:defcfun ("gsl_matrix_ushort_sub" #.(swig-lispify "gsl_matrix_ushort_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_sub" 'function))
(cffi:defcfun ("gsl_matrix_ushort_mul_elements" #.(swig-lispify "gsl_matrix_ushort_mul_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_mul_elements" 'function))
(cffi:defcfun ("gsl_matrix_ushort_div_elements" #.(swig-lispify "gsl_matrix_ushort_div_elements" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_div_elements" 'function))
(cffi:defcfun ("gsl_matrix_ushort_scale" #.(swig-lispify "gsl_matrix_ushort_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_scale" 'function))
(cffi:defcfun ("gsl_matrix_ushort_add_constant" #.(swig-lispify "gsl_matrix_ushort_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_add_constant" 'function))
(cffi:defcfun ("gsl_matrix_ushort_add_diagonal" #.(swig-lispify "gsl_matrix_ushort_add_diagonal" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_add_diagonal" 'function))
(cffi:defcfun ("gsl_matrix_ushort_get_row" #.(swig-lispify "gsl_matrix_ushort_get_row" 'function)) :int
(v :pointer)
(m :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_get_row" 'function))
(cffi:defcfun ("gsl_matrix_ushort_get_col" #.(swig-lispify "gsl_matrix_ushort_get_col" 'function)) :int
(v :pointer)
(m :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_get_col" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set_row" #.(swig-lispify "gsl_matrix_ushort_set_row" 'function)) :int
(m :pointer)
(i :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set_row" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set_col" #.(swig-lispify "gsl_matrix_ushort_set_col" 'function)) :int
(m :pointer)
(j :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set_col" 'function))
(cffi:defcfun ("gsl_matrix_ushort_get" #.(swig-lispify "gsl_matrix_ushort_get" 'function)) :unsigned-short
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_get" 'function))
(cffi:defcfun ("gsl_matrix_ushort_set" #.(swig-lispify "gsl_matrix_ushort_set" 'function)) :void
(m :pointer)
(i :pointer)
(j :pointer)
(x :unsigned-short))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_set" 'function))
(cffi:defcfun ("gsl_matrix_ushort_ptr" #.(swig-lispify "gsl_matrix_ushort_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_ptr" 'function))
(cffi:defcfun ("gsl_matrix_ushort_const_ptr" #.(swig-lispify "gsl_matrix_ushort_const_ptr" 'function)) :pointer
(m :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_matrix_ushort_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_min_fminimizer_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_min_fminimizer" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "x_minimum" 'slotname) :double)
(#.(swig-lispify "x_lower" 'slotname) :double)
(#.(swig-lispify "x_upper" 'slotname) :double)
(#.(swig-lispify "f_minimum" 'slotname) :double)
(#.(swig-lispify "f_lower" 'slotname) :double)
(#.(swig-lispify "f_upper" 'slotname) :double)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "x_minimum" 'slotname))
(cl:export '#.(swig-lispify "x_lower" 'slotname))
(cl:export '#.(swig-lispify "x_upper" 'slotname))
(cl:export '#.(swig-lispify "f_minimum" 'slotname))
(cl:export '#.(swig-lispify "f_lower" 'slotname))
(cl:export '#.(swig-lispify "f_upper" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_min_fminimizer_alloc" #.(swig-lispify "gsl_min_fminimizer_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_alloc" 'function))
(cffi:defcfun ("gsl_min_fminimizer_free" #.(swig-lispify "gsl_min_fminimizer_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_free" 'function))
(cffi:defcfun ("gsl_min_fminimizer_set" #.(swig-lispify "gsl_min_fminimizer_set" 'function)) :int
(s :pointer)
(f :pointer)
(x_minimum :double)
(x_lower :double)
(x_upper :double))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_set" 'function))
(cffi:defcfun ("gsl_min_fminimizer_set_with_values" #.(swig-lispify "gsl_min_fminimizer_set_with_values" 'function)) :int
(s :pointer)
(f :pointer)
(x_minimum :double)
(f_minimum :double)
(x_lower :double)
(f_lower :double)
(x_upper :double)
(f_upper :double))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_set_with_values" 'function))
(cffi:defcfun ("gsl_min_fminimizer_iterate" #.(swig-lispify "gsl_min_fminimizer_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_iterate" 'function))
(cffi:defcfun ("gsl_min_fminimizer_name" #.(swig-lispify "gsl_min_fminimizer_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_name" 'function))
(cffi:defcfun ("gsl_min_fminimizer_x_minimum" #.(swig-lispify "gsl_min_fminimizer_x_minimum" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_x_minimum" 'function))
(cffi:defcfun ("gsl_min_fminimizer_x_lower" #.(swig-lispify "gsl_min_fminimizer_x_lower" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_x_lower" 'function))
(cffi:defcfun ("gsl_min_fminimizer_x_upper" #.(swig-lispify "gsl_min_fminimizer_x_upper" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_x_upper" 'function))
(cffi:defcfun ("gsl_min_fminimizer_f_minimum" #.(swig-lispify "gsl_min_fminimizer_f_minimum" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_f_minimum" 'function))
(cffi:defcfun ("gsl_min_fminimizer_f_lower" #.(swig-lispify "gsl_min_fminimizer_f_lower" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_f_lower" 'function))
(cffi:defcfun ("gsl_min_fminimizer_f_upper" #.(swig-lispify "gsl_min_fminimizer_f_upper" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_f_upper" 'function))
(cffi:defcfun ("gsl_min_fminimizer_minimum" #.(swig-lispify "gsl_min_fminimizer_minimum" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_min_fminimizer_minimum" 'function))
(cffi:defcfun ("gsl_min_test_interval" #.(swig-lispify "gsl_min_test_interval" 'function)) :int
(x_lower :double)
(x_upper :double)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_min_test_interval" 'function))
(cffi:defcvar ("gsl_min_fminimizer_goldensection" #.(swig-lispify "gsl_min_fminimizer_goldensection" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_min_fminimizer_goldensection" 'variable))
(cffi:defcvar ("gsl_min_fminimizer_brent" #.(swig-lispify "gsl_min_fminimizer_brent" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_min_fminimizer_brent" 'variable))
(cffi:defcvar ("gsl_min_fminimizer_quad_golden" #.(swig-lispify "gsl_min_fminimizer_quad_golden" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_min_fminimizer_quad_golden" 'variable))
(cffi:defcfun ("gsl_min_find_bracket" #.(swig-lispify "gsl_min_find_bracket" 'function)) :int
(f :pointer)
(x_minimum :pointer)
(f_minimum :pointer)
(x_lower :pointer)
(f_lower :pointer)
(x_upper :pointer)
(f_upper :pointer)
(eval_max :pointer))
(cl:export '#.(swig-lispify "gsl_min_find_bracket" 'function))
(cffi:defcfun ("gsl_max" #.(swig-lispify "gsl_max" 'function)) :double
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_max" 'function))
(cffi:defcfun ("gsl_min" #.(swig-lispify "gsl_min" 'function)) :double
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_min" 'function))
(cl:defconstant #.(swig-lispify "GSL_PREC_DOUBLE" 'constant) 0)
(cl:export '#.(swig-lispify "GSL_PREC_DOUBLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_PREC_SINGLE" 'constant) 1)
(cl:export '#.(swig-lispify "GSL_PREC_SINGLE" 'constant))
(cl:defconstant #.(swig-lispify "GSL_PREC_APPROX" 'constant) 2)
(cl:export '#.(swig-lispify "GSL_PREC_APPROX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_MODE_DEFAULT" 'constant) 0)
(cl:export '#.(swig-lispify "GSL_MODE_DEFAULT" 'constant))
(cffi:defcstruct #.(swig-lispify "gsl_monte_function_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "dim" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_monte_function_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "dim" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_monte_miser_state" 'classname)
(#.(swig-lispify "min_calls" 'slotname) :pointer)
(#.(swig-lispify "min_calls_per_bisection" 'slotname) :pointer)
(#.(swig-lispify "dither" 'slotname) :double)
(#.(swig-lispify "estimate_frac" 'slotname) :double)
(#.(swig-lispify "alpha" 'slotname) :double)
(#.(swig-lispify "dim" 'slotname) :pointer)
(#.(swig-lispify "estimate_style" 'slotname) :int)
(#.(swig-lispify "depth" 'slotname) :int)
(#.(swig-lispify "verbose" 'slotname) :int)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "xmid" 'slotname) :pointer)
(#.(swig-lispify "sigma_l" 'slotname) :pointer)
(#.(swig-lispify "sigma_r" 'slotname) :pointer)
(#.(swig-lispify "fmax_l" 'slotname) :pointer)
(#.(swig-lispify "fmax_r" 'slotname) :pointer)
(#.(swig-lispify "fmin_l" 'slotname) :pointer)
(#.(swig-lispify "fmin_r" 'slotname) :pointer)
(#.(swig-lispify "fsum_l" 'slotname) :pointer)
(#.(swig-lispify "fsum_r" 'slotname) :pointer)
(#.(swig-lispify "fsum2_l" 'slotname) :pointer)
(#.(swig-lispify "fsum2_r" 'slotname) :pointer)
(#.(swig-lispify "hits_l" 'slotname) :pointer)
(#.(swig-lispify "hits_r" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_state" 'classname))
(cl:export '#.(swig-lispify "min_calls" 'slotname))
(cl:export '#.(swig-lispify "min_calls_per_bisection" 'slotname))
(cl:export '#.(swig-lispify "dither" 'slotname))
(cl:export '#.(swig-lispify "estimate_frac" 'slotname))
(cl:export '#.(swig-lispify "alpha" 'slotname))
(cl:export '#.(swig-lispify "dim" 'slotname))
(cl:export '#.(swig-lispify "estimate_style" 'slotname))
(cl:export '#.(swig-lispify "depth" 'slotname))
(cl:export '#.(swig-lispify "verbose" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "xmid" 'slotname))
(cl:export '#.(swig-lispify "sigma_l" 'slotname))
(cl:export '#.(swig-lispify "sigma_r" 'slotname))
(cl:export '#.(swig-lispify "fmax_l" 'slotname))
(cl:export '#.(swig-lispify "fmax_r" 'slotname))
(cl:export '#.(swig-lispify "fmin_l" 'slotname))
(cl:export '#.(swig-lispify "fmin_r" 'slotname))
(cl:export '#.(swig-lispify "fsum_l" 'slotname))
(cl:export '#.(swig-lispify "fsum_r" 'slotname))
(cl:export '#.(swig-lispify "fsum2_l" 'slotname))
(cl:export '#.(swig-lispify "fsum2_r" 'slotname))
(cl:export '#.(swig-lispify "hits_l" 'slotname))
(cl:export '#.(swig-lispify "hits_r" 'slotname))
(cffi:defcfun ("gsl_monte_miser_integrate" #.(swig-lispify "gsl_monte_miser_integrate" 'function)) :int
(f :pointer)
(xl :pointer)
(xh :pointer)
(dim :pointer)
(calls :pointer)
(r :pointer)
(state :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_integrate" 'function))
(cffi:defcfun ("gsl_monte_miser_alloc" #.(swig-lispify "gsl_monte_miser_alloc" 'function)) :pointer
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_alloc" 'function))
(cffi:defcfun ("gsl_monte_miser_init" #.(swig-lispify "gsl_monte_miser_init" 'function)) :int
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_init" 'function))
(cffi:defcfun ("gsl_monte_miser_free" #.(swig-lispify "gsl_monte_miser_free" 'function)) :void
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_free" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_monte_miser_params" 'classname)
(#.(swig-lispify "estimate_frac" 'slotname) :double)
(#.(swig-lispify "min_calls" 'slotname) :pointer)
(#.(swig-lispify "min_calls_per_bisection" 'slotname) :pointer)
(#.(swig-lispify "alpha" 'slotname) :double)
(#.(swig-lispify "dither" 'slotname) :double))
(cl:export '#.(swig-lispify "gsl_monte_miser_params" 'classname))
(cl:export '#.(swig-lispify "estimate_frac" 'slotname))
(cl:export '#.(swig-lispify "min_calls" 'slotname))
(cl:export '#.(swig-lispify "min_calls_per_bisection" 'slotname))
(cl:export '#.(swig-lispify "alpha" 'slotname))
(cl:export '#.(swig-lispify "dither" 'slotname))
(cffi:defcfun ("gsl_monte_miser_params_get" #.(swig-lispify "gsl_monte_miser_params_get" 'function)) :void
(state :pointer)
(params :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_params_get" 'function))
(cffi:defcfun ("gsl_monte_miser_params_set" #.(swig-lispify "gsl_monte_miser_params_set" 'function)) :void
(state :pointer)
(params :pointer))
(cl:export '#.(swig-lispify "gsl_monte_miser_params_set" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_monte_plain_state" 'classname)
(#.(swig-lispify "dim" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_monte_plain_state" 'classname))
(cl:export '#.(swig-lispify "dim" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cffi:defcfun ("gsl_monte_plain_integrate" #.(swig-lispify "gsl_monte_plain_integrate" 'function)) :int
(f :pointer)
(xl :pointer)
(xu :pointer)
(dim :pointer)
(calls :pointer)
(r :pointer)
(state :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_monte_plain_integrate" 'function))
(cffi:defcfun ("gsl_monte_plain_alloc" #.(swig-lispify "gsl_monte_plain_alloc" 'function)) :pointer
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_monte_plain_alloc" 'function))
(cffi:defcfun ("gsl_monte_plain_init" #.(swig-lispify "gsl_monte_plain_init" 'function)) :int
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_plain_init" 'function))
(cffi:defcfun ("gsl_monte_plain_free" #.(swig-lispify "gsl_monte_plain_free" 'function)) :void
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_plain_free" 'function))
(defanonenum
(#.(swig-lispify "GSL_VEGAS_MODE_IMPORTANCE" 'enumvalue) #.1)
(#.(swig-lispify "GSL_VEGAS_MODE_IMPORTANCE_ONLY" 'enumvalue) #.0)
(#.(swig-lispify "GSL_VEGAS_MODE_STRATIFIED" 'enumvalue) #.-1))
(cl:export '#.(swig-lispify "GSL_VEGAS_MODE_IMPORTANCE" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_VEGAS_MODE_IMPORTANCE_ONLY" 'enumvalue))
(cl:export '#.(swig-lispify "GSL_VEGAS_MODE_STRATIFIED" 'enumvalue))
(cffi:defcstruct #.(swig-lispify "gsl_monte_vegas_state" 'classname)
(#.(swig-lispify "dim" 'slotname) :pointer)
(#.(swig-lispify "bins_max" 'slotname) :pointer)
(#.(swig-lispify "bins" 'slotname) :unsigned-int)
(#.(swig-lispify "boxes" 'slotname) :unsigned-int)
(#.(swig-lispify "xi" 'slotname) :pointer)
(#.(swig-lispify "xin" 'slotname) :pointer)
(#.(swig-lispify "delx" 'slotname) :pointer)
(#.(swig-lispify "weight" 'slotname) :pointer)
(#.(swig-lispify "vol" 'slotname) :double)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "bin" 'slotname) :pointer)
(#.(swig-lispify "box" 'slotname) :pointer)
(#.(swig-lispify "d" 'slotname) :pointer)
(#.(swig-lispify "alpha" 'slotname) :double)
(#.(swig-lispify "mode" 'slotname) :int)
(#.(swig-lispify "verbose" 'slotname) :int)
(#.(swig-lispify "iterations" 'slotname) :unsigned-int)
(#.(swig-lispify "stage" 'slotname) :int)
(#.(swig-lispify "jac" 'slotname) :double)
(#.(swig-lispify "wtd_int_sum" 'slotname) :double)
(#.(swig-lispify "sum_wgts" 'slotname) :double)
(#.(swig-lispify "chi_sum" 'slotname) :double)
(#.(swig-lispify "chisq" 'slotname) :double)
(#.(swig-lispify "result" 'slotname) :double)
(#.(swig-lispify "sigma" 'slotname) :double)
(#.(swig-lispify "it_start" 'slotname) :unsigned-int)
(#.(swig-lispify "it_num" 'slotname) :unsigned-int)
(#.(swig-lispify "samples" 'slotname) :unsigned-int)
(#.(swig-lispify "calls_per_box" 'slotname) :unsigned-int)
(#.(swig-lispify "ostream" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_state" 'classname))
(cl:export '#.(swig-lispify "dim" 'slotname))
(cl:export '#.(swig-lispify "bins_max" 'slotname))
(cl:export '#.(swig-lispify "bins" 'slotname))
(cl:export '#.(swig-lispify "boxes" 'slotname))
(cl:export '#.(swig-lispify "xi" 'slotname))
(cl:export '#.(swig-lispify "xin" 'slotname))
(cl:export '#.(swig-lispify "delx" 'slotname))
(cl:export '#.(swig-lispify "weight" 'slotname))
(cl:export '#.(swig-lispify "vol" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "bin" 'slotname))
(cl:export '#.(swig-lispify "box" 'slotname))
(cl:export '#.(swig-lispify "d" 'slotname))
(cl:export '#.(swig-lispify "alpha" 'slotname))
(cl:export '#.(swig-lispify "mode" 'slotname))
(cl:export '#.(swig-lispify "verbose" 'slotname))
(cl:export '#.(swig-lispify "iterations" 'slotname))
(cl:export '#.(swig-lispify "stage" 'slotname))
(cl:export '#.(swig-lispify "jac" 'slotname))
(cl:export '#.(swig-lispify "wtd_int_sum" 'slotname))
(cl:export '#.(swig-lispify "sum_wgts" 'slotname))
(cl:export '#.(swig-lispify "chi_sum" 'slotname))
(cl:export '#.(swig-lispify "chisq" 'slotname))
(cl:export '#.(swig-lispify "result" 'slotname))
(cl:export '#.(swig-lispify "sigma" 'slotname))
(cl:export '#.(swig-lispify "it_start" 'slotname))
(cl:export '#.(swig-lispify "it_num" 'slotname))
(cl:export '#.(swig-lispify "samples" 'slotname))
(cl:export '#.(swig-lispify "calls_per_box" 'slotname))
(cl:export '#.(swig-lispify "ostream" 'slotname))
(cffi:defcfun ("gsl_monte_vegas_integrate" #.(swig-lispify "gsl_monte_vegas_integrate" 'function)) :int
(f :pointer)
(xl :pointer)
(xu :pointer)
(dim :pointer)
(calls :pointer)
(r :pointer)
(state :pointer)
(result :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_integrate" 'function))
(cffi:defcfun ("gsl_monte_vegas_alloc" #.(swig-lispify "gsl_monte_vegas_alloc" 'function)) :pointer
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_alloc" 'function))
(cffi:defcfun ("gsl_monte_vegas_init" #.(swig-lispify "gsl_monte_vegas_init" 'function)) :int
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_init" 'function))
(cffi:defcfun ("gsl_monte_vegas_free" #.(swig-lispify "gsl_monte_vegas_free" 'function)) :void
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_free" 'function))
(cffi:defcfun ("gsl_monte_vegas_chisq" #.(swig-lispify "gsl_monte_vegas_chisq" 'function)) :double
(state :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_chisq" 'function))
(cffi:defcfun ("gsl_monte_vegas_runval" #.(swig-lispify "gsl_monte_vegas_runval" 'function)) :void
(state :pointer)
(result :pointer)
(sigma :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_runval" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_monte_vegas_params" 'classname)
(#.(swig-lispify "alpha" 'slotname) :double)
(#.(swig-lispify "iterations" 'slotname) :pointer)
(#.(swig-lispify "stage" 'slotname) :int)
(#.(swig-lispify "mode" 'slotname) :int)
(#.(swig-lispify "verbose" 'slotname) :int)
(#.(swig-lispify "ostream" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_params" 'classname))
(cl:export '#.(swig-lispify "alpha" 'slotname))
(cl:export '#.(swig-lispify "iterations" 'slotname))
(cl:export '#.(swig-lispify "stage" 'slotname))
(cl:export '#.(swig-lispify "mode" 'slotname))
(cl:export '#.(swig-lispify "verbose" 'slotname))
(cl:export '#.(swig-lispify "ostream" 'slotname))
(cffi:defcfun ("gsl_monte_vegas_params_get" #.(swig-lispify "gsl_monte_vegas_params_get" 'function)) :void
(state :pointer)
(params :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_params_get" 'function))
(cffi:defcfun ("gsl_monte_vegas_params_set" #.(swig-lispify "gsl_monte_vegas_params_set" 'function)) :void
(state :pointer)
(params :pointer))
(cl:export '#.(swig-lispify "gsl_monte_vegas_params_set" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_linear_workspace" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "p" 'slotname) :pointer)
(#.(swig-lispify "A" 'slotname) :pointer)
(#.(swig-lispify "Q" 'slotname) :pointer)
(#.(swig-lispify "QSI" 'slotname) :pointer)
(#.(swig-lispify "S" 'slotname) :pointer)
(#.(swig-lispify "t" 'slotname) :pointer)
(#.(swig-lispify "xt" 'slotname) :pointer)
(#.(swig-lispify "D" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_workspace" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "p" 'slotname))
(cl:export '#.(swig-lispify "A" 'slotname))
(cl:export '#.(swig-lispify "Q" 'slotname))
(cl:export '#.(swig-lispify "QSI" 'slotname))
(cl:export '#.(swig-lispify "S" 'slotname))
(cl:export '#.(swig-lispify "t" 'slotname))
(cl:export '#.(swig-lispify "xt" 'slotname))
(cl:export '#.(swig-lispify "D" 'slotname))
(cffi:defcfun ("gsl_multifit_linear_alloc" #.(swig-lispify "gsl_multifit_linear_alloc" 'function)) :pointer
(n :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_alloc" 'function))
(cffi:defcfun ("gsl_multifit_linear_free" #.(swig-lispify "gsl_multifit_linear_free" 'function)) :void
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_free" 'function))
(cffi:defcfun ("gsl_multifit_linear" #.(swig-lispify "gsl_multifit_linear" 'function)) :int
(X :pointer)
(y :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear" 'function))
(cffi:defcfun ("gsl_multifit_linear_svd" #.(swig-lispify "gsl_multifit_linear_svd" 'function)) :int
(X :pointer)
(y :pointer)
(tol :double)
(rank :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_svd" 'function))
(cffi:defcfun ("gsl_multifit_linear_usvd" #.(swig-lispify "gsl_multifit_linear_usvd" 'function)) :int
(X :pointer)
(y :pointer)
(tol :double)
(rank :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_usvd" 'function))
(cffi:defcfun ("gsl_multifit_wlinear" #.(swig-lispify "gsl_multifit_wlinear" 'function)) :int
(X :pointer)
(w :pointer)
(y :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_wlinear" 'function))
(cffi:defcfun ("gsl_multifit_wlinear_svd" #.(swig-lispify "gsl_multifit_wlinear_svd" 'function)) :int
(X :pointer)
(w :pointer)
(y :pointer)
(tol :double)
(rank :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_wlinear_svd" 'function))
(cffi:defcfun ("gsl_multifit_wlinear_usvd" #.(swig-lispify "gsl_multifit_wlinear_usvd" 'function)) :int
(X :pointer)
(w :pointer)
(y :pointer)
(tol :double)
(rank :pointer)
(c :pointer)
(cov :pointer)
(chisq :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_wlinear_usvd" 'function))
(cffi:defcfun ("gsl_multifit_linear_est" #.(swig-lispify "gsl_multifit_linear_est" 'function)) :int
(x :pointer)
(c :pointer)
(cov :pointer)
(y :pointer)
(y_err :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_est" 'function))
(cffi:defcfun ("gsl_multifit_linear_residuals" #.(swig-lispify "gsl_multifit_linear_residuals" 'function)) :int
(X :pointer)
(y :pointer)
(c :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_linear_residuals" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_robust_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "wfun" 'slotname) :pointer)
(#.(swig-lispify "psi_deriv" 'slotname) :pointer)
(#.(swig-lispify "tuning_default" 'slotname) :double))
(cl:export '#.(swig-lispify "gsl_multifit_robust_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "wfun" 'slotname))
(cl:export '#.(swig-lispify "psi_deriv" 'slotname))
(cl:export '#.(swig-lispify "tuning_default" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_robust_stats" 'classname)
(#.(swig-lispify "sigma_ols" 'slotname) :double)
(#.(swig-lispify "sigma_mad" 'slotname) :double)
(#.(swig-lispify "sigma_rob" 'slotname) :double)
(#.(swig-lispify "sigma" 'slotname) :double)
(#.(swig-lispify "Rsq" 'slotname) :double)
(#.(swig-lispify "adj_Rsq" 'slotname) :double)
(#.(swig-lispify "rmse" 'slotname) :double)
(#.(swig-lispify "sse" 'slotname) :double)
(#.(swig-lispify "dof" 'slotname) :pointer)
(#.(swig-lispify "numit" 'slotname) :pointer)
(#.(swig-lispify "weights" 'slotname) :pointer)
(#.(swig-lispify "r" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_stats" 'classname))
(cl:export '#.(swig-lispify "sigma_ols" 'slotname))
(cl:export '#.(swig-lispify "sigma_mad" 'slotname))
(cl:export '#.(swig-lispify "sigma_rob" 'slotname))
(cl:export '#.(swig-lispify "sigma" 'slotname))
(cl:export '#.(swig-lispify "Rsq" 'slotname))
(cl:export '#.(swig-lispify "adj_Rsq" 'slotname))
(cl:export '#.(swig-lispify "rmse" 'slotname))
(cl:export '#.(swig-lispify "sse" 'slotname))
(cl:export '#.(swig-lispify "dof" 'slotname))
(cl:export '#.(swig-lispify "numit" 'slotname))
(cl:export '#.(swig-lispify "weights" 'slotname))
(cl:export '#.(swig-lispify "r" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_robust_workspace" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "p" 'slotname) :pointer)
(#.(swig-lispify "numit" 'slotname) :pointer)
(#.(swig-lispify "maxiter" 'slotname) :pointer)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "tune" 'slotname) :double)
(#.(swig-lispify "r" 'slotname) :pointer)
(#.(swig-lispify "weights" 'slotname) :pointer)
(#.(swig-lispify "c_prev" 'slotname) :pointer)
(#.(swig-lispify "resfac" 'slotname) :pointer)
(#.(swig-lispify "psi" 'slotname) :pointer)
(#.(swig-lispify "dpsi" 'slotname) :pointer)
(#.(swig-lispify "QSI" 'slotname) :pointer)
(#.(swig-lispify "D" 'slotname) :pointer)
(#.(swig-lispify "workn" 'slotname) :pointer)
(#.(swig-lispify "stats" 'slotname) #.(swig-lispify "gsl_multifit_robust_stats" 'classname))
(#.(swig-lispify "multifit_p" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_workspace" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "p" 'slotname))
(cl:export '#.(swig-lispify "numit" 'slotname))
(cl:export '#.(swig-lispify "maxiter" 'slotname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "tune" 'slotname))
(cl:export '#.(swig-lispify "r" 'slotname))
(cl:export '#.(swig-lispify "weights" 'slotname))
(cl:export '#.(swig-lispify "c_prev" 'slotname))
(cl:export '#.(swig-lispify "resfac" 'slotname))
(cl:export '#.(swig-lispify "psi" 'slotname))
(cl:export '#.(swig-lispify "dpsi" 'slotname))
(cl:export '#.(swig-lispify "QSI" 'slotname))
(cl:export '#.(swig-lispify "D" 'slotname))
(cl:export '#.(swig-lispify "workn" 'slotname))
(cl:export '#.(swig-lispify "stats" 'slotname))
(cl:export '#.(swig-lispify "multifit_p" 'slotname))
(cffi:defcvar ("gsl_multifit_robust_default" #.(swig-lispify "gsl_multifit_robust_default" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_default" 'variable))
(cffi:defcvar ("gsl_multifit_robust_bisquare" #.(swig-lispify "gsl_multifit_robust_bisquare" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_bisquare" 'variable))
(cffi:defcvar ("gsl_multifit_robust_cauchy" #.(swig-lispify "gsl_multifit_robust_cauchy" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_cauchy" 'variable))
(cffi:defcvar ("gsl_multifit_robust_fair" #.(swig-lispify "gsl_multifit_robust_fair" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_fair" 'variable))
(cffi:defcvar ("gsl_multifit_robust_huber" #.(swig-lispify "gsl_multifit_robust_huber" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_huber" 'variable))
(cffi:defcvar ("gsl_multifit_robust_ols" #.(swig-lispify "gsl_multifit_robust_ols" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_ols" 'variable))
(cffi:defcvar ("gsl_multifit_robust_welsch" #.(swig-lispify "gsl_multifit_robust_welsch" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_robust_welsch" 'variable))
(cffi:defcfun ("gsl_multifit_robust_alloc" #.(swig-lispify "gsl_multifit_robust_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_alloc" 'function))
(cffi:defcfun ("gsl_multifit_robust_free" #.(swig-lispify "gsl_multifit_robust_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_free" 'function))
(cffi:defcfun ("gsl_multifit_robust_tune" #.(swig-lispify "gsl_multifit_robust_tune" 'function)) :int
(tune :double)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_tune" 'function))
(cffi:defcfun ("gsl_multifit_robust_name" #.(swig-lispify "gsl_multifit_robust_name" 'function)) :string
(w :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_name" 'function))
(cffi:defcfun ("gsl_multifit_robust_statistics" #.(swig-lispify "gsl_multifit_robust_statistics" 'function)) #.(swig-lispify "gsl_multifit_robust_stats" 'classname)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_statistics" 'function))
(cffi:defcfun ("gsl_multifit_robust" #.(swig-lispify "gsl_multifit_robust" 'function)) :int
(X :pointer)
(y :pointer)
(c :pointer)
(cov :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust" 'function))
(cffi:defcfun ("gsl_multifit_robust_est" #.(swig-lispify "gsl_multifit_robust_est" 'function)) :int
(x :pointer)
(c :pointer)
(cov :pointer)
(y :pointer)
(y_err :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_robust_est" 'function))
(cffi:defcfun ("gsl_multifit_gradient" #.(swig-lispify "gsl_multifit_gradient" 'function)) :int
(J :pointer)
(f :pointer)
(g :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_gradient" 'function))
(cffi:defcfun ("gsl_multifit_covar" #.(swig-lispify "gsl_multifit_covar" 'function)) :int
(J :pointer)
(epsrel :double)
(covar :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_covar" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_function_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "p" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_function_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "p" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_fsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_fsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "dx" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "dx" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multifit_fsolver_alloc" #.(swig-lispify "gsl_multifit_fsolver_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_alloc" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_free" #.(swig-lispify "gsl_multifit_fsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_free" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_set" #.(swig-lispify "gsl_multifit_fsolver_set" 'function)) :int
(s :pointer)
(f :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_set" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_iterate" #.(swig-lispify "gsl_multifit_fsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_iterate" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_driver" #.(swig-lispify "gsl_multifit_fsolver_driver" 'function)) :int
(s :pointer)
(maxiter :pointer)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_driver" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_name" #.(swig-lispify "gsl_multifit_fsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_name" 'function))
(cffi:defcfun ("gsl_multifit_fsolver_position" #.(swig-lispify "gsl_multifit_fsolver_position" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fsolver_position" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_function_fdf_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "df" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "p" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_function_fdf_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "df" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "p" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_fdfsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multifit_fdfsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "J" 'slotname) :pointer)
(#.(swig-lispify "dx" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "J" 'slotname))
(cl:export '#.(swig-lispify "dx" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multifit_fdfsolver_alloc" #.(swig-lispify "gsl_multifit_fdfsolver_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_alloc" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_set" #.(swig-lispify "gsl_multifit_fdfsolver_set" 'function)) :int
(s :pointer)
(fdf :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_set" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_iterate" #.(swig-lispify "gsl_multifit_fdfsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_iterate" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_driver" #.(swig-lispify "gsl_multifit_fdfsolver_driver" 'function)) :int
(s :pointer)
(maxiter :pointer)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_driver" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_free" #.(swig-lispify "gsl_multifit_fdfsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_free" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_name" #.(swig-lispify "gsl_multifit_fdfsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_name" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_position" #.(swig-lispify "gsl_multifit_fdfsolver_position" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_position" 'function))
(cffi:defcfun ("gsl_multifit_test_delta" #.(swig-lispify "gsl_multifit_test_delta" 'function)) :int
(dx :pointer)
(x :pointer)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_multifit_test_delta" 'function))
(cffi:defcfun ("gsl_multifit_test_gradient" #.(swig-lispify "gsl_multifit_test_gradient" 'function)) :int
(g :pointer)
(epsabs :double))
(cl:export '#.(swig-lispify "gsl_multifit_test_gradient" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_dif_df" #.(swig-lispify "gsl_multifit_fdfsolver_dif_df" 'function)) :int
(x :pointer)
(fdf :pointer)
(f :pointer)
(J :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_dif_df" 'function))
(cffi:defcfun ("gsl_multifit_fdfsolver_dif_fdf" #.(swig-lispify "gsl_multifit_fdfsolver_dif_fdf" 'function)) :int
(x :pointer)
(fdf :pointer)
(f :pointer)
(J :pointer))
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_dif_fdf" 'function))
(cffi:defcvar ("gsl_multifit_fdfsolver_lmder" #.(swig-lispify "gsl_multifit_fdfsolver_lmder" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_lmder" 'variable))
(cffi:defcvar ("gsl_multifit_fdfsolver_lmsder" #.(swig-lispify "gsl_multifit_fdfsolver_lmsder" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multifit_fdfsolver_lmsder" 'variable))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_function_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_function_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_function_fdf_struct" 'classname)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "df" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_function_fdf_struct" 'classname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "df" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcfun ("gsl_multimin_diff" #.(swig-lispify "gsl_multimin_diff" 'function)) :int
(f :pointer)
(x :pointer)
(g :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_diff" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_fminimizer_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_fminimizer" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :pointer)
(#.(swig-lispify "fval" 'slotname) :double)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "size" 'slotname) :double)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "fval" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multimin_fminimizer_alloc" #.(swig-lispify "gsl_multimin_fminimizer_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_alloc" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_set" #.(swig-lispify "gsl_multimin_fminimizer_set" 'function)) :int
(s :pointer)
(f :pointer)
(x :pointer)
(step_size :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_set" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_free" #.(swig-lispify "gsl_multimin_fminimizer_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_free" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_name" #.(swig-lispify "gsl_multimin_fminimizer_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_name" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_iterate" #.(swig-lispify "gsl_multimin_fminimizer_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_iterate" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_x" #.(swig-lispify "gsl_multimin_fminimizer_x" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_x" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_minimum" #.(swig-lispify "gsl_multimin_fminimizer_minimum" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_minimum" 'function))
(cffi:defcfun ("gsl_multimin_fminimizer_size" #.(swig-lispify "gsl_multimin_fminimizer_size" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_size" 'function))
(cffi:defcfun ("gsl_multimin_test_gradient" #.(swig-lispify "gsl_multimin_test_gradient" 'function)) :int
(g :pointer)
(epsabs :double))
(cl:export '#.(swig-lispify "gsl_multimin_test_gradient" 'function))
(cffi:defcfun ("gsl_multimin_test_size" #.(swig-lispify "gsl_multimin_test_size" 'function)) :int
(size :double)
(epsabs :double))
(cl:export '#.(swig-lispify "gsl_multimin_test_size" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_fdfminimizer_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer)
(#.(swig-lispify "restart" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cl:export '#.(swig-lispify "restart" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_multimin_fdfminimizer" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "f" 'slotname) :double)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "gradient" 'slotname) :pointer)
(#.(swig-lispify "dx" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "f" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "gradient" 'slotname))
(cl:export '#.(swig-lispify "dx" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_multimin_fdfminimizer_alloc" #.(swig-lispify "gsl_multimin_fdfminimizer_alloc" 'function)) :pointer
(t_arg0 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_alloc" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_set" #.(swig-lispify "gsl_multimin_fdfminimizer_set" 'function)) :int
(s :pointer)
(fdf :pointer)
(x :pointer)
(step_size :double)
(tol :double))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_set" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_free" #.(swig-lispify "gsl_multimin_fdfminimizer_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_free" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_name" #.(swig-lispify "gsl_multimin_fdfminimizer_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_name" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_iterate" #.(swig-lispify "gsl_multimin_fdfminimizer_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_iterate" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_restart" #.(swig-lispify "gsl_multimin_fdfminimizer_restart" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_restart" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_x" #.(swig-lispify "gsl_multimin_fdfminimizer_x" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_x" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_dx" #.(swig-lispify "gsl_multimin_fdfminimizer_dx" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_dx" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_gradient" #.(swig-lispify "gsl_multimin_fdfminimizer_gradient" 'function)) :pointer
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_gradient" 'function))
(cffi:defcfun ("gsl_multimin_fdfminimizer_minimum" #.(swig-lispify "gsl_multimin_fdfminimizer_minimum" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_minimum" 'function))
(cffi:defcvar ("gsl_multimin_fdfminimizer_steepest_descent" #.(swig-lispify "gsl_multimin_fdfminimizer_steepest_descent" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_steepest_descent" 'variable))
(cffi:defcvar ("gsl_multimin_fdfminimizer_conjugate_pr" #.(swig-lispify "gsl_multimin_fdfminimizer_conjugate_pr" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_conjugate_pr" 'variable))
(cffi:defcvar ("gsl_multimin_fdfminimizer_conjugate_fr" #.(swig-lispify "gsl_multimin_fdfminimizer_conjugate_fr" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_conjugate_fr" 'variable))
(cffi:defcvar ("gsl_multimin_fdfminimizer_vector_bfgs" #.(swig-lispify "gsl_multimin_fdfminimizer_vector_bfgs" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_vector_bfgs" 'variable))
(cffi:defcvar ("gsl_multimin_fdfminimizer_vector_bfgs2" #.(swig-lispify "gsl_multimin_fdfminimizer_vector_bfgs2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fdfminimizer_vector_bfgs2" 'variable))
(cffi:defcvar ("gsl_multimin_fminimizer_nmsimplex" #.(swig-lispify "gsl_multimin_fminimizer_nmsimplex" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_nmsimplex" 'variable))
(cffi:defcvar ("gsl_multimin_fminimizer_nmsimplex2" #.(swig-lispify "gsl_multimin_fminimizer_nmsimplex2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_nmsimplex2" 'variable))
(cffi:defcvar ("gsl_multimin_fminimizer_nmsimplex2rand" #.(swig-lispify "gsl_multimin_fminimizer_nmsimplex2rand" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_multimin_fminimizer_nmsimplex2rand" 'variable))
(cffi:defcstruct #.(swig-lispify "gsl_multiset_struct" 'classname)
(#.(swig-lispify "n" 'slotname) :pointer)
(#.(swig-lispify "k" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_struct" 'classname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "k" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_multiset_alloc" #.(swig-lispify "gsl_multiset_alloc" 'function)) :pointer
(n :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_alloc" 'function))
(cffi:defcfun ("gsl_multiset_calloc" #.(swig-lispify "gsl_multiset_calloc" 'function)) :pointer
(n :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_calloc" 'function))
(cffi:defcfun ("gsl_multiset_init_first" #.(swig-lispify "gsl_multiset_init_first" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_init_first" 'function))
(cffi:defcfun ("gsl_multiset_init_last" #.(swig-lispify "gsl_multiset_init_last" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_init_last" 'function))
(cffi:defcfun ("gsl_multiset_free" #.(swig-lispify "gsl_multiset_free" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_free" 'function))
(cffi:defcfun ("gsl_multiset_memcpy" #.(swig-lispify "gsl_multiset_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_memcpy" 'function))
(cffi:defcfun ("gsl_multiset_fread" #.(swig-lispify "gsl_multiset_fread" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_fread" 'function))
(cffi:defcfun ("gsl_multiset_fwrite" #.(swig-lispify "gsl_multiset_fwrite" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_fwrite" 'function))
(cffi:defcfun ("gsl_multiset_fscanf" #.(swig-lispify "gsl_multiset_fscanf" 'function)) :int
(stream :pointer)
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_fscanf" 'function))
(cffi:defcfun ("gsl_multiset_fprintf" #.(swig-lispify "gsl_multiset_fprintf" 'function)) :int
(stream :pointer)
(c :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_multiset_fprintf" 'function))
(cffi:defcfun ("gsl_multiset_n" #.(swig-lispify "gsl_multiset_n" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_n" 'function))
(cffi:defcfun ("gsl_multiset_k" #.(swig-lispify "gsl_multiset_k" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_k" 'function))
(cffi:defcfun ("gsl_multiset_data" #.(swig-lispify "gsl_multiset_data" 'function)) :pointer
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_data" 'function))
(cffi:defcfun ("gsl_multiset_valid" #.(swig-lispify "gsl_multiset_valid" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_valid" 'function))
(cffi:defcfun ("gsl_multiset_next" #.(swig-lispify "gsl_multiset_next" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_next" 'function))
(cffi:defcfun ("gsl_multiset_prev" #.(swig-lispify "gsl_multiset_prev" 'function)) :int
(c :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_prev" 'function))
(cffi:defcfun ("gsl_multiset_get" #.(swig-lispify "gsl_multiset_get" 'function)) :pointer
(c :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_multiset_get" 'function))
(cl:defconstant #.(swig-lispify "GSL_POSZERO" 'constant) +0.0d0)
(cl:export '#.(swig-lispify "GSL_POSZERO" 'constant))
(cl:defconstant #.(swig-lispify "GSL_NEGZERO" 'constant) -0.0d0)
(cl:export '#.(swig-lispify "GSL_NEGZERO" 'constant))
(cffi:defcstruct #.(swig-lispify "gsl_ntuple" 'classname)
(#.(swig-lispify "file" 'slotname) :pointer)
(#.(swig-lispify "ntuple_data" 'slotname) :pointer)
(#.(swig-lispify "size" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple" 'classname))
(cl:export '#.(swig-lispify "file" 'slotname))
(cl:export '#.(swig-lispify "ntuple_data" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_ntuple_select_fn" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_select_fn" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_ntuple_value_fn" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_value_fn" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcfun ("gsl_ntuple_open" #.(swig-lispify "gsl_ntuple_open" 'function)) :pointer
(filename :string)
(ntuple_data :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_open" 'function))
(cffi:defcfun ("gsl_ntuple_create" #.(swig-lispify "gsl_ntuple_create" 'function)) :pointer
(filename :string)
(ntuple_data :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_create" 'function))
(cffi:defcfun ("gsl_ntuple_write" #.(swig-lispify "gsl_ntuple_write" 'function)) :int
(ntuple :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_write" 'function))
(cffi:defcfun ("gsl_ntuple_read" #.(swig-lispify "gsl_ntuple_read" 'function)) :int
(ntuple :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_read" 'function))
(cffi:defcfun ("gsl_ntuple_bookdata" #.(swig-lispify "gsl_ntuple_bookdata" 'function)) :int
(ntuple :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_bookdata" 'function))
(cffi:defcfun ("gsl_ntuple_project" #.(swig-lispify "gsl_ntuple_project" 'function)) :int
(h :pointer)
(ntuple :pointer)
(value_func :pointer)
(select_func :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_project" 'function))
(cffi:defcfun ("gsl_ntuple_close" #.(swig-lispify "gsl_ntuple_close" 'function)) :int
(ntuple :pointer))
(cl:export '#.(swig-lispify "gsl_ntuple_close" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_system" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "jacobian" 'slotname) :pointer)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_system" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "jacobian" 'slotname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_step_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "can_use_dydt_in" 'slotname) :int)
(#.(swig-lispify "gives_exact_dydt_out" 'slotname) :int)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "apply" 'slotname) :pointer)
(#.(swig-lispify "reset" 'slotname) :pointer)
(#.(swig-lispify "order" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "can_use_dydt_in" 'slotname))
(cl:export '#.(swig-lispify "gives_exact_dydt_out" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "apply" 'slotname))
(cl:export '#.(swig-lispify "reset" 'slotname))
(cl:export '#.(swig-lispify "order" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_step" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcvar ("gsl_odeiv_step_rk2" #.(swig-lispify "gsl_odeiv_step_rk2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk2" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rk4" #.(swig-lispify "gsl_odeiv_step_rk4" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk4" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rkf45" #.(swig-lispify "gsl_odeiv_step_rkf45" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rkf45" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rkck" #.(swig-lispify "gsl_odeiv_step_rkck" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rkck" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rk8pd" #.(swig-lispify "gsl_odeiv_step_rk8pd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk8pd" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rk2imp" #.(swig-lispify "gsl_odeiv_step_rk2imp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk2imp" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rk2simp" #.(swig-lispify "gsl_odeiv_step_rk2simp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk2simp" 'variable))
(cffi:defcvar ("gsl_odeiv_step_rk4imp" #.(swig-lispify "gsl_odeiv_step_rk4imp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_rk4imp" 'variable))
(cffi:defcvar ("gsl_odeiv_step_bsimp" #.(swig-lispify "gsl_odeiv_step_bsimp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_bsimp" 'variable))
(cffi:defcvar ("gsl_odeiv_step_gear1" #.(swig-lispify "gsl_odeiv_step_gear1" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_gear1" 'variable))
(cffi:defcvar ("gsl_odeiv_step_gear2" #.(swig-lispify "gsl_odeiv_step_gear2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv_step_gear2" 'variable))
(cffi:defcfun ("gsl_odeiv_step_alloc" #.(swig-lispify "gsl_odeiv_step_alloc" 'function)) :pointer
(t_arg0 :pointer)
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_alloc" 'function))
(cffi:defcfun ("gsl_odeiv_step_reset" #.(swig-lispify "gsl_odeiv_step_reset" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_reset" 'function))
(cffi:defcfun ("gsl_odeiv_step_free" #.(swig-lispify "gsl_odeiv_step_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_free" 'function))
(cffi:defcfun ("gsl_odeiv_step_name" #.(swig-lispify "gsl_odeiv_step_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_name" 'function))
(cffi:defcfun ("gsl_odeiv_step_order" #.(swig-lispify "gsl_odeiv_step_order" 'function)) :unsigned-int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_order" 'function))
(cffi:defcfun ("gsl_odeiv_step_apply" #.(swig-lispify "gsl_odeiv_step_apply" 'function)) :int
(s :pointer)
(t_arg1 :double)
(h :double)
(y :pointer)
(yerr :pointer)
(dydt_in :pointer)
(dydt_out :pointer)
(dydt :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_step_apply" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_control_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "init" 'slotname) :pointer)
(#.(swig-lispify "hadjust" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "init" 'slotname))
(cl:export '#.(swig-lispify "hadjust" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_control" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cl:defconstant #.(swig-lispify "GSL_ODEIV_HADJ_INC" 'constant) 1)
(cl:export '#.(swig-lispify "GSL_ODEIV_HADJ_INC" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ODEIV_HADJ_NIL" 'constant) 0)
(cl:export '#.(swig-lispify "GSL_ODEIV_HADJ_NIL" 'constant))
(cl:defconstant #.(swig-lispify "GSL_ODEIV_HADJ_DEC" 'constant) -1)
(cl:export '#.(swig-lispify "GSL_ODEIV_HADJ_DEC" 'constant))
(cffi:defcfun ("gsl_odeiv_control_alloc" #.(swig-lispify "gsl_odeiv_control_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_alloc" 'function))
(cffi:defcfun ("gsl_odeiv_control_init" #.(swig-lispify "gsl_odeiv_control_init" 'function)) :int
(c :pointer)
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double))
(cl:export '#.(swig-lispify "gsl_odeiv_control_init" 'function))
(cffi:defcfun ("gsl_odeiv_control_free" #.(swig-lispify "gsl_odeiv_control_free" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_free" 'function))
(cffi:defcfun ("gsl_odeiv_control_hadjust" #.(swig-lispify "gsl_odeiv_control_hadjust" 'function)) :int
(c :pointer)
(s :pointer)
(y :pointer)
(yerr :pointer)
(dydt :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_hadjust" 'function))
(cffi:defcfun ("gsl_odeiv_control_name" #.(swig-lispify "gsl_odeiv_control_name" 'function)) :string
(c :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_name" 'function))
(cffi:defcfun ("gsl_odeiv_control_standard_new" #.(swig-lispify "gsl_odeiv_control_standard_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double))
(cl:export '#.(swig-lispify "gsl_odeiv_control_standard_new" 'function))
(cffi:defcfun ("gsl_odeiv_control_y_new" #.(swig-lispify "gsl_odeiv_control_y_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double))
(cl:export '#.(swig-lispify "gsl_odeiv_control_y_new" 'function))
(cffi:defcfun ("gsl_odeiv_control_yp_new" #.(swig-lispify "gsl_odeiv_control_yp_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double))
(cl:export '#.(swig-lispify "gsl_odeiv_control_yp_new" 'function))
(cffi:defcfun ("gsl_odeiv_control_scaled_new" #.(swig-lispify "gsl_odeiv_control_scaled_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double)
(scale_abs :pointer)
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_control_scaled_new" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv_evolve" 'classname)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "y0" 'slotname) :pointer)
(#.(swig-lispify "yerr" 'slotname) :pointer)
(#.(swig-lispify "dydt_in" 'slotname) :pointer)
(#.(swig-lispify "dydt_out" 'slotname) :pointer)
(#.(swig-lispify "last_step" 'slotname) :double)
(#.(swig-lispify "count" 'slotname) :unsigned-long)
(#.(swig-lispify "failed_steps" 'slotname) :unsigned-long))
(cl:export '#.(swig-lispify "gsl_odeiv_evolve" 'classname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "y0" 'slotname))
(cl:export '#.(swig-lispify "yerr" 'slotname))
(cl:export '#.(swig-lispify "dydt_in" 'slotname))
(cl:export '#.(swig-lispify "dydt_out" 'slotname))
(cl:export '#.(swig-lispify "last_step" 'slotname))
(cl:export '#.(swig-lispify "count" 'slotname))
(cl:export '#.(swig-lispify "failed_steps" 'slotname))
(cffi:defcfun ("gsl_odeiv_evolve_alloc" #.(swig-lispify "gsl_odeiv_evolve_alloc" 'function)) :pointer
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_evolve_alloc" 'function))
(cffi:defcfun ("gsl_odeiv_evolve_apply" #.(swig-lispify "gsl_odeiv_evolve_apply" 'function)) :int
(e :pointer)
(con :pointer)
(step :pointer)
(dydt :pointer)
(t_arg4 :pointer)
(t1 :double)
(h :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_evolve_apply" 'function))
(cffi:defcfun ("gsl_odeiv_evolve_reset" #.(swig-lispify "gsl_odeiv_evolve_reset" 'function)) :int
(e :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_evolve_reset" 'function))
(cffi:defcfun ("gsl_odeiv_evolve_free" #.(swig-lispify "gsl_odeiv_evolve_free" 'function)) :void
(e :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv_evolve_free" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_system" 'classname)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "jacobian" 'slotname) :pointer)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "params" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_system" 'classname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "jacobian" 'slotname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "params" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_step_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "can_use_dydt_in" 'slotname) :int)
(#.(swig-lispify "gives_exact_dydt_out" 'slotname) :int)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "apply" 'slotname) :pointer)
(#.(swig-lispify "set_driver" 'slotname) :pointer)
(#.(swig-lispify "reset" 'slotname) :pointer)
(#.(swig-lispify "order" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "can_use_dydt_in" 'slotname))
(cl:export '#.(swig-lispify "gives_exact_dydt_out" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "apply" 'slotname))
(cl:export '#.(swig-lispify "set_driver" 'slotname))
(cl:export '#.(swig-lispify "reset" 'slotname))
(cl:export '#.(swig-lispify "order" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_step_struct" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_struct" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcvar ("gsl_odeiv2_step_rk2" #.(swig-lispify "gsl_odeiv2_step_rk2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk2" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rk4" #.(swig-lispify "gsl_odeiv2_step_rk4" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk4" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rkf45" #.(swig-lispify "gsl_odeiv2_step_rkf45" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rkf45" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rkck" #.(swig-lispify "gsl_odeiv2_step_rkck" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rkck" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rk8pd" #.(swig-lispify "gsl_odeiv2_step_rk8pd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk8pd" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rk2imp" #.(swig-lispify "gsl_odeiv2_step_rk2imp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk2imp" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rk4imp" #.(swig-lispify "gsl_odeiv2_step_rk4imp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk4imp" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_bsimp" #.(swig-lispify "gsl_odeiv2_step_bsimp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_bsimp" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_rk1imp" #.(swig-lispify "gsl_odeiv2_step_rk1imp" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_rk1imp" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_msadams" #.(swig-lispify "gsl_odeiv2_step_msadams" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_msadams" 'variable))
(cffi:defcvar ("gsl_odeiv2_step_msbdf" #.(swig-lispify "gsl_odeiv2_step_msbdf" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_odeiv2_step_msbdf" 'variable))
(cffi:defcfun ("gsl_odeiv2_step_alloc" #.(swig-lispify "gsl_odeiv2_step_alloc" 'function)) :pointer
(t_arg0 :pointer)
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_alloc" 'function))
(cffi:defcfun ("gsl_odeiv2_step_reset" #.(swig-lispify "gsl_odeiv2_step_reset" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_reset" 'function))
(cffi:defcfun ("gsl_odeiv2_step_free" #.(swig-lispify "gsl_odeiv2_step_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_free" 'function))
(cffi:defcfun ("gsl_odeiv2_step_name" #.(swig-lispify "gsl_odeiv2_step_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_name" 'function))
(cffi:defcfun ("gsl_odeiv2_step_order" #.(swig-lispify "gsl_odeiv2_step_order" 'function)) :unsigned-int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_order" 'function))
(cffi:defcfun ("gsl_odeiv2_step_apply" #.(swig-lispify "gsl_odeiv2_step_apply" 'function)) :int
(s :pointer)
(t_arg1 :double)
(h :double)
(y :pointer)
(yerr :pointer)
(dydt_in :pointer)
(dydt_out :pointer)
(dydt :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_apply" 'function))
(cffi:defcfun ("gsl_odeiv2_step_set_driver" #.(swig-lispify "gsl_odeiv2_step_set_driver" 'function)) :int
(s :pointer)
(d :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_step_set_driver" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_control_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "alloc" 'slotname) :pointer)
(#.(swig-lispify "init" 'slotname) :pointer)
(#.(swig-lispify "hadjust" 'slotname) :pointer)
(#.(swig-lispify "errlevel" 'slotname) :pointer)
(#.(swig-lispify "set_driver" 'slotname) :pointer)
(#.(swig-lispify "free" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "alloc" 'slotname))
(cl:export '#.(swig-lispify "init" 'slotname))
(cl:export '#.(swig-lispify "hadjust" 'slotname))
(cl:export '#.(swig-lispify "errlevel" 'slotname))
(cl:export '#.(swig-lispify "set_driver" 'slotname))
(cl:export '#.(swig-lispify "free" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_control_struct" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_struct" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_odeiv2_control_alloc" #.(swig-lispify "gsl_odeiv2_control_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_alloc" 'function))
(cffi:defcfun ("gsl_odeiv2_control_init" #.(swig-lispify "gsl_odeiv2_control_init" 'function)) :int
(c :pointer)
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_init" 'function))
(cffi:defcfun ("gsl_odeiv2_control_free" #.(swig-lispify "gsl_odeiv2_control_free" 'function)) :void
(c :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_free" 'function))
(cffi:defcfun ("gsl_odeiv2_control_hadjust" #.(swig-lispify "gsl_odeiv2_control_hadjust" 'function)) :int
(c :pointer)
(s :pointer)
(y :pointer)
(yerr :pointer)
(dydt :pointer)
(h :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_hadjust" 'function))
(cffi:defcfun ("gsl_odeiv2_control_name" #.(swig-lispify "gsl_odeiv2_control_name" 'function)) :string
(c :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_name" 'function))
(cffi:defcfun ("gsl_odeiv2_control_errlevel" #.(swig-lispify "gsl_odeiv2_control_errlevel" 'function)) :int
(c :pointer)
(y :double)
(dydt :double)
(h :double)
(ind :pointer)
(errlev :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_errlevel" 'function))
(cffi:defcfun ("gsl_odeiv2_control_set_driver" #.(swig-lispify "gsl_odeiv2_control_set_driver" 'function)) :int
(c :pointer)
(d :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_set_driver" 'function))
(cffi:defcfun ("gsl_odeiv2_control_standard_new" #.(swig-lispify "gsl_odeiv2_control_standard_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_standard_new" 'function))
(cffi:defcfun ("gsl_odeiv2_control_y_new" #.(swig-lispify "gsl_odeiv2_control_y_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_y_new" 'function))
(cffi:defcfun ("gsl_odeiv2_control_yp_new" #.(swig-lispify "gsl_odeiv2_control_yp_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_yp_new" 'function))
(cffi:defcfun ("gsl_odeiv2_control_scaled_new" #.(swig-lispify "gsl_odeiv2_control_scaled_new" 'function)) :pointer
(eps_abs :double)
(eps_rel :double)
(a_y :double)
(a_dydt :double)
(scale_abs :pointer)
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_control_scaled_new" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_evolve_struct" 'classname)
(#.(swig-lispify "dimension" 'slotname) :pointer)
(#.(swig-lispify "y0" 'slotname) :pointer)
(#.(swig-lispify "yerr" 'slotname) :pointer)
(#.(swig-lispify "dydt_in" 'slotname) :pointer)
(#.(swig-lispify "dydt_out" 'slotname) :pointer)
(#.(swig-lispify "last_step" 'slotname) :double)
(#.(swig-lispify "count" 'slotname) :unsigned-long)
(#.(swig-lispify "failed_steps" 'slotname) :unsigned-long)
(#.(swig-lispify "driver" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_struct" 'classname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "y0" 'slotname))
(cl:export '#.(swig-lispify "yerr" 'slotname))
(cl:export '#.(swig-lispify "dydt_in" 'slotname))
(cl:export '#.(swig-lispify "dydt_out" 'slotname))
(cl:export '#.(swig-lispify "last_step" 'slotname))
(cl:export '#.(swig-lispify "count" 'slotname))
(cl:export '#.(swig-lispify "failed_steps" 'slotname))
(cl:export '#.(swig-lispify "driver" 'slotname))
(cffi:defcfun ("gsl_odeiv2_evolve_alloc" #.(swig-lispify "gsl_odeiv2_evolve_alloc" 'function)) :pointer
(dim :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_alloc" 'function))
(cffi:defcfun ("gsl_odeiv2_evolve_apply" #.(swig-lispify "gsl_odeiv2_evolve_apply" 'function)) :int
(e :pointer)
(con :pointer)
(step :pointer)
(dydt :pointer)
(t_arg4 :pointer)
(t1 :double)
(h :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_apply" 'function))
(cffi:defcfun ("gsl_odeiv2_evolve_apply_fixed_step" #.(swig-lispify "gsl_odeiv2_evolve_apply_fixed_step" 'function)) :int
(e :pointer)
(con :pointer)
(step :pointer)
(dydt :pointer)
(t_arg4 :pointer)
(h0 :double)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_apply_fixed_step" 'function))
(cffi:defcfun ("gsl_odeiv2_evolve_reset" #.(swig-lispify "gsl_odeiv2_evolve_reset" 'function)) :int
(e :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_reset" 'function))
(cffi:defcfun ("gsl_odeiv2_evolve_free" #.(swig-lispify "gsl_odeiv2_evolve_free" 'function)) :void
(e :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_free" 'function))
(cffi:defcfun ("gsl_odeiv2_evolve_set_driver" #.(swig-lispify "gsl_odeiv2_evolve_set_driver" 'function)) :int
(e :pointer)
(d :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_evolve_set_driver" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_odeiv2_driver_struct" 'classname)
(#.(swig-lispify "sys" 'slotname) :pointer)
(#.(swig-lispify "s" 'slotname) :pointer)
(#.(swig-lispify "c" 'slotname) :pointer)
(#.(swig-lispify "e" 'slotname) :pointer)
(#.(swig-lispify "h" 'slotname) :double)
(#.(swig-lispify "hmin" 'slotname) :double)
(#.(swig-lispify "hmax" 'slotname) :double)
(#.(swig-lispify "n" 'slotname) :unsigned-long)
(#.(swig-lispify "nmax" 'slotname) :unsigned-long))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_struct" 'classname))
(cl:export '#.(swig-lispify "sys" 'slotname))
(cl:export '#.(swig-lispify "s" 'slotname))
(cl:export '#.(swig-lispify "c" 'slotname))
(cl:export '#.(swig-lispify "e" 'slotname))
(cl:export '#.(swig-lispify "h" 'slotname))
(cl:export '#.(swig-lispify "hmin" 'slotname))
(cl:export '#.(swig-lispify "hmax" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cl:export '#.(swig-lispify "nmax" 'slotname))
(cffi:defcfun ("gsl_odeiv2_driver_alloc_y_new" #.(swig-lispify "gsl_odeiv2_driver_alloc_y_new" 'function)) :pointer
(sys :pointer)
(t_arg1 :pointer)
(hstart :double)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_alloc_y_new" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_alloc_yp_new" #.(swig-lispify "gsl_odeiv2_driver_alloc_yp_new" 'function)) :pointer
(sys :pointer)
(t_arg1 :pointer)
(hstart :double)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_alloc_yp_new" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_alloc_scaled_new" #.(swig-lispify "gsl_odeiv2_driver_alloc_scaled_new" 'function)) :pointer
(sys :pointer)
(t_arg1 :pointer)
(hstart :double)
(epsabs :double)
(epsrel :double)
(a_y :double)
(a_dydt :double)
(scale_abs :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_alloc_scaled_new" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_alloc_standard_new" #.(swig-lispify "gsl_odeiv2_driver_alloc_standard_new" 'function)) :pointer
(sys :pointer)
(t_arg1 :pointer)
(hstart :double)
(epsabs :double)
(epsrel :double)
(a_y :double)
(a_dydt :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_alloc_standard_new" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_set_hmin" #.(swig-lispify "gsl_odeiv2_driver_set_hmin" 'function)) :int
(d :pointer)
(hmin :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_set_hmin" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_set_hmax" #.(swig-lispify "gsl_odeiv2_driver_set_hmax" 'function)) :int
(d :pointer)
(hmax :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_set_hmax" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_set_nmax" #.(swig-lispify "gsl_odeiv2_driver_set_nmax" 'function)) :int
(d :pointer)
(nmax :unsigned-long))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_set_nmax" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_apply" #.(swig-lispify "gsl_odeiv2_driver_apply" 'function)) :int
(d :pointer)
(t_arg1 :pointer)
(t1 :double)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_apply" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_apply_fixed_step" #.(swig-lispify "gsl_odeiv2_driver_apply_fixed_step" 'function)) :int
(d :pointer)
(t_arg1 :pointer)
(h :double)
(n :unsigned-long)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_apply_fixed_step" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_reset" #.(swig-lispify "gsl_odeiv2_driver_reset" 'function)) :int
(d :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_reset" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_reset_hstart" #.(swig-lispify "gsl_odeiv2_driver_reset_hstart" 'function)) :int
(d :pointer)
(hstart :double))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_reset_hstart" 'function))
(cffi:defcfun ("gsl_odeiv2_driver_free" #.(swig-lispify "gsl_odeiv2_driver_free" 'function)) :void
(state :pointer))
(cl:export '#.(swig-lispify "gsl_odeiv2_driver_free" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_permutation_struct" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_struct" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cffi:defcfun ("gsl_permutation_alloc" #.(swig-lispify "gsl_permutation_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_alloc" 'function))
(cffi:defcfun ("gsl_permutation_calloc" #.(swig-lispify "gsl_permutation_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_calloc" 'function))
(cffi:defcfun ("gsl_permutation_init" #.(swig-lispify "gsl_permutation_init" 'function)) :void
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_init" 'function))
(cffi:defcfun ("gsl_permutation_free" #.(swig-lispify "gsl_permutation_free" 'function)) :void
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_free" 'function))
(cffi:defcfun ("gsl_permutation_memcpy" #.(swig-lispify "gsl_permutation_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_memcpy" 'function))
(cffi:defcfun ("gsl_permutation_fread" #.(swig-lispify "gsl_permutation_fread" 'function)) :int
(stream :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_fread" 'function))
(cffi:defcfun ("gsl_permutation_fwrite" #.(swig-lispify "gsl_permutation_fwrite" 'function)) :int
(stream :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_fwrite" 'function))
(cffi:defcfun ("gsl_permutation_fscanf" #.(swig-lispify "gsl_permutation_fscanf" 'function)) :int
(stream :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_fscanf" 'function))
(cffi:defcfun ("gsl_permutation_fprintf" #.(swig-lispify "gsl_permutation_fprintf" 'function)) :int
(stream :pointer)
(p :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_permutation_fprintf" 'function))
(cffi:defcfun ("gsl_permutation_size" #.(swig-lispify "gsl_permutation_size" 'function)) :pointer
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_size" 'function))
(cffi:defcfun ("gsl_permutation_data" #.(swig-lispify "gsl_permutation_data" 'function)) :pointer
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_data" 'function))
(cffi:defcfun ("gsl_permutation_swap" #.(swig-lispify "gsl_permutation_swap" 'function)) :int
(p :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_swap" 'function))
(cffi:defcfun ("gsl_permutation_valid" #.(swig-lispify "gsl_permutation_valid" 'function)) :int
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_valid" 'function))
(cffi:defcfun ("gsl_permutation_reverse" #.(swig-lispify "gsl_permutation_reverse" 'function)) :void
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_reverse" 'function))
(cffi:defcfun ("gsl_permutation_inverse" #.(swig-lispify "gsl_permutation_inverse" 'function)) :int
(inv :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_inverse" 'function))
(cffi:defcfun ("gsl_permutation_next" #.(swig-lispify "gsl_permutation_next" 'function)) :int
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_next" 'function))
(cffi:defcfun ("gsl_permutation_prev" #.(swig-lispify "gsl_permutation_prev" 'function)) :int
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_prev" 'function))
(cffi:defcfun ("gsl_permutation_mul" #.(swig-lispify "gsl_permutation_mul" 'function)) :int
(p :pointer)
(pa :pointer)
(pb :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_mul" 'function))
(cffi:defcfun ("gsl_permutation_linear_to_canonical" #.(swig-lispify "gsl_permutation_linear_to_canonical" 'function)) :int
(q :pointer)
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_linear_to_canonical" 'function))
(cffi:defcfun ("gsl_permutation_canonical_to_linear" #.(swig-lispify "gsl_permutation_canonical_to_linear" 'function)) :int
(p :pointer)
(q :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_canonical_to_linear" 'function))
(cffi:defcfun ("gsl_permutation_inversions" #.(swig-lispify "gsl_permutation_inversions" 'function)) :pointer
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_inversions" 'function))
(cffi:defcfun ("gsl_permutation_linear_cycles" #.(swig-lispify "gsl_permutation_linear_cycles" 'function)) :pointer
(p :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_linear_cycles" 'function))
(cffi:defcfun ("gsl_permutation_canonical_cycles" #.(swig-lispify "gsl_permutation_canonical_cycles" 'function)) :pointer
(q :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_canonical_cycles" 'function))
(cffi:defcfun ("gsl_permutation_get" #.(swig-lispify "gsl_permutation_get" 'function)) :pointer
(p :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_permutation_get" 'function))
(cffi:defcfun ("gsl_permute_char" #.(swig-lispify "gsl_permute_char" 'function)) :int
(p :pointer)
(data :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_char" 'function))
(cffi:defcfun ("gsl_permute_char_inverse" #.(swig-lispify "gsl_permute_char_inverse" 'function)) :int
(p :pointer)
(data :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_char_inverse" 'function))
(cffi:defcfun ("gsl_permute_complex" #.(swig-lispify "gsl_permute_complex" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex" 'function))
(cffi:defcfun ("gsl_permute_complex_inverse" #.(swig-lispify "gsl_permute_complex_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex_inverse" 'function))
(cffi:defcfun ("gsl_permute_complex_float" #.(swig-lispify "gsl_permute_complex_float" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex_float" 'function))
(cffi:defcfun ("gsl_permute_complex_float_inverse" #.(swig-lispify "gsl_permute_complex_float_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex_float_inverse" 'function))
(cffi:defcfun ("gsl_permute_complex_long_double" #.(swig-lispify "gsl_permute_complex_long_double" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex_long_double" 'function))
(cffi:defcfun ("gsl_permute_complex_long_double_inverse" #.(swig-lispify "gsl_permute_complex_long_double_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_complex_long_double_inverse" 'function))
(cffi:defcfun ("gsl_permute" #.(swig-lispify "gsl_permute" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute" 'function))
(cffi:defcfun ("gsl_permute_inverse" #.(swig-lispify "gsl_permute_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_inverse" 'function))
(cffi:defcfun ("gsl_permute_float" #.(swig-lispify "gsl_permute_float" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_float" 'function))
(cffi:defcfun ("gsl_permute_float_inverse" #.(swig-lispify "gsl_permute_float_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_float_inverse" 'function))
(cffi:defcfun ("gsl_permute_int" #.(swig-lispify "gsl_permute_int" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_int" 'function))
(cffi:defcfun ("gsl_permute_int_inverse" #.(swig-lispify "gsl_permute_int_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_int_inverse" 'function))
(cffi:defcfun ("gsl_permute_long" #.(swig-lispify "gsl_permute_long" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_long" 'function))
(cffi:defcfun ("gsl_permute_long_inverse" #.(swig-lispify "gsl_permute_long_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_long_inverse" 'function))
(cffi:defcfun ("gsl_permute_long_double" #.(swig-lispify "gsl_permute_long_double" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_long_double" 'function))
(cffi:defcfun ("gsl_permute_long_double_inverse" #.(swig-lispify "gsl_permute_long_double_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_long_double_inverse" 'function))
(cffi:defcfun ("gsl_permute_short" #.(swig-lispify "gsl_permute_short" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_short" 'function))
(cffi:defcfun ("gsl_permute_short_inverse" #.(swig-lispify "gsl_permute_short_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_short_inverse" 'function))
(cffi:defcfun ("gsl_permute_uchar" #.(swig-lispify "gsl_permute_uchar" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_uchar" 'function))
(cffi:defcfun ("gsl_permute_uchar_inverse" #.(swig-lispify "gsl_permute_uchar_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_uchar_inverse" 'function))
(cffi:defcfun ("gsl_permute_uint" #.(swig-lispify "gsl_permute_uint" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_uint" 'function))
(cffi:defcfun ("gsl_permute_uint_inverse" #.(swig-lispify "gsl_permute_uint_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_uint_inverse" 'function))
(cffi:defcfun ("gsl_permute_ulong" #.(swig-lispify "gsl_permute_ulong" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_ulong" 'function))
(cffi:defcfun ("gsl_permute_ulong_inverse" #.(swig-lispify "gsl_permute_ulong_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_ulong_inverse" 'function))
(cffi:defcfun ("gsl_permute_ushort" #.(swig-lispify "gsl_permute_ushort" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_ushort" 'function))
(cffi:defcfun ("gsl_permute_ushort_inverse" #.(swig-lispify "gsl_permute_ushort_inverse" 'function)) :int
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_permute_ushort_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_char" #.(swig-lispify "gsl_permute_vector_char" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_char" 'function))
(cffi:defcfun ("gsl_permute_vector_char_inverse" #.(swig-lispify "gsl_permute_vector_char_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_char_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_complex" #.(swig-lispify "gsl_permute_vector_complex" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex" 'function))
(cffi:defcfun ("gsl_permute_vector_complex_inverse" #.(swig-lispify "gsl_permute_vector_complex_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_complex_float" #.(swig-lispify "gsl_permute_vector_complex_float" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex_float" 'function))
(cffi:defcfun ("gsl_permute_vector_complex_float_inverse" #.(swig-lispify "gsl_permute_vector_complex_float_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex_float_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_complex_long_double" #.(swig-lispify "gsl_permute_vector_complex_long_double" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex_long_double" 'function))
(cffi:defcfun ("gsl_permute_vector_complex_long_double_inverse" #.(swig-lispify "gsl_permute_vector_complex_long_double_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_complex_long_double_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector" #.(swig-lispify "gsl_permute_vector" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector" 'function))
(cffi:defcfun ("gsl_permute_vector_inverse" #.(swig-lispify "gsl_permute_vector_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_float" #.(swig-lispify "gsl_permute_vector_float" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_float" 'function))
(cffi:defcfun ("gsl_permute_vector_float_inverse" #.(swig-lispify "gsl_permute_vector_float_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_float_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_int" #.(swig-lispify "gsl_permute_vector_int" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_int" 'function))
(cffi:defcfun ("gsl_permute_vector_int_inverse" #.(swig-lispify "gsl_permute_vector_int_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_int_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_long" #.(swig-lispify "gsl_permute_vector_long" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_long" 'function))
(cffi:defcfun ("gsl_permute_vector_long_inverse" #.(swig-lispify "gsl_permute_vector_long_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_long_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_long_double" #.(swig-lispify "gsl_permute_vector_long_double" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_long_double" 'function))
(cffi:defcfun ("gsl_permute_vector_long_double_inverse" #.(swig-lispify "gsl_permute_vector_long_double_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_long_double_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_short" #.(swig-lispify "gsl_permute_vector_short" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_short" 'function))
(cffi:defcfun ("gsl_permute_vector_short_inverse" #.(swig-lispify "gsl_permute_vector_short_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_short_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_uchar" #.(swig-lispify "gsl_permute_vector_uchar" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_uchar" 'function))
(cffi:defcfun ("gsl_permute_vector_uchar_inverse" #.(swig-lispify "gsl_permute_vector_uchar_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_uchar_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_uint" #.(swig-lispify "gsl_permute_vector_uint" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_uint" 'function))
(cffi:defcfun ("gsl_permute_vector_uint_inverse" #.(swig-lispify "gsl_permute_vector_uint_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_uint_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_ulong" #.(swig-lispify "gsl_permute_vector_ulong" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_ulong" 'function))
(cffi:defcfun ("gsl_permute_vector_ulong_inverse" #.(swig-lispify "gsl_permute_vector_ulong_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_ulong_inverse" 'function))
(cffi:defcfun ("gsl_permute_vector_ushort" #.(swig-lispify "gsl_permute_vector_ushort" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_ushort" 'function))
(cffi:defcfun ("gsl_permute_vector_ushort_inverse" #.(swig-lispify "gsl_permute_vector_ushort_inverse" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_permute_vector_ushort_inverse" 'function))
(cffi:defcfun ("gsl_poly_eval" #.(swig-lispify "gsl_poly_eval" 'function)) :double
(c :pointer)
(len :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_poly_eval" 'function))
(cffi:defcfun ("gsl_poly_complex_eval" #.(swig-lispify "gsl_poly_complex_eval" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(c :pointer)
(len :int)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_poly_complex_eval" 'function))
(cffi:defcfun ("gsl_complex_poly_complex_eval" #.(swig-lispify "gsl_complex_poly_complex_eval" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(c :pointer)
(len :int)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_complex_poly_complex_eval" 'function))
(cffi:defcfun ("gsl_poly_eval_derivs" #.(swig-lispify "gsl_poly_eval_derivs" 'function)) :int
(c :pointer)
(lenc :pointer)
(x :double)
(res :pointer)
(lenres :pointer))
(cl:export '#.(swig-lispify "gsl_poly_eval_derivs" 'function))
(cffi:defcfun ("gsl_poly_dd_init" #.(swig-lispify "gsl_poly_dd_init" 'function)) :int
(dd :pointer)
(x :pointer)
(y :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_poly_dd_init" 'function))
(cffi:defcfun ("gsl_poly_dd_eval" #.(swig-lispify "gsl_poly_dd_eval" 'function)) :double
(dd :pointer)
(xa :pointer)
(size :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_poly_dd_eval" 'function))
(cffi:defcfun ("gsl_poly_dd_taylor" #.(swig-lispify "gsl_poly_dd_taylor" 'function)) :int
(c :pointer)
(xp :double)
(dd :pointer)
(x :pointer)
(size :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_poly_dd_taylor" 'function))
(cffi:defcfun ("gsl_poly_dd_hermite_init" #.(swig-lispify "gsl_poly_dd_hermite_init" 'function)) :int
(dd :pointer)
(z :pointer)
(xa :pointer)
(ya :pointer)
(dya :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_poly_dd_hermite_init" 'function))
(cffi:defcfun ("gsl_poly_solve_quadratic" #.(swig-lispify "gsl_poly_solve_quadratic" 'function)) :int
(a :double)
(b :double)
(c :double)
(x0 :pointer)
(x1 :pointer))
(cl:export '#.(swig-lispify "gsl_poly_solve_quadratic" 'function))
(cffi:defcfun ("gsl_poly_complex_solve_quadratic" #.(swig-lispify "gsl_poly_complex_solve_quadratic" 'function)) :int
(a :double)
(b :double)
(c :double)
(z0 :pointer)
(z1 :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_solve_quadratic" 'function))
(cffi:defcfun ("gsl_poly_solve_cubic" #.(swig-lispify "gsl_poly_solve_cubic" 'function)) :int
(a :double)
(b :double)
(c :double)
(x0 :pointer)
(x1 :pointer)
(x2 :pointer))
(cl:export '#.(swig-lispify "gsl_poly_solve_cubic" 'function))
(cffi:defcfun ("gsl_poly_complex_solve_cubic" #.(swig-lispify "gsl_poly_complex_solve_cubic" 'function)) :int
(a :double)
(b :double)
(c :double)
(z0 :pointer)
(z1 :pointer)
(z2 :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_solve_cubic" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_poly_complex_workspace" 'classname)
(#.(swig-lispify "nc" 'slotname) :pointer)
(#.(swig-lispify "matrix" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_workspace" 'classname))
(cl:export '#.(swig-lispify "nc" 'slotname))
(cl:export '#.(swig-lispify "matrix" 'slotname))
(cffi:defcfun ("gsl_poly_complex_workspace_alloc" #.(swig-lispify "gsl_poly_complex_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_workspace_alloc" 'function))
(cffi:defcfun ("gsl_poly_complex_workspace_free" #.(swig-lispify "gsl_poly_complex_workspace_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_workspace_free" 'function))
(cffi:defcfun ("gsl_poly_complex_solve" #.(swig-lispify "gsl_poly_complex_solve" 'function)) :int
(a :pointer)
(n :pointer)
(w :pointer)
(z :pointer))
(cl:export '#.(swig-lispify "gsl_poly_complex_solve" 'function))
(cffi:defcfun ("gsl_pow_2" #.(swig-lispify "gsl_pow_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_2" 'function))
(cffi:defcfun ("gsl_pow_3" #.(swig-lispify "gsl_pow_3" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_3" 'function))
(cffi:defcfun ("gsl_pow_4" #.(swig-lispify "gsl_pow_4" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_4" 'function))
(cffi:defcfun ("gsl_pow_5" #.(swig-lispify "gsl_pow_5" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_5" 'function))
(cffi:defcfun ("gsl_pow_6" #.(swig-lispify "gsl_pow_6" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_6" 'function))
(cffi:defcfun ("gsl_pow_7" #.(swig-lispify "gsl_pow_7" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_7" 'function))
(cffi:defcfun ("gsl_pow_8" #.(swig-lispify "gsl_pow_8" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_8" 'function))
(cffi:defcfun ("gsl_pow_9" #.(swig-lispify "gsl_pow_9" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_pow_9" 'function))
(cffi:defcfun ("gsl_pow_int" #.(swig-lispify "gsl_pow_int" 'function)) :double
(x :double)
(n :int))
(cl:export '#.(swig-lispify "gsl_pow_int" 'function))
(cffi:defcfun ("gsl_pow_uint" #.(swig-lispify "gsl_pow_uint" 'function)) :double
(x :double)
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_pow_uint" 'function))
(cl:defconstant #.(swig-lispify "_GSL_PREC_T_NUM" 'constant) 3)
(cl:export '#.(swig-lispify "_GSL_PREC_T_NUM" 'constant))
(cffi:defcvar ("gsl_prec_eps" #.(swig-lispify "gsl_prec_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_eps" 'variable))
(cffi:defcvar ("gsl_prec_sqrt_eps" #.(swig-lispify "gsl_prec_sqrt_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_sqrt_eps" 'variable))
(cffi:defcvar ("gsl_prec_root3_eps" #.(swig-lispify "gsl_prec_root3_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_root3_eps" 'variable))
(cffi:defcvar ("gsl_prec_root4_eps" #.(swig-lispify "gsl_prec_root4_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_root4_eps" 'variable))
(cffi:defcvar ("gsl_prec_root5_eps" #.(swig-lispify "gsl_prec_root5_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_root5_eps" 'variable))
(cffi:defcvar ("gsl_prec_root6_eps" #.(swig-lispify "gsl_prec_root6_eps" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_prec_root6_eps" 'variable))
(cffi:defcstruct #.(swig-lispify "gsl_qrng_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "max_dimension" 'slotname) :unsigned-int)
(#.(swig-lispify "state_size" 'slotname) :pointer)
(#.(swig-lispify "init_state" 'slotname) :pointer)
(#.(swig-lispify "get" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "max_dimension" 'slotname))
(cl:export '#.(swig-lispify "state_size" 'slotname))
(cl:export '#.(swig-lispify "init_state" 'slotname))
(cl:export '#.(swig-lispify "get" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_qrng" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "dimension" 'slotname) :unsigned-int)
(#.(swig-lispify "state_size" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_qrng" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "dimension" 'slotname))
(cl:export '#.(swig-lispify "state_size" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcvar ("gsl_qrng_niederreiter_2" #.(swig-lispify "gsl_qrng_niederreiter_2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_qrng_niederreiter_2" 'variable))
(cffi:defcvar ("gsl_qrng_sobol" #.(swig-lispify "gsl_qrng_sobol" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_qrng_sobol" 'variable))
(cffi:defcvar ("gsl_qrng_halton" #.(swig-lispify "gsl_qrng_halton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_qrng_halton" 'variable))
(cffi:defcvar ("gsl_qrng_reversehalton" #.(swig-lispify "gsl_qrng_reversehalton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_qrng_reversehalton" 'variable))
(cffi:defcfun ("gsl_qrng_alloc" #.(swig-lispify "gsl_qrng_alloc" 'function)) :pointer
(t_arg0 :pointer)
(dimension :unsigned-int))
(cl:export '#.(swig-lispify "gsl_qrng_alloc" 'function))
(cffi:defcfun ("gsl_qrng_memcpy" #.(swig-lispify "gsl_qrng_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_memcpy" 'function))
(cffi:defcfun ("gsl_qrng_clone" #.(swig-lispify "gsl_qrng_clone" 'function)) :pointer
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_clone" 'function))
(cffi:defcfun ("gsl_qrng_free" #.(swig-lispify "gsl_qrng_free" 'function)) :void
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_free" 'function))
(cffi:defcfun ("gsl_qrng_init" #.(swig-lispify "gsl_qrng_init" 'function)) :void
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_init" 'function))
(cffi:defcfun ("gsl_qrng_name" #.(swig-lispify "gsl_qrng_name" 'function)) :string
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_name" 'function))
(cffi:defcfun ("gsl_qrng_size" #.(swig-lispify "gsl_qrng_size" 'function)) :pointer
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_size" 'function))
(cffi:defcfun ("gsl_qrng_state" #.(swig-lispify "gsl_qrng_state" 'function)) :pointer
(q :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_state" 'function))
(cffi:defcfun ("gsl_qrng_get" #.(swig-lispify "gsl_qrng_get" 'function)) :int
(q :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_qrng_get" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_rng_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "max" 'slotname) :unsigned-long)
(#.(swig-lispify "min" 'slotname) :unsigned-long)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "get" 'slotname) :pointer)
(#.(swig-lispify "get_double" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_rng_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "max" 'slotname))
(cl:export '#.(swig-lispify "min" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "get" 'slotname))
(cl:export '#.(swig-lispify "get_double" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_rng" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_rng" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcvar ("gsl_rng_borosh13" #.(swig-lispify "gsl_rng_borosh13" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_borosh13" 'variable))
(cffi:defcvar ("gsl_rng_coveyou" #.(swig-lispify "gsl_rng_coveyou" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_coveyou" 'variable))
(cffi:defcvar ("gsl_rng_cmrg" #.(swig-lispify "gsl_rng_cmrg" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_cmrg" 'variable))
(cffi:defcvar ("gsl_rng_fishman18" #.(swig-lispify "gsl_rng_fishman18" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_fishman18" 'variable))
(cffi:defcvar ("gsl_rng_fishman20" #.(swig-lispify "gsl_rng_fishman20" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_fishman20" 'variable))
(cffi:defcvar ("gsl_rng_fishman2x" #.(swig-lispify "gsl_rng_fishman2x" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_fishman2x" 'variable))
(cffi:defcvar ("gsl_rng_gfsr4" #.(swig-lispify "gsl_rng_gfsr4" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_gfsr4" 'variable))
(cffi:defcvar ("gsl_rng_knuthran" #.(swig-lispify "gsl_rng_knuthran" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_knuthran" 'variable))
(cffi:defcvar ("gsl_rng_knuthran2" #.(swig-lispify "gsl_rng_knuthran2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_knuthran2" 'variable))
(cffi:defcvar ("gsl_rng_knuthran2002" #.(swig-lispify "gsl_rng_knuthran2002" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_knuthran2002" 'variable))
(cffi:defcvar ("gsl_rng_lecuyer21" #.(swig-lispify "gsl_rng_lecuyer21" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_lecuyer21" 'variable))
(cffi:defcvar ("gsl_rng_minstd" #.(swig-lispify "gsl_rng_minstd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_minstd" 'variable))
(cffi:defcvar ("gsl_rng_mrg" #.(swig-lispify "gsl_rng_mrg" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_mrg" 'variable))
(cffi:defcvar ("gsl_rng_mt19937" #.(swig-lispify "gsl_rng_mt19937" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_mt19937" 'variable))
(cffi:defcvar ("gsl_rng_mt19937_1999" #.(swig-lispify "gsl_rng_mt19937_1999" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_mt19937_1999" 'variable))
(cffi:defcvar ("gsl_rng_mt19937_1998" #.(swig-lispify "gsl_rng_mt19937_1998" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_mt19937_1998" 'variable))
(cffi:defcvar ("gsl_rng_r250" #.(swig-lispify "gsl_rng_r250" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_r250" 'variable))
(cffi:defcvar ("gsl_rng_ran0" #.(swig-lispify "gsl_rng_ran0" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ran0" 'variable))
(cffi:defcvar ("gsl_rng_ran1" #.(swig-lispify "gsl_rng_ran1" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ran1" 'variable))
(cffi:defcvar ("gsl_rng_ran2" #.(swig-lispify "gsl_rng_ran2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ran2" 'variable))
(cffi:defcvar ("gsl_rng_ran3" #.(swig-lispify "gsl_rng_ran3" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ran3" 'variable))
(cffi:defcvar ("gsl_rng_rand" #.(swig-lispify "gsl_rng_rand" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_rand" 'variable))
(cffi:defcvar ("gsl_rng_rand48" #.(swig-lispify "gsl_rng_rand48" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_rand48" 'variable))
(cffi:defcvar ("gsl_rng_random128_bsd" #.(swig-lispify "gsl_rng_random128_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random128_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random128_glibc2" #.(swig-lispify "gsl_rng_random128_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random128_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random128_libc5" #.(swig-lispify "gsl_rng_random128_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random128_libc5" 'variable))
(cffi:defcvar ("gsl_rng_random256_bsd" #.(swig-lispify "gsl_rng_random256_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random256_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random256_glibc2" #.(swig-lispify "gsl_rng_random256_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random256_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random256_libc5" #.(swig-lispify "gsl_rng_random256_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random256_libc5" 'variable))
(cffi:defcvar ("gsl_rng_random32_bsd" #.(swig-lispify "gsl_rng_random32_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random32_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random32_glibc2" #.(swig-lispify "gsl_rng_random32_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random32_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random32_libc5" #.(swig-lispify "gsl_rng_random32_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random32_libc5" 'variable))
(cffi:defcvar ("gsl_rng_random64_bsd" #.(swig-lispify "gsl_rng_random64_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random64_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random64_glibc2" #.(swig-lispify "gsl_rng_random64_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random64_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random64_libc5" #.(swig-lispify "gsl_rng_random64_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random64_libc5" 'variable))
(cffi:defcvar ("gsl_rng_random8_bsd" #.(swig-lispify "gsl_rng_random8_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random8_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random8_glibc2" #.(swig-lispify "gsl_rng_random8_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random8_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random8_libc5" #.(swig-lispify "gsl_rng_random8_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random8_libc5" 'variable))
(cffi:defcvar ("gsl_rng_random_bsd" #.(swig-lispify "gsl_rng_random_bsd" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random_bsd" 'variable))
(cffi:defcvar ("gsl_rng_random_glibc2" #.(swig-lispify "gsl_rng_random_glibc2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random_glibc2" 'variable))
(cffi:defcvar ("gsl_rng_random_libc5" #.(swig-lispify "gsl_rng_random_libc5" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_random_libc5" 'variable))
(cffi:defcvar ("gsl_rng_randu" #.(swig-lispify "gsl_rng_randu" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_randu" 'variable))
(cffi:defcvar ("gsl_rng_ranf" #.(swig-lispify "gsl_rng_ranf" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranf" 'variable))
(cffi:defcvar ("gsl_rng_ranlux" #.(swig-lispify "gsl_rng_ranlux" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlux" 'variable))
(cffi:defcvar ("gsl_rng_ranlux389" #.(swig-lispify "gsl_rng_ranlux389" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlux389" 'variable))
(cffi:defcvar ("gsl_rng_ranlxd1" #.(swig-lispify "gsl_rng_ranlxd1" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlxd1" 'variable))
(cffi:defcvar ("gsl_rng_ranlxd2" #.(swig-lispify "gsl_rng_ranlxd2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlxd2" 'variable))
(cffi:defcvar ("gsl_rng_ranlxs0" #.(swig-lispify "gsl_rng_ranlxs0" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlxs0" 'variable))
(cffi:defcvar ("gsl_rng_ranlxs1" #.(swig-lispify "gsl_rng_ranlxs1" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlxs1" 'variable))
(cffi:defcvar ("gsl_rng_ranlxs2" #.(swig-lispify "gsl_rng_ranlxs2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranlxs2" 'variable))
(cffi:defcvar ("gsl_rng_ranmar" #.(swig-lispify "gsl_rng_ranmar" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_ranmar" 'variable))
(cffi:defcvar ("gsl_rng_slatec" #.(swig-lispify "gsl_rng_slatec" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_slatec" 'variable))
(cffi:defcvar ("gsl_rng_taus" #.(swig-lispify "gsl_rng_taus" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_taus" 'variable))
(cffi:defcvar ("gsl_rng_taus2" #.(swig-lispify "gsl_rng_taus2" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_taus2" 'variable))
(cffi:defcvar ("gsl_rng_taus113" #.(swig-lispify "gsl_rng_taus113" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_taus113" 'variable))
(cffi:defcvar ("gsl_rng_transputer" #.(swig-lispify "gsl_rng_transputer" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_transputer" 'variable))
(cffi:defcvar ("gsl_rng_tt800" #.(swig-lispify "gsl_rng_tt800" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_tt800" 'variable))
(cffi:defcvar ("gsl_rng_uni" #.(swig-lispify "gsl_rng_uni" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_uni" 'variable))
(cffi:defcvar ("gsl_rng_uni32" #.(swig-lispify "gsl_rng_uni32" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_uni32" 'variable))
(cffi:defcvar ("gsl_rng_vax" #.(swig-lispify "gsl_rng_vax" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_vax" 'variable))
(cffi:defcvar ("gsl_rng_waterman14" #.(swig-lispify "gsl_rng_waterman14" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_waterman14" 'variable))
(cffi:defcvar ("gsl_rng_zuf" #.(swig-lispify "gsl_rng_zuf" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_zuf" 'variable))
(cffi:defcfun ("gsl_rng_types_setup" #.(swig-lispify "gsl_rng_types_setup" 'function)) :pointer)
(cl:export '#.(swig-lispify "gsl_rng_types_setup" 'function))
(cffi:defcvar ("gsl_rng_default" #.(swig-lispify "gsl_rng_default" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_rng_default" 'variable))
(cffi:defcvar ("gsl_rng_default_seed" #.(swig-lispify "gsl_rng_default_seed" 'variable))
:unsigned-long)
(cl:export '#.(swig-lispify "gsl_rng_default_seed" 'variable))
(cffi:defcfun ("gsl_rng_alloc" #.(swig-lispify "gsl_rng_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_rng_alloc" 'function))
(cffi:defcfun ("gsl_rng_memcpy" #.(swig-lispify "gsl_rng_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_rng_memcpy" 'function))
(cffi:defcfun ("gsl_rng_clone" #.(swig-lispify "gsl_rng_clone" 'function)) :pointer
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_clone" 'function))
(cffi:defcfun ("gsl_rng_free" #.(swig-lispify "gsl_rng_free" 'function)) :void
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_free" 'function))
(cffi:defcfun ("gsl_rng_set" #.(swig-lispify "gsl_rng_set" 'function)) :void
(r :pointer)
(seed :unsigned-long))
(cl:export '#.(swig-lispify "gsl_rng_set" 'function))
(cffi:defcfun ("gsl_rng_max" #.(swig-lispify "gsl_rng_max" 'function)) :unsigned-long
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_max" 'function))
(cffi:defcfun ("gsl_rng_min" #.(swig-lispify "gsl_rng_min" 'function)) :unsigned-long
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_min" 'function))
(cffi:defcfun ("gsl_rng_name" #.(swig-lispify "gsl_rng_name" 'function)) :string
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_name" 'function))
(cffi:defcfun ("gsl_rng_fread" #.(swig-lispify "gsl_rng_fread" 'function)) :int
(stream :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_fread" 'function))
(cffi:defcfun ("gsl_rng_fwrite" #.(swig-lispify "gsl_rng_fwrite" 'function)) :int
(stream :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_fwrite" 'function))
(cffi:defcfun ("gsl_rng_size" #.(swig-lispify "gsl_rng_size" 'function)) :pointer
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_size" 'function))
(cffi:defcfun ("gsl_rng_state" #.(swig-lispify "gsl_rng_state" 'function)) :pointer
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_state" 'function))
(cffi:defcfun ("gsl_rng_print_state" #.(swig-lispify "gsl_rng_print_state" 'function)) :void
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_print_state" 'function))
(cffi:defcfun ("gsl_rng_env_setup" #.(swig-lispify "gsl_rng_env_setup" 'function)) :pointer)
(cl:export '#.(swig-lispify "gsl_rng_env_setup" 'function))
(cffi:defcfun ("gsl_rng_get" #.(swig-lispify "gsl_rng_get" 'function)) :unsigned-long
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_get" 'function))
(cffi:defcfun ("gsl_rng_uniform" #.(swig-lispify "gsl_rng_uniform" 'function)) :double
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_uniform" 'function))
(cffi:defcfun ("gsl_rng_uniform_pos" #.(swig-lispify "gsl_rng_uniform_pos" 'function)) :double
(r :pointer))
(cl:export '#.(swig-lispify "gsl_rng_uniform_pos" 'function))
(cffi:defcfun ("gsl_rng_uniform_int" #.(swig-lispify "gsl_rng_uniform_int" 'function)) :unsigned-long
(r :pointer)
(n :unsigned-long))
(cl:export '#.(swig-lispify "gsl_rng_uniform_int" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_root_fsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_root_fsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "function" 'slotname) :pointer)
(#.(swig-lispify "root" 'slotname) :double)
(#.(swig-lispify "x_lower" 'slotname) :double)
(#.(swig-lispify "x_upper" 'slotname) :double)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "function" 'slotname))
(cl:export '#.(swig-lispify "root" 'slotname))
(cl:export '#.(swig-lispify "x_lower" 'slotname))
(cl:export '#.(swig-lispify "x_upper" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_root_fdfsolver_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "set" 'slotname) :pointer)
(#.(swig-lispify "iterate" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "set" 'slotname))
(cl:export '#.(swig-lispify "iterate" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_root_fdfsolver" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "fdf" 'slotname) :pointer)
(#.(swig-lispify "root" 'slotname) :double)
(#.(swig-lispify "state" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "fdf" 'slotname))
(cl:export '#.(swig-lispify "root" 'slotname))
(cl:export '#.(swig-lispify "state" 'slotname))
(cffi:defcfun ("gsl_root_fsolver_alloc" #.(swig-lispify "gsl_root_fsolver_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_alloc" 'function))
(cffi:defcfun ("gsl_root_fsolver_free" #.(swig-lispify "gsl_root_fsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_free" 'function))
(cffi:defcfun ("gsl_root_fsolver_set" #.(swig-lispify "gsl_root_fsolver_set" 'function)) :int
(s :pointer)
(f :pointer)
(x_lower :double)
(x_upper :double))
(cl:export '#.(swig-lispify "gsl_root_fsolver_set" 'function))
(cffi:defcfun ("gsl_root_fsolver_iterate" #.(swig-lispify "gsl_root_fsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_iterate" 'function))
(cffi:defcfun ("gsl_root_fsolver_name" #.(swig-lispify "gsl_root_fsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_name" 'function))
(cffi:defcfun ("gsl_root_fsolver_root" #.(swig-lispify "gsl_root_fsolver_root" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_root" 'function))
(cffi:defcfun ("gsl_root_fsolver_x_lower" #.(swig-lispify "gsl_root_fsolver_x_lower" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_x_lower" 'function))
(cffi:defcfun ("gsl_root_fsolver_x_upper" #.(swig-lispify "gsl_root_fsolver_x_upper" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fsolver_x_upper" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_alloc" #.(swig-lispify "gsl_root_fdfsolver_alloc" 'function)) :pointer
(t_arg0 :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_alloc" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_set" #.(swig-lispify "gsl_root_fdfsolver_set" 'function)) :int
(s :pointer)
(fdf :pointer)
(root :double))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_set" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_iterate" #.(swig-lispify "gsl_root_fdfsolver_iterate" 'function)) :int
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_iterate" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_free" #.(swig-lispify "gsl_root_fdfsolver_free" 'function)) :void
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_free" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_name" #.(swig-lispify "gsl_root_fdfsolver_name" 'function)) :string
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_name" 'function))
(cffi:defcfun ("gsl_root_fdfsolver_root" #.(swig-lispify "gsl_root_fdfsolver_root" 'function)) :double
(s :pointer))
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_root" 'function))
(cffi:defcfun ("gsl_root_test_interval" #.(swig-lispify "gsl_root_test_interval" 'function)) :int
(x_lower :double)
(x_upper :double)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_root_test_interval" 'function))
(cffi:defcfun ("gsl_root_test_residual" #.(swig-lispify "gsl_root_test_residual" 'function)) :int
(f :double)
(epsabs :double))
(cl:export '#.(swig-lispify "gsl_root_test_residual" 'function))
(cffi:defcfun ("gsl_root_test_delta" #.(swig-lispify "gsl_root_test_delta" 'function)) :int
(x1 :double)
(x0 :double)
(epsabs :double)
(epsrel :double))
(cl:export '#.(swig-lispify "gsl_root_test_delta" 'function))
(cffi:defcvar ("gsl_root_fsolver_bisection" #.(swig-lispify "gsl_root_fsolver_bisection" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fsolver_bisection" 'variable))
(cffi:defcvar ("gsl_root_fsolver_brent" #.(swig-lispify "gsl_root_fsolver_brent" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fsolver_brent" 'variable))
(cffi:defcvar ("gsl_root_fsolver_falsepos" #.(swig-lispify "gsl_root_fsolver_falsepos" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fsolver_falsepos" 'variable))
(cffi:defcvar ("gsl_root_fdfsolver_newton" #.(swig-lispify "gsl_root_fdfsolver_newton" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_newton" 'variable))
(cffi:defcvar ("gsl_root_fdfsolver_secant" #.(swig-lispify "gsl_root_fdfsolver_secant" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_secant" 'variable))
(cffi:defcvar ("gsl_root_fdfsolver_steffenson" #.(swig-lispify "gsl_root_fdfsolver_steffenson" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_root_fdfsolver_steffenson" 'variable))
(cffi:defcfun ("gsl_sf_airy_Ai_e" #.(swig-lispify "gsl_sf_airy_Ai_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai" #.(swig-lispify "gsl_sf_airy_Ai" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_e" #.(swig-lispify "gsl_sf_airy_Bi_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi" #.(swig-lispify "gsl_sf_airy_Bi" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_scaled_e" #.(swig-lispify "gsl_sf_airy_Ai_scaled_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_scaled" #.(swig-lispify "gsl_sf_airy_Ai_scaled" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_scaled" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_scaled_e" #.(swig-lispify "gsl_sf_airy_Bi_scaled_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_scaled" #.(swig-lispify "gsl_sf_airy_Bi_scaled" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_scaled" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_deriv_e" #.(swig-lispify "gsl_sf_airy_Ai_deriv_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_deriv_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_deriv" #.(swig-lispify "gsl_sf_airy_Ai_deriv" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_deriv" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_deriv_e" #.(swig-lispify "gsl_sf_airy_Bi_deriv_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_deriv_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_deriv" #.(swig-lispify "gsl_sf_airy_Bi_deriv" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_deriv" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_deriv_scaled_e" #.(swig-lispify "gsl_sf_airy_Ai_deriv_scaled_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_deriv_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Ai_deriv_scaled" #.(swig-lispify "gsl_sf_airy_Ai_deriv_scaled" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Ai_deriv_scaled" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_deriv_scaled_e" #.(swig-lispify "gsl_sf_airy_Bi_deriv_scaled_e" 'function)) :int
(x :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_deriv_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_airy_Bi_deriv_scaled" #.(swig-lispify "gsl_sf_airy_Bi_deriv_scaled" 'function)) :double
(x :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_Bi_deriv_scaled" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Ai_e" #.(swig-lispify "gsl_sf_airy_zero_Ai_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Ai_e" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Ai" #.(swig-lispify "gsl_sf_airy_zero_Ai" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Ai" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Bi_e" #.(swig-lispify "gsl_sf_airy_zero_Bi_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Bi_e" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Bi" #.(swig-lispify "gsl_sf_airy_zero_Bi" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Bi" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Ai_deriv_e" #.(swig-lispify "gsl_sf_airy_zero_Ai_deriv_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Ai_deriv_e" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Ai_deriv" #.(swig-lispify "gsl_sf_airy_zero_Ai_deriv" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Ai_deriv" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Bi_deriv_e" #.(swig-lispify "gsl_sf_airy_zero_Bi_deriv_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Bi_deriv_e" 'function))
(cffi:defcfun ("gsl_sf_airy_zero_Bi_deriv" #.(swig-lispify "gsl_sf_airy_zero_Bi_deriv" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_airy_zero_Bi_deriv" 'function))
(cffi:defcfun ("gsl_sf_bessel_J0_e" #.(swig-lispify "gsl_sf_bessel_jj0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jj0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_J0" #.(swig-lispify "gsl_sf_bessel_jj0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jj0" 'function))
(cffi:defcfun ("gsl_sf_bessel_J1_e" #.(swig-lispify "gsl_sf_bessel_jj1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jj1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_J1" #.(swig-lispify "gsl_sf_bessel_jj1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jj1" 'function))
(cffi:defcfun ("gsl_sf_bessel_Jn_e" #.(swig-lispify "gsl_sf_bessel_jjn_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jjn_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Jn" #.(swig-lispify "gsl_sf_bessel_jjn" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jjn" 'function))
(cffi:defcfun ("gsl_sf_bessel_Jn_array" #.(swig-lispify "gsl_sf_bessel_jjn_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jjn_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_Y0_e" #.(swig-lispify "gsl_sf_bessel_yy0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yy0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Y0" #.(swig-lispify "gsl_sf_bessel_yy0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yy0" 'function))
(cffi:defcfun ("gsl_sf_bessel_Y1_e" #.(swig-lispify "gsl_sf_bessel_yy1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yy1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Y1" #.(swig-lispify "gsl_sf_bessel_yy1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yy1" 'function))
(cffi:defcfun ("gsl_sf_bessel_Yn_e" #.(swig-lispify "gsl_sf_bessel_yyn_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yyn_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Yn" #.(swig-lispify "gsl_sf_bessel_yyn" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yyn" 'function))
(cffi:defcfun ("gsl_sf_bessel_Yn_array" #.(swig-lispify "gsl_sf_bessel_yyn_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yyn_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_I0_e" #.(swig-lispify "gsl_sf_bessel_ii0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_I0" #.(swig-lispify "gsl_sf_bessel_ii0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii0" 'function))
(cffi:defcfun ("gsl_sf_bessel_I1_e" #.(swig-lispify "gsl_sf_bessel_ii1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_I1" #.(swig-lispify "gsl_sf_bessel_ii1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii1" 'function))
(cffi:defcfun ("gsl_sf_bessel_In_e" #.(swig-lispify "gsl_sf_bessel_iin_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_In" #.(swig-lispify "gsl_sf_bessel_iin" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin" 'function))
(cffi:defcfun ("gsl_sf_bessel_In_array" #.(swig-lispify "gsl_sf_bessel_iin_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_I0_scaled_e" #.(swig-lispify "gsl_sf_bessel_ii0_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii0_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_I0_scaled" #.(swig-lispify "gsl_sf_bessel_ii0_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii0_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_I1_scaled_e" #.(swig-lispify "gsl_sf_bessel_ii1_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii1_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_I1_scaled" #.(swig-lispify "gsl_sf_bessel_ii1_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_ii1_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_In_scaled_e" #.(swig-lispify "gsl_sf_bessel_iin_scaled_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_In_scaled" #.(swig-lispify "gsl_sf_bessel_iin_scaled" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_In_scaled_array" #.(swig-lispify "gsl_sf_bessel_iin_scaled_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iin_scaled_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_K0_e" #.(swig-lispify "gsl_sf_bessel_kk0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_K0" #.(swig-lispify "gsl_sf_bessel_kk0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk0" 'function))
(cffi:defcfun ("gsl_sf_bessel_K1_e" #.(swig-lispify "gsl_sf_bessel_kk1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_K1" #.(swig-lispify "gsl_sf_bessel_kk1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk1" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn_e" #.(swig-lispify "gsl_sf_bessel_kkn_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn" #.(swig-lispify "gsl_sf_bessel_kkn" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn_array" #.(swig-lispify "gsl_sf_bessel_kkn_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_K0_scaled_e" #.(swig-lispify "gsl_sf_bessel_kk0_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk0_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_K0_scaled" #.(swig-lispify "gsl_sf_bessel_kk0_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk0_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_K1_scaled_e" #.(swig-lispify "gsl_sf_bessel_kk1_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk1_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_K1_scaled" #.(swig-lispify "gsl_sf_bessel_kk1_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kk1_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn_scaled_e" #.(swig-lispify "gsl_sf_bessel_kkn_scaled_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn_scaled" #.(swig-lispify "gsl_sf_bessel_kkn_scaled" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_Kn_scaled_array" #.(swig-lispify "gsl_sf_bessel_kkn_scaled_array" 'function)) :int
(nmin :int)
(nmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kkn_scaled_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_j0_e" #.(swig-lispify "gsl_sf_bessel_j0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_j0" #.(swig-lispify "gsl_sf_bessel_j0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j0" 'function))
(cffi:defcfun ("gsl_sf_bessel_j1_e" #.(swig-lispify "gsl_sf_bessel_j1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_j1" #.(swig-lispify "gsl_sf_bessel_j1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j1" 'function))
(cffi:defcfun ("gsl_sf_bessel_j2_e" #.(swig-lispify "gsl_sf_bessel_j2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j2_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_j2" #.(swig-lispify "gsl_sf_bessel_j2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_j2" 'function))
(cffi:defcfun ("gsl_sf_bessel_jl_e" #.(swig-lispify "gsl_sf_bessel_jl_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jl_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_jl" #.(swig-lispify "gsl_sf_bessel_jl" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jl" 'function))
(cffi:defcfun ("gsl_sf_bessel_jl_array" #.(swig-lispify "gsl_sf_bessel_jl_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jl_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_jl_steed_array" #.(swig-lispify "gsl_sf_bessel_jl_steed_array" 'function)) :int
(lmax :int)
(x :double)
(jl_x_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jl_steed_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_y0_e" #.(swig-lispify "gsl_sf_bessel_y0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_y0" #.(swig-lispify "gsl_sf_bessel_y0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y0" 'function))
(cffi:defcfun ("gsl_sf_bessel_y1_e" #.(swig-lispify "gsl_sf_bessel_y1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_y1" #.(swig-lispify "gsl_sf_bessel_y1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y1" 'function))
(cffi:defcfun ("gsl_sf_bessel_y2_e" #.(swig-lispify "gsl_sf_bessel_y2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y2_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_y2" #.(swig-lispify "gsl_sf_bessel_y2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_y2" 'function))
(cffi:defcfun ("gsl_sf_bessel_yl_e" #.(swig-lispify "gsl_sf_bessel_yl_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yl_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_yl" #.(swig-lispify "gsl_sf_bessel_yl" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yl" 'function))
(cffi:defcfun ("gsl_sf_bessel_yl_array" #.(swig-lispify "gsl_sf_bessel_yl_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yl_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_i0_scaled_e" #.(swig-lispify "gsl_sf_bessel_i0_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i0_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_i0_scaled" #.(swig-lispify "gsl_sf_bessel_i0_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i0_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_i1_scaled_e" #.(swig-lispify "gsl_sf_bessel_i1_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i1_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_i1_scaled" #.(swig-lispify "gsl_sf_bessel_i1_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i1_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_i2_scaled_e" #.(swig-lispify "gsl_sf_bessel_i2_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i2_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_i2_scaled" #.(swig-lispify "gsl_sf_bessel_i2_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_i2_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_il_scaled_e" #.(swig-lispify "gsl_sf_bessel_il_scaled_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_il_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_il_scaled" #.(swig-lispify "gsl_sf_bessel_il_scaled" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_il_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_il_scaled_array" #.(swig-lispify "gsl_sf_bessel_il_scaled_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_il_scaled_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_k0_scaled_e" #.(swig-lispify "gsl_sf_bessel_k0_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k0_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_k0_scaled" #.(swig-lispify "gsl_sf_bessel_k0_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k0_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_k1_scaled_e" #.(swig-lispify "gsl_sf_bessel_k1_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k1_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_k1_scaled" #.(swig-lispify "gsl_sf_bessel_k1_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k1_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_k2_scaled_e" #.(swig-lispify "gsl_sf_bessel_k2_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k2_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_k2_scaled" #.(swig-lispify "gsl_sf_bessel_k2_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_k2_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_kl_scaled_e" #.(swig-lispify "gsl_sf_bessel_kl_scaled_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kl_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_kl_scaled" #.(swig-lispify "gsl_sf_bessel_kl_scaled" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kl_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_kl_scaled_array" #.(swig-lispify "gsl_sf_bessel_kl_scaled_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kl_scaled_array" 'function))
(cffi:defcfun ("gsl_sf_bessel_Jnu_e" #.(swig-lispify "gsl_sf_bessel_jjnu_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jjnu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Jnu" #.(swig-lispify "gsl_sf_bessel_jjnu" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_jjnu" 'function))
(cffi:defcfun ("gsl_sf_bessel_Ynu_e" #.(swig-lispify "gsl_sf_bessel_yynu_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yynu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Ynu" #.(swig-lispify "gsl_sf_bessel_yynu" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_yynu" 'function))
(cffi:defcfun ("gsl_sf_bessel_sequence_Jnu_e" #.(swig-lispify "gsl_sf_bessel_sequence_Jnu_e" 'function)) :int
(nu :double)
(mode :unsigned-int)
(size :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_sequence_Jnu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Inu_scaled_e" #.(swig-lispify "gsl_sf_bessel_iinu_scaled_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iinu_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Inu_scaled" #.(swig-lispify "gsl_sf_bessel_iinu_scaled" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iinu_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_Inu_e" #.(swig-lispify "gsl_sf_bessel_iinu_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iinu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Inu" #.(swig-lispify "gsl_sf_bessel_iinu" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_iinu" 'function))
(cffi:defcfun ("gsl_sf_bessel_Knu_scaled_e" #.(swig-lispify "gsl_sf_bessel_kknu_scaled_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kknu_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Knu_scaled" #.(swig-lispify "gsl_sf_bessel_kknu_scaled" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kknu_scaled" 'function))
(cffi:defcfun ("gsl_sf_bessel_Knu_scaled_e10_e" #.(swig-lispify "gsl_sf_bessel_kknu_scaled_e10_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kknu_scaled_e10_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Knu_e" #.(swig-lispify "gsl_sf_bessel_kknu_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kknu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_Knu" #.(swig-lispify "gsl_sf_bessel_kknu" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_kknu" 'function))
(cffi:defcfun ("gsl_sf_bessel_lnKnu_e" #.(swig-lispify "gsl_sf_bessel_lnKnu_e" 'function)) :int
(nu :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_lnKnu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_lnKnu" #.(swig-lispify "gsl_sf_bessel_lnKnu" 'function)) :double
(nu :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_bessel_lnKnu" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_J0_e" #.(swig-lispify "gsl_sf_bessel_zero_J0_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_J0_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_J0" #.(swig-lispify "gsl_sf_bessel_zero_J0" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_J0" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_J1_e" #.(swig-lispify "gsl_sf_bessel_zero_J1_e" 'function)) :int
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_J1_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_J1" #.(swig-lispify "gsl_sf_bessel_zero_J1" 'function)) :double
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_J1" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_Jnu_e" #.(swig-lispify "gsl_sf_bessel_zero_Jnu_e" 'function)) :int
(nu :double)
(s :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_Jnu_e" 'function))
(cffi:defcfun ("gsl_sf_bessel_zero_Jnu" #.(swig-lispify "gsl_sf_bessel_zero_Jnu" 'function)) :double
(nu :double)
(s :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_bessel_zero_Jnu" 'function))
(cffi:defcfun ("gsl_sf_clausen_e" #.(swig-lispify "gsl_sf_clausen_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_clausen_e" 'function))
(cffi:defcfun ("gsl_sf_clausen" #.(swig-lispify "gsl_sf_clausen" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_clausen" 'function))
(cffi:defcfun ("gsl_sf_hydrogenicR_1_e" #.(swig-lispify "gsl_sf_hydrogenicR_1_e" 'function)) :int
(Z :double)
(r :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hydrogenicR_1_e" 'function))
(cffi:defcfun ("gsl_sf_hydrogenicR_1" #.(swig-lispify "gsl_sf_hydrogenicR_1" 'function)) :double
(Z :double)
(r :double))
(cl:export '#.(swig-lispify "gsl_sf_hydrogenicR_1" 'function))
(cffi:defcfun ("gsl_sf_hydrogenicR_e" #.(swig-lispify "gsl_sf_hydrogenicR_e" 'function)) :int
(n :int)
(l :int)
(Z :double)
(r :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hydrogenicR_e" 'function))
(cffi:defcfun ("gsl_sf_hydrogenicR" #.(swig-lispify "gsl_sf_hydrogenicR" 'function)) :double
(n :int)
(l :int)
(Z :double)
(r :double))
(cl:export '#.(swig-lispify "gsl_sf_hydrogenicR" 'function))
(cffi:defcfun ("gsl_sf_coulomb_wave_FG_e" #.(swig-lispify "gsl_sf_coulomb_wave_FG_e" 'function)) :int
(eta :double)
(x :double)
(lam_F :double)
(k_lam_G :int)
(F :pointer)
(Fp :pointer)
(G :pointer)
(Gp :pointer)
(exp_F :pointer)
(exp_G :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_wave_FG_e" 'function))
(cffi:defcfun ("gsl_sf_coulomb_wave_F_array" #.(swig-lispify "gsl_sf_coulomb_wave_F_array" 'function)) :int
(lam_min :double)
(kmax :int)
(eta :double)
(x :double)
(fc_array :pointer)
(F_exponent :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_wave_F_array" 'function))
(cffi:defcfun ("gsl_sf_coulomb_wave_FG_array" #.(swig-lispify "gsl_sf_coulomb_wave_FG_array" 'function)) :int
(lam_min :double)
(kmax :int)
(eta :double)
(x :double)
(fc_array :pointer)
(gc_array :pointer)
(F_exponent :pointer)
(G_exponent :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_wave_FG_array" 'function))
(cffi:defcfun ("gsl_sf_coulomb_wave_FGp_array" #.(swig-lispify "gsl_sf_coulomb_wave_FGp_array" 'function)) :int
(lam_min :double)
(kmax :int)
(eta :double)
(x :double)
(fc_array :pointer)
(fcp_array :pointer)
(gc_array :pointer)
(gcp_array :pointer)
(F_exponent :pointer)
(G_exponent :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_wave_FGp_array" 'function))
(cffi:defcfun ("gsl_sf_coulomb_wave_sphF_array" #.(swig-lispify "gsl_sf_coulomb_wave_sphF_array" 'function)) :int
(lam_min :double)
(kmax :int)
(eta :double)
(x :double)
(fc_array :pointer)
(F_exponent :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_wave_sphF_array" 'function))
(cffi:defcfun ("gsl_sf_coulomb_CL_e" #.(swig-lispify "gsl_sf_coulomb_CL_e" 'function)) :int
(L :double)
(eta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_CL_e" 'function))
(cffi:defcfun ("gsl_sf_coulomb_CL_array" #.(swig-lispify "gsl_sf_coulomb_CL_array" 'function)) :int
(Lmin :double)
(kmax :int)
(eta :double)
(cl :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coulomb_CL_array" 'function))
(cffi:defcfun ("gsl_sf_coupling_3j_e" #.(swig-lispify "gsl_sf_coupling_3j_e" 'function)) :int
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_ma :int)
(two_mb :int)
(two_mc :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coupling_3j_e" 'function))
(cffi:defcfun ("gsl_sf_coupling_3j" #.(swig-lispify "gsl_sf_coupling_3j" 'function)) :double
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_ma :int)
(two_mb :int)
(two_mc :int))
(cl:export '#.(swig-lispify "gsl_sf_coupling_3j" 'function))
(cffi:defcfun ("gsl_sf_coupling_6j_e" #.(swig-lispify "gsl_sf_coupling_6j_e" 'function)) :int
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coupling_6j_e" 'function))
(cffi:defcfun ("gsl_sf_coupling_6j" #.(swig-lispify "gsl_sf_coupling_6j" 'function)) :double
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int))
(cl:export '#.(swig-lispify "gsl_sf_coupling_6j" 'function))
(cffi:defcfun ("gsl_sf_coupling_RacahW_e" #.(swig-lispify "gsl_sf_coupling_RacahW_e" 'function)) :int
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coupling_RacahW_e" 'function))
(cffi:defcfun ("gsl_sf_coupling_RacahW" #.(swig-lispify "gsl_sf_coupling_RacahW" 'function)) :double
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int))
(cl:export '#.(swig-lispify "gsl_sf_coupling_RacahW" 'function))
(cffi:defcfun ("gsl_sf_coupling_9j_e" #.(swig-lispify "gsl_sf_coupling_9j_e" 'function)) :int
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int)
(two_jg :int)
(two_jh :int)
(two_ji :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coupling_9j_e" 'function))
(cffi:defcfun ("gsl_sf_coupling_9j" #.(swig-lispify "gsl_sf_coupling_9j" 'function)) :double
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int)
(two_jg :int)
(two_jh :int)
(two_ji :int))
(cl:export '#.(swig-lispify "gsl_sf_coupling_9j" 'function))
(cffi:defcfun ("gsl_sf_coupling_6j_INCORRECT_e" #.(swig-lispify "gsl_sf_coupling_6j_INCORRECT_e" 'function)) :int
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_coupling_6j_INCORRECT_e" 'function))
(cffi:defcfun ("gsl_sf_coupling_6j_INCORRECT" #.(swig-lispify "gsl_sf_coupling_6j_INCORRECT" 'function)) :double
(two_ja :int)
(two_jb :int)
(two_jc :int)
(two_jd :int)
(two_je :int)
(two_jf :int))
(cl:export '#.(swig-lispify "gsl_sf_coupling_6j_INCORRECT" 'function))
(cffi:defcfun ("gsl_sf_dawson_e" #.(swig-lispify "gsl_sf_dawson_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_dawson_e" 'function))
(cffi:defcfun ("gsl_sf_dawson" #.(swig-lispify "gsl_sf_dawson" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_dawson" 'function))
(cffi:defcfun ("gsl_sf_debye_1_e" #.(swig-lispify "gsl_sf_debye_1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_1_e" 'function))
(cffi:defcfun ("gsl_sf_debye_1" #.(swig-lispify "gsl_sf_debye_1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_1" 'function))
(cffi:defcfun ("gsl_sf_debye_2_e" #.(swig-lispify "gsl_sf_debye_2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_2_e" 'function))
(cffi:defcfun ("gsl_sf_debye_2" #.(swig-lispify "gsl_sf_debye_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_2" 'function))
(cffi:defcfun ("gsl_sf_debye_3_e" #.(swig-lispify "gsl_sf_debye_3_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_3_e" 'function))
(cffi:defcfun ("gsl_sf_debye_3" #.(swig-lispify "gsl_sf_debye_3" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_3" 'function))
(cffi:defcfun ("gsl_sf_debye_4_e" #.(swig-lispify "gsl_sf_debye_4_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_4_e" 'function))
(cffi:defcfun ("gsl_sf_debye_4" #.(swig-lispify "gsl_sf_debye_4" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_4" 'function))
(cffi:defcfun ("gsl_sf_debye_5_e" #.(swig-lispify "gsl_sf_debye_5_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_5_e" 'function))
(cffi:defcfun ("gsl_sf_debye_5" #.(swig-lispify "gsl_sf_debye_5" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_5" 'function))
(cffi:defcfun ("gsl_sf_debye_6_e" #.(swig-lispify "gsl_sf_debye_6_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_debye_6_e" 'function))
(cffi:defcfun ("gsl_sf_debye_6" #.(swig-lispify "gsl_sf_debye_6" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_debye_6" 'function))
(cffi:defcfun ("gsl_sf_dilog_e" #.(swig-lispify "gsl_sf_dilog_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_dilog_e" 'function))
(cffi:defcfun ("gsl_sf_dilog" #.(swig-lispify "gsl_sf_dilog" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_dilog" 'function))
(cffi:defcfun ("gsl_sf_complex_dilog_xy_e" #.(swig-lispify "gsl_sf_complex_dilog_xy_e" 'function)) :int
(x :double)
(y :double)
(result_re :pointer)
(result_im :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_dilog_xy_e" 'function))
(cffi:defcfun ("gsl_sf_complex_dilog_e" #.(swig-lispify "gsl_sf_complex_dilog_e" 'function)) :int
(r :double)
(theta :double)
(result_re :pointer)
(result_im :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_dilog_e" 'function))
(cffi:defcfun ("gsl_sf_complex_spence_xy_e" #.(swig-lispify "gsl_sf_complex_spence_xy_e" 'function)) :int
(x :double)
(y :double)
(real_sp :pointer)
(imag_sp :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_spence_xy_e" 'function))
(cffi:defcfun ("gsl_sf_multiply_e" #.(swig-lispify "gsl_sf_multiply_e" 'function)) :int
(x :double)
(y :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_multiply_e" 'function))
(cffi:defcfun ("gsl_sf_multiply" #.(swig-lispify "gsl_sf_multiply" 'function)) :double
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_sf_multiply" 'function))
(cffi:defcfun ("gsl_sf_multiply_err_e" #.(swig-lispify "gsl_sf_multiply_err_e" 'function)) :int
(x :double)
(dx :double)
(y :double)
(dy :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_multiply_err_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_Kcomp_e" #.(swig-lispify "gsl_sf_ellint_Kcomp_e" 'function)) :int
(k :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Kcomp_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_Kcomp" #.(swig-lispify "gsl_sf_ellint_Kcomp" 'function)) :double
(k :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Kcomp" 'function))
(cffi:defcfun ("gsl_sf_ellint_Ecomp_e" #.(swig-lispify "gsl_sf_ellint_Ecomp_e" 'function)) :int
(k :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Ecomp_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_Ecomp" #.(swig-lispify "gsl_sf_ellint_Ecomp" 'function)) :double
(k :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Ecomp" 'function))
(cffi:defcfun ("gsl_sf_ellint_Pcomp_e" #.(swig-lispify "gsl_sf_ellint_Pcomp_e" 'function)) :int
(k :double)
(n :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Pcomp_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_Pcomp" #.(swig-lispify "gsl_sf_ellint_Pcomp" 'function)) :double
(k :double)
(n :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Pcomp" 'function))
(cffi:defcfun ("gsl_sf_ellint_Dcomp_e" #.(swig-lispify "gsl_sf_ellint_Dcomp_e" 'function)) :int
(k :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Dcomp_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_Dcomp" #.(swig-lispify "gsl_sf_ellint_Dcomp" 'function)) :double
(k :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_Dcomp" 'function))
(cffi:defcfun ("gsl_sf_ellint_F_e" #.(swig-lispify "gsl_sf_ellint_F_e" 'function)) :int
(phi :double)
(k :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_F_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_F" #.(swig-lispify "gsl_sf_ellint_F" 'function)) :double
(phi :double)
(k :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_F" 'function))
(cffi:defcfun ("gsl_sf_ellint_E_e" #.(swig-lispify "gsl_sf_ellint_E_e" 'function)) :int
(phi :double)
(k :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_E_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_E" #.(swig-lispify "gsl_sf_ellint_E" 'function)) :double
(phi :double)
(k :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_E" 'function))
(cffi:defcfun ("gsl_sf_ellint_P_e" #.(swig-lispify "gsl_sf_ellint_P_e" 'function)) :int
(phi :double)
(k :double)
(n :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_P_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_P" #.(swig-lispify "gsl_sf_ellint_P" 'function)) :double
(phi :double)
(k :double)
(n :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_P" 'function))
(cffi:defcfun ("gsl_sf_ellint_D_e" #.(swig-lispify "gsl_sf_ellint_D_e" 'function)) :int
(phi :double)
(k :double)
(n :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_D_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_D" #.(swig-lispify "gsl_sf_ellint_D" 'function)) :double
(phi :double)
(k :double)
(n :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_D" 'function))
(cffi:defcfun ("gsl_sf_ellint_RC_e" #.(swig-lispify "gsl_sf_ellint_RC_e" 'function)) :int
(x :double)
(y :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RC_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_RC" #.(swig-lispify "gsl_sf_ellint_RC" 'function)) :double
(x :double)
(y :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RC" 'function))
(cffi:defcfun ("gsl_sf_ellint_RD_e" #.(swig-lispify "gsl_sf_ellint_RD_e" 'function)) :int
(x :double)
(y :double)
(z :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RD_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_RD" #.(swig-lispify "gsl_sf_ellint_RD" 'function)) :double
(x :double)
(y :double)
(z :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RD" 'function))
(cffi:defcfun ("gsl_sf_ellint_RF_e" #.(swig-lispify "gsl_sf_ellint_RF_e" 'function)) :int
(x :double)
(y :double)
(z :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RF_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_RF" #.(swig-lispify "gsl_sf_ellint_RF" 'function)) :double
(x :double)
(y :double)
(z :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RF" 'function))
(cffi:defcfun ("gsl_sf_ellint_RJ_e" #.(swig-lispify "gsl_sf_ellint_RJ_e" 'function)) :int
(x :double)
(y :double)
(z :double)
(p :double)
(mode :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RJ_e" 'function))
(cffi:defcfun ("gsl_sf_ellint_RJ" #.(swig-lispify "gsl_sf_ellint_RJ" 'function)) :double
(x :double)
(y :double)
(z :double)
(p :double)
(mode :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_ellint_RJ" 'function))
(cffi:defcfun ("gsl_sf_elljac_e" #.(swig-lispify "gsl_sf_elljac_e" 'function)) :int
(u :double)
(m :double)
(sn :pointer)
(cn :pointer)
(dn :pointer))
(cl:export '#.(swig-lispify "gsl_sf_elljac_e" 'function))
(cffi:defcfun ("gsl_sf_erfc_e" #.(swig-lispify "gsl_sf_erfc_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_erfc_e" 'function))
(cffi:defcfun ("gsl_sf_erfc" #.(swig-lispify "gsl_sf_erfc" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_erfc" 'function))
(cffi:defcfun ("gsl_sf_log_erfc_e" #.(swig-lispify "gsl_sf_log_erfc_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_log_erfc_e" 'function))
(cffi:defcfun ("gsl_sf_log_erfc" #.(swig-lispify "gsl_sf_log_erfc" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_log_erfc" 'function))
(cffi:defcfun ("gsl_sf_erf_e" #.(swig-lispify "gsl_sf_erf_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_erf_e" 'function))
(cffi:defcfun ("gsl_sf_erf" #.(swig-lispify "gsl_sf_erf" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_erf" 'function))
(cffi:defcfun ("gsl_sf_erf_Z_e" #.(swig-lispify "gsl_sf_erf_Z_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_erf_Z_e" 'function))
(cffi:defcfun ("gsl_sf_erf_Q_e" #.(swig-lispify "gsl_sf_erf_Q_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_erf_Q_e" 'function))
(cffi:defcfun ("gsl_sf_erf_Z" #.(swig-lispify "gsl_sf_erf_Z" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_erf_Z" 'function))
(cffi:defcfun ("gsl_sf_erf_Q" #.(swig-lispify "gsl_sf_erf_Q" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_erf_Q" 'function))
(cffi:defcfun ("gsl_sf_hazard_e" #.(swig-lispify "gsl_sf_hazard_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hazard_e" 'function))
(cffi:defcfun ("gsl_sf_hazard" #.(swig-lispify "gsl_sf_hazard" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hazard" 'function))
(cffi:defcfun ("gsl_sf_exp_e" #.(swig-lispify "gsl_sf_exp_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_e" 'function))
(cffi:defcfun ("gsl_sf_exp" #.(swig-lispify "gsl_sf_exp" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_exp" 'function))
(cffi:defcfun ("gsl_sf_exp_e10_e" #.(swig-lispify "gsl_sf_exp_e10_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_e10_e" 'function))
(cffi:defcfun ("gsl_sf_exp_mult_e" #.(swig-lispify "gsl_sf_exp_mult_e" 'function)) :int
(x :double)
(y :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_mult_e" 'function))
(cffi:defcfun ("gsl_sf_exp_mult" #.(swig-lispify "gsl_sf_exp_mult" 'function)) :double
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_sf_exp_mult" 'function))
(cffi:defcfun ("gsl_sf_exp_mult_e10_e" #.(swig-lispify "gsl_sf_exp_mult_e10_e" 'function)) :int
(x :double)
(y :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_mult_e10_e" 'function))
(cffi:defcfun ("gsl_sf_expm1_e" #.(swig-lispify "gsl_sf_expm1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expm1_e" 'function))
(cffi:defcfun ("gsl_sf_expm1" #.(swig-lispify "gsl_sf_expm1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expm1" 'function))
(cffi:defcfun ("gsl_sf_exprel_e" #.(swig-lispify "gsl_sf_exprel_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exprel_e" 'function))
(cffi:defcfun ("gsl_sf_exprel" #.(swig-lispify "gsl_sf_exprel" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_exprel" 'function))
(cffi:defcfun ("gsl_sf_exprel_2_e" #.(swig-lispify "gsl_sf_exprel_2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exprel_2_e" 'function))
(cffi:defcfun ("gsl_sf_exprel_2" #.(swig-lispify "gsl_sf_exprel_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_exprel_2" 'function))
(cffi:defcfun ("gsl_sf_exprel_n_e" #.(swig-lispify "gsl_sf_exprel_n_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exprel_n_e" 'function))
(cffi:defcfun ("gsl_sf_exprel_n" #.(swig-lispify "gsl_sf_exprel_n" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_exprel_n" 'function))
(cffi:defcfun ("gsl_sf_exprel_n_CF_e" #.(swig-lispify "gsl_sf_exprel_n_CF_e" 'function)) :int
(n :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exprel_n_CF_e" 'function))
(cffi:defcfun ("gsl_sf_exp_err_e" #.(swig-lispify "gsl_sf_exp_err_e" 'function)) :int
(x :double)
(dx :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_err_e" 'function))
(cffi:defcfun ("gsl_sf_exp_err_e10_e" #.(swig-lispify "gsl_sf_exp_err_e10_e" 'function)) :int
(x :double)
(dx :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_err_e10_e" 'function))
(cffi:defcfun ("gsl_sf_exp_mult_err_e" #.(swig-lispify "gsl_sf_exp_mult_err_e" 'function)) :int
(x :double)
(dx :double)
(y :double)
(dy :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_mult_err_e" 'function))
(cffi:defcfun ("gsl_sf_exp_mult_err_e10_e" #.(swig-lispify "gsl_sf_exp_mult_err_e10_e" 'function)) :int
(x :double)
(dx :double)
(y :double)
(dy :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_exp_mult_err_e10_e" 'function))
(cffi:defcfun ("gsl_sf_expint_E1_e" #.(swig-lispify "gsl_sf_expint_E1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_E1_e" 'function))
(cffi:defcfun ("gsl_sf_expint_E1" #.(swig-lispify "gsl_sf_expint_E1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_E1" 'function))
(cffi:defcfun ("gsl_sf_expint_E2_e" #.(swig-lispify "gsl_sf_expint_E2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_E2_e" 'function))
(cffi:defcfun ("gsl_sf_expint_E2" #.(swig-lispify "gsl_sf_expint_E2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_E2" 'function))
(cffi:defcfun ("gsl_sf_expint_En_e" #.(swig-lispify "gsl_sf_expint_En_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_En_e" 'function))
(cffi:defcfun ("gsl_sf_expint_En" #.(swig-lispify "gsl_sf_expint_En" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_En" 'function))
(cffi:defcfun ("gsl_sf_expint_E1_scaled_e" #.(swig-lispify "gsl_sf_expint_E1_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_E1_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_expint_E1_scaled" #.(swig-lispify "gsl_sf_expint_E1_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_E1_scaled" 'function))
(cffi:defcfun ("gsl_sf_expint_E2_scaled_e" #.(swig-lispify "gsl_sf_expint_E2_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_E2_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_expint_E2_scaled" #.(swig-lispify "gsl_sf_expint_E2_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_E2_scaled" 'function))
(cffi:defcfun ("gsl_sf_expint_En_scaled_e" #.(swig-lispify "gsl_sf_expint_En_scaled_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_En_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_expint_En_scaled" #.(swig-lispify "gsl_sf_expint_En_scaled" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_En_scaled" 'function))
(cffi:defcfun ("gsl_sf_expint_Ei_e" #.(swig-lispify "gsl_sf_expint_Ei_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_Ei_e" 'function))
(cffi:defcfun ("gsl_sf_expint_Ei" #.(swig-lispify "gsl_sf_expint_Ei" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_Ei" 'function))
(cffi:defcfun ("gsl_sf_expint_Ei_scaled_e" #.(swig-lispify "gsl_sf_expint_Ei_scaled_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_Ei_scaled_e" 'function))
(cffi:defcfun ("gsl_sf_expint_Ei_scaled" #.(swig-lispify "gsl_sf_expint_Ei_scaled" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_Ei_scaled" 'function))
(cffi:defcfun ("gsl_sf_Shi_e" #.(swig-lispify "gsl_sf_Shi_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_Shi_e" 'function))
(cffi:defcfun ("gsl_sf_Shi" #.(swig-lispify "gsl_sf_Shi" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_Shi" 'function))
(cffi:defcfun ("gsl_sf_Chi_e" #.(swig-lispify "gsl_sf_Chi_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_Chi_e" 'function))
(cffi:defcfun ("gsl_sf_Chi" #.(swig-lispify "gsl_sf_Chi" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_Chi" 'function))
(cffi:defcfun ("gsl_sf_expint_3_e" #.(swig-lispify "gsl_sf_expint_3_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_expint_3_e" 'function))
(cffi:defcfun ("gsl_sf_expint_3" #.(swig-lispify "gsl_sf_expint_3" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_expint_3" 'function))
(cffi:defcfun ("gsl_sf_Si_e" #.(swig-lispify "gsl_sf_Si_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_Si_e" 'function))
(cffi:defcfun ("gsl_sf_Si" #.(swig-lispify "gsl_sf_Si" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_Si" 'function))
(cffi:defcfun ("gsl_sf_Ci_e" #.(swig-lispify "gsl_sf_Ci_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_Ci_e" 'function))
(cffi:defcfun ("gsl_sf_Ci" #.(swig-lispify "gsl_sf_Ci" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_Ci" 'function))
(cffi:defcfun ("gsl_sf_atanint_e" #.(swig-lispify "gsl_sf_atanint_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_atanint_e" 'function))
(cffi:defcfun ("gsl_sf_atanint" #.(swig-lispify "gsl_sf_atanint" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_atanint" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_m1_e" #.(swig-lispify "gsl_sf_fermi_dirac_m1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_m1_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_m1" #.(swig-lispify "gsl_sf_fermi_dirac_m1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_m1" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_0_e" #.(swig-lispify "gsl_sf_fermi_dirac_0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_0_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_0" #.(swig-lispify "gsl_sf_fermi_dirac_0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_0" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_1_e" #.(swig-lispify "gsl_sf_fermi_dirac_1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_1_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_1" #.(swig-lispify "gsl_sf_fermi_dirac_1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_1" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_2_e" #.(swig-lispify "gsl_sf_fermi_dirac_2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_2_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_2" #.(swig-lispify "gsl_sf_fermi_dirac_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_2" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_int_e" #.(swig-lispify "gsl_sf_fermi_dirac_int_e" 'function)) :int
(j :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_int_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_int" #.(swig-lispify "gsl_sf_fermi_dirac_int" 'function)) :double
(j :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_int" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_mhalf_e" #.(swig-lispify "gsl_sf_fermi_dirac_mhalf_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_mhalf_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_mhalf" #.(swig-lispify "gsl_sf_fermi_dirac_mhalf" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_mhalf" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_half_e" #.(swig-lispify "gsl_sf_fermi_dirac_half_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_half_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_half" #.(swig-lispify "gsl_sf_fermi_dirac_half" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_half" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_3half_e" #.(swig-lispify "gsl_sf_fermi_dirac_3half_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_3half_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_3half" #.(swig-lispify "gsl_sf_fermi_dirac_3half" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_3half" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_inc_0_e" #.(swig-lispify "gsl_sf_fermi_dirac_inc_0_e" 'function)) :int
(x :double)
(b :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_inc_0_e" 'function))
(cffi:defcfun ("gsl_sf_fermi_dirac_inc_0" #.(swig-lispify "gsl_sf_fermi_dirac_inc_0" 'function)) :double
(x :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_sf_fermi_dirac_inc_0" 'function))
(cffi:defcfun ("gsl_sf_lngamma_e" #.(swig-lispify "gsl_sf_lngamma_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lngamma_e" 'function))
(cffi:defcfun ("gsl_sf_lngamma" #.(swig-lispify "gsl_sf_lngamma" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lngamma" 'function))
(cffi:defcfun ("gsl_sf_lngamma_sgn_e" #.(swig-lispify "gsl_sf_lngamma_sgn_e" 'function)) :int
(x :double)
(result_lg :pointer)
(sgn :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lngamma_sgn_e" 'function))
(cffi:defcfun ("gsl_sf_gamma_e" #.(swig-lispify "gsl_sf_gamma_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gamma_e" 'function))
(cffi:defcfun ("gsl_sf_gamma" #.(swig-lispify "gsl_sf_gamma" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gamma" 'function))
(cffi:defcfun ("gsl_sf_gammastar_e" #.(swig-lispify "gsl_sf_gammastar_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gammastar_e" 'function))
(cffi:defcfun ("gsl_sf_gammastar" #.(swig-lispify "gsl_sf_gammastar" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gammastar" 'function))
(cffi:defcfun ("gsl_sf_gammainv_e" #.(swig-lispify "gsl_sf_gammainv_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gammainv_e" 'function))
(cffi:defcfun ("gsl_sf_gammainv" #.(swig-lispify "gsl_sf_gammainv" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gammainv" 'function))
(cffi:defcfun ("gsl_sf_lngamma_complex_e" #.(swig-lispify "gsl_sf_lngamma_complex_e" 'function)) :int
(zr :double)
(zi :double)
(lnr :pointer)
(arg :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lngamma_complex_e" 'function))
(cffi:defcfun ("gsl_sf_taylorcoeff_e" #.(swig-lispify "gsl_sf_taylorcoeff_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_taylorcoeff_e" 'function))
(cffi:defcfun ("gsl_sf_taylorcoeff" #.(swig-lispify "gsl_sf_taylorcoeff" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_taylorcoeff" 'function))
(cffi:defcfun ("gsl_sf_fact_e" #.(swig-lispify "gsl_sf_fact_e" 'function)) :int
(n :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_fact_e" 'function))
(cffi:defcfun ("gsl_sf_fact" #.(swig-lispify "gsl_sf_fact" 'function)) :double
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_fact" 'function))
(cffi:defcfun ("gsl_sf_doublefact_e" #.(swig-lispify "gsl_sf_doublefact_e" 'function)) :int
(n :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_doublefact_e" 'function))
(cffi:defcfun ("gsl_sf_doublefact" #.(swig-lispify "gsl_sf_doublefact" 'function)) :double
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_doublefact" 'function))
(cffi:defcfun ("gsl_sf_lnfact_e" #.(swig-lispify "gsl_sf_lnfact_e" 'function)) :int
(n :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnfact_e" 'function))
(cffi:defcfun ("gsl_sf_lnfact" #.(swig-lispify "gsl_sf_lnfact" 'function)) :double
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_lnfact" 'function))
(cffi:defcfun ("gsl_sf_lndoublefact_e" #.(swig-lispify "gsl_sf_lndoublefact_e" 'function)) :int
(n :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lndoublefact_e" 'function))
(cffi:defcfun ("gsl_sf_lndoublefact" #.(swig-lispify "gsl_sf_lndoublefact" 'function)) :double
(n :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_lndoublefact" 'function))
(cffi:defcfun ("gsl_sf_lnchoose_e" #.(swig-lispify "gsl_sf_lnchoose_e" 'function)) :int
(n :unsigned-int)
(m :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnchoose_e" 'function))
(cffi:defcfun ("gsl_sf_lnchoose" #.(swig-lispify "gsl_sf_lnchoose" 'function)) :double
(n :unsigned-int)
(m :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_lnchoose" 'function))
(cffi:defcfun ("gsl_sf_choose_e" #.(swig-lispify "gsl_sf_choose_e" 'function)) :int
(n :unsigned-int)
(m :unsigned-int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_choose_e" 'function))
(cffi:defcfun ("gsl_sf_choose" #.(swig-lispify "gsl_sf_choose" 'function)) :double
(n :unsigned-int)
(m :unsigned-int))
(cl:export '#.(swig-lispify "gsl_sf_choose" 'function))
(cffi:defcfun ("gsl_sf_lnpoch_e" #.(swig-lispify "gsl_sf_lnpoch_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnpoch_e" 'function))
(cffi:defcfun ("gsl_sf_lnpoch" #.(swig-lispify "gsl_sf_lnpoch" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lnpoch" 'function))
(cffi:defcfun ("gsl_sf_lnpoch_sgn_e" #.(swig-lispify "gsl_sf_lnpoch_sgn_e" 'function)) :int
(a :double)
(x :double)
(result :pointer)
(sgn :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnpoch_sgn_e" 'function))
(cffi:defcfun ("gsl_sf_poch_e" #.(swig-lispify "gsl_sf_poch_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_poch_e" 'function))
(cffi:defcfun ("gsl_sf_poch" #.(swig-lispify "gsl_sf_poch" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_poch" 'function))
(cffi:defcfun ("gsl_sf_pochrel_e" #.(swig-lispify "gsl_sf_pochrel_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_pochrel_e" 'function))
(cffi:defcfun ("gsl_sf_pochrel" #.(swig-lispify "gsl_sf_pochrel" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_pochrel" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc_Q_e" #.(swig-lispify "gsl_sf_gamma_inc_Q_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc_Q_e" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc_Q" #.(swig-lispify "gsl_sf_gamma_inc_Q" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc_Q" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc_P_e" #.(swig-lispify "gsl_sf_gamma_inc_P_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc_P_e" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc_P" #.(swig-lispify "gsl_sf_gamma_inc_P" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc_P" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc_e" #.(swig-lispify "gsl_sf_gamma_inc_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc_e" 'function))
(cffi:defcfun ("gsl_sf_gamma_inc" #.(swig-lispify "gsl_sf_gamma_inc" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gamma_inc" 'function))
(cffi:defcfun ("gsl_sf_lnbeta_e" #.(swig-lispify "gsl_sf_lnbeta_e" 'function)) :int
(a :double)
(b :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnbeta_e" 'function))
(cffi:defcfun ("gsl_sf_lnbeta" #.(swig-lispify "gsl_sf_lnbeta" 'function)) :double
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_sf_lnbeta" 'function))
(cffi:defcfun ("gsl_sf_lnbeta_sgn_e" #.(swig-lispify "gsl_sf_lnbeta_sgn_e" 'function)) :int
(x :double)
(y :double)
(result :pointer)
(sgn :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnbeta_sgn_e" 'function))
(cffi:defcfun ("gsl_sf_beta_e" #.(swig-lispify "gsl_sf_beta_e" 'function)) :int
(a :double)
(b :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_beta_e" 'function))
(cffi:defcfun ("gsl_sf_beta" #.(swig-lispify "gsl_sf_beta" 'function)) :double
(a :double)
(b :double))
(cl:export '#.(swig-lispify "gsl_sf_beta" 'function))
(cffi:defcfun ("gsl_sf_beta_inc_e" #.(swig-lispify "gsl_sf_beta_inc_e" 'function)) :int
(a :double)
(b :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_beta_inc_e" 'function))
(cffi:defcfun ("gsl_sf_beta_inc" #.(swig-lispify "gsl_sf_beta_inc" 'function)) :double
(a :double)
(b :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_beta_inc" 'function))
(cl:defconstant #.(swig-lispify "GSL_SF_GAMMA_XMAX" 'constant) 171.0d0)
(cl:export '#.(swig-lispify "GSL_SF_GAMMA_XMAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SF_FACT_NMAX" 'constant) 170)
(cl:export '#.(swig-lispify "GSL_SF_FACT_NMAX" 'constant))
(cl:defconstant #.(swig-lispify "GSL_SF_DOUBLEFACT_NMAX" 'constant) 297)
(cl:export '#.(swig-lispify "GSL_SF_DOUBLEFACT_NMAX" 'constant))
(cffi:defcfun ("gsl_sf_gegenpoly_1_e" #.(swig-lispify "gsl_sf_gegenpoly_1_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_1_e" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_2_e" #.(swig-lispify "gsl_sf_gegenpoly_2_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_2_e" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_3_e" #.(swig-lispify "gsl_sf_gegenpoly_3_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_3_e" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_1" #.(swig-lispify "gsl_sf_gegenpoly_1" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_1" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_2" #.(swig-lispify "gsl_sf_gegenpoly_2" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_2" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_3" #.(swig-lispify "gsl_sf_gegenpoly_3" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_3" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_n_e" #.(swig-lispify "gsl_sf_gegenpoly_n_e" 'function)) :int
(n :int)
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_n_e" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_n" #.(swig-lispify "gsl_sf_gegenpoly_n" 'function)) :double
(n :int)
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_n" 'function))
(cffi:defcfun ("gsl_sf_gegenpoly_array" #.(swig-lispify "gsl_sf_gegenpoly_array" 'function)) :int
(nmax :int)
(lambda :double)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_gegenpoly_array" 'function))
(cffi:defcfun ("gsl_sf_hyperg_0F1_e" #.(swig-lispify "gsl_sf_hyperg_0F1_e" 'function)) :int
(c :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_0F1_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_0F1" #.(swig-lispify "gsl_sf_hyperg_0F1" 'function)) :double
(c :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_0F1" 'function))
(cffi:defcfun ("gsl_sf_hyperg_1F1_int_e" #.(swig-lispify "gsl_sf_hyperg_1F1_int_e" 'function)) :int
(m :int)
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_1F1_int_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_1F1_int" #.(swig-lispify "gsl_sf_hyperg_1F1_int" 'function)) :double
(m :int)
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_1F1_int" 'function))
(cffi:defcfun ("gsl_sf_hyperg_1F1_e" #.(swig-lispify "gsl_sf_hyperg_1F1_e" 'function)) :int
(a :double)
(b :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_1F1_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_1F1" #.(swig-lispify "gsl_sf_hyperg_1F1" 'function)) :double
(a :double)
(b :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_1F1" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U_int_e" #.(swig-lispify "gsl_sf_hyperg_U_int_e" 'function)) :int
(m :int)
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U_int_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U_int" #.(swig-lispify "gsl_sf_hyperg_U_int" 'function)) :double
(m :int)
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U_int" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U_int_e10_e" #.(swig-lispify "gsl_sf_hyperg_U_int_e10_e" 'function)) :int
(m :int)
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U_int_e10_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U_e" #.(swig-lispify "gsl_sf_hyperg_U_e" 'function)) :int
(a :double)
(b :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U" #.(swig-lispify "gsl_sf_hyperg_U" 'function)) :double
(a :double)
(b :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U" 'function))
(cffi:defcfun ("gsl_sf_hyperg_U_e10_e" #.(swig-lispify "gsl_sf_hyperg_U_e10_e" 'function)) :int
(a :double)
(b :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_U_e10_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_e" #.(swig-lispify "gsl_sf_hyperg_2F1_e" 'function)) :int
(a :double)
(b :double)
(c :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1" #.(swig-lispify "gsl_sf_hyperg_2F1" 'function)) :double
(a :double)
(b :double)
(c :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_conj_e" #.(swig-lispify "gsl_sf_hyperg_2F1_conj_e" 'function)) :int
(aR :double)
(aI :double)
(c :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_conj_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_conj" #.(swig-lispify "gsl_sf_hyperg_2F1_conj" 'function)) :double
(aR :double)
(aI :double)
(c :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_conj" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_renorm_e" #.(swig-lispify "gsl_sf_hyperg_2F1_renorm_e" 'function)) :int
(a :double)
(b :double)
(c :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_renorm_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_renorm" #.(swig-lispify "gsl_sf_hyperg_2F1_renorm" 'function)) :double
(a :double)
(b :double)
(c :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_renorm" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_conj_renorm_e" #.(swig-lispify "gsl_sf_hyperg_2F1_conj_renorm_e" 'function)) :int
(aR :double)
(aI :double)
(c :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_conj_renorm_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F1_conj_renorm" #.(swig-lispify "gsl_sf_hyperg_2F1_conj_renorm" 'function)) :double
(aR :double)
(aI :double)
(c :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F1_conj_renorm" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F0_e" #.(swig-lispify "gsl_sf_hyperg_2F0_e" 'function)) :int
(a :double)
(b :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F0_e" 'function))
(cffi:defcfun ("gsl_sf_hyperg_2F0" #.(swig-lispify "gsl_sf_hyperg_2F0" 'function)) :double
(a :double)
(b :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_hyperg_2F0" 'function))
(cffi:defcfun ("gsl_sf_laguerre_1_e" #.(swig-lispify "gsl_sf_laguerre_1_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_1_e" 'function))
(cffi:defcfun ("gsl_sf_laguerre_2_e" #.(swig-lispify "gsl_sf_laguerre_2_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_2_e" 'function))
(cffi:defcfun ("gsl_sf_laguerre_3_e" #.(swig-lispify "gsl_sf_laguerre_3_e" 'function)) :int
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_3_e" 'function))
(cffi:defcfun ("gsl_sf_laguerre_1" #.(swig-lispify "gsl_sf_laguerre_1" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_1" 'function))
(cffi:defcfun ("gsl_sf_laguerre_2" #.(swig-lispify "gsl_sf_laguerre_2" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_2" 'function))
(cffi:defcfun ("gsl_sf_laguerre_3" #.(swig-lispify "gsl_sf_laguerre_3" 'function)) :double
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_3" 'function))
(cffi:defcfun ("gsl_sf_laguerre_n_e" #.(swig-lispify "gsl_sf_laguerre_n_e" 'function)) :int
(n :int)
(a :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_n_e" 'function))
(cffi:defcfun ("gsl_sf_laguerre_n" #.(swig-lispify "gsl_sf_laguerre_n" 'function)) :double
(n :int)
(a :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_laguerre_n" 'function))
(cffi:defcfun ("gsl_sf_lambert_W0_e" #.(swig-lispify "gsl_sf_lambert_W0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lambert_W0_e" 'function))
(cffi:defcfun ("gsl_sf_lambert_W0" #.(swig-lispify "gsl_sf_lambert_W0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lambert_W0" 'function))
(cffi:defcfun ("gsl_sf_lambert_Wm1_e" #.(swig-lispify "gsl_sf_lambert_Wm1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lambert_Wm1_e" 'function))
(cffi:defcfun ("gsl_sf_lambert_Wm1" #.(swig-lispify "gsl_sf_lambert_Wm1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lambert_Wm1" 'function))
(cffi:defcfun ("gsl_sf_legendre_Pl_e" #.(swig-lispify "gsl_sf_legendre_Pl_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Pl_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_Pl" #.(swig-lispify "gsl_sf_legendre_Pl" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Pl" 'function))
(cffi:defcfun ("gsl_sf_legendre_Pl_array" #.(swig-lispify "gsl_sf_legendre_Pl_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Pl_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_Pl_deriv_array" #.(swig-lispify "gsl_sf_legendre_Pl_deriv_array" 'function)) :int
(lmax :int)
(x :double)
(result_array :pointer)
(result_deriv_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Pl_deriv_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_P1_e" #.(swig-lispify "gsl_sf_legendre_P1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P1_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_P2_e" #.(swig-lispify "gsl_sf_legendre_P2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P2_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_P3_e" #.(swig-lispify "gsl_sf_legendre_P3_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P3_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_P1" #.(swig-lispify "gsl_sf_legendre_P1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P1" 'function))
(cffi:defcfun ("gsl_sf_legendre_P2" #.(swig-lispify "gsl_sf_legendre_P2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P2" 'function))
(cffi:defcfun ("gsl_sf_legendre_P3" #.(swig-lispify "gsl_sf_legendre_P3" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_P3" 'function))
(cffi:defcfun ("gsl_sf_legendre_Q0_e" #.(swig-lispify "gsl_sf_legendre_Q0_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Q0_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_Q0" #.(swig-lispify "gsl_sf_legendre_Q0" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Q0" 'function))
(cffi:defcfun ("gsl_sf_legendre_Q1_e" #.(swig-lispify "gsl_sf_legendre_Q1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Q1_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_Q1" #.(swig-lispify "gsl_sf_legendre_Q1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Q1" 'function))
(cffi:defcfun ("gsl_sf_legendre_Ql_e" #.(swig-lispify "gsl_sf_legendre_Ql_e" 'function)) :int
(l :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Ql_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_Ql" #.(swig-lispify "gsl_sf_legendre_Ql" 'function)) :double
(l :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Ql" 'function))
(cffi:defcfun ("gsl_sf_legendre_Plm_e" #.(swig-lispify "gsl_sf_legendre_Plm_e" 'function)) :int
(l :int)
(m :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Plm_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_Plm" #.(swig-lispify "gsl_sf_legendre_Plm" 'function)) :double
(l :int)
(m :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Plm" 'function))
(cffi:defcfun ("gsl_sf_legendre_Plm_array" #.(swig-lispify "gsl_sf_legendre_Plm_array" 'function)) :int
(lmax :int)
(m :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Plm_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_Plm_deriv_array" #.(swig-lispify "gsl_sf_legendre_Plm_deriv_array" 'function)) :int
(lmax :int)
(m :int)
(x :double)
(result_array :pointer)
(result_deriv_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_Plm_deriv_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_sphPlm_e" #.(swig-lispify "gsl_sf_legendre_sphPlm_e" 'function)) :int
(l :int)
(m :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_sphPlm_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_sphPlm" #.(swig-lispify "gsl_sf_legendre_sphPlm" 'function)) :double
(l :int)
(m :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_sphPlm" 'function))
(cffi:defcfun ("gsl_sf_legendre_sphPlm_array" #.(swig-lispify "gsl_sf_legendre_sphPlm_array" 'function)) :int
(lmax :int)
(m :int)
(x :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_sphPlm_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_sphPlm_deriv_array" #.(swig-lispify "gsl_sf_legendre_sphPlm_deriv_array" 'function)) :int
(lmax :int)
(m :int)
(x :double)
(result_array :pointer)
(result_deriv_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_sphPlm_deriv_array" 'function))
(cffi:defcfun ("gsl_sf_legendre_array_size" #.(swig-lispify "gsl_sf_legendre_array_size" 'function)) :int
(lmax :int)
(m :int))
(cl:export '#.(swig-lispify "gsl_sf_legendre_array_size" 'function))
(cffi:defcfun ("gsl_sf_conicalP_half_e" #.(swig-lispify "gsl_sf_conicalP_half_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_half_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_half" #.(swig-lispify "gsl_sf_conicalP_half" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_half" 'function))
(cffi:defcfun ("gsl_sf_conicalP_mhalf_e" #.(swig-lispify "gsl_sf_conicalP_mhalf_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_mhalf_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_mhalf" #.(swig-lispify "gsl_sf_conicalP_mhalf" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_mhalf" 'function))
(cffi:defcfun ("gsl_sf_conicalP_0_e" #.(swig-lispify "gsl_sf_conicalP_0_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_0_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_0" #.(swig-lispify "gsl_sf_conicalP_0" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_0" 'function))
(cffi:defcfun ("gsl_sf_conicalP_1_e" #.(swig-lispify "gsl_sf_conicalP_1_e" 'function)) :int
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_1_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_1" #.(swig-lispify "gsl_sf_conicalP_1" 'function)) :double
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_1" 'function))
(cffi:defcfun ("gsl_sf_conicalP_sph_reg_e" #.(swig-lispify "gsl_sf_conicalP_sph_reg_e" 'function)) :int
(l :int)
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_sph_reg_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_sph_reg" #.(swig-lispify "gsl_sf_conicalP_sph_reg" 'function)) :double
(l :int)
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_sph_reg" 'function))
(cffi:defcfun ("gsl_sf_conicalP_cyl_reg_e" #.(swig-lispify "gsl_sf_conicalP_cyl_reg_e" 'function)) :int
(m :int)
(lambda :double)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_cyl_reg_e" 'function))
(cffi:defcfun ("gsl_sf_conicalP_cyl_reg" #.(swig-lispify "gsl_sf_conicalP_cyl_reg" 'function)) :double
(m :int)
(lambda :double)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_conicalP_cyl_reg" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_0_e" #.(swig-lispify "gsl_sf_legendre_H3d_0_e" 'function)) :int
(lambda :double)
(eta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_0_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_0" #.(swig-lispify "gsl_sf_legendre_H3d_0" 'function)) :double
(lambda :double)
(eta :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_0" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_1_e" #.(swig-lispify "gsl_sf_legendre_H3d_1_e" 'function)) :int
(lambda :double)
(eta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_1_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_1" #.(swig-lispify "gsl_sf_legendre_H3d_1" 'function)) :double
(lambda :double)
(eta :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_1" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_e" #.(swig-lispify "gsl_sf_legendre_H3d_e" 'function)) :int
(l :int)
(lambda :double)
(eta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_e" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d" #.(swig-lispify "gsl_sf_legendre_H3d" 'function)) :double
(l :int)
(lambda :double)
(eta :double))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d" 'function))
(cffi:defcfun ("gsl_sf_legendre_H3d_array" #.(swig-lispify "gsl_sf_legendre_H3d_array" 'function)) :int
(lmax :int)
(lambda :double)
(eta :double)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_legendre_H3d_array" 'function))
(cffi:defcfun ("gsl_sf_log_e" #.(swig-lispify "gsl_sf_log_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_log_e" 'function))
(cffi:defcfun ("gsl_sf_log" #.(swig-lispify "gsl_sf_log" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_log" 'function))
(cffi:defcfun ("gsl_sf_log_abs_e" #.(swig-lispify "gsl_sf_log_abs_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_log_abs_e" 'function))
(cffi:defcfun ("gsl_sf_log_abs" #.(swig-lispify "gsl_sf_log_abs" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_log_abs" 'function))
(cffi:defcfun ("gsl_sf_complex_log_e" #.(swig-lispify "gsl_sf_complex_log_e" 'function)) :int
(zr :double)
(zi :double)
(lnr :pointer)
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_log_e" 'function))
(cffi:defcfun ("gsl_sf_log_1plusx_e" #.(swig-lispify "gsl_sf_log_1plusx_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_log_1plusx_e" 'function))
(cffi:defcfun ("gsl_sf_log_1plusx" #.(swig-lispify "gsl_sf_log_1plusx" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_log_1plusx" 'function))
(cffi:defcfun ("gsl_sf_log_1plusx_mx_e" #.(swig-lispify "gsl_sf_log_1plusx_mx_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_log_1plusx_mx_e" 'function))
(cffi:defcfun ("gsl_sf_log_1plusx_mx" #.(swig-lispify "gsl_sf_log_1plusx_mx" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_log_1plusx_mx" 'function))
(cl:defconstant #.(swig-lispify "GSL_SF_MATHIEU_COEFF" 'constant) 100)
(cl:export '#.(swig-lispify "GSL_SF_MATHIEU_COEFF" 'constant))
(cffi:defcstruct #.(swig-lispify "gsl_sf_mathieu_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "even_order" 'slotname) :pointer)
(#.(swig-lispify "odd_order" 'slotname) :pointer)
(#.(swig-lispify "extra_values" 'slotname) :int)
(#.(swig-lispify "qa" 'slotname) :double)
(#.(swig-lispify "qb" 'slotname) :double)
(#.(swig-lispify "aa" 'slotname) :pointer)
(#.(swig-lispify "bb" 'slotname) :pointer)
(#.(swig-lispify "dd" 'slotname) :pointer)
(#.(swig-lispify "ee" 'slotname) :pointer)
(#.(swig-lispify "tt" 'slotname) :pointer)
(#.(swig-lispify "e2" 'slotname) :pointer)
(#.(swig-lispify "zz" 'slotname) :pointer)
(#.(swig-lispify "eval" 'slotname) :pointer)
(#.(swig-lispify "evec" 'slotname) :pointer)
(#.(swig-lispify "wmat" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "even_order" 'slotname))
(cl:export '#.(swig-lispify "odd_order" 'slotname))
(cl:export '#.(swig-lispify "extra_values" 'slotname))
(cl:export '#.(swig-lispify "qa" 'slotname))
(cl:export '#.(swig-lispify "qb" 'slotname))
(cl:export '#.(swig-lispify "aa" 'slotname))
(cl:export '#.(swig-lispify "bb" 'slotname))
(cl:export '#.(swig-lispify "dd" 'slotname))
(cl:export '#.(swig-lispify "ee" 'slotname))
(cl:export '#.(swig-lispify "tt" 'slotname))
(cl:export '#.(swig-lispify "e2" 'slotname))
(cl:export '#.(swig-lispify "zz" 'slotname))
(cl:export '#.(swig-lispify "eval" 'slotname))
(cl:export '#.(swig-lispify "evec" 'slotname))
(cl:export '#.(swig-lispify "wmat" 'slotname))
(cffi:defcfun ("gsl_sf_mathieu_a_array" #.(swig-lispify "gsl_sf_mathieu_a_array" 'function)) :int
(order_min :int)
(order_max :int)
(qq :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_a_array" 'function))
(cffi:defcfun ("gsl_sf_mathieu_b_array" #.(swig-lispify "gsl_sf_mathieu_b_array" 'function)) :int
(order_min :int)
(order_max :int)
(qq :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_b_array" 'function))
(cffi:defcfun ("gsl_sf_mathieu_a" #.(swig-lispify "gsl_sf_mathieu_a" 'function)) :int
(order :int)
(qq :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_a" 'function))
(cffi:defcfun ("gsl_sf_mathieu_b" #.(swig-lispify "gsl_sf_mathieu_b" 'function)) :int
(order :int)
(qq :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_b" 'function))
(cffi:defcfun ("gsl_sf_mathieu_a_coeff" #.(swig-lispify "gsl_sf_mathieu_a_coeff" 'function)) :int
(order :int)
(qq :double)
(aa :double)
(coeff :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_a_coeff" 'function))
(cffi:defcfun ("gsl_sf_mathieu_b_coeff" #.(swig-lispify "gsl_sf_mathieu_b_coeff" 'function)) :int
(order :int)
(qq :double)
(aa :double)
(coeff :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_b_coeff" 'function))
(cffi:defcfun ("gsl_sf_mathieu_alloc" #.(swig-lispify "gsl_sf_mathieu_alloc" 'function)) :pointer
(nn :pointer)
(qq :double))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_alloc" 'function))
(cffi:defcfun ("gsl_sf_mathieu_free" #.(swig-lispify "gsl_sf_mathieu_free" 'function)) :void
(workspace :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_free" 'function))
(cffi:defcfun ("gsl_sf_mathieu_ce" #.(swig-lispify "gsl_sf_mathieu_ce" 'function)) :int
(order :int)
(qq :double)
(zz :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_ce" 'function))
(cffi:defcfun ("gsl_sf_mathieu_se" #.(swig-lispify "gsl_sf_mathieu_se" 'function)) :int
(order :int)
(qq :double)
(zz :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_se" 'function))
(cffi:defcfun ("gsl_sf_mathieu_ce_array" #.(swig-lispify "gsl_sf_mathieu_ce_array" 'function)) :int
(nmin :int)
(nmax :int)
(qq :double)
(zz :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_ce_array" 'function))
(cffi:defcfun ("gsl_sf_mathieu_se_array" #.(swig-lispify "gsl_sf_mathieu_se_array" 'function)) :int
(nmin :int)
(nmax :int)
(qq :double)
(zz :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_se_array" 'function))
(cffi:defcfun ("gsl_sf_mathieu_Mc" #.(swig-lispify "gsl_sf_mathieu_Mc" 'function)) :int
(kind :int)
(order :int)
(qq :double)
(zz :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_Mc" 'function))
(cffi:defcfun ("gsl_sf_mathieu_Ms" #.(swig-lispify "gsl_sf_mathieu_Ms" 'function)) :int
(kind :int)
(order :int)
(qq :double)
(zz :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_Ms" 'function))
(cffi:defcfun ("gsl_sf_mathieu_Mc_array" #.(swig-lispify "gsl_sf_mathieu_Mc_array" 'function)) :int
(kind :int)
(nmin :int)
(nmax :int)
(qq :double)
(zz :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_Mc_array" 'function))
(cffi:defcfun ("gsl_sf_mathieu_Ms_array" #.(swig-lispify "gsl_sf_mathieu_Ms_array" 'function)) :int
(kind :int)
(nmin :int)
(nmax :int)
(qq :double)
(zz :double)
(work :pointer)
(result_array :pointer))
(cl:export '#.(swig-lispify "gsl_sf_mathieu_Ms_array" 'function))
(cffi:defcfun ("gsl_sf_pow_int_e" #.(swig-lispify "gsl_sf_pow_int_e" 'function)) :int
(x :double)
(n :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_pow_int_e" 'function))
(cffi:defcfun ("gsl_sf_pow_int" #.(swig-lispify "gsl_sf_pow_int" 'function)) :double
(x :double)
(n :int))
(cl:export '#.(swig-lispify "gsl_sf_pow_int" 'function))
(cffi:defcfun ("gsl_sf_psi_int_e" #.(swig-lispify "gsl_sf_psi_int_e" 'function)) :int
(n :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_int_e" 'function))
(cffi:defcfun ("gsl_sf_psi_int" #.(swig-lispify "gsl_sf_psi_int" 'function)) :double
(n :int))
(cl:export '#.(swig-lispify "gsl_sf_psi_int" 'function))
(cffi:defcfun ("gsl_sf_psi_e" #.(swig-lispify "gsl_sf_psi_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_e" 'function))
(cffi:defcfun ("gsl_sf_psi" #.(swig-lispify "gsl_sf_psi" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_psi" 'function))
(cffi:defcfun ("gsl_sf_psi_1piy_e" #.(swig-lispify "gsl_sf_psi_1piy_e" 'function)) :int
(y :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_1piy_e" 'function))
(cffi:defcfun ("gsl_sf_psi_1piy" #.(swig-lispify "gsl_sf_psi_1piy" 'function)) :double
(y :double))
(cl:export '#.(swig-lispify "gsl_sf_psi_1piy" 'function))
(cffi:defcfun ("gsl_sf_complex_psi_e" #.(swig-lispify "gsl_sf_complex_psi_e" 'function)) :int
(x :double)
(y :double)
(result_re :pointer)
(result_im :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_psi_e" 'function))
(cffi:defcfun ("gsl_sf_psi_1_int_e" #.(swig-lispify "gsl_sf_psi_1_int_e" 'function)) :int
(n :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_1_int_e" 'function))
(cffi:defcfun ("gsl_sf_psi_1_int" #.(swig-lispify "gsl_sf_psi_1_int" 'function)) :double
(n :int))
(cl:export '#.(swig-lispify "gsl_sf_psi_1_int" 'function))
(cffi:defcfun ("gsl_sf_psi_1_e" #.(swig-lispify "gsl_sf_psi_1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_1_e" 'function))
(cffi:defcfun ("gsl_sf_psi_1" #.(swig-lispify "gsl_sf_psi_1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_psi_1" 'function))
(cffi:defcfun ("gsl_sf_psi_n_e" #.(swig-lispify "gsl_sf_psi_n_e" 'function)) :int
(n :int)
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_psi_n_e" 'function))
(cffi:defcfun ("gsl_sf_psi_n" #.(swig-lispify "gsl_sf_psi_n" 'function)) :double
(n :int)
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_psi_n" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_sf_result_struct" 'classname)
(#.(swig-lispify "val" 'slotname) :double)
(#.(swig-lispify "err" 'slotname) :double))
(cl:export '#.(swig-lispify "gsl_sf_result_struct" 'classname))
(cl:export '#.(swig-lispify "val" 'slotname))
(cl:export '#.(swig-lispify "err" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_sf_result_e10_struct" 'classname)
(#.(swig-lispify "val" 'slotname) :double)
(#.(swig-lispify "err" 'slotname) :double)
(#.(swig-lispify "e10" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_sf_result_e10_struct" 'classname))
(cl:export '#.(swig-lispify "val" 'slotname))
(cl:export '#.(swig-lispify "err" 'slotname))
(cl:export '#.(swig-lispify "e10" 'slotname))
(cffi:defcfun ("gsl_sf_result_smash_e" #.(swig-lispify "gsl_sf_result_smash_e" 'function)) :int
(re :pointer)
(r :pointer))
(cl:export '#.(swig-lispify "gsl_sf_result_smash_e" 'function))
(cffi:defcfun ("gsl_sf_synchrotron_1_e" #.(swig-lispify "gsl_sf_synchrotron_1_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_synchrotron_1_e" 'function))
(cffi:defcfun ("gsl_sf_synchrotron_1" #.(swig-lispify "gsl_sf_synchrotron_1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_synchrotron_1" 'function))
(cffi:defcfun ("gsl_sf_synchrotron_2_e" #.(swig-lispify "gsl_sf_synchrotron_2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_synchrotron_2_e" 'function))
(cffi:defcfun ("gsl_sf_synchrotron_2" #.(swig-lispify "gsl_sf_synchrotron_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_synchrotron_2" 'function))
(cffi:defcfun ("gsl_sf_transport_2_e" #.(swig-lispify "gsl_sf_transport_2_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_transport_2_e" 'function))
(cffi:defcfun ("gsl_sf_transport_2" #.(swig-lispify "gsl_sf_transport_2" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_transport_2" 'function))
(cffi:defcfun ("gsl_sf_transport_3_e" #.(swig-lispify "gsl_sf_transport_3_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_transport_3_e" 'function))
(cffi:defcfun ("gsl_sf_transport_3" #.(swig-lispify "gsl_sf_transport_3" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_transport_3" 'function))
(cffi:defcfun ("gsl_sf_transport_4_e" #.(swig-lispify "gsl_sf_transport_4_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_transport_4_e" 'function))
(cffi:defcfun ("gsl_sf_transport_4" #.(swig-lispify "gsl_sf_transport_4" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_transport_4" 'function))
(cffi:defcfun ("gsl_sf_transport_5_e" #.(swig-lispify "gsl_sf_transport_5_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_transport_5_e" 'function))
(cffi:defcfun ("gsl_sf_transport_5" #.(swig-lispify "gsl_sf_transport_5" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_transport_5" 'function))
(cffi:defcfun ("gsl_sf_sin_e" #.(swig-lispify "gsl_sf_sin_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_sin_e" 'function))
(cffi:defcfun ("gsl_sf_sin" #.(swig-lispify "gsl_sf_sin" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_sin" 'function))
(cffi:defcfun ("gsl_sf_cos_e" #.(swig-lispify "gsl_sf_cos_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_cos_e" 'function))
(cffi:defcfun ("gsl_sf_cos" #.(swig-lispify "gsl_sf_cos" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_cos" 'function))
(cffi:defcfun ("gsl_sf_hypot_e" #.(swig-lispify "gsl_sf_hypot_e" 'function)) :int
(x :double)
(y :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hypot_e" 'function))
(cffi:defcfun ("gsl_sf_hypot" #.(swig-lispify "gsl_sf_hypot" 'function)) :double
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_sf_hypot" 'function))
(cffi:defcfun ("gsl_sf_complex_sin_e" #.(swig-lispify "gsl_sf_complex_sin_e" 'function)) :int
(zr :double)
(zi :double)
(szr :pointer)
(szi :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_sin_e" 'function))
(cffi:defcfun ("gsl_sf_complex_cos_e" #.(swig-lispify "gsl_sf_complex_cos_e" 'function)) :int
(zr :double)
(zi :double)
(czr :pointer)
(czi :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_cos_e" 'function))
(cffi:defcfun ("gsl_sf_complex_logsin_e" #.(swig-lispify "gsl_sf_complex_logsin_e" 'function)) :int
(zr :double)
(zi :double)
(lszr :pointer)
(lszi :pointer))
(cl:export '#.(swig-lispify "gsl_sf_complex_logsin_e" 'function))
(cffi:defcfun ("gsl_sf_sinc_e" #.(swig-lispify "gsl_sf_sinc_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_sinc_e" 'function))
(cffi:defcfun ("gsl_sf_sinc" #.(swig-lispify "gsl_sf_sinc" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_sinc" 'function))
(cffi:defcfun ("gsl_sf_lnsinh_e" #.(swig-lispify "gsl_sf_lnsinh_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lnsinh_e" 'function))
(cffi:defcfun ("gsl_sf_lnsinh" #.(swig-lispify "gsl_sf_lnsinh" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lnsinh" 'function))
(cffi:defcfun ("gsl_sf_lncosh_e" #.(swig-lispify "gsl_sf_lncosh_e" 'function)) :int
(x :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_lncosh_e" 'function))
(cffi:defcfun ("gsl_sf_lncosh" #.(swig-lispify "gsl_sf_lncosh" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_sf_lncosh" 'function))
(cffi:defcfun ("gsl_sf_polar_to_rect" #.(swig-lispify "gsl_sf_polar_to_rect" 'function)) :int
(r :double)
(theta :double)
(x :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_sf_polar_to_rect" 'function))
(cffi:defcfun ("gsl_sf_rect_to_polar" #.(swig-lispify "gsl_sf_rect_to_polar" 'function)) :int
(x :double)
(y :double)
(r :pointer)
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_sf_rect_to_polar" 'function))
(cffi:defcfun ("gsl_sf_sin_err_e" #.(swig-lispify "gsl_sf_sin_err_e" 'function)) :int
(x :double)
(dx :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_sin_err_e" 'function))
(cffi:defcfun ("gsl_sf_cos_err_e" #.(swig-lispify "gsl_sf_cos_err_e" 'function)) :int
(x :double)
(dx :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_cos_err_e" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_symm_e" #.(swig-lispify "gsl_sf_angle_restrict_symm_e" 'function)) :int
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_symm_e" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_symm" #.(swig-lispify "gsl_sf_angle_restrict_symm" 'function)) :double
(theta :double))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_symm" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_pos_e" #.(swig-lispify "gsl_sf_angle_restrict_pos_e" 'function)) :int
(theta :pointer))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_pos_e" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_pos" #.(swig-lispify "gsl_sf_angle_restrict_pos" 'function)) :double
(theta :double))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_pos" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_symm_err_e" #.(swig-lispify "gsl_sf_angle_restrict_symm_err_e" 'function)) :int
(theta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_symm_err_e" 'function))
(cffi:defcfun ("gsl_sf_angle_restrict_pos_err_e" #.(swig-lispify "gsl_sf_angle_restrict_pos_err_e" 'function)) :int
(theta :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_angle_restrict_pos_err_e" 'function))
(cffi:defcfun ("gsl_sf_zeta_int_e" #.(swig-lispify "gsl_sf_zeta_int_e" 'function)) :int
(n :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_zeta_int_e" 'function))
(cffi:defcfun ("gsl_sf_zeta_int" #.(swig-lispify "gsl_sf_zeta_int" 'function)) :double
(n :int))
(cl:export '#.(swig-lispify "gsl_sf_zeta_int" 'function))
(cffi:defcfun ("gsl_sf_zeta_e" #.(swig-lispify "gsl_sf_zeta_e" 'function)) :int
(s :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_zeta_e" 'function))
(cffi:defcfun ("gsl_sf_zeta" #.(swig-lispify "gsl_sf_zeta" 'function)) :double
(s :double))
(cl:export '#.(swig-lispify "gsl_sf_zeta" 'function))
(cffi:defcfun ("gsl_sf_zetam1_e" #.(swig-lispify "gsl_sf_zetam1_e" 'function)) :int
(s :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_zetam1_e" 'function))
(cffi:defcfun ("gsl_sf_zetam1" #.(swig-lispify "gsl_sf_zetam1" 'function)) :double
(s :double))
(cl:export '#.(swig-lispify "gsl_sf_zetam1" 'function))
(cffi:defcfun ("gsl_sf_zetam1_int_e" #.(swig-lispify "gsl_sf_zetam1_int_e" 'function)) :int
(s :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_zetam1_int_e" 'function))
(cffi:defcfun ("gsl_sf_zetam1_int" #.(swig-lispify "gsl_sf_zetam1_int" 'function)) :double
(s :int))
(cl:export '#.(swig-lispify "gsl_sf_zetam1_int" 'function))
(cffi:defcfun ("gsl_sf_hzeta_e" #.(swig-lispify "gsl_sf_hzeta_e" 'function)) :int
(s :double)
(q :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_hzeta_e" 'function))
(cffi:defcfun ("gsl_sf_hzeta" #.(swig-lispify "gsl_sf_hzeta" 'function)) :double
(s :double)
(q :double))
(cl:export '#.(swig-lispify "gsl_sf_hzeta" 'function))
(cffi:defcfun ("gsl_sf_eta_int_e" #.(swig-lispify "gsl_sf_eta_int_e" 'function)) :int
(n :int)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_eta_int_e" 'function))
(cffi:defcfun ("gsl_sf_eta_int" #.(swig-lispify "gsl_sf_eta_int" 'function)) :double
(n :int))
(cl:export '#.(swig-lispify "gsl_sf_eta_int" 'function))
(cffi:defcfun ("gsl_sf_eta_e" #.(swig-lispify "gsl_sf_eta_e" 'function)) :int
(s :double)
(result :pointer))
(cl:export '#.(swig-lispify "gsl_sf_eta_e" 'function))
(cffi:defcfun ("gsl_sf_eta" #.(swig-lispify "gsl_sf_eta" 'function)) :double
(s :double))
(cl:export '#.(swig-lispify "gsl_sf_eta" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_siman_params_t" 'classname)
(#.(swig-lispify "n_tries" 'slotname) :int)
(#.(swig-lispify "iters_fixed_T" 'slotname) :int)
(#.(swig-lispify "step_size" 'slotname) :double)
(#.(swig-lispify "k" 'slotname) :double)
(#.(swig-lispify "t_initial" 'slotname) :double)
(#.(swig-lispify "mu_t" 'slotname) :double)
(#.(swig-lispify "t_min" 'slotname) :double))
(cl:export '#.(swig-lispify "gsl_siman_params_t" 'classname))
(cl:export '#.(swig-lispify "n_tries" 'slotname))
(cl:export '#.(swig-lispify "iters_fixed_T" 'slotname))
(cl:export '#.(swig-lispify "step_size" 'slotname))
(cl:export '#.(swig-lispify "k" 'slotname))
(cl:export '#.(swig-lispify "t_initial" 'slotname))
(cl:export '#.(swig-lispify "mu_t" 'slotname))
(cl:export '#.(swig-lispify "t_min" 'slotname))
(cffi:defcfun ("gsl_siman_solve" #.(swig-lispify "gsl_siman_solve" 'function)) :void
(r :pointer)
(x0_p :pointer)
(Ef :pointer)
(take_step :pointer)
(distance :pointer)
(print_position :pointer)
(copyfunc :pointer)
(copy_constructor :pointer)
(destructor :pointer)
(element_size :pointer)
(params #.(swig-lispify "gsl_siman_params_t" 'classname)))
(cl:export '#.(swig-lispify "gsl_siman_solve" 'function))
(cffi:defcfun ("gsl_siman_solve_many" #.(swig-lispify "gsl_siman_solve_many" 'function)) :void
(r :pointer)
(x0_p :pointer)
(Ef :pointer)
(take_step :pointer)
(distance :pointer)
(print_position :pointer)
(element_size :pointer)
(params #.(swig-lispify "gsl_siman_params_t" 'classname)))
(cl:export '#.(swig-lispify "gsl_siman_solve_many" 'function))
(cffi:defcfun ("gsl_sort_char" #.(swig-lispify "gsl_sort_char" 'function)) :void
(data :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char" 'function))
(cffi:defcfun ("gsl_sort2_char" #.(swig-lispify "gsl_sort2_char" 'function)) :void
(data1 :string)
(stride1 :pointer)
(data2 :string)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_char" 'function))
(cffi:defcfun ("gsl_sort_char_index" #.(swig-lispify "gsl_sort_char_index" 'function)) :void
(p :pointer)
(data :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char_index" 'function))
(cffi:defcfun ("gsl_sort_char_smallest" #.(swig-lispify "gsl_sort_char_smallest" 'function)) :int
(dest :string)
(k :pointer)
(src :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char_smallest" 'function))
(cffi:defcfun ("gsl_sort_char_smallest_index" #.(swig-lispify "gsl_sort_char_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_char_largest" #.(swig-lispify "gsl_sort_char_largest" 'function)) :int
(dest :string)
(k :pointer)
(src :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char_largest" 'function))
(cffi:defcfun ("gsl_sort_char_largest_index" #.(swig-lispify "gsl_sort_char_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_char_largest_index" 'function))
(cffi:defcfun ("gsl_sort" #.(swig-lispify "gsl_sort" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort" 'function))
(cffi:defcfun ("gsl_sort2" #.(swig-lispify "gsl_sort2" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2" 'function))
(cffi:defcfun ("gsl_sort_index" #.(swig-lispify "gsl_sort_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_index" 'function))
(cffi:defcfun ("gsl_sort_smallest" #.(swig-lispify "gsl_sort_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_smallest" 'function))
(cffi:defcfun ("gsl_sort_smallest_index" #.(swig-lispify "gsl_sort_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_largest" #.(swig-lispify "gsl_sort_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_largest" 'function))
(cffi:defcfun ("gsl_sort_largest_index" #.(swig-lispify "gsl_sort_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_largest_index" 'function))
(cffi:defcfun ("gsl_sort_float" #.(swig-lispify "gsl_sort_float" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float" 'function))
(cffi:defcfun ("gsl_sort2_float" #.(swig-lispify "gsl_sort2_float" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_float" 'function))
(cffi:defcfun ("gsl_sort_float_index" #.(swig-lispify "gsl_sort_float_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float_index" 'function))
(cffi:defcfun ("gsl_sort_float_smallest" #.(swig-lispify "gsl_sort_float_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float_smallest" 'function))
(cffi:defcfun ("gsl_sort_float_smallest_index" #.(swig-lispify "gsl_sort_float_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_float_largest" #.(swig-lispify "gsl_sort_float_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float_largest" 'function))
(cffi:defcfun ("gsl_sort_float_largest_index" #.(swig-lispify "gsl_sort_float_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_float_largest_index" 'function))
(cffi:defcfun ("gsl_sort_int" #.(swig-lispify "gsl_sort_int" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int" 'function))
(cffi:defcfun ("gsl_sort2_int" #.(swig-lispify "gsl_sort2_int" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_int" 'function))
(cffi:defcfun ("gsl_sort_int_index" #.(swig-lispify "gsl_sort_int_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int_index" 'function))
(cffi:defcfun ("gsl_sort_int_smallest" #.(swig-lispify "gsl_sort_int_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int_smallest" 'function))
(cffi:defcfun ("gsl_sort_int_smallest_index" #.(swig-lispify "gsl_sort_int_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_int_largest" #.(swig-lispify "gsl_sort_int_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int_largest" 'function))
(cffi:defcfun ("gsl_sort_int_largest_index" #.(swig-lispify "gsl_sort_int_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_int_largest_index" 'function))
(cffi:defcfun ("gsl_sort_long" #.(swig-lispify "gsl_sort_long" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long" 'function))
(cffi:defcfun ("gsl_sort2_long" #.(swig-lispify "gsl_sort2_long" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_long" 'function))
(cffi:defcfun ("gsl_sort_long_index" #.(swig-lispify "gsl_sort_long_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_index" 'function))
(cffi:defcfun ("gsl_sort_long_smallest" #.(swig-lispify "gsl_sort_long_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_smallest" 'function))
(cffi:defcfun ("gsl_sort_long_smallest_index" #.(swig-lispify "gsl_sort_long_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_long_largest" #.(swig-lispify "gsl_sort_long_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_largest" 'function))
(cffi:defcfun ("gsl_sort_long_largest_index" #.(swig-lispify "gsl_sort_long_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_largest_index" 'function))
(cffi:defcfun ("gsl_sort_long_double" #.(swig-lispify "gsl_sort_long_double" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double" 'function))
(cffi:defcfun ("gsl_sort2_long_double" #.(swig-lispify "gsl_sort2_long_double" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_long_double" 'function))
(cffi:defcfun ("gsl_sort_long_double_index" #.(swig-lispify "gsl_sort_long_double_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double_index" 'function))
(cffi:defcfun ("gsl_sort_long_double_smallest" #.(swig-lispify "gsl_sort_long_double_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double_smallest" 'function))
(cffi:defcfun ("gsl_sort_long_double_smallest_index" #.(swig-lispify "gsl_sort_long_double_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_long_double_largest" #.(swig-lispify "gsl_sort_long_double_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double_largest" 'function))
(cffi:defcfun ("gsl_sort_long_double_largest_index" #.(swig-lispify "gsl_sort_long_double_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_long_double_largest_index" 'function))
(cffi:defcfun ("gsl_sort_short" #.(swig-lispify "gsl_sort_short" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short" 'function))
(cffi:defcfun ("gsl_sort2_short" #.(swig-lispify "gsl_sort2_short" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_short" 'function))
(cffi:defcfun ("gsl_sort_short_index" #.(swig-lispify "gsl_sort_short_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short_index" 'function))
(cffi:defcfun ("gsl_sort_short_smallest" #.(swig-lispify "gsl_sort_short_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short_smallest" 'function))
(cffi:defcfun ("gsl_sort_short_smallest_index" #.(swig-lispify "gsl_sort_short_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_short_largest" #.(swig-lispify "gsl_sort_short_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short_largest" 'function))
(cffi:defcfun ("gsl_sort_short_largest_index" #.(swig-lispify "gsl_sort_short_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_short_largest_index" 'function))
(cffi:defcfun ("gsl_sort_uchar" #.(swig-lispify "gsl_sort_uchar" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar" 'function))
(cffi:defcfun ("gsl_sort2_uchar" #.(swig-lispify "gsl_sort2_uchar" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_uchar" 'function))
(cffi:defcfun ("gsl_sort_uchar_index" #.(swig-lispify "gsl_sort_uchar_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar_index" 'function))
(cffi:defcfun ("gsl_sort_uchar_smallest" #.(swig-lispify "gsl_sort_uchar_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar_smallest" 'function))
(cffi:defcfun ("gsl_sort_uchar_smallest_index" #.(swig-lispify "gsl_sort_uchar_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_uchar_largest" #.(swig-lispify "gsl_sort_uchar_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar_largest" 'function))
(cffi:defcfun ("gsl_sort_uchar_largest_index" #.(swig-lispify "gsl_sort_uchar_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uchar_largest_index" 'function))
(cffi:defcfun ("gsl_sort_uint" #.(swig-lispify "gsl_sort_uint" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint" 'function))
(cffi:defcfun ("gsl_sort2_uint" #.(swig-lispify "gsl_sort2_uint" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_uint" 'function))
(cffi:defcfun ("gsl_sort_uint_index" #.(swig-lispify "gsl_sort_uint_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint_index" 'function))
(cffi:defcfun ("gsl_sort_uint_smallest" #.(swig-lispify "gsl_sort_uint_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint_smallest" 'function))
(cffi:defcfun ("gsl_sort_uint_smallest_index" #.(swig-lispify "gsl_sort_uint_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_uint_largest" #.(swig-lispify "gsl_sort_uint_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint_largest" 'function))
(cffi:defcfun ("gsl_sort_uint_largest_index" #.(swig-lispify "gsl_sort_uint_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_uint_largest_index" 'function))
(cffi:defcfun ("gsl_sort_ulong" #.(swig-lispify "gsl_sort_ulong" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong" 'function))
(cffi:defcfun ("gsl_sort2_ulong" #.(swig-lispify "gsl_sort2_ulong" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_ulong" 'function))
(cffi:defcfun ("gsl_sort_ulong_index" #.(swig-lispify "gsl_sort_ulong_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong_index" 'function))
(cffi:defcfun ("gsl_sort_ulong_smallest" #.(swig-lispify "gsl_sort_ulong_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong_smallest" 'function))
(cffi:defcfun ("gsl_sort_ulong_smallest_index" #.(swig-lispify "gsl_sort_ulong_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_ulong_largest" #.(swig-lispify "gsl_sort_ulong_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong_largest" 'function))
(cffi:defcfun ("gsl_sort_ulong_largest_index" #.(swig-lispify "gsl_sort_ulong_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ulong_largest_index" 'function))
(cffi:defcfun ("gsl_sort_ushort" #.(swig-lispify "gsl_sort_ushort" 'function)) :void
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort" 'function))
(cffi:defcfun ("gsl_sort2_ushort" #.(swig-lispify "gsl_sort2_ushort" 'function)) :void
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort2_ushort" 'function))
(cffi:defcfun ("gsl_sort_ushort_index" #.(swig-lispify "gsl_sort_ushort_index" 'function)) :void
(p :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort_index" 'function))
(cffi:defcfun ("gsl_sort_ushort_smallest" #.(swig-lispify "gsl_sort_ushort_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort_smallest" 'function))
(cffi:defcfun ("gsl_sort_ushort_smallest_index" #.(swig-lispify "gsl_sort_ushort_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_ushort_largest" #.(swig-lispify "gsl_sort_ushort_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort_largest" 'function))
(cffi:defcfun ("gsl_sort_ushort_largest_index" #.(swig-lispify "gsl_sort_ushort_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(src :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sort_ushort_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_char" #.(swig-lispify "gsl_sort_vector_char" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char" 'function))
(cffi:defcfun ("gsl_sort_vector2_char" #.(swig-lispify "gsl_sort_vector2_char" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_char" 'function))
(cffi:defcfun ("gsl_sort_vector_char_index" #.(swig-lispify "gsl_sort_vector_char_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char_index" 'function))
(cffi:defcfun ("gsl_sort_vector_char_smallest" #.(swig-lispify "gsl_sort_vector_char_smallest" 'function)) :int
(dest :string)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_char_largest" #.(swig-lispify "gsl_sort_vector_char_largest" 'function)) :int
(dest :string)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_char_smallest_index" #.(swig-lispify "gsl_sort_vector_char_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_char_largest_index" #.(swig-lispify "gsl_sort_vector_char_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_char_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector" #.(swig-lispify "gsl_sort_vector" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector" 'function))
(cffi:defcfun ("gsl_sort_vector2" #.(swig-lispify "gsl_sort_vector2" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2" 'function))
(cffi:defcfun ("gsl_sort_vector_index" #.(swig-lispify "gsl_sort_vector_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_index" 'function))
(cffi:defcfun ("gsl_sort_vector_smallest" #.(swig-lispify "gsl_sort_vector_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_largest" #.(swig-lispify "gsl_sort_vector_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_smallest_index" #.(swig-lispify "gsl_sort_vector_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_largest_index" #.(swig-lispify "gsl_sort_vector_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_float" #.(swig-lispify "gsl_sort_vector_float" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float" 'function))
(cffi:defcfun ("gsl_sort_vector2_float" #.(swig-lispify "gsl_sort_vector2_float" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_float" 'function))
(cffi:defcfun ("gsl_sort_vector_float_index" #.(swig-lispify "gsl_sort_vector_float_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float_index" 'function))
(cffi:defcfun ("gsl_sort_vector_float_smallest" #.(swig-lispify "gsl_sort_vector_float_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_float_largest" #.(swig-lispify "gsl_sort_vector_float_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_float_smallest_index" #.(swig-lispify "gsl_sort_vector_float_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_float_largest_index" #.(swig-lispify "gsl_sort_vector_float_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_float_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_int" #.(swig-lispify "gsl_sort_vector_int" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int" 'function))
(cffi:defcfun ("gsl_sort_vector2_int" #.(swig-lispify "gsl_sort_vector2_int" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_int" 'function))
(cffi:defcfun ("gsl_sort_vector_int_index" #.(swig-lispify "gsl_sort_vector_int_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int_index" 'function))
(cffi:defcfun ("gsl_sort_vector_int_smallest" #.(swig-lispify "gsl_sort_vector_int_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_int_largest" #.(swig-lispify "gsl_sort_vector_int_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_int_smallest_index" #.(swig-lispify "gsl_sort_vector_int_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_int_largest_index" #.(swig-lispify "gsl_sort_vector_int_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_int_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long" #.(swig-lispify "gsl_sort_vector_long" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long" 'function))
(cffi:defcfun ("gsl_sort_vector2_long" #.(swig-lispify "gsl_sort_vector2_long" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_long" 'function))
(cffi:defcfun ("gsl_sort_vector_long_index" #.(swig-lispify "gsl_sort_vector_long_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long_smallest" #.(swig-lispify "gsl_sort_vector_long_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_long_largest" #.(swig-lispify "gsl_sort_vector_long_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_long_smallest_index" #.(swig-lispify "gsl_sort_vector_long_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long_largest_index" #.(swig-lispify "gsl_sort_vector_long_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double" #.(swig-lispify "gsl_sort_vector_long_double" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double" 'function))
(cffi:defcfun ("gsl_sort_vector2_long_double" #.(swig-lispify "gsl_sort_vector2_long_double" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_long_double" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double_index" #.(swig-lispify "gsl_sort_vector_long_double_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double_smallest" #.(swig-lispify "gsl_sort_vector_long_double_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double_largest" #.(swig-lispify "gsl_sort_vector_long_double_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double_smallest_index" #.(swig-lispify "gsl_sort_vector_long_double_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_long_double_largest_index" #.(swig-lispify "gsl_sort_vector_long_double_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_long_double_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_short" #.(swig-lispify "gsl_sort_vector_short" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short" 'function))
(cffi:defcfun ("gsl_sort_vector2_short" #.(swig-lispify "gsl_sort_vector2_short" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_short" 'function))
(cffi:defcfun ("gsl_sort_vector_short_index" #.(swig-lispify "gsl_sort_vector_short_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short_index" 'function))
(cffi:defcfun ("gsl_sort_vector_short_smallest" #.(swig-lispify "gsl_sort_vector_short_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_short_largest" #.(swig-lispify "gsl_sort_vector_short_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_short_smallest_index" #.(swig-lispify "gsl_sort_vector_short_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_short_largest_index" #.(swig-lispify "gsl_sort_vector_short_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_short_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar" #.(swig-lispify "gsl_sort_vector_uchar" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar" 'function))
(cffi:defcfun ("gsl_sort_vector2_uchar" #.(swig-lispify "gsl_sort_vector2_uchar" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_uchar" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar_index" #.(swig-lispify "gsl_sort_vector_uchar_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar_smallest" #.(swig-lispify "gsl_sort_vector_uchar_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar_largest" #.(swig-lispify "gsl_sort_vector_uchar_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar_smallest_index" #.(swig-lispify "gsl_sort_vector_uchar_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uchar_largest_index" #.(swig-lispify "gsl_sort_vector_uchar_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uchar_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uint" #.(swig-lispify "gsl_sort_vector_uint" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint" 'function))
(cffi:defcfun ("gsl_sort_vector2_uint" #.(swig-lispify "gsl_sort_vector2_uint" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_uint" 'function))
(cffi:defcfun ("gsl_sort_vector_uint_index" #.(swig-lispify "gsl_sort_vector_uint_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uint_smallest" #.(swig-lispify "gsl_sort_vector_uint_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_uint_largest" #.(swig-lispify "gsl_sort_vector_uint_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_uint_smallest_index" #.(swig-lispify "gsl_sort_vector_uint_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_uint_largest_index" #.(swig-lispify "gsl_sort_vector_uint_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_uint_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong" #.(swig-lispify "gsl_sort_vector_ulong" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong" 'function))
(cffi:defcfun ("gsl_sort_vector2_ulong" #.(swig-lispify "gsl_sort_vector2_ulong" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_ulong" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong_index" #.(swig-lispify "gsl_sort_vector_ulong_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong_smallest" #.(swig-lispify "gsl_sort_vector_ulong_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong_largest" #.(swig-lispify "gsl_sort_vector_ulong_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong_smallest_index" #.(swig-lispify "gsl_sort_vector_ulong_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ulong_largest_index" #.(swig-lispify "gsl_sort_vector_ulong_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ulong_largest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort" #.(swig-lispify "gsl_sort_vector_ushort" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort" 'function))
(cffi:defcfun ("gsl_sort_vector2_ushort" #.(swig-lispify "gsl_sort_vector2_ushort" 'function)) :void
(v1 :pointer)
(v2 :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector2_ushort" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort_index" #.(swig-lispify "gsl_sort_vector_ushort_index" 'function)) :int
(p :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort_smallest" #.(swig-lispify "gsl_sort_vector_ushort_smallest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort_smallest" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort_largest" #.(swig-lispify "gsl_sort_vector_ushort_largest" 'function)) :int
(dest :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort_largest" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort_smallest_index" #.(swig-lispify "gsl_sort_vector_ushort_smallest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort_smallest_index" 'function))
(cffi:defcfun ("gsl_sort_vector_ushort_largest_index" #.(swig-lispify "gsl_sort_vector_ushort_largest_index" 'function)) :int
(p :pointer)
(k :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_sort_vector_ushort_largest_index" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_spline" 'classname)
(#.(swig-lispify "interp" 'slotname) :pointer)
(#.(swig-lispify "x" 'slotname) :pointer)
(#.(swig-lispify "y" 'slotname) :pointer)
(#.(swig-lispify "size" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_spline" 'classname))
(cl:export '#.(swig-lispify "interp" 'slotname))
(cl:export '#.(swig-lispify "x" 'slotname))
(cl:export '#.(swig-lispify "y" 'slotname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cffi:defcfun ("gsl_spline_alloc" #.(swig-lispify "gsl_spline_alloc" 'function)) :pointer
(t_arg0 :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_spline_alloc" 'function))
(cffi:defcfun ("gsl_spline_init" #.(swig-lispify "gsl_spline_init" 'function)) :int
(spline :pointer)
(xa :pointer)
(ya :pointer)
(size :pointer))
(cl:export '#.(swig-lispify "gsl_spline_init" 'function))
(cffi:defcfun ("gsl_spline_name" #.(swig-lispify "gsl_spline_name" 'function)) :string
(spline :pointer))
(cl:export '#.(swig-lispify "gsl_spline_name" 'function))
(cffi:defcfun ("gsl_spline_min_size" #.(swig-lispify "gsl_spline_min_size" 'function)) :unsigned-int
(spline :pointer))
(cl:export '#.(swig-lispify "gsl_spline_min_size" 'function))
(cffi:defcfun ("gsl_spline_eval_e" #.(swig-lispify "gsl_spline_eval_e" 'function)) :int
(spline :pointer)
(x :double)
(a :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_e" 'function))
(cffi:defcfun ("gsl_spline_eval" #.(swig-lispify "gsl_spline_eval" 'function)) :double
(spline :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval" 'function))
(cffi:defcfun ("gsl_spline_eval_deriv_e" #.(swig-lispify "gsl_spline_eval_deriv_e" 'function)) :int
(spline :pointer)
(x :double)
(a :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_deriv_e" 'function))
(cffi:defcfun ("gsl_spline_eval_deriv" #.(swig-lispify "gsl_spline_eval_deriv" 'function)) :double
(spline :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_deriv" 'function))
(cffi:defcfun ("gsl_spline_eval_deriv2_e" #.(swig-lispify "gsl_spline_eval_deriv2_e" 'function)) :int
(spline :pointer)
(x :double)
(a :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_deriv2_e" 'function))
(cffi:defcfun ("gsl_spline_eval_deriv2" #.(swig-lispify "gsl_spline_eval_deriv2" 'function)) :double
(spline :pointer)
(x :double)
(a :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_deriv2" 'function))
(cffi:defcfun ("gsl_spline_eval_integ_e" #.(swig-lispify "gsl_spline_eval_integ_e" 'function)) :int
(spline :pointer)
(a :double)
(b :double)
(acc :pointer)
(y :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_integ_e" 'function))
(cffi:defcfun ("gsl_spline_eval_integ" #.(swig-lispify "gsl_spline_eval_integ" 'function)) :double
(spline :pointer)
(a :double)
(b :double)
(acc :pointer))
(cl:export '#.(swig-lispify "gsl_spline_eval_integ" 'function))
(cffi:defcfun ("gsl_spline_free" #.(swig-lispify "gsl_spline_free" 'function)) :void
(spline :pointer))
(cl:export '#.(swig-lispify "gsl_spline_free" 'function))
(cffi:defcfun ("gsl_stats_char_mean" #.(swig-lispify "gsl_stats_char_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_mean" 'function))
(cffi:defcfun ("gsl_stats_char_variance" #.(swig-lispify "gsl_stats_char_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_variance" 'function))
(cffi:defcfun ("gsl_stats_char_sd" #.(swig-lispify "gsl_stats_char_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_sd" 'function))
(cffi:defcfun ("gsl_stats_char_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_char_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_char_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_char_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_char_tss" #.(swig-lispify "gsl_stats_char_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_tss" 'function))
(cffi:defcfun ("gsl_stats_char_tss_m" #.(swig-lispify "gsl_stats_char_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_tss_m" 'function))
(cffi:defcfun ("gsl_stats_char_absdev" #.(swig-lispify "gsl_stats_char_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_absdev" 'function))
(cffi:defcfun ("gsl_stats_char_skew" #.(swig-lispify "gsl_stats_char_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_skew" 'function))
(cffi:defcfun ("gsl_stats_char_kurtosis" #.(swig-lispify "gsl_stats_char_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_char_lag1_autocorrelation" #.(swig-lispify "gsl_stats_char_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_char_covariance" #.(swig-lispify "gsl_stats_char_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_covariance" 'function))
(cffi:defcfun ("gsl_stats_char_correlation" #.(swig-lispify "gsl_stats_char_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_correlation" 'function))
(cffi:defcfun ("gsl_stats_char_spearman" #.(swig-lispify "gsl_stats_char_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_spearman" 'function))
(cffi:defcfun ("gsl_stats_char_variance_m" #.(swig-lispify "gsl_stats_char_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_variance_m" 'function))
(cffi:defcfun ("gsl_stats_char_sd_m" #.(swig-lispify "gsl_stats_char_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_sd_m" 'function))
(cffi:defcfun ("gsl_stats_char_absdev_m" #.(swig-lispify "gsl_stats_char_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_char_skew_m_sd" #.(swig-lispify "gsl_stats_char_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_char_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_char_kurtosis_m_sd" #.(swig-lispify "gsl_stats_char_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_char_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_char_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_char_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_char_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_char_covariance_m" #.(swig-lispify "gsl_stats_char_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_char_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_char_pvariance" #.(swig-lispify "gsl_stats_char_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_pvariance" 'function))
(cffi:defcfun ("gsl_stats_char_ttest" #.(swig-lispify "gsl_stats_char_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_ttest" 'function))
(cffi:defcfun ("gsl_stats_char_max" #.(swig-lispify "gsl_stats_char_max" 'function)) :char
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_max" 'function))
(cffi:defcfun ("gsl_stats_char_min" #.(swig-lispify "gsl_stats_char_min" 'function)) :char
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_min" 'function))
(cffi:defcfun ("gsl_stats_char_minmax" #.(swig-lispify "gsl_stats_char_minmax" 'function)) :void
(min :string)
(max :string)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_minmax" 'function))
(cffi:defcfun ("gsl_stats_char_max_index" #.(swig-lispify "gsl_stats_char_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_max_index" 'function))
(cffi:defcfun ("gsl_stats_char_min_index" #.(swig-lispify "gsl_stats_char_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_min_index" 'function))
(cffi:defcfun ("gsl_stats_char_minmax_index" #.(swig-lispify "gsl_stats_char_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_char_median_from_sorted_data" #.(swig-lispify "gsl_stats_char_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_char_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_char_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_char_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_char_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_mean" #.(swig-lispify "gsl_stats_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_mean" 'function))
(cffi:defcfun ("gsl_stats_variance" #.(swig-lispify "gsl_stats_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_variance" 'function))
(cffi:defcfun ("gsl_stats_sd" #.(swig-lispify "gsl_stats_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_sd" 'function))
(cffi:defcfun ("gsl_stats_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_tss" #.(swig-lispify "gsl_stats_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_tss" 'function))
(cffi:defcfun ("gsl_stats_tss_m" #.(swig-lispify "gsl_stats_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_tss_m" 'function))
(cffi:defcfun ("gsl_stats_absdev" #.(swig-lispify "gsl_stats_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_absdev" 'function))
(cffi:defcfun ("gsl_stats_skew" #.(swig-lispify "gsl_stats_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_skew" 'function))
(cffi:defcfun ("gsl_stats_kurtosis" #.(swig-lispify "gsl_stats_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_lag1_autocorrelation" #.(swig-lispify "gsl_stats_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_covariance" #.(swig-lispify "gsl_stats_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_covariance" 'function))
(cffi:defcfun ("gsl_stats_correlation" #.(swig-lispify "gsl_stats_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_correlation" 'function))
(cffi:defcfun ("gsl_stats_spearman" #.(swig-lispify "gsl_stats_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_spearman" 'function))
(cffi:defcfun ("gsl_stats_variance_m" #.(swig-lispify "gsl_stats_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_variance_m" 'function))
(cffi:defcfun ("gsl_stats_sd_m" #.(swig-lispify "gsl_stats_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_sd_m" 'function))
(cffi:defcfun ("gsl_stats_absdev_m" #.(swig-lispify "gsl_stats_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_skew_m_sd" #.(swig-lispify "gsl_stats_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_kurtosis_m_sd" #.(swig-lispify "gsl_stats_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_covariance_m" #.(swig-lispify "gsl_stats_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_wmean" #.(swig-lispify "gsl_stats_wmean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wmean" 'function))
(cffi:defcfun ("gsl_stats_wvariance" #.(swig-lispify "gsl_stats_wvariance" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wvariance" 'function))
(cffi:defcfun ("gsl_stats_wsd" #.(swig-lispify "gsl_stats_wsd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wsd" 'function))
(cffi:defcfun ("gsl_stats_wvariance_with_fixed_mean" #.(swig-lispify "gsl_stats_wvariance_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_wvariance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_wsd_with_fixed_mean" #.(swig-lispify "gsl_stats_wsd_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_wsd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_wtss" #.(swig-lispify "gsl_stats_wtss" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wtss" 'function))
(cffi:defcfun ("gsl_stats_wtss_m" #.(swig-lispify "gsl_stats_wtss_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_wtss_m" 'function))
(cffi:defcfun ("gsl_stats_wabsdev" #.(swig-lispify "gsl_stats_wabsdev" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wabsdev" 'function))
(cffi:defcfun ("gsl_stats_wskew" #.(swig-lispify "gsl_stats_wskew" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wskew" 'function))
(cffi:defcfun ("gsl_stats_wkurtosis" #.(swig-lispify "gsl_stats_wkurtosis" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_wkurtosis" 'function))
(cffi:defcfun ("gsl_stats_wvariance_m" #.(swig-lispify "gsl_stats_wvariance_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_wvariance_m" 'function))
(cffi:defcfun ("gsl_stats_wsd_m" #.(swig-lispify "gsl_stats_wsd_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_wsd_m" 'function))
(cffi:defcfun ("gsl_stats_wabsdev_m" #.(swig-lispify "gsl_stats_wabsdev_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_wabsdev_m" 'function))
(cffi:defcfun ("gsl_stats_wskew_m_sd" #.(swig-lispify "gsl_stats_wskew_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_wskew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_wkurtosis_m_sd" #.(swig-lispify "gsl_stats_wkurtosis_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_wkurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_pvariance" #.(swig-lispify "gsl_stats_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_pvariance" 'function))
(cffi:defcfun ("gsl_stats_ttest" #.(swig-lispify "gsl_stats_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ttest" 'function))
(cffi:defcfun ("gsl_stats_max" #.(swig-lispify "gsl_stats_max" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_max" 'function))
(cffi:defcfun ("gsl_stats_min" #.(swig-lispify "gsl_stats_min" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_min" 'function))
(cffi:defcfun ("gsl_stats_minmax" #.(swig-lispify "gsl_stats_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_minmax" 'function))
(cffi:defcfun ("gsl_stats_max_index" #.(swig-lispify "gsl_stats_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_max_index" 'function))
(cffi:defcfun ("gsl_stats_min_index" #.(swig-lispify "gsl_stats_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_min_index" 'function))
(cffi:defcfun ("gsl_stats_minmax_index" #.(swig-lispify "gsl_stats_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_median_from_sorted_data" #.(swig-lispify "gsl_stats_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_float_mean" #.(swig-lispify "gsl_stats_float_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_mean" 'function))
(cffi:defcfun ("gsl_stats_float_variance" #.(swig-lispify "gsl_stats_float_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_variance" 'function))
(cffi:defcfun ("gsl_stats_float_sd" #.(swig-lispify "gsl_stats_float_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_sd" 'function))
(cffi:defcfun ("gsl_stats_float_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_float_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_float_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_float_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_float_tss" #.(swig-lispify "gsl_stats_float_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_tss" 'function))
(cffi:defcfun ("gsl_stats_float_tss_m" #.(swig-lispify "gsl_stats_float_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_tss_m" 'function))
(cffi:defcfun ("gsl_stats_float_absdev" #.(swig-lispify "gsl_stats_float_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_absdev" 'function))
(cffi:defcfun ("gsl_stats_float_skew" #.(swig-lispify "gsl_stats_float_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_skew" 'function))
(cffi:defcfun ("gsl_stats_float_kurtosis" #.(swig-lispify "gsl_stats_float_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_float_lag1_autocorrelation" #.(swig-lispify "gsl_stats_float_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_float_covariance" #.(swig-lispify "gsl_stats_float_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_covariance" 'function))
(cffi:defcfun ("gsl_stats_float_correlation" #.(swig-lispify "gsl_stats_float_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_correlation" 'function))
(cffi:defcfun ("gsl_stats_float_spearman" #.(swig-lispify "gsl_stats_float_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_spearman" 'function))
(cffi:defcfun ("gsl_stats_float_variance_m" #.(swig-lispify "gsl_stats_float_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_variance_m" 'function))
(cffi:defcfun ("gsl_stats_float_sd_m" #.(swig-lispify "gsl_stats_float_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_sd_m" 'function))
(cffi:defcfun ("gsl_stats_float_absdev_m" #.(swig-lispify "gsl_stats_float_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_float_skew_m_sd" #.(swig-lispify "gsl_stats_float_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_float_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_float_kurtosis_m_sd" #.(swig-lispify "gsl_stats_float_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_float_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_float_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_float_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_float_covariance_m" #.(swig-lispify "gsl_stats_float_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_float_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_float_wmean" #.(swig-lispify "gsl_stats_float_wmean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wmean" 'function))
(cffi:defcfun ("gsl_stats_float_wvariance" #.(swig-lispify "gsl_stats_float_wvariance" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wvariance" 'function))
(cffi:defcfun ("gsl_stats_float_wsd" #.(swig-lispify "gsl_stats_float_wsd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wsd" 'function))
(cffi:defcfun ("gsl_stats_float_wvariance_with_fixed_mean" #.(swig-lispify "gsl_stats_float_wvariance_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wvariance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_float_wsd_with_fixed_mean" #.(swig-lispify "gsl_stats_float_wsd_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wsd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_float_wtss" #.(swig-lispify "gsl_stats_float_wtss" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wtss" 'function))
(cffi:defcfun ("gsl_stats_float_wtss_m" #.(swig-lispify "gsl_stats_float_wtss_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wtss_m" 'function))
(cffi:defcfun ("gsl_stats_float_wabsdev" #.(swig-lispify "gsl_stats_float_wabsdev" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wabsdev" 'function))
(cffi:defcfun ("gsl_stats_float_wskew" #.(swig-lispify "gsl_stats_float_wskew" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wskew" 'function))
(cffi:defcfun ("gsl_stats_float_wkurtosis" #.(swig-lispify "gsl_stats_float_wkurtosis" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_wkurtosis" 'function))
(cffi:defcfun ("gsl_stats_float_wvariance_m" #.(swig-lispify "gsl_stats_float_wvariance_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wvariance_m" 'function))
(cffi:defcfun ("gsl_stats_float_wsd_m" #.(swig-lispify "gsl_stats_float_wsd_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wsd_m" 'function))
(cffi:defcfun ("gsl_stats_float_wabsdev_m" #.(swig-lispify "gsl_stats_float_wabsdev_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wabsdev_m" 'function))
(cffi:defcfun ("gsl_stats_float_wskew_m_sd" #.(swig-lispify "gsl_stats_float_wskew_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wskew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_float_wkurtosis_m_sd" #.(swig-lispify "gsl_stats_float_wkurtosis_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_float_wkurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_float_pvariance" #.(swig-lispify "gsl_stats_float_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_pvariance" 'function))
(cffi:defcfun ("gsl_stats_float_ttest" #.(swig-lispify "gsl_stats_float_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_ttest" 'function))
(cffi:defcfun ("gsl_stats_float_max" #.(swig-lispify "gsl_stats_float_max" 'function)) :float
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_max" 'function))
(cffi:defcfun ("gsl_stats_float_min" #.(swig-lispify "gsl_stats_float_min" 'function)) :float
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_min" 'function))
(cffi:defcfun ("gsl_stats_float_minmax" #.(swig-lispify "gsl_stats_float_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_minmax" 'function))
(cffi:defcfun ("gsl_stats_float_max_index" #.(swig-lispify "gsl_stats_float_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_max_index" 'function))
(cffi:defcfun ("gsl_stats_float_min_index" #.(swig-lispify "gsl_stats_float_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_min_index" 'function))
(cffi:defcfun ("gsl_stats_float_minmax_index" #.(swig-lispify "gsl_stats_float_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_float_median_from_sorted_data" #.(swig-lispify "gsl_stats_float_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_float_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_float_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_float_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_float_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_int_mean" #.(swig-lispify "gsl_stats_int_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_mean" 'function))
(cffi:defcfun ("gsl_stats_int_variance" #.(swig-lispify "gsl_stats_int_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_variance" 'function))
(cffi:defcfun ("gsl_stats_int_sd" #.(swig-lispify "gsl_stats_int_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_sd" 'function))
(cffi:defcfun ("gsl_stats_int_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_int_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_int_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_int_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_int_tss" #.(swig-lispify "gsl_stats_int_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_tss" 'function))
(cffi:defcfun ("gsl_stats_int_tss_m" #.(swig-lispify "gsl_stats_int_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_tss_m" 'function))
(cffi:defcfun ("gsl_stats_int_absdev" #.(swig-lispify "gsl_stats_int_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_absdev" 'function))
(cffi:defcfun ("gsl_stats_int_skew" #.(swig-lispify "gsl_stats_int_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_skew" 'function))
(cffi:defcfun ("gsl_stats_int_kurtosis" #.(swig-lispify "gsl_stats_int_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_int_lag1_autocorrelation" #.(swig-lispify "gsl_stats_int_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_int_covariance" #.(swig-lispify "gsl_stats_int_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_covariance" 'function))
(cffi:defcfun ("gsl_stats_int_correlation" #.(swig-lispify "gsl_stats_int_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_correlation" 'function))
(cffi:defcfun ("gsl_stats_int_spearman" #.(swig-lispify "gsl_stats_int_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_spearman" 'function))
(cffi:defcfun ("gsl_stats_int_variance_m" #.(swig-lispify "gsl_stats_int_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_variance_m" 'function))
(cffi:defcfun ("gsl_stats_int_sd_m" #.(swig-lispify "gsl_stats_int_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_sd_m" 'function))
(cffi:defcfun ("gsl_stats_int_absdev_m" #.(swig-lispify "gsl_stats_int_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_int_skew_m_sd" #.(swig-lispify "gsl_stats_int_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_int_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_int_kurtosis_m_sd" #.(swig-lispify "gsl_stats_int_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_int_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_int_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_int_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_int_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_int_covariance_m" #.(swig-lispify "gsl_stats_int_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_int_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_int_pvariance" #.(swig-lispify "gsl_stats_int_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_pvariance" 'function))
(cffi:defcfun ("gsl_stats_int_ttest" #.(swig-lispify "gsl_stats_int_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_ttest" 'function))
(cffi:defcfun ("gsl_stats_int_max" #.(swig-lispify "gsl_stats_int_max" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_max" 'function))
(cffi:defcfun ("gsl_stats_int_min" #.(swig-lispify "gsl_stats_int_min" 'function)) :int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_min" 'function))
(cffi:defcfun ("gsl_stats_int_minmax" #.(swig-lispify "gsl_stats_int_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_minmax" 'function))
(cffi:defcfun ("gsl_stats_int_max_index" #.(swig-lispify "gsl_stats_int_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_max_index" 'function))
(cffi:defcfun ("gsl_stats_int_min_index" #.(swig-lispify "gsl_stats_int_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_min_index" 'function))
(cffi:defcfun ("gsl_stats_int_minmax_index" #.(swig-lispify "gsl_stats_int_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_int_median_from_sorted_data" #.(swig-lispify "gsl_stats_int_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_int_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_int_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_int_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_int_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_long_mean" #.(swig-lispify "gsl_stats_long_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_mean" 'function))
(cffi:defcfun ("gsl_stats_long_variance" #.(swig-lispify "gsl_stats_long_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_variance" 'function))
(cffi:defcfun ("gsl_stats_long_sd" #.(swig-lispify "gsl_stats_long_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_sd" 'function))
(cffi:defcfun ("gsl_stats_long_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_long_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_long_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_tss" #.(swig-lispify "gsl_stats_long_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_tss" 'function))
(cffi:defcfun ("gsl_stats_long_tss_m" #.(swig-lispify "gsl_stats_long_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_tss_m" 'function))
(cffi:defcfun ("gsl_stats_long_absdev" #.(swig-lispify "gsl_stats_long_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_absdev" 'function))
(cffi:defcfun ("gsl_stats_long_skew" #.(swig-lispify "gsl_stats_long_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_skew" 'function))
(cffi:defcfun ("gsl_stats_long_kurtosis" #.(swig-lispify "gsl_stats_long_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_long_lag1_autocorrelation" #.(swig-lispify "gsl_stats_long_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_long_covariance" #.(swig-lispify "gsl_stats_long_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_covariance" 'function))
(cffi:defcfun ("gsl_stats_long_correlation" #.(swig-lispify "gsl_stats_long_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_correlation" 'function))
(cffi:defcfun ("gsl_stats_long_spearman" #.(swig-lispify "gsl_stats_long_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_spearman" 'function))
(cffi:defcfun ("gsl_stats_long_variance_m" #.(swig-lispify "gsl_stats_long_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_variance_m" 'function))
(cffi:defcfun ("gsl_stats_long_sd_m" #.(swig-lispify "gsl_stats_long_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_sd_m" 'function))
(cffi:defcfun ("gsl_stats_long_absdev_m" #.(swig-lispify "gsl_stats_long_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_long_skew_m_sd" #.(swig-lispify "gsl_stats_long_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_kurtosis_m_sd" #.(swig-lispify "gsl_stats_long_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_long_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_long_covariance_m" #.(swig-lispify "gsl_stats_long_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_long_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_long_pvariance" #.(swig-lispify "gsl_stats_long_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_pvariance" 'function))
(cffi:defcfun ("gsl_stats_long_ttest" #.(swig-lispify "gsl_stats_long_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_ttest" 'function))
(cffi:defcfun ("gsl_stats_long_max" #.(swig-lispify "gsl_stats_long_max" 'function)) :long
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_max" 'function))
(cffi:defcfun ("gsl_stats_long_min" #.(swig-lispify "gsl_stats_long_min" 'function)) :long
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_min" 'function))
(cffi:defcfun ("gsl_stats_long_minmax" #.(swig-lispify "gsl_stats_long_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_minmax" 'function))
(cffi:defcfun ("gsl_stats_long_max_index" #.(swig-lispify "gsl_stats_long_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_max_index" 'function))
(cffi:defcfun ("gsl_stats_long_min_index" #.(swig-lispify "gsl_stats_long_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_min_index" 'function))
(cffi:defcfun ("gsl_stats_long_minmax_index" #.(swig-lispify "gsl_stats_long_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_long_median_from_sorted_data" #.(swig-lispify "gsl_stats_long_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_long_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_long_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_long_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_long_double_mean" #.(swig-lispify "gsl_stats_long_double_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_mean" 'function))
(cffi:defcfun ("gsl_stats_long_double_variance" #.(swig-lispify "gsl_stats_long_double_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_variance" 'function))
(cffi:defcfun ("gsl_stats_long_double_sd" #.(swig-lispify "gsl_stats_long_double_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_sd" 'function))
(cffi:defcfun ("gsl_stats_long_double_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_long_double_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_double_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_long_double_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_double_tss" #.(swig-lispify "gsl_stats_long_double_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_tss" 'function))
(cffi:defcfun ("gsl_stats_long_double_tss_m" #.(swig-lispify "gsl_stats_long_double_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_tss_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_absdev" #.(swig-lispify "gsl_stats_long_double_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_absdev" 'function))
(cffi:defcfun ("gsl_stats_long_double_skew" #.(swig-lispify "gsl_stats_long_double_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_skew" 'function))
(cffi:defcfun ("gsl_stats_long_double_kurtosis" #.(swig-lispify "gsl_stats_long_double_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_long_double_lag1_autocorrelation" #.(swig-lispify "gsl_stats_long_double_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_long_double_covariance" #.(swig-lispify "gsl_stats_long_double_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_covariance" 'function))
(cffi:defcfun ("gsl_stats_long_double_correlation" #.(swig-lispify "gsl_stats_long_double_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_correlation" 'function))
(cffi:defcfun ("gsl_stats_long_double_spearman" #.(swig-lispify "gsl_stats_long_double_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_spearman" 'function))
(cffi:defcfun ("gsl_stats_long_double_variance_m" #.(swig-lispify "gsl_stats_long_double_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_variance_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_sd_m" #.(swig-lispify "gsl_stats_long_double_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_sd_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_absdev_m" #.(swig-lispify "gsl_stats_long_double_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_skew_m_sd" #.(swig-lispify "gsl_stats_long_double_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_double_kurtosis_m_sd" #.(swig-lispify "gsl_stats_long_double_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_double_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_long_double_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_covariance_m" #.(swig-lispify "gsl_stats_long_double_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_wmean" #.(swig-lispify "gsl_stats_long_double_wmean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wmean" 'function))
(cffi:defcfun ("gsl_stats_long_double_wvariance" #.(swig-lispify "gsl_stats_long_double_wvariance" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wvariance" 'function))
(cffi:defcfun ("gsl_stats_long_double_wsd" #.(swig-lispify "gsl_stats_long_double_wsd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wsd" 'function))
(cffi:defcfun ("gsl_stats_long_double_wvariance_with_fixed_mean" #.(swig-lispify "gsl_stats_long_double_wvariance_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wvariance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_double_wsd_with_fixed_mean" #.(swig-lispify "gsl_stats_long_double_wsd_with_fixed_mean" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wsd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_long_double_wtss" #.(swig-lispify "gsl_stats_long_double_wtss" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wtss" 'function))
(cffi:defcfun ("gsl_stats_long_double_wtss_m" #.(swig-lispify "gsl_stats_long_double_wtss_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wtss_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_wabsdev" #.(swig-lispify "gsl_stats_long_double_wabsdev" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wabsdev" 'function))
(cffi:defcfun ("gsl_stats_long_double_wskew" #.(swig-lispify "gsl_stats_long_double_wskew" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wskew" 'function))
(cffi:defcfun ("gsl_stats_long_double_wkurtosis" #.(swig-lispify "gsl_stats_long_double_wkurtosis" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wkurtosis" 'function))
(cffi:defcfun ("gsl_stats_long_double_wvariance_m" #.(swig-lispify "gsl_stats_long_double_wvariance_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wvariance_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_wsd_m" #.(swig-lispify "gsl_stats_long_double_wsd_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wsd_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_wabsdev_m" #.(swig-lispify "gsl_stats_long_double_wabsdev_m" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wabsdev_m" 'function))
(cffi:defcfun ("gsl_stats_long_double_wskew_m_sd" #.(swig-lispify "gsl_stats_long_double_wskew_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wskew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_double_wkurtosis_m_sd" #.(swig-lispify "gsl_stats_long_double_wkurtosis_m_sd" 'function)) :double
(w :pointer)
(wstride :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(wmean :double)
(wsd :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_wkurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_long_double_pvariance" #.(swig-lispify "gsl_stats_long_double_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_pvariance" 'function))
(cffi:defcfun ("gsl_stats_long_double_ttest" #.(swig-lispify "gsl_stats_long_double_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_ttest" 'function))
(cffi:defcfun ("gsl_stats_long_double_max" #.(swig-lispify "gsl_stats_long_double_max" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_max" 'function))
(cffi:defcfun ("gsl_stats_long_double_min" #.(swig-lispify "gsl_stats_long_double_min" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_min" 'function))
(cffi:defcfun ("gsl_stats_long_double_minmax" #.(swig-lispify "gsl_stats_long_double_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_minmax" 'function))
(cffi:defcfun ("gsl_stats_long_double_max_index" #.(swig-lispify "gsl_stats_long_double_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_max_index" 'function))
(cffi:defcfun ("gsl_stats_long_double_min_index" #.(swig-lispify "gsl_stats_long_double_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_min_index" 'function))
(cffi:defcfun ("gsl_stats_long_double_minmax_index" #.(swig-lispify "gsl_stats_long_double_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_long_double_median_from_sorted_data" #.(swig-lispify "gsl_stats_long_double_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_long_double_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_long_double_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_long_double_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_long_double_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_short_mean" #.(swig-lispify "gsl_stats_short_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_mean" 'function))
(cffi:defcfun ("gsl_stats_short_variance" #.(swig-lispify "gsl_stats_short_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_variance" 'function))
(cffi:defcfun ("gsl_stats_short_sd" #.(swig-lispify "gsl_stats_short_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_sd" 'function))
(cffi:defcfun ("gsl_stats_short_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_short_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_short_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_short_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_short_tss" #.(swig-lispify "gsl_stats_short_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_tss" 'function))
(cffi:defcfun ("gsl_stats_short_tss_m" #.(swig-lispify "gsl_stats_short_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_tss_m" 'function))
(cffi:defcfun ("gsl_stats_short_absdev" #.(swig-lispify "gsl_stats_short_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_absdev" 'function))
(cffi:defcfun ("gsl_stats_short_skew" #.(swig-lispify "gsl_stats_short_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_skew" 'function))
(cffi:defcfun ("gsl_stats_short_kurtosis" #.(swig-lispify "gsl_stats_short_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_short_lag1_autocorrelation" #.(swig-lispify "gsl_stats_short_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_short_covariance" #.(swig-lispify "gsl_stats_short_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_covariance" 'function))
(cffi:defcfun ("gsl_stats_short_correlation" #.(swig-lispify "gsl_stats_short_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_correlation" 'function))
(cffi:defcfun ("gsl_stats_short_spearman" #.(swig-lispify "gsl_stats_short_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_spearman" 'function))
(cffi:defcfun ("gsl_stats_short_variance_m" #.(swig-lispify "gsl_stats_short_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_variance_m" 'function))
(cffi:defcfun ("gsl_stats_short_sd_m" #.(swig-lispify "gsl_stats_short_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_sd_m" 'function))
(cffi:defcfun ("gsl_stats_short_absdev_m" #.(swig-lispify "gsl_stats_short_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_short_skew_m_sd" #.(swig-lispify "gsl_stats_short_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_short_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_short_kurtosis_m_sd" #.(swig-lispify "gsl_stats_short_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_short_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_short_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_short_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_short_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_short_covariance_m" #.(swig-lispify "gsl_stats_short_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_short_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_short_pvariance" #.(swig-lispify "gsl_stats_short_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_pvariance" 'function))
(cffi:defcfun ("gsl_stats_short_ttest" #.(swig-lispify "gsl_stats_short_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_ttest" 'function))
(cffi:defcfun ("gsl_stats_short_max" #.(swig-lispify "gsl_stats_short_max" 'function)) :short
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_max" 'function))
(cffi:defcfun ("gsl_stats_short_min" #.(swig-lispify "gsl_stats_short_min" 'function)) :short
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_min" 'function))
(cffi:defcfun ("gsl_stats_short_minmax" #.(swig-lispify "gsl_stats_short_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_minmax" 'function))
(cffi:defcfun ("gsl_stats_short_max_index" #.(swig-lispify "gsl_stats_short_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_max_index" 'function))
(cffi:defcfun ("gsl_stats_short_min_index" #.(swig-lispify "gsl_stats_short_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_min_index" 'function))
(cffi:defcfun ("gsl_stats_short_minmax_index" #.(swig-lispify "gsl_stats_short_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_short_median_from_sorted_data" #.(swig-lispify "gsl_stats_short_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_short_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_short_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_short_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_short_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_uchar_mean" #.(swig-lispify "gsl_stats_uchar_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_mean" 'function))
(cffi:defcfun ("gsl_stats_uchar_variance" #.(swig-lispify "gsl_stats_uchar_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_variance" 'function))
(cffi:defcfun ("gsl_stats_uchar_sd" #.(swig-lispify "gsl_stats_uchar_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_sd" 'function))
(cffi:defcfun ("gsl_stats_uchar_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_uchar_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_uchar_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_uchar_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_uchar_tss" #.(swig-lispify "gsl_stats_uchar_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_tss" 'function))
(cffi:defcfun ("gsl_stats_uchar_tss_m" #.(swig-lispify "gsl_stats_uchar_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_tss_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_absdev" #.(swig-lispify "gsl_stats_uchar_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_absdev" 'function))
(cffi:defcfun ("gsl_stats_uchar_skew" #.(swig-lispify "gsl_stats_uchar_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_skew" 'function))
(cffi:defcfun ("gsl_stats_uchar_kurtosis" #.(swig-lispify "gsl_stats_uchar_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_uchar_lag1_autocorrelation" #.(swig-lispify "gsl_stats_uchar_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_uchar_covariance" #.(swig-lispify "gsl_stats_uchar_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_covariance" 'function))
(cffi:defcfun ("gsl_stats_uchar_correlation" #.(swig-lispify "gsl_stats_uchar_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_correlation" 'function))
(cffi:defcfun ("gsl_stats_uchar_spearman" #.(swig-lispify "gsl_stats_uchar_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_spearman" 'function))
(cffi:defcfun ("gsl_stats_uchar_variance_m" #.(swig-lispify "gsl_stats_uchar_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_variance_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_sd_m" #.(swig-lispify "gsl_stats_uchar_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_sd_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_absdev_m" #.(swig-lispify "gsl_stats_uchar_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_skew_m_sd" #.(swig-lispify "gsl_stats_uchar_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_uchar_kurtosis_m_sd" #.(swig-lispify "gsl_stats_uchar_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_uchar_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_uchar_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_covariance_m" #.(swig-lispify "gsl_stats_uchar_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_uchar_pvariance" #.(swig-lispify "gsl_stats_uchar_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_pvariance" 'function))
(cffi:defcfun ("gsl_stats_uchar_ttest" #.(swig-lispify "gsl_stats_uchar_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_ttest" 'function))
(cffi:defcfun ("gsl_stats_uchar_max" #.(swig-lispify "gsl_stats_uchar_max" 'function)) :unsigned-char
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_max" 'function))
(cffi:defcfun ("gsl_stats_uchar_min" #.(swig-lispify "gsl_stats_uchar_min" 'function)) :unsigned-char
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_min" 'function))
(cffi:defcfun ("gsl_stats_uchar_minmax" #.(swig-lispify "gsl_stats_uchar_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_minmax" 'function))
(cffi:defcfun ("gsl_stats_uchar_max_index" #.(swig-lispify "gsl_stats_uchar_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_max_index" 'function))
(cffi:defcfun ("gsl_stats_uchar_min_index" #.(swig-lispify "gsl_stats_uchar_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_min_index" 'function))
(cffi:defcfun ("gsl_stats_uchar_minmax_index" #.(swig-lispify "gsl_stats_uchar_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_uchar_median_from_sorted_data" #.(swig-lispify "gsl_stats_uchar_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uchar_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_uchar_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_uchar_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_uchar_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_uint_mean" #.(swig-lispify "gsl_stats_uint_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_mean" 'function))
(cffi:defcfun ("gsl_stats_uint_variance" #.(swig-lispify "gsl_stats_uint_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_variance" 'function))
(cffi:defcfun ("gsl_stats_uint_sd" #.(swig-lispify "gsl_stats_uint_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_sd" 'function))
(cffi:defcfun ("gsl_stats_uint_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_uint_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_uint_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_uint_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_uint_tss" #.(swig-lispify "gsl_stats_uint_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_tss" 'function))
(cffi:defcfun ("gsl_stats_uint_tss_m" #.(swig-lispify "gsl_stats_uint_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_tss_m" 'function))
(cffi:defcfun ("gsl_stats_uint_absdev" #.(swig-lispify "gsl_stats_uint_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_absdev" 'function))
(cffi:defcfun ("gsl_stats_uint_skew" #.(swig-lispify "gsl_stats_uint_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_skew" 'function))
(cffi:defcfun ("gsl_stats_uint_kurtosis" #.(swig-lispify "gsl_stats_uint_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_uint_lag1_autocorrelation" #.(swig-lispify "gsl_stats_uint_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_uint_covariance" #.(swig-lispify "gsl_stats_uint_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_covariance" 'function))
(cffi:defcfun ("gsl_stats_uint_correlation" #.(swig-lispify "gsl_stats_uint_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_correlation" 'function))
(cffi:defcfun ("gsl_stats_uint_spearman" #.(swig-lispify "gsl_stats_uint_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_spearman" 'function))
(cffi:defcfun ("gsl_stats_uint_variance_m" #.(swig-lispify "gsl_stats_uint_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_variance_m" 'function))
(cffi:defcfun ("gsl_stats_uint_sd_m" #.(swig-lispify "gsl_stats_uint_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_sd_m" 'function))
(cffi:defcfun ("gsl_stats_uint_absdev_m" #.(swig-lispify "gsl_stats_uint_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_uint_skew_m_sd" #.(swig-lispify "gsl_stats_uint_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_uint_kurtosis_m_sd" #.(swig-lispify "gsl_stats_uint_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_uint_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_uint_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_uint_covariance_m" #.(swig-lispify "gsl_stats_uint_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_uint_pvariance" #.(swig-lispify "gsl_stats_uint_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_pvariance" 'function))
(cffi:defcfun ("gsl_stats_uint_ttest" #.(swig-lispify "gsl_stats_uint_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_ttest" 'function))
(cffi:defcfun ("gsl_stats_uint_max" #.(swig-lispify "gsl_stats_uint_max" 'function)) :unsigned-int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_max" 'function))
(cffi:defcfun ("gsl_stats_uint_min" #.(swig-lispify "gsl_stats_uint_min" 'function)) :unsigned-int
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_min" 'function))
(cffi:defcfun ("gsl_stats_uint_minmax" #.(swig-lispify "gsl_stats_uint_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_minmax" 'function))
(cffi:defcfun ("gsl_stats_uint_max_index" #.(swig-lispify "gsl_stats_uint_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_max_index" 'function))
(cffi:defcfun ("gsl_stats_uint_min_index" #.(swig-lispify "gsl_stats_uint_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_min_index" 'function))
(cffi:defcfun ("gsl_stats_uint_minmax_index" #.(swig-lispify "gsl_stats_uint_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_uint_median_from_sorted_data" #.(swig-lispify "gsl_stats_uint_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_uint_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_uint_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_uint_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_uint_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_ulong_mean" #.(swig-lispify "gsl_stats_ulong_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_mean" 'function))
(cffi:defcfun ("gsl_stats_ulong_variance" #.(swig-lispify "gsl_stats_ulong_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_variance" 'function))
(cffi:defcfun ("gsl_stats_ulong_sd" #.(swig-lispify "gsl_stats_ulong_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_sd" 'function))
(cffi:defcfun ("gsl_stats_ulong_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_ulong_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_ulong_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_ulong_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_ulong_tss" #.(swig-lispify "gsl_stats_ulong_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_tss" 'function))
(cffi:defcfun ("gsl_stats_ulong_tss_m" #.(swig-lispify "gsl_stats_ulong_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_tss_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_absdev" #.(swig-lispify "gsl_stats_ulong_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_absdev" 'function))
(cffi:defcfun ("gsl_stats_ulong_skew" #.(swig-lispify "gsl_stats_ulong_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_skew" 'function))
(cffi:defcfun ("gsl_stats_ulong_kurtosis" #.(swig-lispify "gsl_stats_ulong_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_ulong_lag1_autocorrelation" #.(swig-lispify "gsl_stats_ulong_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_ulong_covariance" #.(swig-lispify "gsl_stats_ulong_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_covariance" 'function))
(cffi:defcfun ("gsl_stats_ulong_correlation" #.(swig-lispify "gsl_stats_ulong_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_correlation" 'function))
(cffi:defcfun ("gsl_stats_ulong_spearman" #.(swig-lispify "gsl_stats_ulong_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_spearman" 'function))
(cffi:defcfun ("gsl_stats_ulong_variance_m" #.(swig-lispify "gsl_stats_ulong_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_variance_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_sd_m" #.(swig-lispify "gsl_stats_ulong_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_sd_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_absdev_m" #.(swig-lispify "gsl_stats_ulong_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_skew_m_sd" #.(swig-lispify "gsl_stats_ulong_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_ulong_kurtosis_m_sd" #.(swig-lispify "gsl_stats_ulong_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_ulong_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_ulong_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_covariance_m" #.(swig-lispify "gsl_stats_ulong_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_ulong_pvariance" #.(swig-lispify "gsl_stats_ulong_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_pvariance" 'function))
(cffi:defcfun ("gsl_stats_ulong_ttest" #.(swig-lispify "gsl_stats_ulong_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_ttest" 'function))
(cffi:defcfun ("gsl_stats_ulong_max" #.(swig-lispify "gsl_stats_ulong_max" 'function)) :unsigned-long
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_max" 'function))
(cffi:defcfun ("gsl_stats_ulong_min" #.(swig-lispify "gsl_stats_ulong_min" 'function)) :unsigned-long
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_min" 'function))
(cffi:defcfun ("gsl_stats_ulong_minmax" #.(swig-lispify "gsl_stats_ulong_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_minmax" 'function))
(cffi:defcfun ("gsl_stats_ulong_max_index" #.(swig-lispify "gsl_stats_ulong_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_max_index" 'function))
(cffi:defcfun ("gsl_stats_ulong_min_index" #.(swig-lispify "gsl_stats_ulong_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_min_index" 'function))
(cffi:defcfun ("gsl_stats_ulong_minmax_index" #.(swig-lispify "gsl_stats_ulong_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_ulong_median_from_sorted_data" #.(swig-lispify "gsl_stats_ulong_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ulong_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_ulong_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_ulong_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_ulong_quantile_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_ushort_mean" #.(swig-lispify "gsl_stats_ushort_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_mean" 'function))
(cffi:defcfun ("gsl_stats_ushort_variance" #.(swig-lispify "gsl_stats_ushort_variance" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_variance" 'function))
(cffi:defcfun ("gsl_stats_ushort_sd" #.(swig-lispify "gsl_stats_ushort_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_sd" 'function))
(cffi:defcfun ("gsl_stats_ushort_variance_with_fixed_mean" #.(swig-lispify "gsl_stats_ushort_variance_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_variance_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_ushort_sd_with_fixed_mean" #.(swig-lispify "gsl_stats_ushort_sd_with_fixed_mean" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_sd_with_fixed_mean" 'function))
(cffi:defcfun ("gsl_stats_ushort_tss" #.(swig-lispify "gsl_stats_ushort_tss" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_tss" 'function))
(cffi:defcfun ("gsl_stats_ushort_tss_m" #.(swig-lispify "gsl_stats_ushort_tss_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_tss_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_absdev" #.(swig-lispify "gsl_stats_ushort_absdev" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_absdev" 'function))
(cffi:defcfun ("gsl_stats_ushort_skew" #.(swig-lispify "gsl_stats_ushort_skew" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_skew" 'function))
(cffi:defcfun ("gsl_stats_ushort_kurtosis" #.(swig-lispify "gsl_stats_ushort_kurtosis" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_kurtosis" 'function))
(cffi:defcfun ("gsl_stats_ushort_lag1_autocorrelation" #.(swig-lispify "gsl_stats_ushort_lag1_autocorrelation" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_lag1_autocorrelation" 'function))
(cffi:defcfun ("gsl_stats_ushort_covariance" #.(swig-lispify "gsl_stats_ushort_covariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_covariance" 'function))
(cffi:defcfun ("gsl_stats_ushort_correlation" #.(swig-lispify "gsl_stats_ushort_correlation" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_correlation" 'function))
(cffi:defcfun ("gsl_stats_ushort_spearman" #.(swig-lispify "gsl_stats_ushort_spearman" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_spearman" 'function))
(cffi:defcfun ("gsl_stats_ushort_variance_m" #.(swig-lispify "gsl_stats_ushort_variance_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_variance_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_sd_m" #.(swig-lispify "gsl_stats_ushort_sd_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_sd_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_absdev_m" #.(swig-lispify "gsl_stats_ushort_absdev_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_absdev_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_skew_m_sd" #.(swig-lispify "gsl_stats_ushort_skew_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_skew_m_sd" 'function))
(cffi:defcfun ("gsl_stats_ushort_kurtosis_m_sd" #.(swig-lispify "gsl_stats_ushort_kurtosis_m_sd" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double)
(sd :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_kurtosis_m_sd" 'function))
(cffi:defcfun ("gsl_stats_ushort_lag1_autocorrelation_m" #.(swig-lispify "gsl_stats_ushort_lag1_autocorrelation_m" 'function)) :double
(data :pointer)
(stride :pointer)
(n :pointer)
(mean :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_lag1_autocorrelation_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_covariance_m" #.(swig-lispify "gsl_stats_ushort_covariance_m" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n :pointer)
(mean1 :double)
(mean2 :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_covariance_m" 'function))
(cffi:defcfun ("gsl_stats_ushort_pvariance" #.(swig-lispify "gsl_stats_ushort_pvariance" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_pvariance" 'function))
(cffi:defcfun ("gsl_stats_ushort_ttest" #.(swig-lispify "gsl_stats_ushort_ttest" 'function)) :double
(data1 :pointer)
(stride1 :pointer)
(n1 :pointer)
(data2 :pointer)
(stride2 :pointer)
(n2 :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_ttest" 'function))
(cffi:defcfun ("gsl_stats_ushort_max" #.(swig-lispify "gsl_stats_ushort_max" 'function)) :unsigned-short
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_max" 'function))
(cffi:defcfun ("gsl_stats_ushort_min" #.(swig-lispify "gsl_stats_ushort_min" 'function)) :unsigned-short
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_min" 'function))
(cffi:defcfun ("gsl_stats_ushort_minmax" #.(swig-lispify "gsl_stats_ushort_minmax" 'function)) :void
(min :pointer)
(max :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_minmax" 'function))
(cffi:defcfun ("gsl_stats_ushort_max_index" #.(swig-lispify "gsl_stats_ushort_max_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_max_index" 'function))
(cffi:defcfun ("gsl_stats_ushort_min_index" #.(swig-lispify "gsl_stats_ushort_min_index" 'function)) :pointer
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_min_index" 'function))
(cffi:defcfun ("gsl_stats_ushort_minmax_index" #.(swig-lispify "gsl_stats_ushort_minmax_index" 'function)) :void
(min_index :pointer)
(max_index :pointer)
(data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_minmax_index" 'function))
(cffi:defcfun ("gsl_stats_ushort_median_from_sorted_data" #.(swig-lispify "gsl_stats_ushort_median_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_stats_ushort_median_from_sorted_data" 'function))
(cffi:defcfun ("gsl_stats_ushort_quantile_from_sorted_data" #.(swig-lispify "gsl_stats_ushort_quantile_from_sorted_data" 'function)) :double
(sorted_data :pointer)
(stride :pointer)
(n :pointer)
(f :double))
(cl:export '#.(swig-lispify "gsl_stats_ushort_quantile_from_sorted_data" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_sum_levin_u_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "i" 'slotname) :pointer)
(#.(swig-lispify "terms_used" 'slotname) :pointer)
(#.(swig-lispify "sum_plain" 'slotname) :double)
(#.(swig-lispify "q_num" 'slotname) :pointer)
(#.(swig-lispify "q_den" 'slotname) :pointer)
(#.(swig-lispify "dq_num" 'slotname) :pointer)
(#.(swig-lispify "dq_den" 'slotname) :pointer)
(#.(swig-lispify "dsum" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "i" 'slotname))
(cl:export '#.(swig-lispify "terms_used" 'slotname))
(cl:export '#.(swig-lispify "sum_plain" 'slotname))
(cl:export '#.(swig-lispify "q_num" 'slotname))
(cl:export '#.(swig-lispify "q_den" 'slotname))
(cl:export '#.(swig-lispify "dq_num" 'slotname))
(cl:export '#.(swig-lispify "dq_den" 'slotname))
(cl:export '#.(swig-lispify "dsum" 'slotname))
(cffi:defcfun ("gsl_sum_levin_u_alloc" #.(swig-lispify "gsl_sum_levin_u_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_alloc" 'function))
(cffi:defcfun ("gsl_sum_levin_u_free" #.(swig-lispify "gsl_sum_levin_u_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_free" 'function))
(cffi:defcfun ("gsl_sum_levin_u_accel" #.(swig-lispify "gsl_sum_levin_u_accel" 'function)) :int
(array :pointer)
(n :pointer)
(w :pointer)
(sum_accel :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_accel" 'function))
(cffi:defcfun ("gsl_sum_levin_u_minmax" #.(swig-lispify "gsl_sum_levin_u_minmax" 'function)) :int
(array :pointer)
(n :pointer)
(min_terms :pointer)
(max_terms :pointer)
(w :pointer)
(sum_accel :pointer)
(abserr :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_minmax" 'function))
(cffi:defcfun ("gsl_sum_levin_u_step" #.(swig-lispify "gsl_sum_levin_u_step" 'function)) :int
(term :double)
(n :pointer)
(nmax :pointer)
(w :pointer)
(sum_accel :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_u_step" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_sum_levin_utrunc_workspace" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "i" 'slotname) :pointer)
(#.(swig-lispify "terms_used" 'slotname) :pointer)
(#.(swig-lispify "sum_plain" 'slotname) :double)
(#.(swig-lispify "q_num" 'slotname) :pointer)
(#.(swig-lispify "q_den" 'slotname) :pointer)
(#.(swig-lispify "dsum" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_workspace" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "i" 'slotname))
(cl:export '#.(swig-lispify "terms_used" 'slotname))
(cl:export '#.(swig-lispify "sum_plain" 'slotname))
(cl:export '#.(swig-lispify "q_num" 'slotname))
(cl:export '#.(swig-lispify "q_den" 'slotname))
(cl:export '#.(swig-lispify "dsum" 'slotname))
(cffi:defcfun ("gsl_sum_levin_utrunc_alloc" #.(swig-lispify "gsl_sum_levin_utrunc_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_alloc" 'function))
(cffi:defcfun ("gsl_sum_levin_utrunc_free" #.(swig-lispify "gsl_sum_levin_utrunc_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_free" 'function))
(cffi:defcfun ("gsl_sum_levin_utrunc_accel" #.(swig-lispify "gsl_sum_levin_utrunc_accel" 'function)) :int
(array :pointer)
(n :pointer)
(w :pointer)
(sum_accel :pointer)
(abserr_trunc :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_accel" 'function))
(cffi:defcfun ("gsl_sum_levin_utrunc_minmax" #.(swig-lispify "gsl_sum_levin_utrunc_minmax" 'function)) :int
(array :pointer)
(n :pointer)
(min_terms :pointer)
(max_terms :pointer)
(w :pointer)
(sum_accel :pointer)
(abserr_trunc :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_minmax" 'function))
(cffi:defcfun ("gsl_sum_levin_utrunc_step" #.(swig-lispify "gsl_sum_levin_utrunc_step" 'function)) :int
(term :double)
(n :pointer)
(w :pointer)
(sum_accel :pointer))
(cl:export '#.(swig-lispify "gsl_sum_levin_utrunc_step" 'function))
(cffi:defcfun ("gsl_log1p" #.(swig-lispify "gsl_log1p" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_log1p" 'function))
(cffi:defcfun ("gsl_expm1" #.(swig-lispify "gsl_expm1" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_expm1" 'function))
(cffi:defcfun ("gsl_hypot" #.(swig-lispify "gsl_hypot" 'function)) :double
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_hypot" 'function))
(cffi:defcfun ("gsl_hypot3" #.(swig-lispify "gsl_hypot3" 'function)) :double
(x :double)
(y :double)
(z :double))
(cl:export '#.(swig-lispify "gsl_hypot3" 'function))
(cffi:defcfun ("gsl_acosh" #.(swig-lispify "gsl_acosh" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_acosh" 'function))
(cffi:defcfun ("gsl_asinh" #.(swig-lispify "gsl_asinh" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_asinh" 'function))
(cffi:defcfun ("gsl_atanh" #.(swig-lispify "gsl_atanh" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_atanh" 'function))
(cffi:defcfun ("gsl_isnan" #.(swig-lispify "gsl_isnan" 'function)) :int
(x :double))
(cl:export '#.(swig-lispify "gsl_isnan" 'function))
(cffi:defcfun ("gsl_isinf" #.(swig-lispify "gsl_isinf" 'function)) :int
(x :double))
(cl:export '#.(swig-lispify "gsl_isinf" 'function))
(cffi:defcfun ("gsl_finite" #.(swig-lispify "gsl_finite" 'function)) :int
(x :double))
(cl:export '#.(swig-lispify "gsl_finite" 'function))
(cffi:defcfun ("gsl_nan" #.(swig-lispify "gsl_nan" 'function)) :double)
(cl:export '#.(swig-lispify "gsl_nan" 'function))
(cffi:defcfun ("gsl_posinf" #.(swig-lispify "gsl_posinf" 'function)) :double)
(cl:export '#.(swig-lispify "gsl_posinf" 'function))
(cffi:defcfun ("gsl_neginf" #.(swig-lispify "gsl_neginf" 'function)) :double)
(cl:export '#.(swig-lispify "gsl_neginf" 'function))
(cffi:defcfun ("gsl_fdiv" #.(swig-lispify "gsl_fdiv" 'function)) :double
(x :double)
(y :double))
(cl:export '#.(swig-lispify "gsl_fdiv" 'function))
(cffi:defcfun ("gsl_coerce_double" #.(swig-lispify "gsl_coerce_double" 'function)) :double
(x :double))
(cl:export '#.(swig-lispify "gsl_coerce_double" 'function))
(cffi:defcfun ("gsl_coerce_float" #.(swig-lispify "gsl_coerce_float" 'function)) :float
(x :float))
(cl:export '#.(swig-lispify "gsl_coerce_float" 'function))
(cffi:defcfun ("gsl_coerce_long_double" #.(swig-lispify "gsl_coerce_long_double" 'function)) :pointer
(x :pointer))
(cl:export '#.(swig-lispify "gsl_coerce_long_double" 'function))
(cffi:defcfun ("gsl_ldexp" #.(swig-lispify "gsl_ldexp" 'function)) :double
(x :double)
(e :int))
(cl:export '#.(swig-lispify "gsl_ldexp" 'function))
(cffi:defcfun ("gsl_frexp" #.(swig-lispify "gsl_frexp" 'function)) :double
(x :double)
(e :pointer))
(cl:export '#.(swig-lispify "gsl_frexp" 'function))
(cffi:defcfun ("gsl_fcmp" #.(swig-lispify "gsl_fcmp" 'function)) :int
(x1 :double)
(x2 :double)
(epsilon :double))
(cl:export '#.(swig-lispify "gsl_fcmp" 'function))
(cffi:defcfun ("gsl_test" #.(swig-lispify "gsl_test" 'function)) :void
(status :int)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test" 'function))
(cffi:defcfun ("gsl_test_rel" #.(swig-lispify "gsl_test_rel" 'function)) :void
(result :double)
(expected :double)
(relative_error :double)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test_rel" 'function))
(cffi:defcfun ("gsl_test_abs" #.(swig-lispify "gsl_test_abs" 'function)) :void
(result :double)
(expected :double)
(absolute_error :double)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test_abs" 'function))
(cffi:defcfun ("gsl_test_factor" #.(swig-lispify "gsl_test_factor" 'function)) :void
(result :double)
(expected :double)
(factor :double)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test_factor" 'function))
(cffi:defcfun ("gsl_test_int" #.(swig-lispify "gsl_test_int" 'function)) :void
(result :int)
(expected :int)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test_int" 'function))
(cffi:defcfun ("gsl_test_str" #.(swig-lispify "gsl_test_str" 'function)) :void
(result :string)
(expected :string)
(test_description :string)
&rest)
(cl:export '#.(swig-lispify "gsl_test_str" 'function))
(cffi:defcfun ("gsl_test_verbose" #.(swig-lispify "gsl_test_verbose" 'function)) :void
(verbose :int))
(cl:export '#.(swig-lispify "gsl_test_verbose" 'function))
(cffi:defcfun ("gsl_test_summary" #.(swig-lispify "gsl_test_summary" 'function)) :int)
(cl:export '#.(swig-lispify "gsl_test_summary" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_char" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :string)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_char" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_char_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_char" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_char_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_char_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_char" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_char_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_char_alloc" #.(swig-lispify "gsl_vector_char_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_alloc" 'function))
(cffi:defcfun ("gsl_vector_char_calloc" #.(swig-lispify "gsl_vector_char_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_calloc" 'function))
(cffi:defcfun ("gsl_vector_char_alloc_from_block" #.(swig-lispify "gsl_vector_char_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_char_alloc_from_vector" #.(swig-lispify "gsl_vector_char_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_char_free" #.(swig-lispify "gsl_vector_char_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_free" 'function))
(cffi:defcfun ("gsl_vector_char_view_array" #.(swig-lispify "gsl_vector_char_view_array" 'function)) #.(swig-lispify "_gsl_vector_char_view" 'classname)
(v :string)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_view_array" 'function))
(cffi:defcfun ("gsl_vector_char_view_array_with_stride" #.(swig-lispify "gsl_vector_char_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_char_view" 'classname)
(base :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_char_const_view_array" #.(swig-lispify "gsl_vector_char_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_char_const_view" 'classname)
(v :string)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_char_const_view_array_with_stride" #.(swig-lispify "gsl_vector_char_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_char_const_view" 'classname)
(base :string)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_char_subvector" #.(swig-lispify "gsl_vector_char_subvector" 'function)) #.(swig-lispify "_gsl_vector_char_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_subvector" 'function))
(cffi:defcfun ("gsl_vector_char_subvector_with_stride" #.(swig-lispify "gsl_vector_char_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_char_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_char_const_subvector" #.(swig-lispify "gsl_vector_char_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_char_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_char_const_subvector_with_stride" #.(swig-lispify "gsl_vector_char_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_char_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_char_set_zero" #.(swig-lispify "gsl_vector_char_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_set_zero" 'function))
(cffi:defcfun ("gsl_vector_char_set_all" #.(swig-lispify "gsl_vector_char_set_all" 'function)) :void
(v :pointer)
(x :char))
(cl:export '#.(swig-lispify "gsl_vector_char_set_all" 'function))
(cffi:defcfun ("gsl_vector_char_set_basis" #.(swig-lispify "gsl_vector_char_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_set_basis" 'function))
(cffi:defcfun ("gsl_vector_char_fread" #.(swig-lispify "gsl_vector_char_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_fread" 'function))
(cffi:defcfun ("gsl_vector_char_fwrite" #.(swig-lispify "gsl_vector_char_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_fwrite" 'function))
(cffi:defcfun ("gsl_vector_char_fscanf" #.(swig-lispify "gsl_vector_char_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_fscanf" 'function))
(cffi:defcfun ("gsl_vector_char_fprintf" #.(swig-lispify "gsl_vector_char_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_char_fprintf" 'function))
(cffi:defcfun ("gsl_vector_char_memcpy" #.(swig-lispify "gsl_vector_char_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_memcpy" 'function))
(cffi:defcfun ("gsl_vector_char_reverse" #.(swig-lispify "gsl_vector_char_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_reverse" 'function))
(cffi:defcfun ("gsl_vector_char_swap" #.(swig-lispify "gsl_vector_char_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_swap" 'function))
(cffi:defcfun ("gsl_vector_char_swap_elements" #.(swig-lispify "gsl_vector_char_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_char_max" #.(swig-lispify "gsl_vector_char_max" 'function)) :char
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_max" 'function))
(cffi:defcfun ("gsl_vector_char_min" #.(swig-lispify "gsl_vector_char_min" 'function)) :char
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_min" 'function))
(cffi:defcfun ("gsl_vector_char_minmax" #.(swig-lispify "gsl_vector_char_minmax" 'function)) :void
(v :pointer)
(min_out :string)
(max_out :string))
(cl:export '#.(swig-lispify "gsl_vector_char_minmax" 'function))
(cffi:defcfun ("gsl_vector_char_max_index" #.(swig-lispify "gsl_vector_char_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_max_index" 'function))
(cffi:defcfun ("gsl_vector_char_min_index" #.(swig-lispify "gsl_vector_char_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_min_index" 'function))
(cffi:defcfun ("gsl_vector_char_minmax_index" #.(swig-lispify "gsl_vector_char_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_char_add" #.(swig-lispify "gsl_vector_char_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_add" 'function))
(cffi:defcfun ("gsl_vector_char_sub" #.(swig-lispify "gsl_vector_char_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_sub" 'function))
(cffi:defcfun ("gsl_vector_char_mul" #.(swig-lispify "gsl_vector_char_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_mul" 'function))
(cffi:defcfun ("gsl_vector_char_div" #.(swig-lispify "gsl_vector_char_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_div" 'function))
(cffi:defcfun ("gsl_vector_char_scale" #.(swig-lispify "gsl_vector_char_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_char_scale" 'function))
(cffi:defcfun ("gsl_vector_char_add_constant" #.(swig-lispify "gsl_vector_char_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_char_add_constant" 'function))
(cffi:defcfun ("gsl_vector_char_equal" #.(swig-lispify "gsl_vector_char_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_equal" 'function))
(cffi:defcfun ("gsl_vector_char_isnull" #.(swig-lispify "gsl_vector_char_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_isnull" 'function))
(cffi:defcfun ("gsl_vector_char_ispos" #.(swig-lispify "gsl_vector_char_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_ispos" 'function))
(cffi:defcfun ("gsl_vector_char_isneg" #.(swig-lispify "gsl_vector_char_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_isneg" 'function))
(cffi:defcfun ("gsl_vector_char_isnonneg" #.(swig-lispify "gsl_vector_char_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_char_get" #.(swig-lispify "gsl_vector_char_get" 'function)) :char
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_get" 'function))
(cffi:defcfun ("gsl_vector_char_set" #.(swig-lispify "gsl_vector_char_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :char))
(cl:export '#.(swig-lispify "gsl_vector_char_set" 'function))
(cffi:defcfun ("gsl_vector_char_ptr" #.(swig-lispify "gsl_vector_char_ptr" 'function)) :string
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_ptr" 'function))
(cffi:defcfun ("gsl_vector_char_const_ptr" #.(swig-lispify "gsl_vector_char_const_ptr" 'function)) :string
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_char_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_complex" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_complex" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_complex_alloc" #.(swig-lispify "gsl_vector_complex_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_alloc" 'function))
(cffi:defcfun ("gsl_vector_complex_calloc" #.(swig-lispify "gsl_vector_complex_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_calloc" 'function))
(cffi:defcfun ("gsl_vector_complex_alloc_from_block" #.(swig-lispify "gsl_vector_complex_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_complex_alloc_from_vector" #.(swig-lispify "gsl_vector_complex_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_complex_free" #.(swig-lispify "gsl_vector_complex_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_free" 'function))
(cffi:defcfun ("gsl_vector_complex_view_array" #.(swig-lispify "gsl_vector_complex_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_const_view_array" #.(swig-lispify "gsl_vector_complex_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_const_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_const_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_subvector" #.(swig-lispify "gsl_vector_complex_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_const_subvector" #.(swig-lispify "gsl_vector_complex_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_const_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_const_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_real" #.(swig-lispify "gsl_vector_complex_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_real" 'function))
(cffi:defcfun ("gsl_vector_complex_imag" #.(swig-lispify "gsl_vector_complex_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_const_real" #.(swig-lispify "gsl_vector_complex_const_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_real" 'function))
(cffi:defcfun ("gsl_vector_complex_const_imag" #.(swig-lispify "gsl_vector_complex_const_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_set_zero" #.(swig-lispify "gsl_vector_complex_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_set_zero" 'function))
(cffi:defcfun ("gsl_vector_complex_set_all" #.(swig-lispify "gsl_vector_complex_set_all" 'function)) :void
(v :pointer)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_set_all" 'function))
(cffi:defcfun ("gsl_vector_complex_set_basis" #.(swig-lispify "gsl_vector_complex_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_set_basis" 'function))
(cffi:defcfun ("gsl_vector_complex_fread" #.(swig-lispify "gsl_vector_complex_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_fread" 'function))
(cffi:defcfun ("gsl_vector_complex_fwrite" #.(swig-lispify "gsl_vector_complex_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_fwrite" 'function))
(cffi:defcfun ("gsl_vector_complex_fscanf" #.(swig-lispify "gsl_vector_complex_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_fscanf" 'function))
(cffi:defcfun ("gsl_vector_complex_fprintf" #.(swig-lispify "gsl_vector_complex_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_complex_fprintf" 'function))
(cffi:defcfun ("gsl_vector_complex_memcpy" #.(swig-lispify "gsl_vector_complex_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_memcpy" 'function))
(cffi:defcfun ("gsl_vector_complex_reverse" #.(swig-lispify "gsl_vector_complex_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_reverse" 'function))
(cffi:defcfun ("gsl_vector_complex_swap" #.(swig-lispify "gsl_vector_complex_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_swap" 'function))
(cffi:defcfun ("gsl_vector_complex_swap_elements" #.(swig-lispify "gsl_vector_complex_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_complex_equal" #.(swig-lispify "gsl_vector_complex_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_equal" 'function))
(cffi:defcfun ("gsl_vector_complex_isnull" #.(swig-lispify "gsl_vector_complex_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_isnull" 'function))
(cffi:defcfun ("gsl_vector_complex_ispos" #.(swig-lispify "gsl_vector_complex_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_ispos" 'function))
(cffi:defcfun ("gsl_vector_complex_isneg" #.(swig-lispify "gsl_vector_complex_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_isneg" 'function))
(cffi:defcfun ("gsl_vector_complex_isnonneg" #.(swig-lispify "gsl_vector_complex_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_complex_add" #.(swig-lispify "gsl_vector_complex_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_add" 'function))
(cffi:defcfun ("gsl_vector_complex_sub" #.(swig-lispify "gsl_vector_complex_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_sub" 'function))
(cffi:defcfun ("gsl_vector_complex_mul" #.(swig-lispify "gsl_vector_complex_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_mul" 'function))
(cffi:defcfun ("gsl_vector_complex_div" #.(swig-lispify "gsl_vector_complex_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_div" 'function))
(cffi:defcfun ("gsl_vector_complex_scale" #.(swig-lispify "gsl_vector_complex_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_scale" 'function))
(cffi:defcfun ("gsl_vector_complex_add_constant" #.(swig-lispify "gsl_vector_complex_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_add_constant" 'function))
(cffi:defcfun ("gsl_vector_complex_get" #.(swig-lispify "gsl_vector_complex_get" 'function)) #.(swig-lispify "gsl_complex" 'classname)
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_get" 'function))
(cffi:defcfun ("gsl_vector_complex_set" #.(swig-lispify "gsl_vector_complex_set" 'function)) :void
(v :pointer)
(i :pointer)
(z #.(swig-lispify "gsl_complex" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_set" 'function))
(cffi:defcfun ("gsl_vector_complex_ptr" #.(swig-lispify "gsl_vector_complex_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_ptr" 'function))
(cffi:defcfun ("gsl_vector_complex_const_ptr" #.(swig-lispify "gsl_vector_complex_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_complex_float" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_complex_float" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_float_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_float_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_complex_float_alloc" #.(swig-lispify "gsl_vector_complex_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_alloc" 'function))
(cffi:defcfun ("gsl_vector_complex_float_calloc" #.(swig-lispify "gsl_vector_complex_float_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_calloc" 'function))
(cffi:defcfun ("gsl_vector_complex_float_alloc_from_block" #.(swig-lispify "gsl_vector_complex_float_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_complex_float_alloc_from_vector" #.(swig-lispify "gsl_vector_complex_float_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_complex_float_free" #.(swig-lispify "gsl_vector_complex_float_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_free" 'function))
(cffi:defcfun ("gsl_vector_complex_float_view_array" #.(swig-lispify "gsl_vector_complex_float_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_float_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_float_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_float_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_float_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_view_array" #.(swig-lispify "gsl_vector_complex_float_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_float_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_float_subvector" #.(swig-lispify "gsl_vector_complex_float_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_float_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_float_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_float_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_float_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_subvector" #.(swig-lispify "gsl_vector_complex_float_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_float_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_float_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_float_real" #.(swig-lispify "gsl_vector_complex_float_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_real" 'function))
(cffi:defcfun ("gsl_vector_complex_float_imag" #.(swig-lispify "gsl_vector_complex_float_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_real" #.(swig-lispify "gsl_vector_complex_float_const_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_real" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_imag" #.(swig-lispify "gsl_vector_complex_float_const_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_float_set_zero" #.(swig-lispify "gsl_vector_complex_float_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_set_zero" 'function))
(cffi:defcfun ("gsl_vector_complex_float_set_all" #.(swig-lispify "gsl_vector_complex_float_set_all" 'function)) :void
(v :pointer)
(z #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_set_all" 'function))
(cffi:defcfun ("gsl_vector_complex_float_set_basis" #.(swig-lispify "gsl_vector_complex_float_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_set_basis" 'function))
(cffi:defcfun ("gsl_vector_complex_float_fread" #.(swig-lispify "gsl_vector_complex_float_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_fread" 'function))
(cffi:defcfun ("gsl_vector_complex_float_fwrite" #.(swig-lispify "gsl_vector_complex_float_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_fwrite" 'function))
(cffi:defcfun ("gsl_vector_complex_float_fscanf" #.(swig-lispify "gsl_vector_complex_float_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_fscanf" 'function))
(cffi:defcfun ("gsl_vector_complex_float_fprintf" #.(swig-lispify "gsl_vector_complex_float_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_fprintf" 'function))
(cffi:defcfun ("gsl_vector_complex_float_memcpy" #.(swig-lispify "gsl_vector_complex_float_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_memcpy" 'function))
(cffi:defcfun ("gsl_vector_complex_float_reverse" #.(swig-lispify "gsl_vector_complex_float_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_reverse" 'function))
(cffi:defcfun ("gsl_vector_complex_float_swap" #.(swig-lispify "gsl_vector_complex_float_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_swap" 'function))
(cffi:defcfun ("gsl_vector_complex_float_swap_elements" #.(swig-lispify "gsl_vector_complex_float_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_complex_float_equal" #.(swig-lispify "gsl_vector_complex_float_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_equal" 'function))
(cffi:defcfun ("gsl_vector_complex_float_isnull" #.(swig-lispify "gsl_vector_complex_float_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_isnull" 'function))
(cffi:defcfun ("gsl_vector_complex_float_ispos" #.(swig-lispify "gsl_vector_complex_float_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_ispos" 'function))
(cffi:defcfun ("gsl_vector_complex_float_isneg" #.(swig-lispify "gsl_vector_complex_float_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_isneg" 'function))
(cffi:defcfun ("gsl_vector_complex_float_isnonneg" #.(swig-lispify "gsl_vector_complex_float_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_complex_float_add" #.(swig-lispify "gsl_vector_complex_float_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_add" 'function))
(cffi:defcfun ("gsl_vector_complex_float_sub" #.(swig-lispify "gsl_vector_complex_float_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_sub" 'function))
(cffi:defcfun ("gsl_vector_complex_float_mul" #.(swig-lispify "gsl_vector_complex_float_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_mul" 'function))
(cffi:defcfun ("gsl_vector_complex_float_div" #.(swig-lispify "gsl_vector_complex_float_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_div" 'function))
(cffi:defcfun ("gsl_vector_complex_float_scale" #.(swig-lispify "gsl_vector_complex_float_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_scale" 'function))
(cffi:defcfun ("gsl_vector_complex_float_add_constant" #.(swig-lispify "gsl_vector_complex_float_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_add_constant" 'function))
(cffi:defcfun ("gsl_vector_complex_float_get" #.(swig-lispify "gsl_vector_complex_float_get" 'function)) #.(swig-lispify "gsl_complex_float" 'classname)
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_get" 'function))
(cffi:defcfun ("gsl_vector_complex_float_set" #.(swig-lispify "gsl_vector_complex_float_set" 'function)) :void
(v :pointer)
(i :pointer)
(z #.(swig-lispify "gsl_complex_float" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_set" 'function))
(cffi:defcfun ("gsl_vector_complex_float_ptr" #.(swig-lispify "gsl_vector_complex_float_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_ptr" 'function))
(cffi:defcfun ("gsl_vector_complex_float_const_ptr" #.(swig-lispify "gsl_vector_complex_float_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_float_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_complex_long_double" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_complex_long_double_alloc" #.(swig-lispify "gsl_vector_complex_long_double_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_alloc" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_calloc" #.(swig-lispify "gsl_vector_complex_long_double_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_calloc" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_alloc_from_block" #.(swig-lispify "gsl_vector_complex_long_double_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_alloc_from_vector" #.(swig-lispify "gsl_vector_complex_long_double_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_free" #.(swig-lispify "gsl_vector_complex_long_double_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_free" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_view_array" #.(swig-lispify "gsl_vector_complex_long_double_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_long_double_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_view_array" #.(swig-lispify "gsl_vector_complex_long_double_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname)
(base :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_view_array_with_stride" #.(swig-lispify "gsl_vector_complex_long_double_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_subvector" #.(swig-lispify "gsl_vector_complex_long_double_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_long_double_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_subvector" #.(swig-lispify "gsl_vector_complex_long_double_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname)
(base :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_subvector_with_stride" #.(swig-lispify "gsl_vector_complex_long_double_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_complex_long_double_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_real" #.(swig-lispify "gsl_vector_complex_long_double_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_real" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_imag" #.(swig-lispify "gsl_vector_complex_long_double_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_real" #.(swig-lispify "gsl_vector_complex_long_double_const_real" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_real" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_imag" #.(swig-lispify "gsl_vector_complex_long_double_const_imag" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_imag" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_set_zero" #.(swig-lispify "gsl_vector_complex_long_double_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_set_zero" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_set_all" #.(swig-lispify "gsl_vector_complex_long_double_set_all" 'function)) :void
(v :pointer)
(z #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_set_all" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_set_basis" #.(swig-lispify "gsl_vector_complex_long_double_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_set_basis" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_fread" #.(swig-lispify "gsl_vector_complex_long_double_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_fread" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_fwrite" #.(swig-lispify "gsl_vector_complex_long_double_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_fscanf" #.(swig-lispify "gsl_vector_complex_long_double_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_fprintf" #.(swig-lispify "gsl_vector_complex_long_double_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_memcpy" #.(swig-lispify "gsl_vector_complex_long_double_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_memcpy" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_reverse" #.(swig-lispify "gsl_vector_complex_long_double_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_reverse" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_swap" #.(swig-lispify "gsl_vector_complex_long_double_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_swap" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_swap_elements" #.(swig-lispify "gsl_vector_complex_long_double_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_equal" #.(swig-lispify "gsl_vector_complex_long_double_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_equal" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_isnull" #.(swig-lispify "gsl_vector_complex_long_double_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_isnull" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_ispos" #.(swig-lispify "gsl_vector_complex_long_double_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_ispos" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_isneg" #.(swig-lispify "gsl_vector_complex_long_double_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_isneg" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_isnonneg" #.(swig-lispify "gsl_vector_complex_long_double_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_add" #.(swig-lispify "gsl_vector_complex_long_double_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_add" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_sub" #.(swig-lispify "gsl_vector_complex_long_double_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_sub" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_mul" #.(swig-lispify "gsl_vector_complex_long_double_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_mul" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_div" #.(swig-lispify "gsl_vector_complex_long_double_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_div" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_scale" #.(swig-lispify "gsl_vector_complex_long_double_scale" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_scale" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_add_constant" #.(swig-lispify "gsl_vector_complex_long_double_add_constant" 'function)) :int
(a :pointer)
(x #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_add_constant" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_get" #.(swig-lispify "gsl_vector_complex_long_double_get" 'function)) #.(swig-lispify "gsl_complex_long_double" 'classname)
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_get" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_set" #.(swig-lispify "gsl_vector_complex_long_double_set" 'function)) :void
(v :pointer)
(i :pointer)
(z #.(swig-lispify "gsl_complex_long_double" 'classname)))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_set" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_ptr" #.(swig-lispify "gsl_vector_complex_long_double_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_ptr" 'function))
(cffi:defcfun ("gsl_vector_complex_long_double_const_ptr" #.(swig-lispify "gsl_vector_complex_long_double_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_complex_long_double_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_alloc" #.(swig-lispify "gsl_vector_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_alloc" 'function))
(cffi:defcfun ("gsl_vector_calloc" #.(swig-lispify "gsl_vector_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_calloc" 'function))
(cffi:defcfun ("gsl_vector_alloc_from_block" #.(swig-lispify "gsl_vector_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_alloc_from_vector" #.(swig-lispify "gsl_vector_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_free" #.(swig-lispify "gsl_vector_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_free" 'function))
(cffi:defcfun ("gsl_vector_view_array" #.(swig-lispify "gsl_vector_view_array" 'function)) #.(swig-lispify "_gsl_vector_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_view_array" 'function))
(cffi:defcfun ("gsl_vector_view_array_with_stride" #.(swig-lispify "gsl_vector_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_const_view_array" #.(swig-lispify "gsl_vector_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_const_view_array_with_stride" #.(swig-lispify "gsl_vector_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_subvector" #.(swig-lispify "gsl_vector_subvector" 'function)) #.(swig-lispify "_gsl_vector_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_subvector" 'function))
(cffi:defcfun ("gsl_vector_subvector_with_stride" #.(swig-lispify "gsl_vector_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_const_subvector" #.(swig-lispify "gsl_vector_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_const_subvector_with_stride" #.(swig-lispify "gsl_vector_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_set_zero" #.(swig-lispify "gsl_vector_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_set_zero" 'function))
(cffi:defcfun ("gsl_vector_set_all" #.(swig-lispify "gsl_vector_set_all" 'function)) :void
(v :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_set_all" 'function))
(cffi:defcfun ("gsl_vector_set_basis" #.(swig-lispify "gsl_vector_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_set_basis" 'function))
(cffi:defcfun ("gsl_vector_fread" #.(swig-lispify "gsl_vector_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_fread" 'function))
(cffi:defcfun ("gsl_vector_fwrite" #.(swig-lispify "gsl_vector_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_fwrite" 'function))
(cffi:defcfun ("gsl_vector_fscanf" #.(swig-lispify "gsl_vector_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_fscanf" 'function))
(cffi:defcfun ("gsl_vector_fprintf" #.(swig-lispify "gsl_vector_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_fprintf" 'function))
(cffi:defcfun ("gsl_vector_memcpy" #.(swig-lispify "gsl_vector_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_memcpy" 'function))
(cffi:defcfun ("gsl_vector_reverse" #.(swig-lispify "gsl_vector_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_reverse" 'function))
(cffi:defcfun ("gsl_vector_swap" #.(swig-lispify "gsl_vector_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_swap" 'function))
(cffi:defcfun ("gsl_vector_swap_elements" #.(swig-lispify "gsl_vector_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_max" #.(swig-lispify "gsl_vector_max" 'function)) :double
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_max" 'function))
(cffi:defcfun ("gsl_vector_min" #.(swig-lispify "gsl_vector_min" 'function)) :double
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_min" 'function))
(cffi:defcfun ("gsl_vector_minmax" #.(swig-lispify "gsl_vector_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_minmax" 'function))
(cffi:defcfun ("gsl_vector_max_index" #.(swig-lispify "gsl_vector_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_max_index" 'function))
(cffi:defcfun ("gsl_vector_min_index" #.(swig-lispify "gsl_vector_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_min_index" 'function))
(cffi:defcfun ("gsl_vector_minmax_index" #.(swig-lispify "gsl_vector_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_add" #.(swig-lispify "gsl_vector_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_add" 'function))
(cffi:defcfun ("gsl_vector_sub" #.(swig-lispify "gsl_vector_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_sub" 'function))
(cffi:defcfun ("gsl_vector_mul" #.(swig-lispify "gsl_vector_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_mul" 'function))
(cffi:defcfun ("gsl_vector_div" #.(swig-lispify "gsl_vector_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_div" 'function))
(cffi:defcfun ("gsl_vector_scale" #.(swig-lispify "gsl_vector_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_scale" 'function))
(cffi:defcfun ("gsl_vector_add_constant" #.(swig-lispify "gsl_vector_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_add_constant" 'function))
(cffi:defcfun ("gsl_vector_equal" #.(swig-lispify "gsl_vector_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_equal" 'function))
(cffi:defcfun ("gsl_vector_isnull" #.(swig-lispify "gsl_vector_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_isnull" 'function))
(cffi:defcfun ("gsl_vector_ispos" #.(swig-lispify "gsl_vector_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ispos" 'function))
(cffi:defcfun ("gsl_vector_isneg" #.(swig-lispify "gsl_vector_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_isneg" 'function))
(cffi:defcfun ("gsl_vector_isnonneg" #.(swig-lispify "gsl_vector_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_get" #.(swig-lispify "gsl_vector_get" 'function)) :double
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_get" 'function))
(cffi:defcfun ("gsl_vector_set" #.(swig-lispify "gsl_vector_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_set" 'function))
(cffi:defcfun ("gsl_vector_ptr" #.(swig-lispify "gsl_vector_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ptr" 'function))
(cffi:defcfun ("gsl_vector_const_ptr" #.(swig-lispify "gsl_vector_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_float" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_float" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_float_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_float_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_float_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_float" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_float_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_float_alloc" #.(swig-lispify "gsl_vector_float_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_alloc" 'function))
(cffi:defcfun ("gsl_vector_float_calloc" #.(swig-lispify "gsl_vector_float_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_calloc" 'function))
(cffi:defcfun ("gsl_vector_float_alloc_from_block" #.(swig-lispify "gsl_vector_float_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_float_alloc_from_vector" #.(swig-lispify "gsl_vector_float_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_float_free" #.(swig-lispify "gsl_vector_float_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_free" 'function))
(cffi:defcfun ("gsl_vector_float_view_array" #.(swig-lispify "gsl_vector_float_view_array" 'function)) #.(swig-lispify "_gsl_vector_float_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_view_array" 'function))
(cffi:defcfun ("gsl_vector_float_view_array_with_stride" #.(swig-lispify "gsl_vector_float_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_float_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_float_const_view_array" #.(swig-lispify "gsl_vector_float_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_float_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_float_const_view_array_with_stride" #.(swig-lispify "gsl_vector_float_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_float_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_float_subvector" #.(swig-lispify "gsl_vector_float_subvector" 'function)) #.(swig-lispify "_gsl_vector_float_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_subvector" 'function))
(cffi:defcfun ("gsl_vector_float_subvector_with_stride" #.(swig-lispify "gsl_vector_float_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_float_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_float_const_subvector" #.(swig-lispify "gsl_vector_float_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_float_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_float_const_subvector_with_stride" #.(swig-lispify "gsl_vector_float_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_float_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_float_set_zero" #.(swig-lispify "gsl_vector_float_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_set_zero" 'function))
(cffi:defcfun ("gsl_vector_float_set_all" #.(swig-lispify "gsl_vector_float_set_all" 'function)) :void
(v :pointer)
(x :float))
(cl:export '#.(swig-lispify "gsl_vector_float_set_all" 'function))
(cffi:defcfun ("gsl_vector_float_set_basis" #.(swig-lispify "gsl_vector_float_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_set_basis" 'function))
(cffi:defcfun ("gsl_vector_float_fread" #.(swig-lispify "gsl_vector_float_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_fread" 'function))
(cffi:defcfun ("gsl_vector_float_fwrite" #.(swig-lispify "gsl_vector_float_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_fwrite" 'function))
(cffi:defcfun ("gsl_vector_float_fscanf" #.(swig-lispify "gsl_vector_float_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_fscanf" 'function))
(cffi:defcfun ("gsl_vector_float_fprintf" #.(swig-lispify "gsl_vector_float_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_float_fprintf" 'function))
(cffi:defcfun ("gsl_vector_float_memcpy" #.(swig-lispify "gsl_vector_float_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_memcpy" 'function))
(cffi:defcfun ("gsl_vector_float_reverse" #.(swig-lispify "gsl_vector_float_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_reverse" 'function))
(cffi:defcfun ("gsl_vector_float_swap" #.(swig-lispify "gsl_vector_float_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_swap" 'function))
(cffi:defcfun ("gsl_vector_float_swap_elements" #.(swig-lispify "gsl_vector_float_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_float_max" #.(swig-lispify "gsl_vector_float_max" 'function)) :float
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_max" 'function))
(cffi:defcfun ("gsl_vector_float_min" #.(swig-lispify "gsl_vector_float_min" 'function)) :float
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_min" 'function))
(cffi:defcfun ("gsl_vector_float_minmax" #.(swig-lispify "gsl_vector_float_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_minmax" 'function))
(cffi:defcfun ("gsl_vector_float_max_index" #.(swig-lispify "gsl_vector_float_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_max_index" 'function))
(cffi:defcfun ("gsl_vector_float_min_index" #.(swig-lispify "gsl_vector_float_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_min_index" 'function))
(cffi:defcfun ("gsl_vector_float_minmax_index" #.(swig-lispify "gsl_vector_float_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_float_add" #.(swig-lispify "gsl_vector_float_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_add" 'function))
(cffi:defcfun ("gsl_vector_float_sub" #.(swig-lispify "gsl_vector_float_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_sub" 'function))
(cffi:defcfun ("gsl_vector_float_mul" #.(swig-lispify "gsl_vector_float_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_mul" 'function))
(cffi:defcfun ("gsl_vector_float_div" #.(swig-lispify "gsl_vector_float_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_div" 'function))
(cffi:defcfun ("gsl_vector_float_scale" #.(swig-lispify "gsl_vector_float_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_float_scale" 'function))
(cffi:defcfun ("gsl_vector_float_add_constant" #.(swig-lispify "gsl_vector_float_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_float_add_constant" 'function))
(cffi:defcfun ("gsl_vector_float_equal" #.(swig-lispify "gsl_vector_float_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_equal" 'function))
(cffi:defcfun ("gsl_vector_float_isnull" #.(swig-lispify "gsl_vector_float_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_isnull" 'function))
(cffi:defcfun ("gsl_vector_float_ispos" #.(swig-lispify "gsl_vector_float_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_ispos" 'function))
(cffi:defcfun ("gsl_vector_float_isneg" #.(swig-lispify "gsl_vector_float_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_isneg" 'function))
(cffi:defcfun ("gsl_vector_float_isnonneg" #.(swig-lispify "gsl_vector_float_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_float_get" #.(swig-lispify "gsl_vector_float_get" 'function)) :float
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_get" 'function))
(cffi:defcfun ("gsl_vector_float_set" #.(swig-lispify "gsl_vector_float_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :float))
(cl:export '#.(swig-lispify "gsl_vector_float_set" 'function))
(cffi:defcfun ("gsl_vector_float_ptr" #.(swig-lispify "gsl_vector_float_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_ptr" 'function))
(cffi:defcfun ("gsl_vector_float_const_ptr" #.(swig-lispify "gsl_vector_float_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_float_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_int" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_int" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_int_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_int" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_int_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_int_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_int" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_int_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_int_alloc" #.(swig-lispify "gsl_vector_int_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_alloc" 'function))
(cffi:defcfun ("gsl_vector_int_calloc" #.(swig-lispify "gsl_vector_int_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_calloc" 'function))
(cffi:defcfun ("gsl_vector_int_alloc_from_block" #.(swig-lispify "gsl_vector_int_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_int_alloc_from_vector" #.(swig-lispify "gsl_vector_int_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_int_free" #.(swig-lispify "gsl_vector_int_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_free" 'function))
(cffi:defcfun ("gsl_vector_int_view_array" #.(swig-lispify "gsl_vector_int_view_array" 'function)) #.(swig-lispify "_gsl_vector_int_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_view_array" 'function))
(cffi:defcfun ("gsl_vector_int_view_array_with_stride" #.(swig-lispify "gsl_vector_int_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_int_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_int_const_view_array" #.(swig-lispify "gsl_vector_int_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_int_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_int_const_view_array_with_stride" #.(swig-lispify "gsl_vector_int_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_int_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_int_subvector" #.(swig-lispify "gsl_vector_int_subvector" 'function)) #.(swig-lispify "_gsl_vector_int_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_subvector" 'function))
(cffi:defcfun ("gsl_vector_int_subvector_with_stride" #.(swig-lispify "gsl_vector_int_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_int_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_int_const_subvector" #.(swig-lispify "gsl_vector_int_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_int_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_int_const_subvector_with_stride" #.(swig-lispify "gsl_vector_int_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_int_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_int_set_zero" #.(swig-lispify "gsl_vector_int_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_set_zero" 'function))
(cffi:defcfun ("gsl_vector_int_set_all" #.(swig-lispify "gsl_vector_int_set_all" 'function)) :void
(v :pointer)
(x :int))
(cl:export '#.(swig-lispify "gsl_vector_int_set_all" 'function))
(cffi:defcfun ("gsl_vector_int_set_basis" #.(swig-lispify "gsl_vector_int_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_set_basis" 'function))
(cffi:defcfun ("gsl_vector_int_fread" #.(swig-lispify "gsl_vector_int_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_fread" 'function))
(cffi:defcfun ("gsl_vector_int_fwrite" #.(swig-lispify "gsl_vector_int_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_fwrite" 'function))
(cffi:defcfun ("gsl_vector_int_fscanf" #.(swig-lispify "gsl_vector_int_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_fscanf" 'function))
(cffi:defcfun ("gsl_vector_int_fprintf" #.(swig-lispify "gsl_vector_int_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_int_fprintf" 'function))
(cffi:defcfun ("gsl_vector_int_memcpy" #.(swig-lispify "gsl_vector_int_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_memcpy" 'function))
(cffi:defcfun ("gsl_vector_int_reverse" #.(swig-lispify "gsl_vector_int_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_reverse" 'function))
(cffi:defcfun ("gsl_vector_int_swap" #.(swig-lispify "gsl_vector_int_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_swap" 'function))
(cffi:defcfun ("gsl_vector_int_swap_elements" #.(swig-lispify "gsl_vector_int_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_int_max" #.(swig-lispify "gsl_vector_int_max" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_max" 'function))
(cffi:defcfun ("gsl_vector_int_min" #.(swig-lispify "gsl_vector_int_min" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_min" 'function))
(cffi:defcfun ("gsl_vector_int_minmax" #.(swig-lispify "gsl_vector_int_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_minmax" 'function))
(cffi:defcfun ("gsl_vector_int_max_index" #.(swig-lispify "gsl_vector_int_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_max_index" 'function))
(cffi:defcfun ("gsl_vector_int_min_index" #.(swig-lispify "gsl_vector_int_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_min_index" 'function))
(cffi:defcfun ("gsl_vector_int_minmax_index" #.(swig-lispify "gsl_vector_int_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_int_add" #.(swig-lispify "gsl_vector_int_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_add" 'function))
(cffi:defcfun ("gsl_vector_int_sub" #.(swig-lispify "gsl_vector_int_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_sub" 'function))
(cffi:defcfun ("gsl_vector_int_mul" #.(swig-lispify "gsl_vector_int_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_mul" 'function))
(cffi:defcfun ("gsl_vector_int_div" #.(swig-lispify "gsl_vector_int_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_div" 'function))
(cffi:defcfun ("gsl_vector_int_scale" #.(swig-lispify "gsl_vector_int_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_int_scale" 'function))
(cffi:defcfun ("gsl_vector_int_add_constant" #.(swig-lispify "gsl_vector_int_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_int_add_constant" 'function))
(cffi:defcfun ("gsl_vector_int_equal" #.(swig-lispify "gsl_vector_int_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_equal" 'function))
(cffi:defcfun ("gsl_vector_int_isnull" #.(swig-lispify "gsl_vector_int_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_isnull" 'function))
(cffi:defcfun ("gsl_vector_int_ispos" #.(swig-lispify "gsl_vector_int_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_ispos" 'function))
(cffi:defcfun ("gsl_vector_int_isneg" #.(swig-lispify "gsl_vector_int_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_isneg" 'function))
(cffi:defcfun ("gsl_vector_int_isnonneg" #.(swig-lispify "gsl_vector_int_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_int_get" #.(swig-lispify "gsl_vector_int_get" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_get" 'function))
(cffi:defcfun ("gsl_vector_int_set" #.(swig-lispify "gsl_vector_int_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :int))
(cl:export '#.(swig-lispify "gsl_vector_int_set" 'function))
(cffi:defcfun ("gsl_vector_int_ptr" #.(swig-lispify "gsl_vector_int_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_ptr" 'function))
(cffi:defcfun ("gsl_vector_int_const_ptr" #.(swig-lispify "gsl_vector_int_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_int_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_long" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_long" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_long_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_long" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_long_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_long_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_long" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_long_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_long_alloc" #.(swig-lispify "gsl_vector_long_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_alloc" 'function))
(cffi:defcfun ("gsl_vector_long_calloc" #.(swig-lispify "gsl_vector_long_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_calloc" 'function))
(cffi:defcfun ("gsl_vector_long_alloc_from_block" #.(swig-lispify "gsl_vector_long_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_long_alloc_from_vector" #.(swig-lispify "gsl_vector_long_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_long_free" #.(swig-lispify "gsl_vector_long_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_free" 'function))
(cffi:defcfun ("gsl_vector_long_view_array" #.(swig-lispify "gsl_vector_long_view_array" 'function)) #.(swig-lispify "_gsl_vector_long_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_view_array" 'function))
(cffi:defcfun ("gsl_vector_long_view_array_with_stride" #.(swig-lispify "gsl_vector_long_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_const_view_array" #.(swig-lispify "gsl_vector_long_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_long_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_long_const_view_array_with_stride" #.(swig-lispify "gsl_vector_long_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_subvector" #.(swig-lispify "gsl_vector_long_subvector" 'function)) #.(swig-lispify "_gsl_vector_long_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_subvector" 'function))
(cffi:defcfun ("gsl_vector_long_subvector_with_stride" #.(swig-lispify "gsl_vector_long_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_const_subvector" #.(swig-lispify "gsl_vector_long_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_long_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_long_const_subvector_with_stride" #.(swig-lispify "gsl_vector_long_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_set_zero" #.(swig-lispify "gsl_vector_long_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_set_zero" 'function))
(cffi:defcfun ("gsl_vector_long_set_all" #.(swig-lispify "gsl_vector_long_set_all" 'function)) :void
(v :pointer)
(x :long))
(cl:export '#.(swig-lispify "gsl_vector_long_set_all" 'function))
(cffi:defcfun ("gsl_vector_long_set_basis" #.(swig-lispify "gsl_vector_long_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_set_basis" 'function))
(cffi:defcfun ("gsl_vector_long_fread" #.(swig-lispify "gsl_vector_long_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_fread" 'function))
(cffi:defcfun ("gsl_vector_long_fwrite" #.(swig-lispify "gsl_vector_long_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_fwrite" 'function))
(cffi:defcfun ("gsl_vector_long_fscanf" #.(swig-lispify "gsl_vector_long_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_fscanf" 'function))
(cffi:defcfun ("gsl_vector_long_fprintf" #.(swig-lispify "gsl_vector_long_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_long_fprintf" 'function))
(cffi:defcfun ("gsl_vector_long_memcpy" #.(swig-lispify "gsl_vector_long_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_memcpy" 'function))
(cffi:defcfun ("gsl_vector_long_reverse" #.(swig-lispify "gsl_vector_long_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_reverse" 'function))
(cffi:defcfun ("gsl_vector_long_swap" #.(swig-lispify "gsl_vector_long_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_swap" 'function))
(cffi:defcfun ("gsl_vector_long_swap_elements" #.(swig-lispify "gsl_vector_long_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_long_max" #.(swig-lispify "gsl_vector_long_max" 'function)) :long
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_max" 'function))
(cffi:defcfun ("gsl_vector_long_min" #.(swig-lispify "gsl_vector_long_min" 'function)) :long
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_min" 'function))
(cffi:defcfun ("gsl_vector_long_minmax" #.(swig-lispify "gsl_vector_long_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_minmax" 'function))
(cffi:defcfun ("gsl_vector_long_max_index" #.(swig-lispify "gsl_vector_long_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_max_index" 'function))
(cffi:defcfun ("gsl_vector_long_min_index" #.(swig-lispify "gsl_vector_long_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_min_index" 'function))
(cffi:defcfun ("gsl_vector_long_minmax_index" #.(swig-lispify "gsl_vector_long_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_long_add" #.(swig-lispify "gsl_vector_long_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_add" 'function))
(cffi:defcfun ("gsl_vector_long_sub" #.(swig-lispify "gsl_vector_long_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_sub" 'function))
(cffi:defcfun ("gsl_vector_long_mul" #.(swig-lispify "gsl_vector_long_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_mul" 'function))
(cffi:defcfun ("gsl_vector_long_div" #.(swig-lispify "gsl_vector_long_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_div" 'function))
(cffi:defcfun ("gsl_vector_long_scale" #.(swig-lispify "gsl_vector_long_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_long_scale" 'function))
(cffi:defcfun ("gsl_vector_long_add_constant" #.(swig-lispify "gsl_vector_long_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_long_add_constant" 'function))
(cffi:defcfun ("gsl_vector_long_equal" #.(swig-lispify "gsl_vector_long_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_equal" 'function))
(cffi:defcfun ("gsl_vector_long_isnull" #.(swig-lispify "gsl_vector_long_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_isnull" 'function))
(cffi:defcfun ("gsl_vector_long_ispos" #.(swig-lispify "gsl_vector_long_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_ispos" 'function))
(cffi:defcfun ("gsl_vector_long_isneg" #.(swig-lispify "gsl_vector_long_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_isneg" 'function))
(cffi:defcfun ("gsl_vector_long_isnonneg" #.(swig-lispify "gsl_vector_long_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_long_get" #.(swig-lispify "gsl_vector_long_get" 'function)) :long
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_get" 'function))
(cffi:defcfun ("gsl_vector_long_set" #.(swig-lispify "gsl_vector_long_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :long))
(cl:export '#.(swig-lispify "gsl_vector_long_set" 'function))
(cffi:defcfun ("gsl_vector_long_ptr" #.(swig-lispify "gsl_vector_long_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_ptr" 'function))
(cffi:defcfun ("gsl_vector_long_const_ptr" #.(swig-lispify "gsl_vector_long_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_long_double" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_long_double" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_long_double_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_long_double_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_long_double_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_long_double" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_long_double_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_long_double_alloc" #.(swig-lispify "gsl_vector_long_double_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_alloc" 'function))
(cffi:defcfun ("gsl_vector_long_double_calloc" #.(swig-lispify "gsl_vector_long_double_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_calloc" 'function))
(cffi:defcfun ("gsl_vector_long_double_alloc_from_block" #.(swig-lispify "gsl_vector_long_double_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_long_double_alloc_from_vector" #.(swig-lispify "gsl_vector_long_double_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_long_double_free" #.(swig-lispify "gsl_vector_long_double_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_free" 'function))
(cffi:defcfun ("gsl_vector_long_double_view_array" #.(swig-lispify "gsl_vector_long_double_view_array" 'function)) #.(swig-lispify "_gsl_vector_long_double_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_view_array" 'function))
(cffi:defcfun ("gsl_vector_long_double_view_array_with_stride" #.(swig-lispify "gsl_vector_long_double_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_double_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_double_const_view_array" #.(swig-lispify "gsl_vector_long_double_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_long_double_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_long_double_const_view_array_with_stride" #.(swig-lispify "gsl_vector_long_double_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_double_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_double_subvector" #.(swig-lispify "gsl_vector_long_double_subvector" 'function)) #.(swig-lispify "_gsl_vector_long_double_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_subvector" 'function))
(cffi:defcfun ("gsl_vector_long_double_subvector_with_stride" #.(swig-lispify "gsl_vector_long_double_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_double_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_double_const_subvector" #.(swig-lispify "gsl_vector_long_double_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_long_double_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_long_double_const_subvector_with_stride" #.(swig-lispify "gsl_vector_long_double_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_long_double_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_long_double_set_zero" #.(swig-lispify "gsl_vector_long_double_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_set_zero" 'function))
(cffi:defcfun ("gsl_vector_long_double_set_all" #.(swig-lispify "gsl_vector_long_double_set_all" 'function)) :void
(v :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_set_all" 'function))
(cffi:defcfun ("gsl_vector_long_double_set_basis" #.(swig-lispify "gsl_vector_long_double_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_set_basis" 'function))
(cffi:defcfun ("gsl_vector_long_double_fread" #.(swig-lispify "gsl_vector_long_double_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_fread" 'function))
(cffi:defcfun ("gsl_vector_long_double_fwrite" #.(swig-lispify "gsl_vector_long_double_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_fwrite" 'function))
(cffi:defcfun ("gsl_vector_long_double_fscanf" #.(swig-lispify "gsl_vector_long_double_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_fscanf" 'function))
(cffi:defcfun ("gsl_vector_long_double_fprintf" #.(swig-lispify "gsl_vector_long_double_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_long_double_fprintf" 'function))
(cffi:defcfun ("gsl_vector_long_double_memcpy" #.(swig-lispify "gsl_vector_long_double_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_memcpy" 'function))
(cffi:defcfun ("gsl_vector_long_double_reverse" #.(swig-lispify "gsl_vector_long_double_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_reverse" 'function))
(cffi:defcfun ("gsl_vector_long_double_swap" #.(swig-lispify "gsl_vector_long_double_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_swap" 'function))
(cffi:defcfun ("gsl_vector_long_double_swap_elements" #.(swig-lispify "gsl_vector_long_double_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_long_double_max" #.(swig-lispify "gsl_vector_long_double_max" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_max" 'function))
(cffi:defcfun ("gsl_vector_long_double_min" #.(swig-lispify "gsl_vector_long_double_min" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_min" 'function))
(cffi:defcfun ("gsl_vector_long_double_minmax" #.(swig-lispify "gsl_vector_long_double_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_minmax" 'function))
(cffi:defcfun ("gsl_vector_long_double_max_index" #.(swig-lispify "gsl_vector_long_double_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_max_index" 'function))
(cffi:defcfun ("gsl_vector_long_double_min_index" #.(swig-lispify "gsl_vector_long_double_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_min_index" 'function))
(cffi:defcfun ("gsl_vector_long_double_minmax_index" #.(swig-lispify "gsl_vector_long_double_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_long_double_add" #.(swig-lispify "gsl_vector_long_double_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_add" 'function))
(cffi:defcfun ("gsl_vector_long_double_sub" #.(swig-lispify "gsl_vector_long_double_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_sub" 'function))
(cffi:defcfun ("gsl_vector_long_double_mul" #.(swig-lispify "gsl_vector_long_double_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_mul" 'function))
(cffi:defcfun ("gsl_vector_long_double_div" #.(swig-lispify "gsl_vector_long_double_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_div" 'function))
(cffi:defcfun ("gsl_vector_long_double_scale" #.(swig-lispify "gsl_vector_long_double_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_long_double_scale" 'function))
(cffi:defcfun ("gsl_vector_long_double_add_constant" #.(swig-lispify "gsl_vector_long_double_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_long_double_add_constant" 'function))
(cffi:defcfun ("gsl_vector_long_double_equal" #.(swig-lispify "gsl_vector_long_double_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_equal" 'function))
(cffi:defcfun ("gsl_vector_long_double_isnull" #.(swig-lispify "gsl_vector_long_double_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_isnull" 'function))
(cffi:defcfun ("gsl_vector_long_double_ispos" #.(swig-lispify "gsl_vector_long_double_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_ispos" 'function))
(cffi:defcfun ("gsl_vector_long_double_isneg" #.(swig-lispify "gsl_vector_long_double_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_isneg" 'function))
(cffi:defcfun ("gsl_vector_long_double_isnonneg" #.(swig-lispify "gsl_vector_long_double_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_long_double_get" #.(swig-lispify "gsl_vector_long_double_get" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_get" 'function))
(cffi:defcfun ("gsl_vector_long_double_set" #.(swig-lispify "gsl_vector_long_double_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_set" 'function))
(cffi:defcfun ("gsl_vector_long_double_ptr" #.(swig-lispify "gsl_vector_long_double_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_ptr" 'function))
(cffi:defcfun ("gsl_vector_long_double_const_ptr" #.(swig-lispify "gsl_vector_long_double_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_long_double_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_short" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_short" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_short_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_short" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_short_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_short_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_short" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_short_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_short_alloc" #.(swig-lispify "gsl_vector_short_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_alloc" 'function))
(cffi:defcfun ("gsl_vector_short_calloc" #.(swig-lispify "gsl_vector_short_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_calloc" 'function))
(cffi:defcfun ("gsl_vector_short_alloc_from_block" #.(swig-lispify "gsl_vector_short_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_short_alloc_from_vector" #.(swig-lispify "gsl_vector_short_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_short_free" #.(swig-lispify "gsl_vector_short_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_free" 'function))
(cffi:defcfun ("gsl_vector_short_view_array" #.(swig-lispify "gsl_vector_short_view_array" 'function)) #.(swig-lispify "_gsl_vector_short_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_view_array" 'function))
(cffi:defcfun ("gsl_vector_short_view_array_with_stride" #.(swig-lispify "gsl_vector_short_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_short_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_short_const_view_array" #.(swig-lispify "gsl_vector_short_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_short_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_short_const_view_array_with_stride" #.(swig-lispify "gsl_vector_short_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_short_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_short_subvector" #.(swig-lispify "gsl_vector_short_subvector" 'function)) #.(swig-lispify "_gsl_vector_short_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_subvector" 'function))
(cffi:defcfun ("gsl_vector_short_subvector_with_stride" #.(swig-lispify "gsl_vector_short_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_short_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_short_const_subvector" #.(swig-lispify "gsl_vector_short_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_short_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_short_const_subvector_with_stride" #.(swig-lispify "gsl_vector_short_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_short_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_short_set_zero" #.(swig-lispify "gsl_vector_short_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_set_zero" 'function))
(cffi:defcfun ("gsl_vector_short_set_all" #.(swig-lispify "gsl_vector_short_set_all" 'function)) :void
(v :pointer)
(x :short))
(cl:export '#.(swig-lispify "gsl_vector_short_set_all" 'function))
(cffi:defcfun ("gsl_vector_short_set_basis" #.(swig-lispify "gsl_vector_short_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_set_basis" 'function))
(cffi:defcfun ("gsl_vector_short_fread" #.(swig-lispify "gsl_vector_short_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_fread" 'function))
(cffi:defcfun ("gsl_vector_short_fwrite" #.(swig-lispify "gsl_vector_short_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_fwrite" 'function))
(cffi:defcfun ("gsl_vector_short_fscanf" #.(swig-lispify "gsl_vector_short_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_fscanf" 'function))
(cffi:defcfun ("gsl_vector_short_fprintf" #.(swig-lispify "gsl_vector_short_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_short_fprintf" 'function))
(cffi:defcfun ("gsl_vector_short_memcpy" #.(swig-lispify "gsl_vector_short_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_memcpy" 'function))
(cffi:defcfun ("gsl_vector_short_reverse" #.(swig-lispify "gsl_vector_short_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_reverse" 'function))
(cffi:defcfun ("gsl_vector_short_swap" #.(swig-lispify "gsl_vector_short_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_swap" 'function))
(cffi:defcfun ("gsl_vector_short_swap_elements" #.(swig-lispify "gsl_vector_short_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_short_max" #.(swig-lispify "gsl_vector_short_max" 'function)) :short
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_max" 'function))
(cffi:defcfun ("gsl_vector_short_min" #.(swig-lispify "gsl_vector_short_min" 'function)) :short
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_min" 'function))
(cffi:defcfun ("gsl_vector_short_minmax" #.(swig-lispify "gsl_vector_short_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_minmax" 'function))
(cffi:defcfun ("gsl_vector_short_max_index" #.(swig-lispify "gsl_vector_short_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_max_index" 'function))
(cffi:defcfun ("gsl_vector_short_min_index" #.(swig-lispify "gsl_vector_short_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_min_index" 'function))
(cffi:defcfun ("gsl_vector_short_minmax_index" #.(swig-lispify "gsl_vector_short_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_short_add" #.(swig-lispify "gsl_vector_short_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_add" 'function))
(cffi:defcfun ("gsl_vector_short_sub" #.(swig-lispify "gsl_vector_short_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_sub" 'function))
(cffi:defcfun ("gsl_vector_short_mul" #.(swig-lispify "gsl_vector_short_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_mul" 'function))
(cffi:defcfun ("gsl_vector_short_div" #.(swig-lispify "gsl_vector_short_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_div" 'function))
(cffi:defcfun ("gsl_vector_short_scale" #.(swig-lispify "gsl_vector_short_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_short_scale" 'function))
(cffi:defcfun ("gsl_vector_short_add_constant" #.(swig-lispify "gsl_vector_short_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_short_add_constant" 'function))
(cffi:defcfun ("gsl_vector_short_equal" #.(swig-lispify "gsl_vector_short_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_equal" 'function))
(cffi:defcfun ("gsl_vector_short_isnull" #.(swig-lispify "gsl_vector_short_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_isnull" 'function))
(cffi:defcfun ("gsl_vector_short_ispos" #.(swig-lispify "gsl_vector_short_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_ispos" 'function))
(cffi:defcfun ("gsl_vector_short_isneg" #.(swig-lispify "gsl_vector_short_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_isneg" 'function))
(cffi:defcfun ("gsl_vector_short_isnonneg" #.(swig-lispify "gsl_vector_short_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_short_get" #.(swig-lispify "gsl_vector_short_get" 'function)) :short
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_get" 'function))
(cffi:defcfun ("gsl_vector_short_set" #.(swig-lispify "gsl_vector_short_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :short))
(cl:export '#.(swig-lispify "gsl_vector_short_set" 'function))
(cffi:defcfun ("gsl_vector_short_ptr" #.(swig-lispify "gsl_vector_short_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_ptr" 'function))
(cffi:defcfun ("gsl_vector_short_const_ptr" #.(swig-lispify "gsl_vector_short_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_short_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_uchar" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_uchar" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_uchar_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_uchar" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_uchar_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_uchar_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_uchar" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_uchar_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_uchar_alloc" #.(swig-lispify "gsl_vector_uchar_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_alloc" 'function))
(cffi:defcfun ("gsl_vector_uchar_calloc" #.(swig-lispify "gsl_vector_uchar_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_calloc" 'function))
(cffi:defcfun ("gsl_vector_uchar_alloc_from_block" #.(swig-lispify "gsl_vector_uchar_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_uchar_alloc_from_vector" #.(swig-lispify "gsl_vector_uchar_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_uchar_free" #.(swig-lispify "gsl_vector_uchar_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_free" 'function))
(cffi:defcfun ("gsl_vector_uchar_view_array" #.(swig-lispify "gsl_vector_uchar_view_array" 'function)) #.(swig-lispify "_gsl_vector_uchar_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_view_array" 'function))
(cffi:defcfun ("gsl_vector_uchar_view_array_with_stride" #.(swig-lispify "gsl_vector_uchar_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uchar_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uchar_const_view_array" #.(swig-lispify "gsl_vector_uchar_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_uchar_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_uchar_const_view_array_with_stride" #.(swig-lispify "gsl_vector_uchar_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uchar_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uchar_subvector" #.(swig-lispify "gsl_vector_uchar_subvector" 'function)) #.(swig-lispify "_gsl_vector_uchar_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_subvector" 'function))
(cffi:defcfun ("gsl_vector_uchar_subvector_with_stride" #.(swig-lispify "gsl_vector_uchar_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uchar_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uchar_const_subvector" #.(swig-lispify "gsl_vector_uchar_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_uchar_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_uchar_const_subvector_with_stride" #.(swig-lispify "gsl_vector_uchar_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uchar_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uchar_set_zero" #.(swig-lispify "gsl_vector_uchar_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_set_zero" 'function))
(cffi:defcfun ("gsl_vector_uchar_set_all" #.(swig-lispify "gsl_vector_uchar_set_all" 'function)) :void
(v :pointer)
(x :unsigned-char))
(cl:export '#.(swig-lispify "gsl_vector_uchar_set_all" 'function))
(cffi:defcfun ("gsl_vector_uchar_set_basis" #.(swig-lispify "gsl_vector_uchar_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_set_basis" 'function))
(cffi:defcfun ("gsl_vector_uchar_fread" #.(swig-lispify "gsl_vector_uchar_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_fread" 'function))
(cffi:defcfun ("gsl_vector_uchar_fwrite" #.(swig-lispify "gsl_vector_uchar_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_fwrite" 'function))
(cffi:defcfun ("gsl_vector_uchar_fscanf" #.(swig-lispify "gsl_vector_uchar_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_fscanf" 'function))
(cffi:defcfun ("gsl_vector_uchar_fprintf" #.(swig-lispify "gsl_vector_uchar_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_uchar_fprintf" 'function))
(cffi:defcfun ("gsl_vector_uchar_memcpy" #.(swig-lispify "gsl_vector_uchar_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_memcpy" 'function))
(cffi:defcfun ("gsl_vector_uchar_reverse" #.(swig-lispify "gsl_vector_uchar_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_reverse" 'function))
(cffi:defcfun ("gsl_vector_uchar_swap" #.(swig-lispify "gsl_vector_uchar_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_swap" 'function))
(cffi:defcfun ("gsl_vector_uchar_swap_elements" #.(swig-lispify "gsl_vector_uchar_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_uchar_max" #.(swig-lispify "gsl_vector_uchar_max" 'function)) :unsigned-char
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_max" 'function))
(cffi:defcfun ("gsl_vector_uchar_min" #.(swig-lispify "gsl_vector_uchar_min" 'function)) :unsigned-char
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_min" 'function))
(cffi:defcfun ("gsl_vector_uchar_minmax" #.(swig-lispify "gsl_vector_uchar_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_minmax" 'function))
(cffi:defcfun ("gsl_vector_uchar_max_index" #.(swig-lispify "gsl_vector_uchar_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_max_index" 'function))
(cffi:defcfun ("gsl_vector_uchar_min_index" #.(swig-lispify "gsl_vector_uchar_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_min_index" 'function))
(cffi:defcfun ("gsl_vector_uchar_minmax_index" #.(swig-lispify "gsl_vector_uchar_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_uchar_add" #.(swig-lispify "gsl_vector_uchar_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_add" 'function))
(cffi:defcfun ("gsl_vector_uchar_sub" #.(swig-lispify "gsl_vector_uchar_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_sub" 'function))
(cffi:defcfun ("gsl_vector_uchar_mul" #.(swig-lispify "gsl_vector_uchar_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_mul" 'function))
(cffi:defcfun ("gsl_vector_uchar_div" #.(swig-lispify "gsl_vector_uchar_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_div" 'function))
(cffi:defcfun ("gsl_vector_uchar_scale" #.(swig-lispify "gsl_vector_uchar_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_uchar_scale" 'function))
(cffi:defcfun ("gsl_vector_uchar_add_constant" #.(swig-lispify "gsl_vector_uchar_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_uchar_add_constant" 'function))
(cffi:defcfun ("gsl_vector_uchar_equal" #.(swig-lispify "gsl_vector_uchar_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_equal" 'function))
(cffi:defcfun ("gsl_vector_uchar_isnull" #.(swig-lispify "gsl_vector_uchar_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_isnull" 'function))
(cffi:defcfun ("gsl_vector_uchar_ispos" #.(swig-lispify "gsl_vector_uchar_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_ispos" 'function))
(cffi:defcfun ("gsl_vector_uchar_isneg" #.(swig-lispify "gsl_vector_uchar_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_isneg" 'function))
(cffi:defcfun ("gsl_vector_uchar_isnonneg" #.(swig-lispify "gsl_vector_uchar_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_uchar_get" #.(swig-lispify "gsl_vector_uchar_get" 'function)) :unsigned-char
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_get" 'function))
(cffi:defcfun ("gsl_vector_uchar_set" #.(swig-lispify "gsl_vector_uchar_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :unsigned-char))
(cl:export '#.(swig-lispify "gsl_vector_uchar_set" 'function))
(cffi:defcfun ("gsl_vector_uchar_ptr" #.(swig-lispify "gsl_vector_uchar_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_ptr" 'function))
(cffi:defcfun ("gsl_vector_uchar_const_ptr" #.(swig-lispify "gsl_vector_uchar_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uchar_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_uint" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_uint" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_uint_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_uint" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_uint_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_uint_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_uint" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_uint_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_uint_alloc" #.(swig-lispify "gsl_vector_uint_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_alloc" 'function))
(cffi:defcfun ("gsl_vector_uint_calloc" #.(swig-lispify "gsl_vector_uint_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_calloc" 'function))
(cffi:defcfun ("gsl_vector_uint_alloc_from_block" #.(swig-lispify "gsl_vector_uint_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_uint_alloc_from_vector" #.(swig-lispify "gsl_vector_uint_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_uint_free" #.(swig-lispify "gsl_vector_uint_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_free" 'function))
(cffi:defcfun ("gsl_vector_uint_view_array" #.(swig-lispify "gsl_vector_uint_view_array" 'function)) #.(swig-lispify "_gsl_vector_uint_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_view_array" 'function))
(cffi:defcfun ("gsl_vector_uint_view_array_with_stride" #.(swig-lispify "gsl_vector_uint_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uint_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uint_const_view_array" #.(swig-lispify "gsl_vector_uint_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_uint_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_uint_const_view_array_with_stride" #.(swig-lispify "gsl_vector_uint_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uint_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uint_subvector" #.(swig-lispify "gsl_vector_uint_subvector" 'function)) #.(swig-lispify "_gsl_vector_uint_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_subvector" 'function))
(cffi:defcfun ("gsl_vector_uint_subvector_with_stride" #.(swig-lispify "gsl_vector_uint_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uint_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uint_const_subvector" #.(swig-lispify "gsl_vector_uint_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_uint_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_uint_const_subvector_with_stride" #.(swig-lispify "gsl_vector_uint_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_uint_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_uint_set_zero" #.(swig-lispify "gsl_vector_uint_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_set_zero" 'function))
(cffi:defcfun ("gsl_vector_uint_set_all" #.(swig-lispify "gsl_vector_uint_set_all" 'function)) :void
(v :pointer)
(x :unsigned-int))
(cl:export '#.(swig-lispify "gsl_vector_uint_set_all" 'function))
(cffi:defcfun ("gsl_vector_uint_set_basis" #.(swig-lispify "gsl_vector_uint_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_set_basis" 'function))
(cffi:defcfun ("gsl_vector_uint_fread" #.(swig-lispify "gsl_vector_uint_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_fread" 'function))
(cffi:defcfun ("gsl_vector_uint_fwrite" #.(swig-lispify "gsl_vector_uint_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_fwrite" 'function))
(cffi:defcfun ("gsl_vector_uint_fscanf" #.(swig-lispify "gsl_vector_uint_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_fscanf" 'function))
(cffi:defcfun ("gsl_vector_uint_fprintf" #.(swig-lispify "gsl_vector_uint_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_uint_fprintf" 'function))
(cffi:defcfun ("gsl_vector_uint_memcpy" #.(swig-lispify "gsl_vector_uint_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_memcpy" 'function))
(cffi:defcfun ("gsl_vector_uint_reverse" #.(swig-lispify "gsl_vector_uint_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_reverse" 'function))
(cffi:defcfun ("gsl_vector_uint_swap" #.(swig-lispify "gsl_vector_uint_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_swap" 'function))
(cffi:defcfun ("gsl_vector_uint_swap_elements" #.(swig-lispify "gsl_vector_uint_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_uint_max" #.(swig-lispify "gsl_vector_uint_max" 'function)) :unsigned-int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_max" 'function))
(cffi:defcfun ("gsl_vector_uint_min" #.(swig-lispify "gsl_vector_uint_min" 'function)) :unsigned-int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_min" 'function))
(cffi:defcfun ("gsl_vector_uint_minmax" #.(swig-lispify "gsl_vector_uint_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_minmax" 'function))
(cffi:defcfun ("gsl_vector_uint_max_index" #.(swig-lispify "gsl_vector_uint_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_max_index" 'function))
(cffi:defcfun ("gsl_vector_uint_min_index" #.(swig-lispify "gsl_vector_uint_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_min_index" 'function))
(cffi:defcfun ("gsl_vector_uint_minmax_index" #.(swig-lispify "gsl_vector_uint_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_uint_add" #.(swig-lispify "gsl_vector_uint_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_add" 'function))
(cffi:defcfun ("gsl_vector_uint_sub" #.(swig-lispify "gsl_vector_uint_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_sub" 'function))
(cffi:defcfun ("gsl_vector_uint_mul" #.(swig-lispify "gsl_vector_uint_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_mul" 'function))
(cffi:defcfun ("gsl_vector_uint_div" #.(swig-lispify "gsl_vector_uint_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_div" 'function))
(cffi:defcfun ("gsl_vector_uint_scale" #.(swig-lispify "gsl_vector_uint_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_uint_scale" 'function))
(cffi:defcfun ("gsl_vector_uint_add_constant" #.(swig-lispify "gsl_vector_uint_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_uint_add_constant" 'function))
(cffi:defcfun ("gsl_vector_uint_equal" #.(swig-lispify "gsl_vector_uint_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_equal" 'function))
(cffi:defcfun ("gsl_vector_uint_isnull" #.(swig-lispify "gsl_vector_uint_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_isnull" 'function))
(cffi:defcfun ("gsl_vector_uint_ispos" #.(swig-lispify "gsl_vector_uint_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_ispos" 'function))
(cffi:defcfun ("gsl_vector_uint_isneg" #.(swig-lispify "gsl_vector_uint_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_isneg" 'function))
(cffi:defcfun ("gsl_vector_uint_isnonneg" #.(swig-lispify "gsl_vector_uint_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_uint_get" #.(swig-lispify "gsl_vector_uint_get" 'function)) :unsigned-int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_get" 'function))
(cffi:defcfun ("gsl_vector_uint_set" #.(swig-lispify "gsl_vector_uint_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :unsigned-int))
(cl:export '#.(swig-lispify "gsl_vector_uint_set" 'function))
(cffi:defcfun ("gsl_vector_uint_ptr" #.(swig-lispify "gsl_vector_uint_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_ptr" 'function))
(cffi:defcfun ("gsl_vector_uint_const_ptr" #.(swig-lispify "gsl_vector_uint_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_uint_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_ulong" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_ulong" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_ulong_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_ulong" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_ulong_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_ulong_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_ulong" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_ulong_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_ulong_alloc" #.(swig-lispify "gsl_vector_ulong_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_alloc" 'function))
(cffi:defcfun ("gsl_vector_ulong_calloc" #.(swig-lispify "gsl_vector_ulong_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_calloc" 'function))
(cffi:defcfun ("gsl_vector_ulong_alloc_from_block" #.(swig-lispify "gsl_vector_ulong_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_ulong_alloc_from_vector" #.(swig-lispify "gsl_vector_ulong_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_ulong_free" #.(swig-lispify "gsl_vector_ulong_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_free" 'function))
(cffi:defcfun ("gsl_vector_ulong_view_array" #.(swig-lispify "gsl_vector_ulong_view_array" 'function)) #.(swig-lispify "_gsl_vector_ulong_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_view_array" 'function))
(cffi:defcfun ("gsl_vector_ulong_view_array_with_stride" #.(swig-lispify "gsl_vector_ulong_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ulong_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ulong_const_view_array" #.(swig-lispify "gsl_vector_ulong_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_ulong_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_ulong_const_view_array_with_stride" #.(swig-lispify "gsl_vector_ulong_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ulong_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ulong_subvector" #.(swig-lispify "gsl_vector_ulong_subvector" 'function)) #.(swig-lispify "_gsl_vector_ulong_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_subvector" 'function))
(cffi:defcfun ("gsl_vector_ulong_subvector_with_stride" #.(swig-lispify "gsl_vector_ulong_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ulong_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ulong_const_subvector" #.(swig-lispify "gsl_vector_ulong_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_ulong_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_ulong_const_subvector_with_stride" #.(swig-lispify "gsl_vector_ulong_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ulong_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ulong_set_zero" #.(swig-lispify "gsl_vector_ulong_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_set_zero" 'function))
(cffi:defcfun ("gsl_vector_ulong_set_all" #.(swig-lispify "gsl_vector_ulong_set_all" 'function)) :void
(v :pointer)
(x :unsigned-long))
(cl:export '#.(swig-lispify "gsl_vector_ulong_set_all" 'function))
(cffi:defcfun ("gsl_vector_ulong_set_basis" #.(swig-lispify "gsl_vector_ulong_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_set_basis" 'function))
(cffi:defcfun ("gsl_vector_ulong_fread" #.(swig-lispify "gsl_vector_ulong_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_fread" 'function))
(cffi:defcfun ("gsl_vector_ulong_fwrite" #.(swig-lispify "gsl_vector_ulong_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_fwrite" 'function))
(cffi:defcfun ("gsl_vector_ulong_fscanf" #.(swig-lispify "gsl_vector_ulong_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_fscanf" 'function))
(cffi:defcfun ("gsl_vector_ulong_fprintf" #.(swig-lispify "gsl_vector_ulong_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_ulong_fprintf" 'function))
(cffi:defcfun ("gsl_vector_ulong_memcpy" #.(swig-lispify "gsl_vector_ulong_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_memcpy" 'function))
(cffi:defcfun ("gsl_vector_ulong_reverse" #.(swig-lispify "gsl_vector_ulong_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_reverse" 'function))
(cffi:defcfun ("gsl_vector_ulong_swap" #.(swig-lispify "gsl_vector_ulong_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_swap" 'function))
(cffi:defcfun ("gsl_vector_ulong_swap_elements" #.(swig-lispify "gsl_vector_ulong_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_ulong_max" #.(swig-lispify "gsl_vector_ulong_max" 'function)) :unsigned-long
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_max" 'function))
(cffi:defcfun ("gsl_vector_ulong_min" #.(swig-lispify "gsl_vector_ulong_min" 'function)) :unsigned-long
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_min" 'function))
(cffi:defcfun ("gsl_vector_ulong_minmax" #.(swig-lispify "gsl_vector_ulong_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_minmax" 'function))
(cffi:defcfun ("gsl_vector_ulong_max_index" #.(swig-lispify "gsl_vector_ulong_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_max_index" 'function))
(cffi:defcfun ("gsl_vector_ulong_min_index" #.(swig-lispify "gsl_vector_ulong_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_min_index" 'function))
(cffi:defcfun ("gsl_vector_ulong_minmax_index" #.(swig-lispify "gsl_vector_ulong_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_ulong_add" #.(swig-lispify "gsl_vector_ulong_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_add" 'function))
(cffi:defcfun ("gsl_vector_ulong_sub" #.(swig-lispify "gsl_vector_ulong_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_sub" 'function))
(cffi:defcfun ("gsl_vector_ulong_mul" #.(swig-lispify "gsl_vector_ulong_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_mul" 'function))
(cffi:defcfun ("gsl_vector_ulong_div" #.(swig-lispify "gsl_vector_ulong_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_div" 'function))
(cffi:defcfun ("gsl_vector_ulong_scale" #.(swig-lispify "gsl_vector_ulong_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_ulong_scale" 'function))
(cffi:defcfun ("gsl_vector_ulong_add_constant" #.(swig-lispify "gsl_vector_ulong_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_ulong_add_constant" 'function))
(cffi:defcfun ("gsl_vector_ulong_equal" #.(swig-lispify "gsl_vector_ulong_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_equal" 'function))
(cffi:defcfun ("gsl_vector_ulong_isnull" #.(swig-lispify "gsl_vector_ulong_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_isnull" 'function))
(cffi:defcfun ("gsl_vector_ulong_ispos" #.(swig-lispify "gsl_vector_ulong_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_ispos" 'function))
(cffi:defcfun ("gsl_vector_ulong_isneg" #.(swig-lispify "gsl_vector_ulong_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_isneg" 'function))
(cffi:defcfun ("gsl_vector_ulong_isnonneg" #.(swig-lispify "gsl_vector_ulong_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_ulong_get" #.(swig-lispify "gsl_vector_ulong_get" 'function)) :unsigned-long
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_get" 'function))
(cffi:defcfun ("gsl_vector_ulong_set" #.(swig-lispify "gsl_vector_ulong_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :unsigned-long))
(cl:export '#.(swig-lispify "gsl_vector_ulong_set" 'function))
(cffi:defcfun ("gsl_vector_ulong_ptr" #.(swig-lispify "gsl_vector_ulong_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_ptr" 'function))
(cffi:defcfun ("gsl_vector_ulong_const_ptr" #.(swig-lispify "gsl_vector_ulong_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ulong_const_ptr" 'function))
(cffi:defcstruct #.(swig-lispify "gsl_vector_ushort" 'classname)
(#.(swig-lispify "size" 'slotname) :pointer)
(#.(swig-lispify "stride" 'slotname) :pointer)
(#.(swig-lispify "data" 'slotname) :pointer)
(#.(swig-lispify "block" 'slotname) :pointer)
(#.(swig-lispify "owner" 'slotname) :int))
(cl:export '#.(swig-lispify "gsl_vector_ushort" 'classname))
(cl:export '#.(swig-lispify "size" 'slotname))
(cl:export '#.(swig-lispify "stride" 'slotname))
(cl:export '#.(swig-lispify "data" 'slotname))
(cl:export '#.(swig-lispify "block" 'slotname))
(cl:export '#.(swig-lispify "owner" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_ushort_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_ushort" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_ushort_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcstruct #.(swig-lispify "_gsl_vector_ushort_const_view" 'classname)
(#.(swig-lispify "vector" 'slotname) #.(swig-lispify "gsl_vector_ushort" 'classname)))
(cl:export '#.(swig-lispify "_gsl_vector_ushort_const_view" 'classname))
(cl:export '#.(swig-lispify "vector" 'slotname))
(cffi:defcfun ("gsl_vector_ushort_alloc" #.(swig-lispify "gsl_vector_ushort_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_alloc" 'function))
(cffi:defcfun ("gsl_vector_ushort_calloc" #.(swig-lispify "gsl_vector_ushort_calloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_calloc" 'function))
(cffi:defcfun ("gsl_vector_ushort_alloc_from_block" #.(swig-lispify "gsl_vector_ushort_alloc_from_block" 'function)) :pointer
(b :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_alloc_from_block" 'function))
(cffi:defcfun ("gsl_vector_ushort_alloc_from_vector" #.(swig-lispify "gsl_vector_ushort_alloc_from_vector" 'function)) :pointer
(v :pointer)
(offset :pointer)
(n :pointer)
(stride :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_alloc_from_vector" 'function))
(cffi:defcfun ("gsl_vector_ushort_free" #.(swig-lispify "gsl_vector_ushort_free" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_free" 'function))
(cffi:defcfun ("gsl_vector_ushort_view_array" #.(swig-lispify "gsl_vector_ushort_view_array" 'function)) #.(swig-lispify "_gsl_vector_ushort_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_view_array" 'function))
(cffi:defcfun ("gsl_vector_ushort_view_array_with_stride" #.(swig-lispify "gsl_vector_ushort_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ushort_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ushort_const_view_array" #.(swig-lispify "gsl_vector_ushort_const_view_array" 'function)) #.(swig-lispify "_gsl_vector_ushort_const_view" 'classname)
(v :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_const_view_array" 'function))
(cffi:defcfun ("gsl_vector_ushort_const_view_array_with_stride" #.(swig-lispify "gsl_vector_ushort_const_view_array_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ushort_const_view" 'classname)
(base :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_const_view_array_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ushort_subvector" #.(swig-lispify "gsl_vector_ushort_subvector" 'function)) #.(swig-lispify "_gsl_vector_ushort_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_subvector" 'function))
(cffi:defcfun ("gsl_vector_ushort_subvector_with_stride" #.(swig-lispify "gsl_vector_ushort_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ushort_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ushort_const_subvector" #.(swig-lispify "gsl_vector_ushort_const_subvector" 'function)) #.(swig-lispify "_gsl_vector_ushort_const_view" 'classname)
(v :pointer)
(i :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_const_subvector" 'function))
(cffi:defcfun ("gsl_vector_ushort_const_subvector_with_stride" #.(swig-lispify "gsl_vector_ushort_const_subvector_with_stride" 'function)) #.(swig-lispify "_gsl_vector_ushort_const_view" 'classname)
(v :pointer)
(i :pointer)
(stride :pointer)
(n :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_const_subvector_with_stride" 'function))
(cffi:defcfun ("gsl_vector_ushort_set_zero" #.(swig-lispify "gsl_vector_ushort_set_zero" 'function)) :void
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_set_zero" 'function))
(cffi:defcfun ("gsl_vector_ushort_set_all" #.(swig-lispify "gsl_vector_ushort_set_all" 'function)) :void
(v :pointer)
(x :unsigned-short))
(cl:export '#.(swig-lispify "gsl_vector_ushort_set_all" 'function))
(cffi:defcfun ("gsl_vector_ushort_set_basis" #.(swig-lispify "gsl_vector_ushort_set_basis" 'function)) :int
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_set_basis" 'function))
(cffi:defcfun ("gsl_vector_ushort_fread" #.(swig-lispify "gsl_vector_ushort_fread" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_fread" 'function))
(cffi:defcfun ("gsl_vector_ushort_fwrite" #.(swig-lispify "gsl_vector_ushort_fwrite" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_fwrite" 'function))
(cffi:defcfun ("gsl_vector_ushort_fscanf" #.(swig-lispify "gsl_vector_ushort_fscanf" 'function)) :int
(stream :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_fscanf" 'function))
(cffi:defcfun ("gsl_vector_ushort_fprintf" #.(swig-lispify "gsl_vector_ushort_fprintf" 'function)) :int
(stream :pointer)
(v :pointer)
(format :string))
(cl:export '#.(swig-lispify "gsl_vector_ushort_fprintf" 'function))
(cffi:defcfun ("gsl_vector_ushort_memcpy" #.(swig-lispify "gsl_vector_ushort_memcpy" 'function)) :int
(dest :pointer)
(src :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_memcpy" 'function))
(cffi:defcfun ("gsl_vector_ushort_reverse" #.(swig-lispify "gsl_vector_ushort_reverse" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_reverse" 'function))
(cffi:defcfun ("gsl_vector_ushort_swap" #.(swig-lispify "gsl_vector_ushort_swap" 'function)) :int
(v :pointer)
(w :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_swap" 'function))
(cffi:defcfun ("gsl_vector_ushort_swap_elements" #.(swig-lispify "gsl_vector_ushort_swap_elements" 'function)) :int
(v :pointer)
(i :pointer)
(j :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_swap_elements" 'function))
(cffi:defcfun ("gsl_vector_ushort_max" #.(swig-lispify "gsl_vector_ushort_max" 'function)) :unsigned-short
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_max" 'function))
(cffi:defcfun ("gsl_vector_ushort_min" #.(swig-lispify "gsl_vector_ushort_min" 'function)) :unsigned-short
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_min" 'function))
(cffi:defcfun ("gsl_vector_ushort_minmax" #.(swig-lispify "gsl_vector_ushort_minmax" 'function)) :void
(v :pointer)
(min_out :pointer)
(max_out :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_minmax" 'function))
(cffi:defcfun ("gsl_vector_ushort_max_index" #.(swig-lispify "gsl_vector_ushort_max_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_max_index" 'function))
(cffi:defcfun ("gsl_vector_ushort_min_index" #.(swig-lispify "gsl_vector_ushort_min_index" 'function)) :pointer
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_min_index" 'function))
(cffi:defcfun ("gsl_vector_ushort_minmax_index" #.(swig-lispify "gsl_vector_ushort_minmax_index" 'function)) :void
(v :pointer)
(imin :pointer)
(imax :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_minmax_index" 'function))
(cffi:defcfun ("gsl_vector_ushort_add" #.(swig-lispify "gsl_vector_ushort_add" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_add" 'function))
(cffi:defcfun ("gsl_vector_ushort_sub" #.(swig-lispify "gsl_vector_ushort_sub" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_sub" 'function))
(cffi:defcfun ("gsl_vector_ushort_mul" #.(swig-lispify "gsl_vector_ushort_mul" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_mul" 'function))
(cffi:defcfun ("gsl_vector_ushort_div" #.(swig-lispify "gsl_vector_ushort_div" 'function)) :int
(a :pointer)
(b :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_div" 'function))
(cffi:defcfun ("gsl_vector_ushort_scale" #.(swig-lispify "gsl_vector_ushort_scale" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_ushort_scale" 'function))
(cffi:defcfun ("gsl_vector_ushort_add_constant" #.(swig-lispify "gsl_vector_ushort_add_constant" 'function)) :int
(a :pointer)
(x :double))
(cl:export '#.(swig-lispify "gsl_vector_ushort_add_constant" 'function))
(cffi:defcfun ("gsl_vector_ushort_equal" #.(swig-lispify "gsl_vector_ushort_equal" 'function)) :int
(u :pointer)
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_equal" 'function))
(cffi:defcfun ("gsl_vector_ushort_isnull" #.(swig-lispify "gsl_vector_ushort_isnull" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_isnull" 'function))
(cffi:defcfun ("gsl_vector_ushort_ispos" #.(swig-lispify "gsl_vector_ushort_ispos" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_ispos" 'function))
(cffi:defcfun ("gsl_vector_ushort_isneg" #.(swig-lispify "gsl_vector_ushort_isneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_isneg" 'function))
(cffi:defcfun ("gsl_vector_ushort_isnonneg" #.(swig-lispify "gsl_vector_ushort_isnonneg" 'function)) :int
(v :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_isnonneg" 'function))
(cffi:defcfun ("gsl_vector_ushort_get" #.(swig-lispify "gsl_vector_ushort_get" 'function)) :unsigned-short
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_get" 'function))
(cffi:defcfun ("gsl_vector_ushort_set" #.(swig-lispify "gsl_vector_ushort_set" 'function)) :void
(v :pointer)
(i :pointer)
(x :unsigned-short))
(cl:export '#.(swig-lispify "gsl_vector_ushort_set" 'function))
(cffi:defcfun ("gsl_vector_ushort_ptr" #.(swig-lispify "gsl_vector_ushort_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_ptr" 'function))
(cffi:defcfun ("gsl_vector_ushort_const_ptr" #.(swig-lispify "gsl_vector_ushort_const_ptr" 'function)) :pointer
(v :pointer)
(i :pointer))
(cl:export '#.(swig-lispify "gsl_vector_ushort_const_ptr" 'function))
(cffi:defcenum #.(swig-lispify "gsl_wavelet_direction" 'enumname)
(#.(swig-lispify "gsl_wavelet_forward" 'enumvalue :keyword) #.1)
(#.(swig-lispify "gsl_wavelet_backward" 'enumvalue :keyword) #.-1))
(cl:export '#.(swig-lispify "gsl_wavelet_direction" 'enumname))
(cffi:defcstruct #.(swig-lispify "gsl_wavelet_type" 'classname)
(#.(swig-lispify "name" 'slotname) :string)
(#.(swig-lispify "init" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_type" 'classname))
(cl:export '#.(swig-lispify "name" 'slotname))
(cl:export '#.(swig-lispify "init" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_wavelet" 'classname)
(#.(swig-lispify "type" 'slotname) :pointer)
(#.(swig-lispify "h1" 'slotname) :pointer)
(#.(swig-lispify "g1" 'slotname) :pointer)
(#.(swig-lispify "h2" 'slotname) :pointer)
(#.(swig-lispify "g2" 'slotname) :pointer)
(#.(swig-lispify "nc" 'slotname) :pointer)
(#.(swig-lispify "offset" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet" 'classname))
(cl:export '#.(swig-lispify "type" 'slotname))
(cl:export '#.(swig-lispify "h1" 'slotname))
(cl:export '#.(swig-lispify "g1" 'slotname))
(cl:export '#.(swig-lispify "h2" 'slotname))
(cl:export '#.(swig-lispify "g2" 'slotname))
(cl:export '#.(swig-lispify "nc" 'slotname))
(cl:export '#.(swig-lispify "offset" 'slotname))
(cffi:defcstruct #.(swig-lispify "gsl_wavelet_workspace" 'classname)
(#.(swig-lispify "scratch" 'slotname) :pointer)
(#.(swig-lispify "n" 'slotname) :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_workspace" 'classname))
(cl:export '#.(swig-lispify "scratch" 'slotname))
(cl:export '#.(swig-lispify "n" 'slotname))
(cffi:defcvar ("gsl_wavelet_daubechies" #.(swig-lispify "gsl_wavelet_daubechies" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_daubechies" 'variable))
(cffi:defcvar ("gsl_wavelet_daubechies_centered" #.(swig-lispify "gsl_wavelet_daubechies_centered" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_daubechies_centered" 'variable))
(cffi:defcvar ("gsl_wavelet_haar" #.(swig-lispify "gsl_wavelet_haar" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_haar" 'variable))
(cffi:defcvar ("gsl_wavelet_haar_centered" #.(swig-lispify "gsl_wavelet_haar_centered" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_haar_centered" 'variable))
(cffi:defcvar ("gsl_wavelet_bspline" #.(swig-lispify "gsl_wavelet_bspline" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_bspline" 'variable))
(cffi:defcvar ("gsl_wavelet_bspline_centered" #.(swig-lispify "gsl_wavelet_bspline_centered" 'variable))
:pointer)
(cl:export '#.(swig-lispify "gsl_wavelet_bspline_centered" 'variable))
(cffi:defcfun ("gsl_wavelet_alloc" #.(swig-lispify "gsl_wavelet_alloc" 'function)) :pointer
(t_arg0 :pointer)
(k :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_alloc" 'function))
(cffi:defcfun ("gsl_wavelet_free" #.(swig-lispify "gsl_wavelet_free" 'function)) :void
(w :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_free" 'function))
(cffi:defcfun ("gsl_wavelet_name" #.(swig-lispify "gsl_wavelet_name" 'function)) :string
(w :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_name" 'function))
(cffi:defcfun ("gsl_wavelet_workspace_alloc" #.(swig-lispify "gsl_wavelet_workspace_alloc" 'function)) :pointer
(n :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_workspace_alloc" 'function))
(cffi:defcfun ("gsl_wavelet_workspace_free" #.(swig-lispify "gsl_wavelet_workspace_free" 'function)) :void
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_workspace_free" 'function))
(cffi:defcfun ("gsl_wavelet_transform" #.(swig-lispify "gsl_wavelet_transform" 'function)) :int
(w :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(dir #.(swig-lispify "gsl_wavelet_direction" 'enumname))
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_transform" 'function))
(cffi:defcfun ("gsl_wavelet_transform_forward" #.(swig-lispify "gsl_wavelet_transform_forward" 'function)) :int
(w :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_transform_forward" 'function))
(cffi:defcfun ("gsl_wavelet_transform_inverse" #.(swig-lispify "gsl_wavelet_transform_inverse" 'function)) :int
(w :pointer)
(data :pointer)
(stride :pointer)
(n :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet_transform_inverse" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform" #.(swig-lispify "gsl_wavelet2d_transform" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(dir #.(swig-lispify "gsl_wavelet_direction" 'enumname))
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform_forward" #.(swig-lispify "gsl_wavelet2d_transform_forward" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform_forward" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform_inverse" #.(swig-lispify "gsl_wavelet2d_transform_inverse" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform_inverse" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform" #.(swig-lispify "gsl_wavelet2d_nstransform" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(dir #.(swig-lispify "gsl_wavelet_direction" 'enumname))
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform_forward" #.(swig-lispify "gsl_wavelet2d_nstransform_forward" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform_forward" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform_inverse" #.(swig-lispify "gsl_wavelet2d_nstransform_inverse" 'function)) :int
(w :pointer)
(data :pointer)
(tda :pointer)
(size1 :pointer)
(size2 :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform_inverse" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform_matrix" #.(swig-lispify "gsl_wavelet2d_transform_matrix" 'function)) :int
(w :pointer)
(a :pointer)
(dir #.(swig-lispify "gsl_wavelet_direction" 'enumname))
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform_matrix" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform_matrix_forward" #.(swig-lispify "gsl_wavelet2d_transform_matrix_forward" 'function)) :int
(w :pointer)
(a :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform_matrix_forward" 'function))
(cffi:defcfun ("gsl_wavelet2d_transform_matrix_inverse" #.(swig-lispify "gsl_wavelet2d_transform_matrix_inverse" 'function)) :int
(w :pointer)
(a :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_transform_matrix_inverse" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform_matrix" #.(swig-lispify "gsl_wavelet2d_nstransform_matrix" 'function)) :int
(w :pointer)
(a :pointer)
(dir #.(swig-lispify "gsl_wavelet_direction" 'enumname))
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform_matrix" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform_matrix_forward" #.(swig-lispify "gsl_wavelet2d_nstransform_matrix_forward" 'function)) :int
(w :pointer)
(a :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform_matrix_forward" 'function))
(cffi:defcfun ("gsl_wavelet2d_nstransform_matrix_inverse" #.(swig-lispify "gsl_wavelet2d_nstransform_matrix_inverse" 'function)) :int
(w :pointer)
(a :pointer)
(work :pointer))
(cl:export '#.(swig-lispify "gsl_wavelet2d_nstransform_matrix_inverse" 'function))
| 1,185,508 | Common Lisp | .lisp | 24,674 | 45.512402 | 239 | 0.702382 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 12569b0ccc6c0a58fe8a8d28720dc2dbdc7bb29d79b7e6bab303853f38335abf | 31,777 | [
-1
] |
31,778 | problem.lisp | appleby_cl-opsresearch/lisp/problem.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:cl-opsresearch)
(defclass Problem ()())
(defgeneric release (problem))
(defgeneric name-of (problem))
| 894 | Common Lisp | .lisp | 22 | 39.181818 | 74 | 0.700115 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | b84ed72a934ebd5fa77210db3e901532f36c7a6cdd79c462c2cb639954855d27 | 31,778 | [
-1
] |
31,779 | foreign.lisp | appleby_cl-opsresearch/lisp/foreign.lisp | ;;;; fireign.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-cffi)
(defmacro with-foreign-alloc ((var type &rest rest) &body body)
(let ((obj (gensym)))
`(let (,var ,obj)
(unwind-protect
(progn (setq ,obj (cffi:foreign-alloc ,type ,@rest )
,var ,obj)
,@body)
(unless (null ,obj)
(cffi:foreign-free ,obj))))))
| 1,142 | Common Lisp | .lisp | 28 | 36 | 81 | 0.629163 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 73b0aa771db8eeb59cd79f616623c587c08defceb54f51d1a0d6aa56cbc3e134 | 31,779 | [
-1
] |
31,780 | milp.lisp | appleby_cl-opsresearch/lisp/milp.lisp | ;;;; test.lisp
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(in-package #:or-milp)
(defclass Problem (cl-opsresearch:Problem)())
(defgeneric read-mps (problem path &key format))
(defgeneric write-mps (problem path &key format))
(defgeneric read-cplex-lp (problem path))
(defgeneric write-cplex-lp (problem path))
| 1,030 | Common Lisp | .lisp | 24 | 41.541667 | 74 | 0.711577 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 30989c2eae00b6c1960633d742b2fde82c3d56cae003f85c8a90b502cdeb62ac | 31,780 | [
-1
] |
31,781 | cl-opsresearch.asd | appleby_cl-opsresearch/cl-opsresearch.asd | ;;;; cl-opsresearch.asd
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:cl-opsresearch
:description "Common Lisp library for Operations Research."
:author "Donald Anderson <[email protected]>"
:license "GPL3"
:depends-on (#:cffi)
:serial t
:components ((:file "package")
(:file "cl-opsresearch")
(:module lisp
:serial t
:components
((:file "foreign")
(:file "problem")
(:file "milp")))))
| 1,256 | Common Lisp | .asd | 32 | 34 | 74 | 0.635545 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 73c67ad4153e4a7b05f866b2cc9615d37df6d8965e5049b1839e77f41d5144d5 | 31,781 | [
-1
] |
31,782 | or-cluster.asd | appleby_cl-opsresearch/subsystem/or-cluster/or-cluster.asd | ;;;; or-cluster.asd
;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2016 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU Affero General Public License as published by
;;;; the Free Software Foundation, either version 3 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 Affero General Public License for more details.
;;;;
;;;; You should have received a copy of the GNU Affero General Public License
;;;; along with this program. If not, see <http://www.gnu.org/licenses/>.
;;;;
;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:or-cluster
:description "Describe or-cluster here"
:author "Your Name <[email protected]>"
:license "Specify license here"
:depends-on ( #:cl-opsresearch
#:hunchentoot
#:drakma)
:serial t
:components ((:file "package")
(:file "or-cluster")))
| 1,179 | Common Lisp | .asd | 29 | 37.344828 | 80 | 0.68265 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | d060cbea5efe7652dcd6faa7915027bdbff84376b4d4de0f230a91f437355e43 | 31,782 | [
-1
] |
31,783 | or-fann.asd | appleby_cl-opsresearch/subsystem/or-fann/or-fann.asd | ;;;; or-fann.asd
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:or-fann
:description "Subsystem - Fast Artificial Neural Network Library"
:author "Donald Anderson <[email protected]>"
:license "GPL3"
:depends-on (#:cl-opsresearch #:cffi)
:serial t
:components ((:file "package")
(:module swig
:serial t
:components ((:file "fann")))
(:file "network")
(:file "parameters")
(:file "or-fann")))
| 1,246 | Common Lisp | .asd | 31 | 35.290323 | 74 | 0.640264 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 44c875589f6cfb7f8be1df37f81dc6dd5ea0ba816585c93c47e3fac1e7b209ad | 31,783 | [
-1
] |
31,784 | or-glpk.asd | appleby_cl-opsresearch/subsystem/or-glpk/or-glpk.asd | ;;;; or-glpk.asd
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:or-glpk
:description "Subsystem - GNU Linear Programming Kit."
:author "Donald Anderson <[email protected]>"
:license "GPL3"
:depends-on (#:cl-opsresearch #:cffi)
:serial t
:components ((:file "package")
(:module swig
:serial t
:components ((:file "glpk")))
(:file "or-glpk")
(:file "problem")))
| 1,193 | Common Lisp | .asd | 30 | 35.433333 | 74 | 0.647414 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 47722dcfb7da0eb8c876e53a075507098afd7d82a5e224c7106765cbc22531d0 | 31,784 | [
-1
] |
31,785 | or-test.asd | appleby_cl-opsresearch/subsystem/or-test/or-test.asd | ;;;; or-test.asd
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:or-test
:description "Tests for the system cl-opsresearch"
:author "Donald Anderson <[email protected]>"
:license "GPL3"
:depends-on(
#:fiveam
#:cl-opsresearch
#:or-glpk
#:or-gsl
#:or-fann)
:serial t
:components (
(:file "package")
(:module tests
:serial t
:components ((:file "test-opsresearch")
(:file "test-gsl")
(:file "test-glpk")
(:file "test-fann")
(:file "test")))
(:file "or-test")))
| 1,255 | Common Lisp | .asd | 39 | 29.512821 | 74 | 0.669415 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | aa35e8a2cd0fb5f6bd5511d06eb41c547ea1af88c6f9fb0dae95af010cc46ee9 | 31,785 | [
-1
] |
31,786 | or-gsl.asd | appleby_cl-opsresearch/subsystem/or-gsl/or-gsl.asd | ;;;; or-gsl.asd
;;;; ;;;;; BEGIN LICENSE BLOCK ;;;;;
;;;;
;;;; Copyright (C) 2015 OpsResearch LLC (a Delaware company)
;;;;
;;;; This program is free software: you can redistribute it and/or modify
;;;; it under the terms of the GNU General Public License, version 3,
;;;; as published by the Free Software Foundation.
;;;;
;;;; 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, see <http://www.gnu.org/licenses/>.
;;;;
;;;; ;;;;; END LICENSE BLOCK ;;;;;
(asdf:defsystem #:or-gsl
:description "Subsystem - GNU Scientific Library"
:author "Donald Anderson <[email protected]>"
:license "GPL3"
:depends-on (#:cl-opsresearch #:cffi)
:serial t
:components ((:file "package")
(:module swig
:components ((:file "gsl")))
(:file "or-gsl")))
| 1,124 | Common Lisp | .asd | 28 | 36.714286 | 74 | 0.664227 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 1adab57e8e631e492d187d610685493a6faa828be670802bfe923ce70dd2d9e4 | 31,786 | [
-1
] |
31,801 | doublefann.h | appleby_cl-opsresearch/subsystem/or-fann/swig/patched/2.2.0/doublefann.h | /*
Fast Artificial Neural Network Library (fann)
Copyright (C) 2003-2012 Steffen Nissen ([email protected])
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Lesser General Public
License as published by the Free Software Foundation; either
version 2.1 of the License, or (at your option) any later version.
This library 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
Lesser General Public License for more details.
You should have received a copy of the GNU Lesser General Public
License along with this library; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
*/
#ifndef __doublefann_h__
#define __doublefann_h__
typedef double fann_type;
#undef DOUBLEFANN
#define DOUBLEFANN
#define FANN_INCLUDE
#include "fann.h"
#endif
| 973 | Common Lisp | .l | 23 | 40.956522 | 73 | 0.805732 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 9445f6f04269a9af03011e4f9731e658a10dbcac3af6dbbc84d1343bd9bd673a | 31,801 | [
-1
] |
31,818 | gsl_message.h | appleby_cl-opsresearch/subsystem/or-gsl/swig/patched/1.16/gsl_message.h | /* err/gsl_message.h
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Gerard Jungman, Brian Gough
*
* 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 3 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __GSL_MESSAGE_H__
#define __GSL_MESSAGE_H__
#include <gsl/gsl_types.h>
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif
__BEGIN_DECLS
/* Provide a general messaging service for client use. Messages can
* be selectively turned off at compile time by defining an
* appropriate message mask. Client code which uses the GSL_MESSAGE()
* macro must provide a mask which is or'ed with the GSL_MESSAGE_MASK.
*
* The messaging service can be completely turned off
* by defining GSL_MESSAGING_OFF. */
void gsl_message(const char * message, const char * file, int line,
unsigned int mask);
GSL_VAR unsigned int gsl_message_mask ;
/* Provide some symolic masks for client ease of use. */
enum {
GSL_MESSAGE_MASK_A = 1,
GSL_MESSAGE_MASK_B = 2,
GSL_MESSAGE_MASK_C = 4,
GSL_MESSAGE_MASK_D = 8,
GSL_MESSAGE_MASK_E = 16,
GSL_MESSAGE_MASK_F = 32,
GSL_MESSAGE_MASK_G = 64,
GSL_MESSAGE_MASK_H = 128
} ;
#ifdef GSL_MESSAGING_OFF /* throw away messages */
#define GSL_MESSAGE(message, mask) do { } while(0)
#else /* output all messages */
#define GSL_MESSAGE(message, mask) \
do { \
if (mask & GSL_MESSAGE_MASK) \
gsl_message (message, __FILE__, __LINE__, mask) ; \
} while (0)
#endif
__END_DECLS
#endif /* __GSL_MESSAGE_H__ */
| 2,317 | Common Lisp | .l | 63 | 34.095238 | 81 | 0.697186 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | c4fd491ad8d81447be65a861809f493d475cc423b6b88ae741034126cbdfa81b | 31,818 | [
-1
] |
31,819 | gsl_multiroots.h | appleby_cl-opsresearch/subsystem/or-gsl/swig/patched/1.16/gsl_multiroots.h | /* multiroots/gsl_multiroots.h
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 Brian Gough
*
* 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 3 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __GSL_MULTIROOTS_H__
#define __GSL_MULTIROOTS_H__
#include <stdlib.h>
#include <gsl/gsl_types.h>
#include <gsl/gsl_math.h>
#include <gsl/gsl_vector.h>
#include <gsl/gsl_matrix.h>
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif
__BEGIN_DECLS
/* Definition of vector-valued functions with parameters based on gsl_vector */
struct gsl_multiroot_function_struct
{
int (* f) (const gsl_vector * x, void * params, gsl_vector * f);
size_t n;
void * params;
};
typedef struct gsl_multiroot_function_struct gsl_multiroot_function ;
#define GSL_MULTIROOT_FN_EVAL(F,x,y) (*((F)->f))(x,(F)->params,(y))
int gsl_multiroot_fdjacobian (gsl_multiroot_function * FF,
const gsl_vector * x, const gsl_vector * f,
double epsrel, gsl_matrix * jacobian);
typedef struct
{
const char *name;
size_t size;
int (*alloc) (void *state, size_t n);
int (*set) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx);
int (*iterate) (void *state, gsl_multiroot_function * function, gsl_vector * x, gsl_vector * f, gsl_vector * dx);
void (*free) (void *state);
}
gsl_multiroot_fsolver_type;
typedef struct
{
const gsl_multiroot_fsolver_type * type;
gsl_multiroot_function * function ;
gsl_vector * x ;
gsl_vector * f ;
gsl_vector * dx ;
void *state;
}
gsl_multiroot_fsolver;
gsl_multiroot_fsolver *
gsl_multiroot_fsolver_alloc (const gsl_multiroot_fsolver_type * T,
size_t n);
void gsl_multiroot_fsolver_free (gsl_multiroot_fsolver * s);
int gsl_multiroot_fsolver_set (gsl_multiroot_fsolver * s,
gsl_multiroot_function * f,
const gsl_vector * x);
int gsl_multiroot_fsolver_iterate (gsl_multiroot_fsolver * s);
const char * gsl_multiroot_fsolver_name (const gsl_multiroot_fsolver * s);
gsl_vector * gsl_multiroot_fsolver_root (const gsl_multiroot_fsolver * s);
gsl_vector * gsl_multiroot_fsolver_dx (const gsl_multiroot_fsolver * s);
gsl_vector * gsl_multiroot_fsolver_f (const gsl_multiroot_fsolver * s);
/* Definition of vector-valued functions and gradient with parameters
based on gsl_vector */
struct gsl_multiroot_function_fdf_struct
{
int (* f) (const gsl_vector * x, void * params, gsl_vector * f);
int (* df) (const gsl_vector * x, void * params, gsl_matrix * df);
int (* fdf) (const gsl_vector * x, void * params, gsl_vector * f, gsl_matrix *df);
size_t n;
void * params;
};
typedef struct gsl_multiroot_function_fdf_struct gsl_multiroot_function_fdf ;
#define GSL_MULTIROOT_FN_EVAL_F(F,x,y) ((*((F)->f))(x,(F)->params,(y)))
#define GSL_MULTIROOT_FN_EVAL_DF(F,x,dy) ((*((F)->df))(x,(F)->params,(dy)))
#define GSL_MULTIROOT_FN_EVAL_F_DF(F,x,y,dy) ((*((F)->fdf))(x,(F)->params,(y),(dy)))
typedef struct
{
const char *name;
size_t size;
int (*alloc) (void *state, size_t n);
int (*set) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx);
int (*iterate) (void *state, gsl_multiroot_function_fdf * fdf, gsl_vector * x, gsl_vector * f, gsl_matrix * J, gsl_vector * dx);
void (*free) (void *state);
}
gsl_multiroot_fdfsolver_type;
typedef struct
{
const gsl_multiroot_fdfsolver_type * type;
gsl_multiroot_function_fdf * fdf ;
gsl_vector * x;
gsl_vector * f;
gsl_matrix * J;
gsl_vector * dx;
void *state;
}
gsl_multiroot_fdfsolver;
gsl_multiroot_fdfsolver *
gsl_multiroot_fdfsolver_alloc (const gsl_multiroot_fdfsolver_type * T,
size_t n);
int
gsl_multiroot_fdfsolver_set (gsl_multiroot_fdfsolver * s,
gsl_multiroot_function_fdf * fdf,
const gsl_vector * x);
int
gsl_multiroot_fdfsolver_iterate (gsl_multiroot_fdfsolver * s);
void
gsl_multiroot_fdfsolver_free (gsl_multiroot_fdfsolver * s);
const char * gsl_multiroot_fdfsolver_name (const gsl_multiroot_fdfsolver * s);
gsl_vector * gsl_multiroot_fdfsolver_root (const gsl_multiroot_fdfsolver * s);
gsl_vector * gsl_multiroot_fdfsolver_dx (const gsl_multiroot_fdfsolver * s);
gsl_vector * gsl_multiroot_fdfsolver_f (const gsl_multiroot_fdfsolver * s);
int gsl_multiroot_test_delta (const gsl_vector * dx, const gsl_vector * x,
double epsabs, double epsrel);
int gsl_multiroot_test_residual (const gsl_vector * f, double epsabs);
GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_dnewton;
GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_broyden;
GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrid;
GSL_VAR const gsl_multiroot_fsolver_type * gsl_multiroot_fsolver_hybrids;
GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_newton;
GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_gnewton;
GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridj;
GSL_VAR const gsl_multiroot_fdfsolver_type * gsl_multiroot_fdfsolver_hybridsj;
__END_DECLS
#endif /* __GSL_MULTIROOTS_H__ */
| 6,153 | Common Lisp | .l | 142 | 38.929577 | 132 | 0.690763 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 9b8e576d185faed14be6649a9621fcb77fccf7a6242dfe632155e8800b6d7189 | 31,819 | [
-1
] |
31,820 | gsl_randist.h | appleby_cl-opsresearch/subsystem/or-gsl/swig/patched/1.16/gsl_randist.h | /* randist/gsl_randist.h
*
* Copyright (C) 1996, 1997, 1998, 1999, 2000, 2007 James Theiler, Brian Gough
*
* 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 3 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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
*/
#ifndef __GSL_RANDIST_H__
#define __GSL_RANDIST_H__
#include <gsl/gsl_rng.h>
#undef __BEGIN_DECLS
#undef __END_DECLS
#ifdef __cplusplus
# define __BEGIN_DECLS extern "C" {
# define __END_DECLS }
#else
# define __BEGIN_DECLS /* empty */
# define __END_DECLS /* empty */
#endif
__BEGIN_DECLS
unsigned int gsl_ran_bernoulli (const gsl_rng * r, double p);
double gsl_ran_bernoulli_pdf (const unsigned int k, double p);
double gsl_ran_beta (const gsl_rng * r, const double a, const double b);
double gsl_ran_beta_pdf (const double x, const double a, const double b);
unsigned int gsl_ran_binomial (const gsl_rng * r, double p, unsigned int n);
unsigned int gsl_ran_binomial_knuth (const gsl_rng * r, double p, unsigned int n);
unsigned int gsl_ran_binomial_tpe (const gsl_rng * r, double p, unsigned int n);
double gsl_ran_binomial_pdf (const unsigned int k, const double p, const unsigned int n);
double gsl_ran_exponential (const gsl_rng * r, const double mu);
double gsl_ran_exponential_pdf (const double x, const double mu);
double gsl_ran_exppow (const gsl_rng * r, const double a, const double b);
double gsl_ran_exppow_pdf (const double x, const double a, const double b);
double gsl_ran_cauchy (const gsl_rng * r, const double a);
double gsl_ran_cauchy_pdf (const double x, const double a);
double gsl_ran_chisq (const gsl_rng * r, const double nu);
double gsl_ran_chisq_pdf (const double x, const double nu);
void gsl_ran_dirichlet (const gsl_rng * r, const size_t K, const double alpha[], double theta[]);
double gsl_ran_dirichlet_pdf (const size_t K, const double alpha[], const double theta[]);
double gsl_ran_dirichlet_lnpdf (const size_t K, const double alpha[], const double theta[]);
double gsl_ran_erlang (const gsl_rng * r, const double a, const double n);
double gsl_ran_erlang_pdf (const double x, const double a, const double n);
double gsl_ran_fdist (const gsl_rng * r, const double nu1, const double nu2);
double gsl_ran_fdist_pdf (const double x, const double nu1, const double nu2);
double gsl_ran_flat (const gsl_rng * r, const double a, const double b);
double gsl_ran_flat_pdf (double x, const double a, const double b);
double gsl_ran_gamma (const gsl_rng * r, const double a, const double b);
double gsl_ran_gamma_int (const gsl_rng * r, const unsigned int a);
double gsl_ran_gamma_pdf (const double x, const double a, const double b);
double gsl_ran_gamma_mt (const gsl_rng * r, const double a, const double b);
double gsl_ran_gamma_knuth (const gsl_rng * r, const double a, const double b);
double gsl_ran_gaussian (const gsl_rng * r, const double sigma);
double gsl_ran_gaussian_ratio_method (const gsl_rng * r, const double sigma);
double gsl_ran_gaussian_ziggurat (const gsl_rng * r, const double sigma);
double gsl_ran_gaussian_pdf (const double x, const double sigma);
double gsl_ran_ugaussian (const gsl_rng * r);
double gsl_ran_ugaussian_ratio_method (const gsl_rng * r);
double gsl_ran_ugaussian_pdf (const double x);
double gsl_ran_gaussian_tail (const gsl_rng * r, const double a, const double sigma);
double gsl_ran_gaussian_tail_pdf (const double x, const double a, const double sigma);
double gsl_ran_ugaussian_tail (const gsl_rng * r, const double a);
double gsl_ran_ugaussian_tail_pdf (const double x, const double a);
void gsl_ran_bivariate_gaussian (const gsl_rng * r, double sigma_x, double sigma_y, double rho, double *x, double *y);
double gsl_ran_bivariate_gaussian_pdf (const double x, const double y, const double sigma_x, const double sigma_y, const double rho);
double gsl_ran_landau (const gsl_rng * r);
double gsl_ran_landau_pdf (const double x);
unsigned int gsl_ran_geometric (const gsl_rng * r, const double p);
double gsl_ran_geometric_pdf (const unsigned int k, const double p);
unsigned int gsl_ran_hypergeometric (const gsl_rng * r, unsigned int n1, unsigned int n2, unsigned int t);
double gsl_ran_hypergeometric_pdf (const unsigned int k, const unsigned int n1, const unsigned int n2, unsigned int t);
double gsl_ran_gumbel1 (const gsl_rng * r, const double a, const double b);
double gsl_ran_gumbel1_pdf (const double x, const double a, const double b);
double gsl_ran_gumbel2 (const gsl_rng * r, const double a, const double b);
double gsl_ran_gumbel2_pdf (const double x, const double a, const double b);
double gsl_ran_logistic (const gsl_rng * r, const double a);
double gsl_ran_logistic_pdf (const double x, const double a);
double gsl_ran_lognormal (const gsl_rng * r, const double zeta, const double sigma);
double gsl_ran_lognormal_pdf (const double x, const double zeta, const double sigma);
unsigned int gsl_ran_logarithmic (const gsl_rng * r, const double p);
double gsl_ran_logarithmic_pdf (const unsigned int k, const double p);
void gsl_ran_multinomial (const gsl_rng * r, const size_t K,
const unsigned int NN, const double p[],
unsigned int n[] );
double gsl_ran_multinomial_pdf (const size_t K,
const double p[], const unsigned int n[] );
double gsl_ran_multinomial_lnpdf (const size_t K,
const double p[], const unsigned int n[] );
unsigned int gsl_ran_negative_binomial (const gsl_rng * r, double p, double n);
double gsl_ran_negative_binomial_pdf (const unsigned int k, const double p, double n);
unsigned int gsl_ran_pascal (const gsl_rng * r, double p, unsigned int n);
double gsl_ran_pascal_pdf (const unsigned int k, const double p, unsigned int n);
double gsl_ran_pareto (const gsl_rng * r, double a, const double b);
double gsl_ran_pareto_pdf (const double x, const double a, const double b);
unsigned int gsl_ran_poisson (const gsl_rng * r, double mu);
void gsl_ran_poisson_array (const gsl_rng * r, size_t n, unsigned int array[],
double mu);
double gsl_ran_poisson_pdf (const unsigned int k, const double mu);
double gsl_ran_rayleigh (const gsl_rng * r, const double sigma);
double gsl_ran_rayleigh_pdf (const double x, const double sigma);
double gsl_ran_rayleigh_tail (const gsl_rng * r, const double a, const double sigma);
double gsl_ran_rayleigh_tail_pdf (const double x, const double a, const double sigma);
double gsl_ran_tdist (const gsl_rng * r, const double nu);
double gsl_ran_tdist_pdf (const double x, const double nu);
double gsl_ran_laplace (const gsl_rng * r, const double a);
double gsl_ran_laplace_pdf (const double x, const double a);
double gsl_ran_levy (const gsl_rng * r, const double c, const double alpha);
double gsl_ran_levy_skew (const gsl_rng * r, const double c, const double alpha, const double beta);
double gsl_ran_weibull (const gsl_rng * r, const double a, const double b);
double gsl_ran_weibull_pdf (const double x, const double a, const double b);
void gsl_ran_dir_2d (const gsl_rng * r, double * x, double * y);
void gsl_ran_dir_2d_trig_method (const gsl_rng * r, double * x, double * y);
void gsl_ran_dir_3d (const gsl_rng * r, double * x, double * y, double * z);
void gsl_ran_dir_nd (const gsl_rng * r, size_t n, double * x);
void gsl_ran_shuffle (const gsl_rng * r, void * base, size_t nmembm, size_t size);
int gsl_ran_choose (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ;
void gsl_ran_sample (const gsl_rng * r, void * dest, size_t k, void * src, size_t n, size_t size) ;
typedef struct { /* struct for Walker algorithm */
size_t K;
size_t *A;
double *F;
} gsl_ran_discrete_t;
gsl_ran_discrete_t * gsl_ran_discrete_preproc (size_t K, const double *P);
void gsl_ran_discrete_free(gsl_ran_discrete_t *g);
size_t gsl_ran_discrete (const gsl_rng *r, const gsl_ran_discrete_t *g);
double gsl_ran_discrete_pdf (size_t k, const gsl_ran_discrete_t *g);
__END_DECLS
#endif /* __GSL_RANDIST_H__ */
| 8,608 | Common Lisp | .l | 137 | 60.226277 | 133 | 0.726226 | appleby/cl-opsresearch | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 4ffe07ce3212c44b4c0082604678c288a7269962e00bc9ce27d9a142cd3239ed | 31,820 | [
-1
] |
31,838 | mvpoli.lisp | dcasella_multivariate-polynomials/Lisp/mvpoli.lisp | ;;;; -*- Mode: Lisp -*-
;;;; mvpoli.lisp --
;;;; Matricola Cognome Nome
;;;; Matricola Cognome Nome
;;;; Matricola Cognome Nome
;; type: Poly
;; (POLY MONOS:list)
;; type: Mono
;; (M COEFFICIENT:number TOTALDEGREE:int VARPOWERS:list)
;; type: VarPower
;; (V POWER:int VARIABLE:symbol)
;; polynomials are monomials and viceversa
;; (POLY (M C TD VPS)) is the same as (M C TD VPS)
(defun varpower-power (vp)
(if (and (listp vp)
(eq 'v (first vp)))
(second vp)
(error "Invalid input (VarPower expected).")))
(defun varpower-symbol (vp)
(if (and (listp vp)
(eq 'v (first vp)))
(third vp)
(error "Invalid input (VarPower expected).")))
(defun is-varpower (vp)
(and (listp vp)
(eq 'v (first vp))
(let ((p (varpower-power vp))
(v (varpower-symbol vp)))
(and (integerp p)
(>= p 0)
(symbolp v)))))
(defun monomial-degree (m)
"Return monomial's total degree.
Input M, structure of type Mono."
(if (and (listp m)
(eq 'm (first m)))
(third m)
(error "Invalid input (Mono expected).")))
(defun varpowers (m)
"Return monomial's varpowers list.
Input M, structure of type Mono."
(if (and (listp m)
(eq 'm (first m)))
(fourth m)
(error "Invalid input (Mono expected).")))
(defun is-monomial (m)
(and (listp m)
(eq 'm (first m))
(let ((mtd (monomial-degree m))
(vps (varpowers m)))
(and (integerp mtd)
(>= mtd 0)
(listp vps)
(every #'is-varpower vps)))))
;; Parsing functions
;; parse-monomial is used to parse a monomial or a s-exp (representing a
;; monomial) to a monomial
;; parse-monomial Mono → Mono
;; parse-monomial S-Exp → Mono
(defun parse-monomial (m)
(if (is-monomial m)
m
(as-monomial m)))
;; parse-polynomial is used to parse a polynomial, a monomial or a s-exp
;; (representing a polynomial or a monomial) to a polynomial
;; parse-polynomial Poly → Poly
;; parse-polynomial Mono → Poly
;; parse-polynomial S-Exp → Poly
(defun parse-polynomial (p)
(cond ((and (listp p)
(eq 'poly (first p)))
p)
((is-monomial p)
(list 'poly (cons p nil)))
(t
(as-polynomial p))))
(defun null-ms (ms)
(if ms
;; ms is not nil
ms
;; else (ms is nil)
(cons (list 'm 0 0 nil) nil)))
(defun monomials (p)
"Return the list of monomials that appear in P.
Input P, structure of type Poly or S-Exp."
(null-ms (first (rest (parse-polynomial p)))))
(defun is-polynomial (p)
(and (listp p)
(let ((ms (monomials p)))
(and (listp ms)
(every #'is-monomial ms)))))
(defun variables-vps (vps)
(if vps
(cons (varpower-symbol (first vps))
(variables-vps (rest vps)))))
;; Every "main" functon checks if the input is correct by calling let with
;; parse-monomial or parse-polynomial as the first variable
(defun vars-of (m)
"Return the list of variables (symbols) that appear in M.
Input M, structure of type Mono or S-Exp."
(variables-vps (varpowers (parse-monomial m))))
(defun monomial-coefficient (m)
"Return monomial's coefficient.
Input M, structure of type Mono or S-Exp."
(second (parse-monomial m)))
(defun coefficients-ms (ms)
(if ms
(cons (monomial-coefficient (first ms))
(coefficients-ms (rest ms)))))
(defun coefficients (p)
"Return the list of coefficients that appear in P.
Input P, structure of type Poly or S-Exp."
(coefficients-ms (monomials p)))
(defun variables-ms (ms)
(if ms
(append (vars-of (first ms))
(variables-ms (rest ms)))))
(defun variables (p)
"Return the list of variables (symbols) that appear in P.
Input P, structure of type Poly or S-Exp."
;; copy-seq is needed to not degrade the input P when sorting
;; sort by symbol (string<)
(sort (copy-seq (remove-duplicates (variables-ms (monomials p)))) #'string<))
(defun degree-vps (vps)
(if vps
(cons (varpower-power (first vps)) (degree-vps (rest vps)))
nil))
(defun degree-ms (ms)
(if ms
(append (degree-vps (varpowers (first ms))) (degree-ms (rest ms)))
nil))
(defun null-degree (degrees)
(if degrees
degrees
(cons 0 nil)))
(defun maxdegree (p)
"Return the highest variable degree in P.
Input P, structure of type Poly or S-Exp."
;; input 0 as starting degree
(apply #'max (null-degree (degree-ms (monomials p)))))
(defun mindegree (p)
"Return the lowest variable degree in P.
Input P, structure of type Poly or S-Exp."
;; input -1 as starting degree
(apply #'min (null-degree (degree-ms (monomials p)))))
;; Sorting functions
;; vps< returns true when VPS1 is "less than" VPS2;
;; it checks each variable:
;; if it's the same, check the power (*)
;; else return true when V1 < V2 (symbol-wise)
;;
;; (*) if it's the same, check the other variables
;; else return true when P1 < P2
(defun vps< (vps1 vps2)
(if (equal vps1 vps2)
;; order is unimportant
t
;; else
(let ((vp1 (first vps1))
(vp2 (first vps2)))
(cond ((equal vp1 vp2)
(vps< (rest vps1) (rest vps2)))
((eq (varpower-symbol vp1) (varpower-symbol vp2))
(< (varpower-power vp1) (varpower-power vp2)))
(t
(string< (varpower-symbol vp1) (varpower-symbol vp2)))))))
;; monomial< returs true when M1 is "less-than" M2;
;; it checks each TD:
;; if it's the same, check the variables (VPS) with vps<
;; else returns true when TD1 < TD2
(defun monomial< (m1 m2)
(let ((td1 (monomial-degree m1))
(td2 (monomial-degree m2)))
(if (= td1 td2)
(vps< (varpowers m1) (varpowers m2))
(< td1 td2))))
;; Normalization functions
;; liketerms-vps removes all duplicate variables (by adding their powers)
;; and "null" variables (power 0)
(defun liketerms-vps (vps)
(cond ((null vps)
nil)
((not (null (second vps)))
;; vps is made up of at least two elements
(let* ((vp1 (first vps))
(vp2 (second vps))
(p1 (varpower-power vp1))
(p2 (varpower-power vp2))
(v1 (varpower-symbol vp1))
(v2 (varpower-symbol vp2)))
(cond ((eq v1 v2)
(liketerms-vps (cons (list 'v (+ p1 p2) v1)
(rest (rest vps)))))
((= 0 p1)
(liketerms-vps (rest vps)))
(t
(cons vp1 (liketerms-vps (rest vps)))))))
(t
;; vps only has one element
;; (no need to check for other variables to "normalize")
(let ((vp (first vps)))
(if (= 0 (varpower-power vp))
(liketerms-vps (rest vps))
(cons vp (liketerms-vps (rest vps))))))))
;; liketerms-ms removes all duplicate monomials (by adding their coefficients)
;; and "null" monomials (coefficient 0)
(defun liketerms-ms (ms)
(cond ((null ms)
nil)
((not (null (second ms)))
(let* ((m1 (first ms))
(m2 (second ms))
(c1 (monomial-coefficient m1))
(c2 (monomial-coefficient m2))
(td (monomial-degree m1))
(vps1 (varpowers m1))
(vps2 (varpowers m2)))
(cond ((= 0 c1)
(liketerms-ms (rest ms)))
((equal vps1 vps2)
(liketerms-ms (cons (list 'm (+ c1 c2) td vps1)
(rest (rest ms)))))
(t
(cons m1 (liketerms-ms (rest ms)))))))
(t
(let ((m (first ms)))
(if (= 0 (monomial-coefficient m))
(liketerms-ms (rest ms))
(cons m (liketerms-ms (rest ms))))))))
(defun liketerms (ms)
;; sort the input (monomials) by monomial<, normalize and return it
(liketerms-ms (sort (copy-seq ms) #'monomial<)))
(defun polyplus (p1 p2)
"Return the polynomial produced by the polynomial sum of P1 and P2.
Input P1, structure of type Poly or S-Exp;
Input P2, structure of type Poly or S-Exp."
(list 'poly (liketerms (append (monomials p1) (monomials p2)))))
;; Negation functions
;; neg-m inverts M's coefficient
(defun neg-m (m)
(list 'm (* -1 (monomial-coefficient m)) (monomial-degree m) (varpowers m)))
;; neg-ms inverts all MS' coefficients
(defun neg-ms (ms)
(if ms
(cons (neg-m (first ms))
(neg-ms (rest ms)))))
;; neg-poly inverts all monomials' coefficients in P
(defun neg-poly (p)
(list 'poly (neg-ms (monomials p))))
(defun polyminus (p1 p2)
"Return the polynomial produced by the polynomial subtraction of P1 and P2.
Input P1, structure of type Poly or S-Exp;
Input P2, structure of type Poly or S-Exp."
(polyplus p1 (neg-poly p2)))
(defun monotimes (m1 ms2)
(if ms2
(let ((m2 (first ms2)))
;; append vps1 and vps2 (first ms2's vps), sort it by variable and
;; normalize it (liketerms-vps)
(cons (list 'm
(* (monomial-coefficient m1) (monomial-coefficient m2))
(+ (monomial-degree m1) (monomial-degree m2))
(liketerms-vps (sort (copy-seq (append (varpowers m1)
(varpowers m2)))
#'string< :key #'third)))
(monotimes m1 (rest ms2))))))
(defun monostimes (ms1 ms2)
(if ms1
(append (monotimes (first ms1) ms2)
(monostimes (rest ms1) ms2))))
(defun polytimes (p1 p2)
"Return the polynomial produced by the polynomial multiplication of P1 and P2.
Input P1, structure of type Poly or S-Exp;
Input P2, structure of type Poly or S-Exp."
(list 'poly (liketerms (monostimes (monomials p1) (monomials p2)))))
;; as- functions
;; as-vp Symbol → (V 1 Symbol)
;; as-vp (expt Symbol Power) → (V Power Symbol)
(defun as-vp (exp)
(cond ((and (listp exp)
(eq 'expt (first exp))
(symbolp (second exp))
(integerp (third exp))
(>= (third exp) 0))
(list 'v (third exp) (second exp)))
((symbolp exp)
(list 'v 1 exp))))
;; as-vps
;; list of recursive calls to as-vp
(defun as-vps (lexp)
(if lexp
(cons (as-vp (first lexp)) (as-vps (rest lexp)))))
(defun total-degree-vps (vps)
(if vps
(+ (varpower-power (first vps))
(total-degree-vps (rest vps)))
0))
;; as-monomial-help Number → (M Number 0 NIL)
;; as-monomial-help Symbol → (M 1 1 (V 1 Symbol))
;; as-monomial-help (* &rest Symbol) → (M 1 TD VPS)
;; as-monomial-help (* Number &rest Symbol) → (M Number TD VPS)
(defun as-monomial-help (exp)
(cond ((numberp exp)
(list 'm exp 0 nil))
((or (symbolp exp)
(and (listp exp)
(eq 'expt (first exp))))
(let ((vps (cons (as-vp exp) nil)))
(list 'm 1 (total-degree-vps vps) vps)))
((and (listp exp)
(eq '* (first exp))
(numberp (second exp)))
(let* ((vps (liketerms-vps (sort (copy-seq (as-vps (rest (rest exp))))
#'string< :key #'third)))
(td (total-degree-vps vps)))
(list 'm (second exp) td vps)))
((and (listp exp)
(eq '* (first exp)))
(let* ((vps (liketerms-vps (sort (copy-seq (as-vps (rest exp)))
#'string< :key #'third)))
(td (total-degree-vps vps)))
(list 'm 1 td vps)))
(t
(error "Invalid input type."))))
(defun null-m (m)
(if (= 0 (monomial-coefficient m))
;; null coefficient: ignore vps
(list 'm 0 0 nil)
m))
(defun as-monomial (exp)
"Return a structure of type Mono representing the monomial parsed from EXP.
Input EXP, Symbolic-Expression."
(null-m (as-monomial-help exp)))
;; as-monomials-help
;; list of recursive calls to as-monomial
(defun as-monomials-help (exp)
(if exp
(cons (as-monomial (first exp))
(as-monomials-help (rest exp)))))
;; as-monomials Mono → (Mono . NIL)
;; as-monomials (&rest Mono) → Monos
(defun as-monomials (exp)
(if (and (listp exp)
(eq '+ (first exp)))
(as-monomials-help (rest exp))
(cons (as-monomial exp) nil)))
(defun as-polynomial (exp)
"Return a structure of type Poly representing the polynomial parsed from EXP.
Input EXP, Symbolic-Expression."
(list 'poly (liketerms (as-monomials exp))))
(defun polyval-vps (vps vars varvals)
(if vps
(let* ((vp (first vps))
(val (nth (position (varpower-symbol vp) vars) varvals)))
;; val is the element at position index in varvals
;; (where index is the position of varpower-symbol in vars)
(if val
(* (expt val (varpower-power vp))
(polyval-vps (rest vps) vars varvals))
(error "Invalid variable values (less than expected).")))
1))
(defun polyval-m (m vars varvals)
(* (monomial-coefficient m) (polyval-vps (varpowers m) vars varvals)))
(defun polval-ms (ms vars varvals)
(if ms
(+ (polyval-m (first ms) vars varvals)
(polval-ms (rest ms) vars varvals))
0))
(defun polyval (p varvals)
"Return the value of P in the n-dimensional point represented by VARVALS.
Input P, structure of type Poly or S-Exp;
Input VARVALS, list of numbers (mapped to function variables' output)."
(let ((ms (monomials p)))
(polval-ms ms (variables (list 'poly ms)) varvals)))
;; PPrint functions
;; OUT is the output string
;; pprint-varpowers (V 1 Symbol) → Symbol
;; pprint-varpowers (V Power Symbol) → Symbol^Power
;; pprint-varpowers (&rest VPs) → VP * PrintedVPs
(defun pprint-varpowers (vps out)
(let* ((vp (first vps))
(p (varpower-power vp))
(v (varpower-symbol vp)))
(cond ((and (null (rest vps))
(= p 1))
(format out "~a" v))
((null (rest vps))
(format out "~a^~d" v p))
((= p 1)
(format out "~a * " v)
(pprint-varpowers (rest vps) out))
(t
(format out "~a^~d * " v p)
(pprint-varpowers (rest vps) out)))))
;; pprint-monomial (M Number 0 NIL) → Number
;; pprint-monomial (M 1 TD VPs) → PrintedVPs
;; pprint-monomial (M Number TD VPs) → Number * PrintedVPs
(defun pprint-monomial (m out)
(let ((c (monomial-coefficient m))
(vps (varpowers m)))
(cond ((null vps)
(format out "~d" c))
((= c 1)
(pprint-varpowers vps out))
(t
(format out "~d * " c)
(pprint-varpowers vps out)))))
;; pprint-monomials Mono → PrintedMono\n
;; pprint-monomials (&rest Mono) → PrintedMono + PrintedMonos
(defun pprint-monomials (ms out)
(if (null (rest ms))
(progn (pprint-monomial (first ms) out)
(format out "~%"))
(progn (pprint-monomial (first ms) out)
(format out " + ")
(pprint-monomials (rest ms) out))))
(defun pprint-polynomial (p)
"Output a traditional representation of P to *STANDARD-OUTPUT*.
Input P, structure of type Poly or S-Exp."
(let ((out (make-string-output-stream)))
;; out is a string output-stream
;; write on out with format calls in pprint-monomials
(pprint-monomials (monomials p) out)
;; print out to standard-output (t)
(format t "~a" (get-output-stream-string out))))
;;;; end of file -- mvpoli.lisp --
| 15,782 | Common Lisp | .lisp | 426 | 29.776995 | 80 | 0.580197 | dcasella/multivariate-polynomials | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | a3fe0ed571336a85066413e0577f2bea60fc0cf2ff99ef1cd686098a4f3fe1f3 | 31,838 | [
-1
] |
31,840 | mvpoli.pl | dcasella_multivariate-polynomials/Prolog/mvpoli.pl | %%%% -*- Mode: Prolog -*-
%%%% mvpoli.pl --
%%%% Matricola Cognome Nome
%%%% Matricola Cognome Nome
%%%% Matricola Cognome Nome
%% type:poly
%
% poly(Monos:list)
%% type:mono
%
% m(Coefficient:number, TotalDegree:int, VarPowers:list)
%% type:varpower
%
% v(Power:int, Variable:atom)
%% polynomials are monomials and viceversa
%
% poly([m(C, TD, VPs)]) is the same as m(C, TD, VPs)
%! coefficients(+Poly:poly, -Coefficients:list)
%
% coefficients/2 is true when
% Coefficients is the list of Poly's coefficients;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
coefficients(Poly, Cs) :-
monomials(Poly, Monos),
monoscoefficients(Monos, Cs).
monoscoefficients([m(C, _TD, _VPs) | Monos], [C | Cs]) :-
!,
monoscoefficients(Monos, Cs).
monoscoefficients([], []).
%% Parsing predicates used to verify if the input can be unified with a
%% polynomial structure or expression
parse_polynomial(Poly, Poly) :-
is_polynomial(Poly),
!.
parse_polynomial(Mono, poly([Mono])) :-
is_monomial(Mono),
!.
parse_polynomial(Exp, Poly) :-
as_polynomial(Exp, Poly).
%! variables(+Poly:poly, -Variables:list)
%
% variables/2 is true when
% Variables is the list of variables that appear in Poly;
% Variables is lexicographically ordered (ascending);
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
variables(Poly, Vars) :-
% sort variables lexicographically (@< in sort/4 removes duplicates)
monomials(Poly, Monos),
monosvariables(Monos, LVars),
sort(0, @<, LVars, Vars).
monosvariables([m(C, TD, [v(_P, Var) | VPs]) | Monos], [Var | Vars]) :-
!,
monosvariables([m(C, TD, VPs) | Monos], Vars).
monosvariables([m(_C, _TD, []) | Monos], Vars) :-
!,
monosvariables(Monos, Vars).
monosvariables([], []).
%! monomials(+Poly:poly, -Monomials:list)
%
% monomials/2 is true when
% Monomials is the list of monomials that appear in Poly;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
monomials(Poly, Result) :-
parse_polynomial(Poly, poly(Monos)),
monosnull(Monos, Result).
monosnull([], [m(0, 0, [])]) :- !.
monosnull(Monos, Monos).
%! maxdegree(+Poly:poly, -Degree:int)
%
% maxdegree/2 is true when
% Degree is the highest degree of variables that appears in Poly;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
maxdegree(Poly, Degree) :-
monomials(Poly, Monos),
monosdegrees(Monos, Degrees),
degreesnull(Degrees, NDegrees),
max_list(NDegrees, Degree).
monosdegrees([m(C, TD, [v(P, _Var) | VPs]) | Monos], [P | Powers]) :-
!,
monosdegrees([m(C, TD, VPs) | Monos], Powers).
monosdegrees([m(_C, _TD, []) | Monos], Powers) :-
!,
monosdegrees(Monos, Powers).
monosdegrees([], []).
degreesnull([], [0]) :- !.
degreesnull(Degrees, Degrees).
%! mindegree(+Poly:poly, -Degree:int)
%
% mindegree/2 is true when
% Degree is the lowest degree of variables (that appear in Poly;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
mindegree(Poly, Degree) :-
monomials(Poly, Monos),
monosdegrees(Monos, Degrees),
degreesnull(Degrees, NDegrees),
min_list(NDegrees, Degree).
%! polyplus(+Poly1:poly, +Poly2:poly, -Result:poly)
%
% polyplus/3 is true when
% Result is the polynomial calculated by the polynomial sum
% between Poly1 and Poly2;
% fails when Poly1 or Poly2 can't be unified with polynomials written in the
% (previously defined) polynomial representation (or expression).
polyplus(Poly1, Poly2, poly(Result)) :-
% append Poly1 and Poly2
% normalize the list of monomials (sum liketerms and reorder)
monomials(Poly1, Monos1),
monomials(Poly2, Monos2),
append(Monos1, Monos2, Monos),
liketerms(Monos, Result).
%% Compare predicates used by predsort/3 to sort the list of monomials in
%% a polynomial; sorting order is:
%% order by TD (ascending) first,
%% order by VPs (ascending) second.
%% Ordering "by VPs" means checking each VP:
%% order by Variable (lexicographically ascending) first,
%% order by Power (ascending) second.
monocompare(<, m(_C1, TD, VPs1), m(_C2, TD, VPs2)) :-
% same TD, compare VPs
vpscompare(VPs1, VPs2),
!.
monocompare(>, m(_C1, TD, _VPs1), m(_C2, TD, _VPs2)) :-
% no need to compare VPs: vpscompare/2 failed
!.
monocompare(<, m(_C1, TD1, _VPs1), m(_C2, TD2, _VPs2)) :-
% different TD, sort @< (ascending)
TD1 < TD2,
!.
monocompare(>, m(_C1, _TD1, _VPs1), m(_C2, _TD2, _VPs2)).
% no need to compare TD: TD1 < TD2 failed, and TDs are not equal
vpscompare([VP | VPs1], [VP | VPs2]) :-
% same VP, keep recursing
!,
vpscompare(VPs1, VPs2).
vpscompare([VP1 | _VPs1], [VP2 | _VPs2]) :-
% stop and compare the first VPs that are not equal
vpcompare(VP1, VP2).
vpcompare(v(P1, Var), v(P2, Var)) :-
!,
P1 < P2.
vpcompare(v(_P1, Var1), v(_P2, Var2)) :-
Var1 @< Var2.
%! liketerms(+Monos:list, -Result:list)
%
% liketerms/2 is true when
% Result is the list of sorted monomials in Monos;
% fails when Monos can't be unified with a list of monomials.
liketerms(Monos, Result) :-
% sort Monos with predsort/3 and monocompare/3
% normalize "like terms"
predsort(monocompare, Monos, SortedMonos),
monosliketerms(SortedMonos, Result).
%% "Like terms" predicate called by liketerms/2 to normalize the list of
%% monomials Monos:
%% like-terms are added between eachother;
%% null monomials (0, or m(0, 0, [])) are removed.
monosliketerms([m(C1, TD, VPs), m(C2, TD, VPs) | Monos], LTMonos) :-
% sum monomials with the same TD and VPs
C is C1 + C2,
!,
monosliketerms([m(C, TD, VPs) | Monos], LTMonos).
monosliketerms([m(0, _TD, _VPs) | Monos], LTMonos) :-
% remove null monomials
!,
monosliketerms(Monos, LTMonos).
monosliketerms([Mono | Monos], [Mono | LTMonos]) :-
!,
monosliketerms(Monos, LTMonos).
monosliketerms([], []).
%% "Like terms" predicate called by monotimes/3 and as_monomial/2 to normalize
%% the list of varpowers VPs:
%% same Variable VPs have their Powers added;
%% VPs with Power equal to 0 are removed.
varpowersliketerms([v(P1, Var), v(P2, Var) | VPs], LTVPs) :-
P is P1 + P2,
!,
varpowersliketerms([v(P, Var) | VPs], LTVPs).
varpowersliketerms([v(0, _Var) | VPs], LTVPs) :-
!,
varpowersliketerms(VPs, LTVPs).
varpowersliketerms([VP | VPs], [VP | LTVPs]) :-
!,
varpowersliketerms(VPs, LTVPs).
varpowersliketerms([], []).
%! polyminus(+Poly1:poly, +Poly2:poly, -Result:poly)
%
% polyminus/3 is true when
% Result is the polynomial calculated by the polynomial subtraction
% between Poly1 and Poly2;
% fails when Poly1 or Poly2 can't be unified with polynomials written in the
% (previously defined) polynomial representation (or expression).
polyminus(Poly1, Poly2, Result) :-
% invert all Poly2's monomials coefficients
polyneg(Poly2, NegPoly2),
polyplus(Poly1, NegPoly2, Result).
polyneg(Poly, poly(NegMonos)) :-
monomials(Poly, Monos),
monosneg(Monos, NegMonos).
monosneg([m(C, TD, VPs) | Monos], [m(NegC, TD, VPs) | NegMonos]) :-
!,
NegC is -C,
monosneg(Monos, NegMonos).
monosneg([], []).
%! polytimes(+Poly1:poly, +Poly2:poly, -Result:poly)
%
% polytimes/3 is true when
% Result is the polynomial calculated by the polynomial multiplication
% between Poly1 and Poly2;
% fails when Poly1 or Poly2 can't be unified with polynomials written in the
% (previously defined) polynomial representation (or expression).
polytimes(Poly1, Poly2, poly(Result)) :-
monomials(Poly1, Monos1),
monomials(Poly2, Monos2),
monostimes(Monos1, Monos2, Monos),
liketerms(Monos, Result).
monostimes([Mono | Monos1], Monos2, Result) :-
% "multiply" each Mono in Monos1 with all Monos in Monos2
monotimes(Mono, Monos2, Result1),
!,
monostimes(Monos1, Monos2, Result2),
append(Result1, Result2, Result).
monostimes([], _Monos2, []).
monotimes(m(C1, TD1, VPs1), [m(C2, TD2, VPs2) | Ms], [m(CR, TDR, VPsR) | R]) :-
% calculate new coefficient and totaldegree
% append and normalize the two VPs
CR is C1 * C2,
TDR is TD1 + TD2,
append(VPs1, VPs2, VPs),
sort(2, @=<, VPs, SortedVPs),
varpowersliketerms(SortedVPs, VPsR),
!,
monotimes(m(C1, TD1, VPs1), Ms, R).
monotimes(_Mono, [], []).
%! as_monomial(+Expression:exp, -Monomial:mono)
%
% as_monomial/2 is true when
% Monomial is the term representing the monomial obtained after parsing
% the expression Expression;
% Monomial's variables are lexicographically ordered (ascending);
% fails when Expression can't be unified with an algebrically correct
% expression representing a monomial.
as_monomial(Exp, m(C, NTD, Result)) :-
% parse expression, calculate totaldegree, normalize VPs
as_monomial_help(Exp, C, VPs),
monodegree(VPs, TD),
mononull(m(C, TD, VPs), m(C, NTD, NVPs)),
sort(2, @=<, NVPs, SortedVPs),
varpowersliketerms(SortedVPs, Result).
as_monomial_help(Exp * Var, C, [VP | VPs]) :-
!,
as_varpower(Var, VP),
as_monomial_help(Exp, C, VPs).
as_monomial_help(C, C, []) :-
number(C),
!.
as_monomial_help(-Var, -1, [VP]) :-
!,
as_varpower(Var, VP).
as_monomial_help(Var, 1, [VP]) :-
as_varpower(Var, VP).
as_varpower(Var ^ P, v(P, Var)) :-
!,
atom(Var),
integer(P),
P >= 0.
as_varpower(Var, v(1, Var)) :-
atom(Var).
monodegree([v(P, _Var) | VPs], Result) :-
% sum Power to the last calculated Degree
!,
monodegree(VPs, Degree),
Result is Degree + P.
monodegree([], 0).
mononull(m(0, _TD, _VPs), m(0, 0, [])) :- !.
mononull(Mono, Mono).
%! as_polynomial(+Expression:exp, -Poly:poly)
%
% as_polynomial/2 is true when
% Polynomial is the term representing the polynomial obtained after parsing
% the expression Expression;
% Polynomial's monomials are ordered by total degree (descending);
% fails when Expression can't be unified with an algebrically correct
% expression representing a polynomial.
as_polynomial(Exp, poly(Result)) :-
% parse all monomials, normalize the resulting list Monos
as_polynomial_help(Exp, Monos),
liketerms(Monos, Result).
as_polynomial_help(Exp + Mono, [M | Ms]) :-
!,
as_polynomial_help(Exp, Ms),
as_monomial(Mono, M).
as_polynomial_help(Exp - Mono, [m(NegC, TD, VPs) | Ms]) :-
!,
as_polynomial_help(Exp, Ms),
as_monomial(Mono, m(C, TD, VPs)),
NegC is -C.
as_polynomial_help(Mono, [M]) :-
as_monomial(Mono, M).
%! polyval(+Poly:poly, +VariableValues:list, -Value:number)
%
% polyval/3 is true when
% Value is the value of Poly in the n-dimensional point
% represented by VariableValues;
% VariableValues is a list of numbers directly mapped to variables/2;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression),
% when VariableValues can't be mapped to variables/2 (different length) or
% when VariableValues isn't a list of numbers.
polyval(Poly, VarVals, Value) :-
% variables/2 gets called with poly(Monos) because monomials/2 has been called
% already by polyval/3
% (monomials/2 in variables/2 will just check is_polynomial/2)
monomials(Poly, Monos),
variables(poly(Monos), Vars),
monoscalc(Monos, Vars, VarVals, Value).
monoscalc([Mono | Monos], Vars, VarVals, Result) :-
!,
monocalc(Mono, Vars, VarVals, MonoValue),
monoscalc(Monos, Vars, VarVals, MonosValue),
Result is MonoValue + MonosValue.
monoscalc([], _Vars, _VarVals, 0).
monocalc(m(C, TD, [v(P, Var) | VPs]), Vars, VarVals, Result) :-
% search for Var in Vars (get Index with nth0/3)
% using Index, get the value in VarVals
nth0(Index, Vars, Var),
nth0(Index, VarVals, Val),
!,
monocalc(m(C, TD, VPs), Vars, VarVals, Value),
Result is Val ^ P * Value.
monocalc(m(C, _TD, []), _Vars, _VarVals, C).
%! pprint_polynomial(+Poly:poly)
%
% pprint_polynomial/1 is true when
% it prints on std_out a traditional (algebrical) representation of Poly;
% fails when Poly can't be unified with a polynomial written in the
% (previously defined) polynomial representation (or expression).
pprint_polynomial(Poly) :-
% with_output_to/2 redirects pprint_monomials/1's format calls to a string,
% making sure to not print anything if there's an error
monomials(Poly, Monos),
with_output_to(string(Out), pprint_monomials(Monos)),
write(Out).
pprint_monomials([Mono]) :-
!,
pprint_monomial(Mono),
format('~n').
pprint_monomials([Mono | Monos]) :-
pprint_monomial(Mono),
format(' + '),
pprint_monomials(Monos).
pprint_monomial(m(C, 0, [])) :-
% known term (no variables), no recursion
!,
format('~d', [C]).
pprint_monomial(m(1, _TD, VPs)) :-
!,
pprint_varpowers(VPs).
pprint_monomial(m(C, _TD, VPs)) :-
format('~d * ', [C]),
pprint_varpowers(VPs).
pprint_varpowers([v(1, Var)]) :-
!,
upcase_atom(Var, UPVar),
format('~a', [UPVar]).
pprint_varpowers([v(P, Var)]) :-
!,
upcase_atom(Var, UPVar),
format('~a^~d', [UPVar, P]).
pprint_varpowers([v(1, Var) | VPs]) :-
!,
upcase_atom(Var, UPVar),
format('~a * ', [UPVar]),
pprint_varpowers(VPs).
pprint_varpowers([v(P, Var) | VPs]) :-
upcase_atom(Var, UPVar),
format('~a^~d * ', [UPVar, P]),
pprint_varpowers(VPs).
%% Given predicates
is_monomial(m(_C, TD, VPs)) :-
integer(TD),
TD >= 0,
is_list(VPs).
is_varpower(v(Power, VarSymbol)) :-
integer(Power),
Power >= 0,
atom(VarSymbol).
is_polynomial(poly(Monomials)) :-
is_list(Monomials),
foreach(member(M, Monomials), is_monomial(M)).
%%%% end of file -- mvpoli.pl --
| 13,500 | Common Lisp | .l | 395 | 32.506329 | 79 | 0.709999 | dcasella/multivariate-polynomials | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | ff55a0df6ac301686ef5eae000608410a13c61729de51a8152a09677cfe4cc2d | 31,840 | [
-1
] |
31,856 | package.lisp | epsilon-phase_bullrender/package.lisp | ;;;; package.lisp
(defpackage #:bullrender
(:use #:cl)
(:export :aslice-multi :interpolate-lists :list-lte))
| 115 | Common Lisp | .lisp | 4 | 26.25 | 55 | 0.697248 | epsilon-phase/bullrender | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 0ea455686818ed718adf853c0a945f781ff355524bf5cfcb4c0886fcbdf0e037 | 31,856 | [
-1
] |
31,857 | bullrender.lisp | epsilon-phase_bullrender/bullrender.lisp | ;;;; bullrender.lisp
(in-package #:bullrender)
;;; "bullrender" goes here. Hacks and glory await!
(defstruct color
"A simple rgb color"
(r 0 :type unsigned-byte)
(g 0 :type unsigned-byte)
(b 0 :type unsigned-byte)
)
(defstruct vertex
"A Vertex similar to the sort found in the SFML library"
(x 0.0 :type single-float)
(y 0.0 :type single-float)
(texture-x 0.0 :type single-float)
(texture-y 0.0 :type single-float)
(color (make-color :r 0 :g 0 :b 0) :type color))
(defun interpolate-lists(a b)
(assert (= (length a) (length b)))
(let ((c (copy-list a)))
(loop for i from 0 to (1- (length c) )
do(if (< (elt c i) (elt b i))
(progn
(incf (elt c i))
(return c))
(progn
(setf (elt c i) 0)
(if (< (1- (length a)) i)
(incf (elt c (+ i 1)))))))
))
(defun make-array-accessor(array)
(lambda (&rest a)
(apply #'aref (concatenate 'list (list array) a))))
(defun list-lte(a b)
(loop for i from 0 to (1- (length a))
do(if (not (<= (elt a i) (elt b i)))
(return nil))
finally (return t)))
(defun aslice-multi(array start end)
(let* ((size (map 'list #'- end start))
(offset (make-list (length start) :initial-element 0))
(result (make-array (map 'list #'1+ size) :element-type (array-element-type array))))
(loop until (equal offset size)
do(progn
(setf (apply #'aref (concatenate 'list (list result) offset))
(apply #'aref (concatenate 'list (list array)(map 'list #'+ start offset))))
(setf offset (interpolate-lists offset size))
)
finally(setf (apply #'aref result offset) (apply #'aref array (map 'list #'+ start offset))))
result))
;(defun aslice(array start end)
;())
(defun make-transform-matrix()
(make-array '(3 3) :element-type 'single-float :initial-contents '((1.0 0.0 0.0) (0.0 1.0 0.0) (0.0 0.0 1.0))))
(deftype matrix(a)
(and (= 3 (array-dimension a 0))
(= 3 (array-dimension a 1))))
(defun column(array index)
(loop for i from 0 to (- (array-dimension array 0) 1)
collect (aref array i index )))
(defun row(array index)
(loop for i from 0 to (- (array-dimension array 1) 1)
collect (aref array index i)))
(defun dot(a b)
(reduce #'+ (map (type-of a) #'* a b) ))
(defun make-translate-matrix(dx dy)
(declare (type single-float dx dy))
(make-array '(3 3) :element-type 'single-float :initial-contents
(list
(list 1.0 0.0 dx)
(list 0.0 1.0 dy)
(list 0.0 0.0 1.0))))
(defun make-rotation-matrix(theta)
(declare (type single-float theta) )
(make-array '(3 3) :element-type 'single-float :initial-contents
(list (list (cos theta) (- 0(sin theta)) 0.0) (list (sin theta) (cos theta) 0.0)
(list 0.0 0.0 1.0))))
(defun make-scale-matrix(sx sy)
(declare (type single-float sx sy))
(make-array '(3 3) :element-type 'single-float :initial-contents (list (list sx 0.0 0.0) (list 0.0 sy 0.0) '(0.0 0.0 1.0))))
(defun mat-mult(a b)
"Perform matrix multiplication. No checks are performed here, so take care to make sure matrix multiplication is applicable to both arguments"
(let ((result (make-array (list (array-dimension a 0) (array-dimension b 1)))))
(loop for i from 0 to (- (array-dimension a 0) 1)
do(loop for j from 0 to (- (array-dimension b 1) 1)
do(setf (aref result i j) (dot (row a i) (column b j))))
)
result))
(defgeneric transform(element transform))
(defmethod transform((element vertex) m)
(let ((coords (make-array '(1 3) :initial-contents (list (list (vertex-x element) (vertex-y element) 1.0)))))
(mat-mult coords m )))
;(defvar *a* (make-array '(5 5) :element-type 'single-float :initial-contents '
; ((1.0 1.0 1.0 1.0 1.0) (2.0 2.0 2.0 2.0 2.0) (3.0 3.0 3.0 3.0 3.0)
; (4.0 4.0 4.0 4.0 4.0) (5.0 5.0 5.0 5.0 5.0)))) 3
| 4,256 | Common Lisp | .lisp | 94 | 37.074468 | 144 | 0.561357 | epsilon-phase/bullrender | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 27c137ea483dd54476aaca84b1f54dc38b1a27a252895cde479ab8d0dad49842 | 31,857 | [
-1
] |
31,858 | tests.lisp | epsilon-phase_bullrender/tests/tests.lisp | (in-package #:bullrender-test)
(use-package :fiveam)
(defun generate-multi-dim-array(n)
(let* ((size (loop for i from 1 to n
collect(1+ (random 12) )))
(result (make-array size :element-type 'integer )))
(loop for i from 0 to (1- (array-total-size result))
do(setf (row-major-aref result i) (random 40)))
result))
(def-suite bullrender-tests :description "")
(in-suite bullrender-tests)
(test array-clone
(is (array-clone-func) "Arrays were not equal"))
(defun make-index(array &key (start nil))
(let ((dimensions (array-dimensions array)))
(if start
(map 'list #'+ start (loop for j in dimensions for i in start collect(max 0 (random (1- (- j i))))))
(loop for i in dimensions collect(random (1- i))))))
(defun array-clone-func()
(loop named outer for i from 1 to 3
do(let* ((original-array (generate-multi-dim-array i))
(start-point (make-index original-array))
(end-point (make-index original-array :start start-point)
)
(sizes (map 'list #'- end-point start-point))
(subset
(bullrender:aslice-multi
original-array start-point end-point)))
(print original-array)
(loop with index = (make-list i :initial-element 0)
until (equal sizes index)
do(progn
(if (not (equal
(apply #'aref original-array (map 'list #'+ start-point index))
(apply #'aref subset index)))
(progn
(print original-array)
(print subset)
(return-from outer nil)))
(setf index (bullrender:interpolate-lists index sizes)))
)
t)
finally (return-from outer t)))
| 1,874 | Common Lisp | .lisp | 43 | 32.209302 | 108 | 0.555191 | epsilon-phase/bullrender | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 8bd260ba7488d0af431cb47aca38e39c430fab847904d0c68814b1dbedf63d9f | 31,858 | [
-1
] |
31,859 | bullrender.asd | epsilon-phase_bullrender/bullrender.asd | ;;;; bullrender.asd
(asdf:defsystem #:bullrender
:description "Describe bullrender here"
:author "Alexander White"
:license "Specify license here"
:serial t
:components ((:file "package")
(:file "bullrender")))
(asdf:defsystem #:bullrender-test
:pathname "tests/"
:serial t
:components ((:file "package")
(:file "tests"))
:depends-on (#:bullrender #:fiveam))
| 410 | Common Lisp | .asd | 14 | 24.642857 | 41 | 0.656489 | epsilon-phase/bullrender | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 7d988714ba59b5c409db4df6952cbd69311f3bac0a9dd4698628db7a4b5ba78a | 31,859 | [
-1
] |
31,894 | see-constants-in.lisp | pablovaldes_quickdot/src/see-constants-in.lisp | (defun see-constants-in (package)
"show all constants in package which name is provided as 'package or :package.
The current value of each one is also printed after the name of the constant
i.e (see-constants-in 'cl)"
(loop initially (format t "[Constant: actual value] found in ~a:~%" package)
for i being the present-symbols in package do
(when (constantp i) (format t "~a: ~a~%" i (eval i)))))
| 421 | Common Lisp | .lisp | 7 | 55.714286 | 81 | 0.70073 | pablovaldes/quickdot | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:41:09 AM (Europe/Amsterdam) | 3a6b88cc7bdb36dcbc301debb7ce5f027f70316e8a9f3821fceb0b55237832a1 | 31,894 | [
-1
] |
31,911 | lab4.lisp | kdymov_functional_lab4/lab4/lab4.lisp | (load "splitseq/split-sequence.lisp")
(in-package :split-sequence)
; Word class
(defclass word()
((content :accessor word_content
:initform (error "No word content supplied")
:initarg :content))
)
; Sentence class
(defclass sentence()
((content :accessor sentence_content
:initform (error "No sentence content supplied")
:initarg :content))
)
; List of vowel chars
(defparameter vowels '(#\a #\o #\i #\u #\e #\y))
; Read file contents
(defun file-string (path)
(with-open-file (stream path)
(let ((data (make-string (file-length stream)))) (read-sequence data stream) data)
)
)
;-------------------------------------------------------------------
; Printing methods
;-------------------------------------------------------------------
(defmethod print_word((w word) &key)
(print (slot-value w 'content))
)
(defun print_word_list (ls)
(cond
((null ls) 0)
(t (print_word (car ls)) (print_word_list (cdr ls)))
)
)
;-------------------------------------------------------------------
;-------------------------------------------------------------------
; Strange reading cleanup
;-------------------------------------------------------------------
(defmethod clean-word ((w Word))
(setf ww (make-instance 'word :content (subseq (word_content w) 1)))
)
(defun cleanup-first (ls)
(cons (clean-word (cadr ls)) (cddr ls))
)
;-------------------------------------------------------------------
;-------------------------------------------------------------------
; Sorting
;-------------------------------------------------------------------
; Filter - if vowel return 1, else return 0
(defun filt (chr)
(cond
((member chr vowels) 1)
(T 0)
)
)
; Sum vowels
(defun sum (lst)
(cond
((null lst) 0)
(T (+ (car lst) (sum (cdr lst))))
)
)
; Vowel quantity in word
(defmethod vowels-word ((w word))
(sum (map 'list #'filt (word_content w)))
)
; Letter quantity in word
(defmethod length-word ((w word))
(length (word_content w))
)
; Comparator function - vowelQ/letterQ
(defmethod comparator ((w word))
(/ (vowels-word w) (length-word w))
)
; Sorting method
(defmethod sorter ((s sentence))
(sort (sentence_content s) #'< :key #'comparator)
)
;-------------------------------------------------------------------
(setq fname "input_text.txt")
(setq text (file-string fname))
(setq list_all (remove-if #'(lambda (x) (equal "" x)) (split-sequence-if-not 'alpha-char-p text)))
(setq all_words_list (map 'list (lambda (x) (make-instance 'word :content (string-downcase x))) (remove-duplicates list_all :test #'equal)))
(setq all_words (cleanup-first all_words_list))
(setq all (make-instance 'sentence :content all_words))
(format t "~%TEXT:~%")
(print_word_list (sentence_content all))
(format t "~%~%-----------------------------~%~%SORTED:~%")
(print_word_list (sorter all)) | 2,931 | Common Lisp | .lisp | 89 | 29.977528 | 141 | 0.51157 | kdymov/functional_lab4 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:17 AM (Europe/Amsterdam) | 4ae7c180c53f015f88be6f70046723046e9b3a6c0b696ef7239545bb905cfa39 | 31,911 | [
-1
] |
31,912 | split-sequence.lisp | kdymov_functional_lab4/lab4/splitseq/split-sequence.lisp | ;;;; -*- Mode: Lisp; indent-tabs-mode: nil -*-
;;;
;;; SPLIT-SEQUENCE
;;;
;;; This code was based on Arthur Lemmens' in
;;; <URL:http://groups.google.com/groups?as_umsgid=39F36F1A.B8F19D20%40simplex.nl>;
;;;
;;; changes include:
;;;
;;; * altering the behaviour of the :from-end keyword argument to
;;; return the subsequences in original order, for consistency with
;;; CL:REMOVE, CL:SUBSTITUTE et al. (:from-end being non-NIL only
;;; affects the answer if :count is less than the number of
;;; subsequences, by analogy with the above-referenced functions).
;;;
;;; * changing the :maximum keyword argument to :count, by analogy
;;; with CL:REMOVE, CL:SUBSTITUTE, and so on.
;;;
;;; * naming the function SPLIT-SEQUENCE rather than PARTITION rather
;;; than SPLIT.
;;;
;;; * adding SPLIT-SEQUENCE-IF and SPLIT-SEQUENCE-IF-NOT.
;;;
;;; * The second return value is now an index rather than a copy of a
;;; portion of the sequence; this index is the `right' one to feed to
;;; CL:SUBSEQ for continued processing.
;;; There's a certain amount of code duplication here, which is kept
;;; to illustrate the relationship between the SPLIT-SEQUENCE
;;; functions and the CL:POSITION functions.
(defpackage :split-sequence
(:use :common-lisp)
(:export #:split-sequence
#:split-sequence-if
#:split-sequence-if-not))
(in-package :split-sequence)
(deftype array-index (&optional (length array-dimension-limit))
`(integer 0 (,length)))
(declaim (ftype (function (&rest t) (values list integer))
split-sequence split-sequence-if split-sequence-if-not))
(declaim (ftype (function (function sequence array-index
(or null array-index) (or null array-index) boolean)
(values list integer))
split-from-start split-from-end))
(macrolet ((check-bounds (sequence start end)
(let ((length (gensym (string '#:length))))
`(let ((,length (length ,sequence)))
(check-type ,start unsigned-byte "a non-negative integer")
(when ,end (check-type ,end unsigned-byte "a non-negative integer or NIL"))
(unless ,end
(setf ,end ,length))
(unless (<= ,start ,end ,length)
(error "Wrong sequence bounds. start: ~S end: ~S" ,start ,end))))))
(defun split-sequence (delimiter sequence &key (start 0) (end nil) (from-end nil)
(count nil) (remove-empty-subseqs nil)
(test #'eql) (test-not nil) (key #'identity))
"Return a list of subsequences in seq delimited by delimiter.
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE. In particular, the
behaviour of :from-end is possibly different from other versions of
this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(cond
((and (not from-end) (null test-not))
(split-from-start (lambda (sequence start)
(position delimiter sequence :start start :key key :test test))
sequence start end count remove-empty-subseqs))
((and (not from-end) test-not)
(split-from-start (lambda (sequence start)
(position delimiter sequence :start start :key key :test-not test-not))
sequence start end count remove-empty-subseqs))
((and from-end (null test-not))
(split-from-end (lambda (sequence end)
(position delimiter sequence :end end :from-end t :key key :test test))
sequence start end count remove-empty-subseqs))
(t
(split-from-end (lambda (sequence end)
(position delimiter sequence :end end :from-end t :key key :test-not test-not))
sequence start end count remove-empty-subseqs))))
(defun split-sequence-if (predicate sequence &key (start 0) (end nil) (from-end nil)
(count nil) (remove-empty-subseqs nil) (key #'identity))
"Return a list of subsequences in seq delimited by items satisfying
predicate.
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE-IF. In particular, the
behaviour of :from-end is possibly different from other versions of
this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(if from-end
(split-from-end (lambda (sequence end)
(position-if predicate sequence :end end :from-end t :key key))
sequence start end count remove-empty-subseqs)
(split-from-start (lambda (sequence start)
(position-if predicate sequence :start start :key key))
sequence start end count remove-empty-subseqs)))
(defun split-sequence-if-not (predicate sequence &key (count nil) (remove-empty-subseqs nil)
(from-end nil) (start 0) (end nil) (key #'identity))
"Return a list of subsequences in seq delimited by items satisfying
\(CL:COMPLEMENT predicate).
If :remove-empty-subseqs is NIL, empty subsequences will be included
in the result; otherwise they will be discarded. All other keywords
work analogously to those for CL:SUBSTITUTE-IF-NOT. In particular,
the behaviour of :from-end is possibly different from other versions
of this function; :from-end values of NIL and T are equivalent unless
:count is supplied. The second return value is an index suitable as an
argument to CL:SUBSEQ into the sequence indicating where processing
stopped."
(check-bounds sequence start end)
(if from-end
(split-from-end (lambda (sequence end)
(position-if-not predicate sequence :end end :from-end t :key key))
sequence start end count remove-empty-subseqs)
(split-from-start (lambda (sequence start)
(position-if-not predicate sequence :start start :key key))
sequence start end count remove-empty-subseqs))))
(defun split-from-end (position-fn sequence start end count remove-empty-subseqs)
(declare (optimize (speed 3) (debug 0)))
(loop
:for right := end :then left
:for left := (max (or (funcall position-fn sequence right) -1)
(1- start))
:unless (and (= right (1+ left))
remove-empty-subseqs) ; empty subseq we don't want
:if (and count (>= nr-elts count))
;; We can't take any more. Return now.
:return (values (nreverse subseqs) right)
:else
:collect (subseq sequence (1+ left) right) into subseqs
:and :sum 1 :into nr-elts
:until (< left start)
:finally (return (values (nreverse subseqs) (1+ left)))))
(defun split-from-start (position-fn sequence start end count remove-empty-subseqs)
(declare (optimize (speed 3) (debug 0)))
(let ((length (length sequence)))
(loop
:for left := start :then (+ right 1)
:for right := (min (or (funcall position-fn sequence left) length)
end)
:unless (and (= right left)
remove-empty-subseqs) ; empty subseq we don't want
:if (and count (>= nr-elts count))
;; We can't take any more. Return now.
:return (values subseqs left)
:else
:collect (subseq sequence left right) :into subseqs
:and :sum 1 :into nr-elts
:until (>= right end)
:finally (return (values subseqs right)))))
(pushnew :split-sequence *features*)
| 8,164 | Common Lisp | .lisp | 156 | 43.891026 | 104 | 0.652027 | kdymov/functional_lab4 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:17 AM (Europe/Amsterdam) | 786ad954bb928a1c34b44cd73a527429cd55012ed99c5344fe437b2bb64edf9b | 31,912 | [
-1
] |
31,914 | split-sequence.asd | kdymov_functional_lab4/lab4/splitseq/split-sequence.asd | ;;; -*- Lisp -*-
(defsystem :split-sequence
:author "Arthur Lemmens <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Splits a sequence into a list of subsequences
delimited by objects satisfying a test."
:license "public domain"
:version (:read-file-form "version.sexp")
:components ((:static-file "version.sexp")
(:file "split-sequence"))
:in-order-to ((asdf:test-op (asdf:load-op :split-sequence-tests)))
:perform (asdf:test-op :after (op c)
(funcall (intern (symbol-name '#:run!) '#:5am) :split-sequence)))
(defsystem :split-sequence-tests
:author "Arthur Lemmens <[email protected]>"
:maintainer "Sharp Lispers <[email protected]>"
:description "Split-Sequence test suite"
:license "public domain"
:depends-on (:split-sequence :fiveam)
:components ((:file "tests")))
| 891 | Common Lisp | .asd | 20 | 40.55 | 78 | 0.705409 | kdymov/functional_lab4 | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:17 AM (Europe/Amsterdam) | 24b9dc8b06b562ee8e4bd7059f37e3a3b009d71b5fa0940382ac67dd1d9951f8 | 31,914 | [
-1
] |
31,934 | logger.lisp | dendrown_ostrich-ideas/logger.lisp | ;;; --------------------------------------------------------------------------
;;;
;;; _/
;;; _/ _/_/ _/_/_/ _/_/_/ _/_/ _/ _/_/
;;; _/ _/ _/ _/ _/ _/ _/ _/_/_/_/ _/_/
;;; _/ _/ _/ _/ _/ _/ _/ _/ _/
;;; _/ _/_/ _/_/_/ _/_/_/ _/_/_/ _/
;;; _/ _/
;;; _/_/ _/_/
;;;
;;; MODULE: logger.lisp
;;;
;;; @package ostrich-ideas
;;; @author Dennis Drown
;;; @date 26 Jan 2013
;;;
;;; @copyright 2016 Dennis Drown and Ostrich Ideas
;;;
;;; --------------------------------------------------------------------------
(defpackage :ostrich-ideas
(:use :common-lisp)
(:nicknames :oi)
(:export #:log-set-wow
#:log-msg
#:log-panic
#:log-crit
#:log-error
#:log-warn
#:log-notice
#:log-info
#:log-debug))
(in-package :ostrich-ideas)
(defparameter *LOG-BLUE* (format nil "~a[1;34m" #\Esc))
(defparameter *LOG-ORANGE* (format nil "~a[1;33m" #\Esc))
(defparameter *LOG-RED* (format nil "~a[0;31m" #\Esc))
(defparameter *LOG-TEXT* (format nil "~a[0m" #\Esc))
;; ---------------------------------------------------------------------------
(defvar *LOGGER* t "Stream for logging")
(defvar *LOG-WOW* t "Make it fancy when logging to standard output")
;; ---------------------------------------------------------------------------
;; ╻ ┏━┓┏━╸ ┏━┓┏━╸╺┳╸ ╻ ╻┏━┓╻ ╻
;; ┃ ┃ ┃┃╺┓╺━╸┗━┓┣╸ ┃ ╺━╸┃╻┃┃ ┃┃╻┃
;; ┗━╸┗━┛┗━┛ ┗━┛┗━╸ ╹ ┗┻┛┗━┛┗┻┛
(declaim (inline log-set-wow))
;; ---------------------------------------------------------------------------
(defun log-set-wow (&optional (yesno t))
"
Set whether or not to use colours and generally a fancy style when logging to
standard output. Specify YESNO as t or 'WOW for fancy logging (the default),
or as NIL (or anything else) for plain monochromatic text logging.
"
(if (eq yesno t)
(prog1 :| Wow!!! | (setq *LOG-WOW* t))
(prog1 :| Aww... | (setq *LOG-WOW* nil))))
;; ---------------------------------------------------------------------------
;; ╻ ╻┏━┓╻ ╻
;; ┃╻┃┃ ┃┃╻┃
;; ┗┻┛┗━┛┗┻┛
;; ---------------------------------------------------------------------------
(defun wow (level)
(let ((colour (when (and *LOG-WOW* (eq *LOGGER* t))
(cond
((member level '(PANIC CRIT ERROR)) *LOG-RED*)
((eq level 'WARN) *LOG-ORANGE*)
((eq level 'NOTICE) *LOG-BLUE*)))))
(if (null colour)
level
(format nil "~A~A~A" colour level *LOG-TEXT*))))
;; ---------------------------------------------------------------------------
(defmacro log-msg (level &rest msg-args)
"General logger function. Prepends date-time stamp and informational level"
`(multiple-value-bind (sec min hour day month year) (get-decoded-time)
(format *LOGGER* "~&~d-~2,'0d-~2,'0d ~2,'0d:~2,'0d:~2,'0d: ~a: "
year month day
hour min sec
(wow ,level))
(format *LOGGER* ,@msg-args)))
(defmacro log-panic (&rest msg-args) `(log-msg 'PANIC ,@msg-args))
(defmacro log-crit (&rest msg-args) `(log-msg 'CRIT ,@msg-args))
(defmacro log-error (&rest msg-args) `(log-msg 'ERROR ,@msg-args))
(defmacro log-warn (&rest msg-args) `(log-msg 'WARN ,@msg-args))
(defmacro log-notice (&rest msg-args) `(log-msg 'NOTICE ,@msg-args))
(defmacro log-info (&rest msg-args) `(log-msg 'INFO ,@msg-args))
(defmacro log-debug (&rest msg-args) `(log-msg 'DEBUG ,@msg-args))
| 3,834 | Common Lisp | .lisp | 84 | 38.77381 | 78 | 0.407846 | dendrown/ostrich-ideas | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | 19041761ab28368d97ef822a5d1cf744cfa8b409fb4ee2ae5b5604430cd40b3f | 31,934 | [
-1
] |
31,935 | ostrich-ideas.asd | dendrown_ostrich-ideas/ostrich-ideas.asd | ;;; -*- Lisp -*-
(asdf:defsystem :ostrich-ideas
:version "0.2"
:author "Dennis Drown <[email protected]>"
:description "Get your head out of the sand!"
:components ((:file "logger")))
| 196 | Common Lisp | .asd | 6 | 30.166667 | 47 | 0.671958 | dendrown/ostrich-ideas | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | cced260f02c0598c1fc6b9d066f0b577ac07c0ff803ca8fae9fe4e240684d861 | 31,935 | [
-1
] |
31,952 | cl-hello-world.lisp | csvitlik_cl-hello-world/cl-hello-world.lisp | (defpackage #:cl-hello-world
(:use #:cl #:1am))
(in-package #:cl-hello-world)
(defun cl-hello-world ()
"Return the canonical ``Hello, World!'' string."
"Hello, World!")
(defconstant +expected-output-cl-hello-world+
"Hello, World!")
(test test-cl-hello
(is (string-equal (cl-hello-world) +expected-output-cl-hello-world+)))
| 337 | Common Lisp | .lisp | 10 | 31.3 | 72 | 0.696594 | csvitlik/cl-hello-world | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | 2a2096774a300e7b89d6f0da807c51203f5efd266441e224be634d2041d211ae | 31,952 | [
-1
] |
31,953 | cl-hello-world.asd | csvitlik_cl-hello-world/cl-hello-world.asd | (defsystem :cl-hello-world
:description "Common Lisp: Hello World"
:license "GPL-3"
:author "Charlie Svitlik <[email protected]>"
:components ((:file "cl-hello-world")))
| 187 | Common Lisp | .asd | 5 | 33.2 | 50 | 0.686813 | csvitlik/cl-hello-world | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | 5586c696212b9cc17a1b6008600b5c468b96774f943bc0d7ac01a23294b79675 | 31,953 | [
-1
] |
31,971 | mplayer.lisp | JMC-design_mplayer/mplayer.lisp | (defpackage :mplayer
(:use :cl :sb-ext)
(:export #:play
#:*mplayer-defaults*
#:send-command))
(in-package :mplayer)
;;; defaults --really should be replaced by defaults file and handle by the defaults package.
(defparameter *mplayer-defaults* '("-panscan" "1" "-volume" "5" "-loop" "0" "-quiet" "-slave" "-vo" "gl3")
"a list of strings to be fed to the mplayer executable, formatted as per man page")
(defun signal-status-changes (process)
"simply prints out status of the process"
(format t "~s" (process-status process)))
(defun play (file &key window (options *mplayer-defaults*) (status-hook #'signal-status-changes))
"Plays file with mplayer. You can specify an X11 window to be parented to, or options in addition to a status hook besides the basic default one."
(let ((arglist options))
(when window (setf arglist (concatenate 'list arglist `("-wid" ,(princ-to-string (xlib:window-id window))))))
(sb-ext:run-program "/usr/bin/mplayer"
`(,file ,@arglist)
:wait nil :input :stream :output :stream :status-hook status-hook)))
(defun send-command (mplayer-process command)
"Send the text string command, as per slave.txt, to mplayers input stream. Automatically adds a newline."
(with-open-stream (input-stream (sb-ext:process-input mplayer-process))
(format input-stream "~a~%" command )
(finish-output input-stream)))
| 1,384 | Common Lisp | .lisp | 24 | 54.208333 | 148 | 0.71323 | JMC-design/mplayer | 0 | 0 | 0 | LGPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | dfba54965d4d7d5d64644f102ed71f4e5733b012dd83cc59dd934c5e7efbfce8 | 31,971 | [
-1
] |
31,972 | mplayer.asd | JMC-design_mplayer/mplayer.asd | (in-package :asdf-user)
(defsystem "mplayer"
:description "A simple slave interface for mplayer to build a video application on."
:version "0.0.1"
:author "Johannes Martinez Calzada"
:licence "GNU LGPL 3.0"
:components ((:file "mplayer")))
| 252 | Common Lisp | .asd | 7 | 33.285714 | 86 | 0.728395 | JMC-design/mplayer | 0 | 0 | 0 | LGPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | 76768f9604f0ea4b22c10bbbbefe5cd5999ffb4560a02b58a26623433f932db1 | 31,972 | [
-1
] |
31,975 | slave.txt | JMC-design_mplayer/slave.txt | SLAVE MODE PROTOCOL
-------------------
The -slave option switches on slave mode, in which MPlayer works as a backend
for other programs. Instead of intercepting keyboard events, MPlayer will read
commands separated by a newline (\n) from stdin.
To try slave mode out by hand, run
mplayer -slave -quiet <movie>
and type slave commands into the console window.
You can also use a FIFO file (named pipe):
mkfifo </tmp/fifofile>
mplayer -slave -input file=</tmp/fifofile> <movie>
Most slave mode commands are equivalent to command line options, though not
necessarily under the same name. Detailed descriptions can be found in the
man page.
All commands can be prefixed with one of "pausing ", "pausing_keep ", or
"pausing_toggle ". "pausing " tells MPlayer to pause as soon as possible
after processing the command. "pausing_keep " tells MPlayer to do so only if
it was already in paused mode. "pausing_toggle " tells MPlayer to do so
only if it was not already in paused mode. Please note that "as soon as
possible" can be before the command is fully executed.
As a temporary hack, there is also the _experimental_ "pausing_keep_force "
prefix, with which MPlayer will not exit the pause loop at all.
Like this you can avoid the "frame stepping" effect of "pausing_keep "
but most commands will either not work at all or behave in unexpected ways.
For "set_mouse_pos" and "key_down_event", "pausing_keep_force" is the default
since other values do not make much sense for them.
Various tips and tricks (please help expand it!):
- Try using something like
pausing_keep_force pt_step 1
get_property pause
to switch to the next file. It avoids audio playback starting to play
the old file for a short time before switching to the new one.
- To ensure the user can't control MPlayer "behind your back" use
something like -input nodefault-bindings -noconfig all
Available commands ('mplayer -input cmdlist' will print a list):
af_add <filter_arguments_list> (comma separated list of audio filters with parameters)
(experimental) Load the given list of audio filters.
af_clr
(experimental) Unload all loaded audio filters.
af_cmdline <filter_name> <filter_arguments>
(experimental) Send new command-line options to a filter with the given name.
af_del <filter_name_list> (comma separated list of audio filter's names)
(experimental) Unload the first occurrence of the filters, if loaded.
af_switch <filter_arguments_list> (comma separated list of audio filters with parameters)
(experimental) Remove all the audio filters and replace them with the given list.
alt_src_step <value> (ASX playlist only)
When more than one source is available it selects the next/previous one.
audio_delay <value> [abs]
Set/adjust the audio delay.
If [abs] is not given or is zero, adjust the delay by <value> seconds.
If [abs] is nonzero, set the delay to <value> seconds.
[brightness|contrast|gamma|hue|saturation] <value> [abs]
Set/adjust video parameters.
If [abs] is not given or is zero, modifies parameter by <value>.
If [abs] is non-zero, parameter is set to <value>.
<value> is in the range [-100, 100].
capturing [value]
Toggle/set capturing the primary stream like -dumpstream.
Requires the -capture parameter to be given.
change_rectangle <val1> <val2>
Change the position of the rectangle filter rectangle.
<val1>
Must be one of the following:
0 = width
1 = height
2 = x position
3 = y position
<val2>
If <val1> is 0 or 1:
Integer amount to add/subtract from the width/height.
Positive values add to width/height and negative values
subtract from it.
If <val1> is 2 or 3:
Relative integer amount by which to move the upper left
rectangle corner. Positive values move the rectangle
right/down and negative values move the rectangle left/up.
dvb_set_channel <channel_number> <card_number>
Set DVB channel.
dvdnav <button_name>
Press the given dvdnav button.
up
down
left
right
menu
select
prev
mouse
edl_loadfile <filename>
Load new EDL file.
edl_mark
Write the current position into the EDL file.
frame_drop [value]
Toggle/set frame dropping mode.
get_audio_bitrate
Print out the audio bitrate of the current file.
get_audio_codec
Print out the audio codec name of the current file.
get_audio_samples
Print out the audio frequency and number of channels of the current file.
get_file_name
Print out the name of the current file.
get_meta_album
Print out the 'Album' metadata of the current file.
get_meta_artist
Print out the 'Artist' metadata of the current file.
get_meta_comment
Print out the 'Comment' metadata of the current file.
get_meta_genre
Print out the 'Genre' metadata of the current file.
get_meta_title
Print out the 'Title' metadata of the current file.
get_meta_track
Print out the 'Track Number' metadata of the current file.
get_meta_year
Print out the 'Year' metadata of the current file.
get_percent_pos
Print out the current position in the file, as integer percentage [0-100).
get_property <property>
Print out the current value of a property.
get_sub_visibility
Print out subtitle visibility (1 == on, 0 == off).
get_time_length
Print out the length of the current file in seconds.
get_time_pos
Print out the current position in the file in seconds, as float.
get_vo_fullscreen
Print out fullscreen status (1 == fullscreened, 0 == windowed).
get_video_bitrate
Print out the video bitrate of the current file.
get_video_codec
Print out the video codec name of the current file.
get_video_resolution
Print out the video resolution of the current file.
gui <message>
Send GUI skin message <message>. (See the skin documentation on GUI
messages for details.)
screenshot <value>
Take a screenshot. Requires the screenshot filter to be loaded.
0 Take a single screenshot.
1 Start/stop taking screenshot of each frame.
key_down_event <value>
Inject <value> key code event into MPlayer.
loadfile <file|url> <append>
Load the given file/URL, stopping playback of the current file/URL.
If <append> is nonzero playback continues and the file/URL is
appended to the current playlist instead.
loadlist <file> <append>
Load the given playlist file, stopping playback of the current file.
If <append> is nonzero playback continues and the playlist file is
appended to the current playlist instead.
loop <value> [abs]
Adjust/set how many times the movie should be looped. -1 means no loop,
and 0 forever.
menu <command>
Execute an OSD menu command.
up Move cursor up.
down Move cursor down.
ok Accept selection.
cancel Cancel selection.
hide Hide the OSD menu.
set_menu <menu_name>
Display the menu named <menu_name>.
mute [value]
Toggle sound output muting or set it to [value] when [value] >= 0
(1 == on, 0 == off).
osd [level]
Toggle OSD mode or set it to [level] when [level] >= 0.
osd_show_progression
Show the progression bar, the elapsed time and the total duration of the
movie on the OSD.
osd_show_property_text <string> [duration] [level]
Show an expanded property string on the OSD, see -playing-msg for a
description of the available expansions. If [duration] is >= 0 the text
is shown for [duration] ms. [level] sets the minimum OSD level needed
for the message to be visible (default: 0 - always show).
osd_show_text <string> [duration] [level]
Show <string> on the OSD.
panscan <-1.0 - 1.0> | <0.0 - 1.0> <abs>
Increase or decrease the pan-and-scan range by <value>, 1.0 is the maximum.
Negative values decrease the pan-and-scan range.
If <abs> is != 0, then the pan-and scan range is interpreted as an
absolute range.
pause
Pause/unpause the playback.
frame_step
Play one frame, then pause again.
pt_step <value> [force]
Go to the next/previous entry in the playtree. The sign of <value> tells
the direction. If no entry is available in the given direction it will do
nothing unless [force] is non-zero.
pt_up_step <value> [force]
Similar to pt_step but jumps to the next/previous entry in the parent list.
Useful to break out of the inner loop in the playtree.
quit [value]
Quit MPlayer. The optional integer [value] is used as the return code
for the mplayer process (default: 0).
radio_set_channel <channel>
Switch to <channel>. The 'channels' radio parameter needs to be set.
radio_set_freq <frequency in MHz>
Set the radio tuner frequency.
radio_step_channel <-1|1>
Step forwards (1) or backwards (-1) in channel list. Works only when the
'channels' radio parameter was set.
radio_step_freq <value>
Tune frequency by the <value> (positive - up, negative - down).
seek <value> [type]
Seek to some place in the movie.
0 is a relative seek of +/- <value> seconds (default).
1 is a seek to <value> % in the movie.
2 is a seek to an absolute position of <value> seconds.
seek_chapter <value> [type]
Seek to the start of a chapter.
0 is a relative seek of +/- <value> chapters (default).
1 is a seek to chapter <value>.
switch_angle <value>
Switch to the angle with the ID [value]. Cycle through the
available angles if [value] is omitted or negative.
set_mouse_pos <x> <y>
Tells MPlayer the coordinates of the mouse in the window.
This command doesn't move the mouse!
set_property <property> <value>
Set a property.
speed_incr <value>
Add <value> to the current playback speed.
speed_mult <value>
Multiply the current speed by <value>.
speed_set <value>
Set the speed to <value>.
step_property <property> [value] [direction]
Change a property by value, or increase by a default if value is
not given or zero. The direction is reversed if direction is less
than zero.
stop
Stop playback.
sub_alignment [value]
Toggle/set subtitle alignment.
0 top alignment
1 center alignment
2 bottom alignment
sub_delay <value> [abs]
Adjust the subtitle delay by +/- <value> seconds or set it to <value>
seconds when [abs] is nonzero.
sub_load <subtitle_file>
Loads subtitles from <subtitle_file>.
sub_log
Logs the current or last displayed subtitle together with filename
and time information to ~/.mplayer/subtitle_log. Intended purpose
is to allow convenient marking of bogus subtitles which need to be
fixed while watching the movie.
sub_pos <value> [abs]
Adjust/set subtitle position.
sub_remove [value]
If the [value] argument is present and non-negative, removes the subtitle
file with index [value]. If the argument is omitted or negative, removes
all subtitle files.
sub_select [value]
Display subtitle with index [value]. Turn subtitle display off if
[value] is -1 or greater than the highest available subtitle index.
Cycle through the available subtitles if [value] is omitted or less
than -1 (forward or backward respectively).
Supported subtitle sources are -sub options on the command
line, VOBsubs, DVD subtitles, and Ogg and Matroska text streams.
This command is mainly for cycling all subtitles, if you want to set
a specific subtitle, use sub_file, sub_vob, or sub_demux.
sub_source [source]
Display first subtitle from [source]. Here [source] is an integer:
SUB_SOURCE_SUBS (0) for file subs
SUB_SOURCE_VOBSUB (1) for VOBsub files
SUB_SOURCE_DEMUX (2) for subtitle embedded in the media file or DVD subs.
If [source] is -1, will turn off subtitle display.
If [value] is omitted or less than -1, will cycle between the first subtitle
of each currently available source (forward or backward respectively).
sub_file [value]
Display subtitle specified by [value] for file subs. The [value] is
corresponding to ID_FILE_SUB_ID values reported by '-identify'.
If [value] is -1, will turn off subtitle display.
If [value] is omitted or less than -1, will cycle all file subs
(forward or backward respectively).
sub_vob [value]
Display subtitle specified by [value] for VOBsubs. The [value] is
corresponding to ID_VOBSUB_ID values reported by '-identify'.
If [value] is -1, will turn off subtitle display.
If [value] is omitted or less than -1, will cycle all VOBsubs
(forward or backward respectively).
sub_demux [value]
Display subtitle specified by [value] for subtitles from DVD or embedded
in media file. The [value] is corresponding to ID_SUBTITLE_ID values
reported by '-identify'. If [value] is -1, will turn off subtitle display.
If [value] is omitted or less than -1, will cycle all DVD subs or embedded subs
(forward or backward respectively).
sub_scale <value> [abs]
Adjust the subtitle size by +/- <value> or set it to <value> when [abs]
is nonzero.
vobsub_lang
This is a stub linked to sub_select for backwards compatibility.
sub_step <value>
Step forward in the subtitle list by <value> steps or backwards if <value>
is negative.
sub_visibility [value]
Toggle/set subtitle visibility.
forced_subs_only [value]
Toggle/set forced subtitles only.
switch_audio [value] (currently MPEG*, AVI, Matroska and streams handled by libavformat)
Switch to the audio track with the ID [value]. Cycle through the
available tracks if [value] is omitted or negative.
switch_angle [value] (DVDs only)
Switch to the DVD angle with the ID [value]. Cycle through the
available angles if [value] is omitted or negative.
switch_ratio [value]
Change aspect ratio at runtime. [value] is the new aspect ratio expressed
as a float (e.g. 1.77778 for 16/9), or special value -1 to reset to
original aspect ratio (ditto if [value] is missing), or special value 0
to disable automatic movie aspect ratio compensation.
There might be problems with some video filters.
switch_title [value] (DVDNAV only)
Switch to the DVD title with the ID [value]. Cycle through the
available titles if [value] is omitted or negative.
switch_vsync [value]
Toggle vsync (1 == on, 0 == off). If [value] is not provided,
vsync status is inverted.
teletext_add_digit <value>
Enter/leave teletext page number editing mode and append given digit to
previously entered one.
0..9 - Append appropriate digit. (Enables editing mode if called from normal
mode, and switches to normal mode when third digit is entered.)
- - Delete last digit from page number. (Backspace emulation, works only
in page number editing mode.)
teletext_go_link <1-6>
Follow given link on current teletext page.
tv_start_scan
Start automatic TV channel scanning.
tv_step_channel <channel>
Select next/previous TV channel.
tv_step_norm
Change TV norm.
tv_step_chanlist
Change channel list.
tv_set_channel <channel>
Set the current TV channel.
tv_last_channel
Set the current TV channel to the last one.
tv_set_freq <frequency in MHz>
Set the TV tuner frequency.
tv_step_freq <frequency offset in MHz>
Set the TV tuner frequency relative to current value.
tv_set_norm <norm>
Set the TV tuner norm (PAL, SECAM, NTSC, ...).
tv_set_brightness <-100 - 100> [abs]
Set TV tuner brightness or adjust it if [abs] is set to 0.
tv_set_contrast <-100 -100> [abs]
Set TV tuner contrast or adjust it if [abs] is set to 0.
tv_set_hue <-100 - 100> [abs]
Set TV tuner hue or adjust it if [abs] is set to 0.
tv_set_saturation <-100 - 100> [abs]
Set TV tuner saturation or adjust it if [abs] is set to 0.
use_master
Switch volume control between master and PCM.
vo_border [value]
Toggle/set borderless display.
vo_fullscreen [value]
Toggle/set fullscreen mode.
vo_ontop [value]
Toggle/set stay-on-top.
vo_rootwin [value]
Toggle/set playback on the root window.
volume <value> [abs]
Increase/decrease volume or set it to <value> if [abs] is nonzero.
overlay_add <file> <id> <x> <y> <color>
Add an overlay bitmap. <file> must be a PGM file without comments.
<id> is an arbitrary integer used to identify the overlay.
overlay_remove <id>
Remove all overlays identified by <id>.
The following commands are really only useful for OSD menu console mode:
help
Displays help text, currently empty.
exit
Exits from OSD menu console. Unlike 'quit', does not quit MPlayer.
hide
Hides the OSD menu console. Clicking a menu command unhides it. Other
keybindings act as usual.
run <string>
Run <string> with properties expanded as shell command. In OSD menu
console mode stdout and stdin are through the video output driver.
Property expansion happens in the same way as for osd_show_property_text.
Note: MPlayer will do property expansion on anything of the form
${somevar} before it is passed to the shell.
This means that you cannot use this syntax for anything you actually
want the shell to handle, though any other form like $somevar will
be passed on to and processed by the shell.
Example:
run "echo ${filename} ${stream_pos} >> <path_to_file>"
Available properties:
name type min max get set step comment
=================================================================
osdlevel int 0 3 X X X as -osdlevel
speed float 0.01 100 X X X as -speed
loop int -1 X X X as -loop
pause flag 0 1 X 1 if paused, use with pausing_keep_force
filename string X file playing w/o path
path string X file playing
demuxer string X demuxer used
stream_pos pos 0 X X position in stream
stream_start pos 0 X start pos in stream
stream_end pos 0 X end pos in stream
stream_length pos 0 X (end - start)
stream_time_pos time 0 X present position in stream (in seconds)
titles int X number of titles
chapter int 0 X X X select chapter
chapters int X number of chapters
angle int 0 X X X select angle
length time X length of file in seconds
percent_pos int 0 100 X X X position in percent
time_pos time 0 X X X position in seconds
metadata str list X list of metadata key/value
metadata/* string X metadata values
volume float 0 100 X X X change volume
balance float -1 1 X X X change audio balance
mute flag 0 1 X X X
audio_delay float -100 100 X X X
audio_format int X
audio_codec string X
audio_bitrate int X
samplerate int X
channels int X
switch_audio int -2 255 X X X select audio stream
switch_angle int -2 255 X X X select DVD angle
switch_title int -2 255 X X X select DVD title
capturing flag 0 1 X X X dump primary stream if enabled
fullscreen flag 0 1 X X X
deinterlace flag 0 1 X X X
ontop flag 0 1 X X X
rootwin flag 0 1 X X X
border flag 0 1 X X X
framedropping int 0 2 X X X 1 = soft, 2 = hard
gamma int -100 100 X X X
brightness int -100 100 X X X
contrast int -100 100 X X X
saturation int -100 100 X X X
hue int -100 100 X X X
panscan float 0 1 X X X
vsync flag 0 1 X X X
video_format int X
video_codec string X
video_bitrate int X
width int X "display" width
height int X "display" height
fps float X
aspect float X
switch_video int -2 255 X X X select video stream
switch_program int -1 65535 X X X (see TAB default keybinding)
sub int -1 X X X select subtitle stream
sub_source int -1 2 X X X select subtitle source
sub_file int -1 X X X select file subtitles
sub_vob int -1 X X X select VOBsubs
sub_demux int -1 X X X select subs from demux
sub_delay float X X X
sub_pos int 0 100 X X X subtitle position
sub_alignment int 0 2 X X X subtitle alignment
sub_visibility flag 0 1 X X X show/hide subtitles
sub_forced_only flag 0 1 X X X
sub_scale float 0 100 X X X subtitles font size
tv_brightness int -100 100 X X X
tv_contrast int -100 100 X X X
tv_saturation int -100 100 X X X
tv_hue int -100 100 X X X
teletext_page int 0 799 X X X
teletext_subpage int 0 64 X X X
teletext_mode flag 0 1 X X X 0 - off, 1 - on
teletext_format int 0 3 X X X 0 - opaque,
1 - transparent,
2 - opaque inverted,
3 - transparency inverted,
teletext_half_page int 0 2 X X X 0 - off, 1 - top half,
2- bottom half
| 23,108 | Common Lisp | .l | 475 | 44.267368 | 98 | 0.642975 | JMC-design/mplayer | 0 | 0 | 0 | LGPL-3.0 | 9/19/2024, 11:41:25 AM (Europe/Amsterdam) | af1fd36bcbcf2c8f5f8938fb958afaa3e1eeb248e559b9c3cf7712904cbc829e | 31,975 | [
-1
] |
31,991 | lshell-util.lisp | LeZheng_l-lisp-tools/lshell-util.lisp | (defun sh (cmd)
#+clisp
(let ((str (ext:run-shell-command cmd :output :stream)))
(loop for line = (read-line str nil)
until (null line)
do (print line)
collect line))
#+ecl
(si:system cmd)
#+sbcl
(sb-ext:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*)
#+clozure
(ccl:run-program "/bin/sh" (list "-c" cmd) :input nil :output *standard-output*))
| 474 | Common Lisp | .lisp | 13 | 27.615385 | 91 | 0.54013 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 94a80fe73ced0b3c7ad8e92c0c0a4dbada57e0802bd2e1c436a1ea1d34c6daad | 31,991 | [
-1
] |
31,992 | tools-macro.lisp | LeZheng_l-lisp-tools/tools-macro.lisp | (defpackage :com.skyline.owl.lmacro
(:use "COMMON-LISP")
(:nicknames "l-macro" :l-macro l-macro)
(:export :nil!
:while
:for
:with-gensyms
:when-bind
:when-bind*
:if3 :nif :in-if :in :inq :>case
:till :do-tuples/c :do-tuples/o))
(in-package :com.skyline.owl.lmacro)
(defmacro nil! (var)
`(setf ,var nil))
(defmacro while (test &body body)
`(do ()
((not ,test))
,@body))
(defmacro for ((var start stop) &body body)
(let ((gstop (gensym)))
`(do ((,var ,start (1+ ,var))
(,gstop ,stop))
((> ,var ,gstop))
,&body)))
(defmacro when-bind ((var expr) &body body)
`(let ((,var ,expr))
(when ,var
,@body)))
;;;(when-bind* ((x (find-if #’consp ’(a (1 2) b)))
;;; (y (find-if #’oddp x)))
;;; (+ y 10))
(defmacro when-bind* (binds &body body)
(if (null binds)
`(prog ,@body)
`(let (,(car binds))
(if ,(caar binds)
(bind-when* ,(cdr binds) ,@body)))))
;;;(defmacro with-redraw ((var objs) &body body)
;;; (with-gensyms (gob x0 y0 x1 y1)
;;; ...))
(defmacro with-gensyms (syms &body body)
`(let ,(mapcar #'(lambda (s) `(,s (gensym))) syms)
,@body))
(defun condlet-clause (vars cl bodfn)
`(,(car cl) (let ,(mapcar #'cdr vars)
(let ,(condlet-binds vars cl)
(,bodfn ,@(mapcar #'cdr vars))))))
(defun condlet-binds (vars cl)
(mapcar #'(lambda (bindform)
(if (consp bindform)
(cons (cdr (assoc (car bindform) vars))
(cdr bindform))))
(cdr cl)))
;;;(condlet (((= 1 2) (x (princ ’a)) (y (princ ’b)))
;;; ((= 1 1) (y (princ ’c)) (x (princ ’d)))
;;; (t
;;; (x (princ ’e)) (z (princ ’f))))
;;; (list x y z))
(defmacro condlet (clauses &body body)
(let ((bodfn (gensym))
(vars (mapcar #'(lambda (v) (cons v (gensym)))
(remove-duplicates
(mapcar #'car (mappend #'cdr clauses))))))
`(labels ((,bodfn ,(mapcar #'car vars)
,@body))
(cond ,@(mapcar #'(lambda (cl)
(condlet-clause vars cl bodfn))
clauses)))))
(defmacro if3 (test t-case nil-case ?-case)
`(case ,test
((nil) ,nil-case)
(? ,?-case)
(t ,t-case)))
(defmacro nif (expr plus zero neg)
(let ((g (gensym)))
`(let ((,g ,expr))
(cond ((plusp ,g) ,plus)
((zerop ,g) ,zero)
(t ,neg)))))
(defmacro in (obj &rest choises)
(let ((insym (gensym)))
`(let ((,insym ,obj))
(or ,@(mapcar #'(lambda (c) `(eql ,insym ,c)) choises)))))
(defmacro inq (obj &rest choises)
`(in ,obj ,@(mapcar #'(lambda (a) `',a) choises)))
(defmacro in-if (fn &rest choises)
(let ((fnsym (gensym)))
`(let ((,fnsym ,fn))
(or ,@(mapcar #'(lambda (x) `(funcall ,fnsym ,x)) choises)))))
(defmacro >case (expr &rest clauses)
(let ((g (gensym)))
`(let ((,g ,expr))
(cond ,@(mapcar #'(lambda (cl) (>casex g cl)) clauses)))))
(defmacro >casex (g cl)
(let ((key (car cl)) (rest (cdr cl)))
(cond ((consp key) `((in ,g ,@key) ,@rest))
((inq key t otherwise) `(t ,@rest))
(t (error "bad >case clause")))))
(defmacro till (test &body body)
`(do ()
(,test)
,@body))
(defmacro do-tuples/o (params source &body body)
(if params
(let ((src (gensym)))
`(prog ((,src ,source))
(mapc #'(lambda ,params ,@body)
,@(map0-n #'(lambda (n)
`(nthcdr ,n ,src))
(- (length source)
(length params))))))))
(defmacro do-tuples/c (params source &body body)
(if params
(with-gensyms (src rest bodfn)
(let ((len (length params)))
`(let ((,src ,source))
(when (nthcdr ,(1- len) ,src)
(labels ((,bodfn ,params ,@body))
(do ((,rest ,src (cdr ,rest)))
((not (nthcdr ,(1- len) ,rest))
,@(mapcar #'(lambda (args)
`(,bodfn ,@args))
(dt-args len rest src))
nil)
(,bodfn ,@(map1-n #'(lambda (n) `(nth ,(1- n)
,rest))
len))))))))))
(defun dt-args (len rest src)
(map0-n #'(lambda (m)
(map1-n #'(lambda (n)
(let ((x (+ m n)))
(if (>= x len)
`(nth ,(-x len) ,src)
`(nth ,(1- x) ,rest))))
len))
(- len 2)))
(defmacro mvdo* (param-cl test-cl &body body)
(mvdo-gen param-cl param-cl test-cl body))
(defun mvdo-gen (binds rebinds test body)
(if (null binds)
(let ((label (gensym)))
`(prog nil
,label
(if ,(car test)
(return (progn ,@(cdr test))))
,@body
,@(mvdo-rebind-gen rebinds)
(go ,label)))
(let ((rec (mvdo-gen (cdr binds) rebinds test body)))
(let ((var/s (caar binds)) (expr (cadar binds)))
(if (atom var/s)
`(let ((,var/s ,expr)) ,rec)
`(multiple-value-bind ,var/s ,expr ,rec))))))
(defun mvdo-rebind-gen (rebinds)
(cond ((null rebinds) nil)
((< (length (car rebinds)) 3)
(mvdo-rebind-gen (cdr rebinds)))
(t
(cons (list (if (atom (caar rebinds))
'setq
'multiple-value-setq)
(caar rebinds)
(third (car rebinds)))
(mvdo-rebind-gen (cdr rebinds))))))
(defmacro mvpsetq (&rest args)
(let* ((pairs (group args 2))
(syms (mapcar #'(lambda (p)
(mapcar #'(lambda (x) (gensym))
(mklist (car p))))
pairs)))
(labels ((rec (ps ss)
(if (null ps)
`(setq
,@(mapcan #'(lambda (p s)
(shuffle (mklist (car p))
s))
pairs syms))
(let ((body (rec (cdr ps) (cdr ss))))
(let ((var/s (caar ps))
(expr (cadar ps)))
(if (consp var/s)
`(multiple-value-bind ,(car ss)
,expr
,body)
`(let ((,@(car ss) ,expr))
,body)))))))
(rec pairs syms))))
(defun shuffle (x y)
(cond ((null x) y)
((null y) x)
(t (list* (car x) (car y) (shuffle (cdr x) (cdr y))))))
(defmacro mvdo (binds (test &rest result) &body body)
(let ((label (gensym))
(temps (mapcar #'(lambda (b)
(if (listp (car b))
(mapcar #'(lambda (x)
(gensym))
(car b))
(gensym)))
binds)))
`(let ,(mappend #'mklist temps)
(mvpsetq ,@(mapcan #'(lambda (b var)
(list var (cadr b)))
binds
temps))
(prog ,(mapcar #'(lambda (b var) (list b var))
(mappend #'mklist (mapcar #'car binds))
(mappend #'mklist temps))
,label
(if ,test
(return (progn ,@result)))
,@body
(mvpsetq ,@(mapcan #'(lambda (b)
(if (third b)
(list (car b)
(third b))))
binds))
(go ,label)))))
;;;12.1
(defmacro allf (val &rest args)
(with-gensyms (gval)
‘(let ((,gval ,val))
(setf ,@(mapcan #’(lambda (a) (list a gval))
args)))))
(defmacro nilf (&rest args) ‘(allf nil ,@args))
(defmacro tf (&rest args) ‘(allf t ,@args))
(defmacro toggle (&rest args)
‘(progn
,@(mapcar #’(lambda (a) ‘(toggle2 ,a))
args)))
(define-modify-macro toggle2 () not)
;;;12.2
(define-modify-macro concf (obj) nconc)
(defun conc1f/function (place obj)
(nconc place (list obj)))
(define-modify-macro conc1f (obj) conc1f/function)
(defun concnew/function (place obj &rest args)
(unless (apply #’member obj place args)
(nconc place (list obj))))
(define-modify-macro concnew (obj &rest args)
concnew/function)
;;;12.3
(defmacro _f (op place &rest args)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
‘(let* (,@(mapcar #’list vars forms)
(,(car var) (,op ,access ,@args)))
,set)))
(defmethod pull (obj place &rest args)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
(let ((g (gensym)))
‘(let* ((,g ,obj)
,@(mapcar #’list vars forms)
(,(car var) (delete ,g ,access ,@args)))
,set))))
(defmacro pull-if (test place &rest args)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
(let ((g (gensym)))
‘(let* ((,g ,test)
,@(mapcar #’list vars forms)
(,(car var) (delete-if ,g ,access ,@args)))
,set))))
(defmacro popn (n place)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
(with-gensyms (gn glst)
‘(let* ((,gn ,n)
,@(mapcar #’list vars forms)
(,glst ,access)
(,(car var) (nthcdr ,gn ,glst)))
(prog1 (subseq ,glst 0 ,gn)
,set)))))
;;;12.4
(defmacro sortf (op &rest places)
(let* ((meths (mapcar #’(lambda (p)
(multiple-value-list
(get-setf-expansion p)))
places))
(temps (apply #’append (mapcar #’third meths))))
‘(let* ,(mapcar #’list
(mapcan #’(lambda (m)
(append (first m)
(third m)))
meths)
(mapcan #’(lambda (m)
(append (second m)
(list (fifth m))))
meths))
,@(mapcon #’(lambda (rest)
(mapcar
#’(lambda (arg)
‘(unless (,op ,(car rest) ,arg)
(rotated ,(car rest) ,arg)))
(cdr rest)))
temps)
,@(mapcar #’fourth meths))))
;;;14.1
(defmacro aif (test-form then-form &optional else-form)
‘(let ((it ,test-form))
(if it ,then-form ,else-form)))
(defmacro awhen (test-form &body body)
‘(aif ,test-form
(progn ,@body)))
(defmacro awhile (expr &body body)
‘(do ((it ,expr ,expr))
((not it))
,@body))
(defmacro aand (&rest args)
(cond ((null args) t)
((null (cdr args)) (car args))
(t ‘(aif ,(car args) (aand ,@(cdr args))))))
(defmacro acond (&rest clauses)
(if (null clauses)
nil
(let ((cl1 (car clauses))
(sym (gensym)))
‘(let ((,sym ,(car cl1)))
(if ,sym
(let ((it ,sym)) ,@(cdr cl1))
(acond ,@(cdr clauses)))))))
;;;14.2
(defmacro alambda (parms &body body)
‘(labels ((self ,parms ,@body))
#’self))
(defmacro ablock (tag &rest args)
‘(block ,tag
,(funcall (alambda (args)
(case (length args)
(0 nil)
(1 (car args))
(t ‘(let ((it ,(car args)))
,(self (cdr args))))))
args)))
;;;14.3
(defmacro aif2 (test &optional then else)
(let ((win (gensym)))
‘(multiple-value-bind (it ,win) ,test
(if (or it ,win) ,then ,else))))
(defmacro awhen2 (test &body body)
‘(aif2 ,test
(progn ,@body)))
(defmacro awhile2 (test &body body)
(let ((flag (gensym)))
‘(let ((,flag t))
(while ,flag
(aif2 ,test
(progn ,@body)
(setq ,flag nil))))))
(defmacro acond2 (&rest clauses)
(if (null clauses)
nil
(let ((cl1 (car clauses))
(val (gensym))
(win (gensym)))
‘(multiple-value-bind (,val ,win) ,(car cl1)
(if (or ,val ,win)
(let ((it ,val)) ,@(cdr cl1))
(acond2 ,@(cdr clauses)))))))
;;;14.4
(let ((g (gensym)))
(defun read2 (&optional (str *standard-input*))
(let ((val (read str nil g)))
(unless (equal val g) (values val t)))))
(defmacro do-file (filename &body body)
(let ((str (gensym)))
‘(with-open-file (,str ,filename)
(awhile2 (read2 ,str)
,@body))))
;;;15.1
(defmacro fn (expr) ‘#’,(rbuild expr))
(defun rbuild (expr)
(if (or (atom expr) (eq (car expr) ’lambda))
expr
(if (eq (car expr) ’compose)
(build-compose (cdr expr))
(build-call (car expr) (cdr expr)))))
(defun build-call (op fns)
(let ((g (gensym)))
‘(lambda (,g)
(,op ,@(mapcar #’(lambda (f)
‘(,(rbuild f) ,g))
fns)))))
(defun build-compose (fns)
(let ((g (gensym)))
‘(lambda (,g)
,(labels ((rec (fns)
(if fns
‘(,(rbuild (car fns))
,(rec (cdr fns)))
g)))
(rec fns)))))
;;;15.2
(defmacro alrec (rec &optional base)
”cltl2 version”
(let ((gfn (gensym)))
‘(lrec #’(lambda (it ,gfn)
(symbol-macrolet ((rec (funcall ,gfn)))
,rec))
,base)))
(defmacro on-cdrs (rec base &rest lsts)
‘(funcall (alrec ,rec #’(lambda () ,base)) ,@lsts))
;;;15.4
(defun unions (&rest sets)
(on-cdrs (union it rec) (car sets) (cdr sets)))
(defun intersections (&rest sets)
(unless (some #’null sets)
(on-cdrs (intersection it rec) (car sets) (cdr sets))))
(defun differences (set &rest outs)
(on-cdrs (set-difference rec it) set outs))
(defun maxmin (args)
(when args
(on-cdrs (multiple-value-bind (mx mn) rec
(values (max mx it) (min mn it)))
(values (car args) (car args))
(cdr args))))
;;;15.5
(defmacro atrec (rec &optional (base ’it))
”cltl2 version”
(let ((lfn (gensym)) (rfn (gensym)))
‘(trec #’(lambda (it ,lfn ,rfn)
(symbol-macrolet ((left (funcall ,lfn))
(right (funcall ,rfn)))
,rec))
#’(lambda (it) ,base))))
(defmacro on-trees (rec base &rest trees)
‘(funcall (atrec ,rec ,base) ,@trees))
;;;15.7
(defconstant unforced (gensym))
(defstruct delay forced closure)
(defmacro delay (expr)
(let ((self (gensym)))
‘(let ((,self (make-delay :forced unforced)))
(setf (delay-closure ,self)
#’(lambda ()
(setf (delay-forced ,self) ,expr)))
,self)))
(defun force (x)
(if (delay-p x)
(if (eq (delay-forced x) unforced)
(funcall (delay-closure x))
(delay-forced x))
x))
| 14,871 | Common Lisp | .lisp | 444 | 24.056306 | 70 | 0.481484 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 3ff8bb5a2f111ed446c9b7cabb017a1b821b2e3b3ea8722cc0c5936803d6de4b | 31,992 | [
-1
] |
31,993 | fs-util.lisp | LeZheng_l-lisp-tools/fs-util.lisp | (defpackage :com.skyline.owl.fs
(:use :COMMON-LISP :EXT)
(:nicknames :l-fs l-fs "l-fs")
(:export :list-directory
:file-exists-p
:walk-directory
:file-to-list
:list-to-file))
(in-package :com.skyline.owl.fs)
(defun component-present-p (value)
(and value (not (eql value :unspecific))))
(defun directory-pathname-p (p)
(and
(not (component-present-p (pathname-name p)))
(not (component-present-p (pathname-type p)))
p))
(defun pathname-as-directory (n)
(let ((path (pathname n)))
(when (wild-pathname-p path)
(error "path error"))
(if (not (directory-pathname-p n))
(make-pathname
:directory (append (or (pathname-directory path) (list :relative))
(list (file-namestring path)))
:name nil
:type nil
:defaults path)
path)))
(defun pathname-as-file (name)
(let ((pathname (pathname name)))
(when (wild-pathname-p pathname)
(error "Can't reliably convert wild pathname."))
(if (directory-pathname-p name)
(let* ((directory (pathname-directory pathname))
(name-and-type (pathname (first (last directory)))))
(make-pathname
:directory (butlast directory)
:name (pathname-name name-and-type)
:type (pathname-type name-and-type)
:defaults pathname))
pathname)))
(defun directory-wildcard (path)
(make-pathname
:name :wild
:type #-clisp :wild #+clisp nil
:defaults (pathname-as-directory path)))
(defun list-directory (dirname)
"This function is to list dir by dirname,like:
(list-directory \"/home\")"
(when (wild-pathname-p dirname)
(error "Can only list concrete directory names.*"))
(let ((wildcard (directory-wildcard dirname)))
#+(or sbcl cmu lispworks)
(directory wildcard)
#+openmcl
(directory wildcard :directories t)
#+allegro
(directory wildcard :directories-are-files nil)
#+clisp
(nconc
(directory wildcard)
(directory (clisp-subdirectories-wildcard wildcard)))
#-(or sbcl cmu lispworks openmcl allegro clisp)
(error "list-directory not implemented")))
#+clisp
(defun clisp-subdirectories-wildcard (wildcard)
(make-pathname
:directory (append (pathname-directory wildcard) (list :wild))
:name nil
:type nil
:defaults wildcard))
(defun file-exists-p (pathname)
"This function is to test file exist or not,like:
(file-exists-p \"/home/admin/a.txt)"
#+(or sbcl lispworks openmcl)
(probe-file pathname)
#+(or allegro cmu)
(or (probe-file (pathname-as-directory pathname))
(probe-file pathname))
#+clisp
(or (ignore-errors
(probe-file (pathname-as-file pathname)))
(ignore-errors
(let ((directory-form (pathname-as-directory pathname)))
(when (ext:probe-directory directory-form)
directory-form))))
#-(or sbcl cmu lispworks openmcl allegro clisp)
(error "list-directory not implemented"))
(defun walk-directory (dirname fn &key directories (test (constantly t)))
"This function is to map fn into items in dirname,like:
(l-fs:walk-directory \"/home/skyline/temp\" #'(lambda (d) (print d)) :directories t)"
(labels
((walk (name)
(cond
((directory-pathname-p name)
(when (and directories (funcall test name))
(funcall fn name))
(dolist (x (list-directory name)) (walk x)))
((funcall test name) (funcall fn name)))))
(walk (pathname-as-directory dirname))))
(defun file-to-list (filename)
"This function to read file to list with line,like:
(file-to-list \"/home/admin/a.txt\")"
(with-open-file (str filename :direction :input
:if-does-not-exist nil)
(loop for line = (read-line str nil) while line collect line)))
(defun list-to-file (lst filename)
"This function is to write list to file with line,like:
(list-to-file '(a b c) \"/home/admin/a.txt\")"
(with-open-file (str filename :direction :output
:if-exists :supersede
:if-does-not-exist :create)
(dolist (line lst)
(format str "~a" line)
(write-line "" str))))
(defun file-to-string (filename)
(with-open-file (stream filename :direction :input :if-does-not-exist nil)
(reduce #'(lambda (s1 s2) (concatenate 'string s1 s2 "\n"))
(loop for line = (read-line stream nil) while line collect line))))
(defun ls (path)
"This function is to list directory in string,like:
(ls \"/home/admin\")"
(mapcar #'(lambda (p)
(namestring p))
(list-directory path)))
| 4,716 | Common Lisp | .lisp | 125 | 31 | 87 | 0.639207 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 18cb0d21f4c9fa406f878e3ff6119101a943e81d21d0ab673e358f0336d0a562 | 31,993 | [
-1
] |
31,994 | tools-fun.lisp | LeZheng_l-lisp-tools/tools-fun.lisp | (ql:quickload "cl-ppcre")
(defpackage :com.skyline.owl.tools
(:use :COMMON-LISP)
(:nicknames "l-util" l-util :l-util)
(:export :single? :append1 :map-int :filter :most :best :mostn :last1 :to-be-list :longer :group :classfy :flatten :prune
:find2 :before :after :duplicate :split-if
:readlist :prompt :break-loop
:mkstr :symb :reread :explode
:mapa-b :map0-n :map1-n :map-> :mappend :mapcars :rmapcar
:!! :def! :memoize :compose :fif :fint :fun :lrec :ttrav :trec
:extract-words :as-keyword))
(in-package :com.skyline.owl.tools)
(proclaim '(inline single? append1 map-int filter most best mostn last1 to-be-list longer group flatten prune
nconc1 mklist
find2 before after duplicate split-if
readlist prompt break-loop
mkstr symb reread explode
mapa-b map0-n map1-n map-> mappend mapcars rmapcar
!! def! memoize compose fif fint fun lrec ttrav trec))
;;;-------------list method-------------
(defun single? (lst)
"This function is to test lst whether contain one item,like:
(single? '(1))"
(if (consp lst)
(null (cdr lst))))
(defun append1 (lst obj)
"This function is to append a item to list,like:
(append1 '(1 2 3) 4)"
(append lst (list obj)))
(defun map-int (fn num)
"This function is to map 0 to num-1 by funcall fn,like:
(map-int #1+ 10)"
(let ((result nil))
(dotimes (n num)
(push (funcall fn n) result))
(nreverse result)))
(defun filter (fn lst)
"This function is to filter item by funcall fn,like:
(filter #'(lambda (x) (if (evenp x) x)) '(1 2 3 4 5 6 7 8 9))"
(let ((result nil))
(dolist (x lst)
(let ((r (funcall fn x)))
(if r (push r result))))
(nreverse result)))
(defun last1 (lst)
"This funcion is to get the last car from lst,like:
(last1 '(1 2 3))"
(car (last lst)))
(defun nconc1 (lst obj)
(nconc lst (list obj)))
(defun mklist (obj)
(if (listp obj) obj (list obj)))
(defun to-be-list (obj)
"This function is to make obj to list,like:
(to-be-list '(1 2 3)) or (to-be-list 1)"
(if (listp obj) obj (list obj)))
(defun longer (x y)
"This function is to judge which list is longer than another,like:
(longer '(1 2 3) '(1 2 3 4))"
(labels ((compare (x y)
(and (consp x)
(or (null y)
(compare (cdr x) (cdr y))))))
(if (and (listp x) (listp y))
(compare x y)
(> (length x) (length y)))))
(defun group (source n)
"This function is to split list by num,like:
(group '(1 2 3 4 5 6 7) 3)"
(if (zerop n) (error ”zero length”))
(labels ((rec (source acc)
(let ((rest (nthcdr n source)))
(if (consp rest)
(rec rest (cons (subseq source 0 n) acc))
(nreverse (cons source acc))))))
(if source (rec source nil) nil)))
(defun associate (&rest objs);;TODO does not have good idea
"This function is to associate objects and return a function,like:
(funcall (associate 1 2 3))"
#'(lambda (&optional (f #'list))
(apply f objs)))
(defun fold-right (op init seq)
"This function is to fold-right seq by op,like:
(fold-right #'+ 0 '(1 2 3 4))"
(if (null seq)
init
(funcall op (car seq)
(fold-right op init (cdr seq)))))
(defun fold-left (op init seq)
"This function is to fold-left seq by op,like:
(fold-left #'+ 0 '(1 2 3 4))"
(labels ((iter (op init rest)
(if (null rest)
init
(iter op (funcall op (car rest) init) (cdr rest)))))
(iter op init seq)))
(defun classfy (items &key (key #'identity) (test #'equal))
"This function is to classfy items by test key,like:
(classfy '(1 2 3 4 5 6 7 8) :key #'evenp)"
(let ((result-table (make-hash-table :test test))
(result nil))
(dolist (item items)
(let ((k (funcall key item)))
(if (null (gethash k result-table))
(setf (gethash k result-table) (list item))
(setf (gethash k result-table) (append (gethash k result-table) (list item))))))
(maphash #'(lambda (k v) (push v result)) result-table)
result))
(defun flatten (x)
"This function is to extract list in list,like:
(flatten '(1 2 (3 4 5)))"
(labels ((rec (x acc)
(cond ((null x) acc)
((atom x) (cons x acc))
(t (rec (car x) (rec (cdr x) acc))))))
(rec x nil)))
(defun prune (test tree)
"This function is filter to tree,like:
(prune #'evenp '(1 2 (3 4 5)))"
(labels ((rec (tree acc)
(cond ((null tree) (nreverse acc))
((consp (car tree))
(rec (cdr tree)
(cons (rec (car tree) nil) acc)))
(t (rec (cdr tree)
(if (funcall test (car tree))
acc
(cons (car tree) acc)))))))
(rec tree nil)))
(defun flatten! (l &key (start "{") (end "}") (test #'equal))
"This function is create tree from list,like this:
(flatten! '(1 2 { 3 { 99 } 4 } 5 { 8 9 } 6) :start '{ :end '} :test #'equal)"
(do* ((result nil)
(res l)
(s-index (position start l :test test) (position start res :test test))
(e-index (position end l :test test) (position end res :test test)))
((or (null s-index) (< e-index s-index)) (if (and (null s-index) (null e-index))
(append result res)
(setf result (cons (append result (subseq res 0 e-index)) (subseq res (1+ e-index))))))
(setf result (append result (subseq res 0 s-index)))
(setf res (flatten! (subseq res (1+ s-index)) :start start :end end :test test))))
;;;-------------- search -------------------
(defun find2 (fn lst)
"This function is to find the item and values which fit in fn,like:
(find2 #'(lambda (x) (> x 5)) '(4 5 6 7 8))"
(if (null lst)
nil
(let ((val (funcall fn (car lst))))
(if val
(values (car lst) val)
(find2 fn (cdr lst))))))
(defun before (x y lst &key (test #'eql))
"This function is to judge whether x is before y in lst,like:
(before 'b 'd '(a b c d))"
(and lst
(let ((item (car lst)))
(cond ((funcall test y item) nil)
((funcall test x item) lst)
(before x y (cdr lst) :test test)))))
(defun after (x y lst &key (test #'eql))
"This function is to judge whether x is after y in lst,like:
(after 'd 'b '(a b c d))"
(let ((res (before x y lst :test test)))
(and res (member y res :test test) )))
(defun duplicate (x lst &key (test #'eql))
"This function is to judge the item whether is duplicate in lst,like:
(duplicate 'a '(a b c d a) :test #'eql)"
(member x (cdr (member x lst :test test)) :test test))
(defun split-if (fn lst)
"This function is to split lst by fn,like:
(split-if #'(lambda (x) (> x 5)) '( 3 4 5 6 7 ))"
(let ((acc nil))
(do ((src lst (cdr src)))
((or (null src) (funcall fn (car src)))
(values (nreverse acc) src))
(push (car src) acc))))
(defun most (fn lst)
"This function is to get the item and score which score is highest with funcall fn,like:
(most #'(lambda (x) (if (> x 0) x (- x))) '(1 -2 3 -4))"
(let ((result nil)(robj nil))
(dolist (x lst)
(let ((s (funcall fn x)))
(if (null result)
(and (setf result s) (setf robj x))
(and (> s result) (setf result s) (setf robj x)))))
(values robj result)))
(defun best (fn lst)
"This function is to get the winner which compare with each other by fn,like:
(best #'> '(1 -2 3 -4))"
(if (null lst)
nil
(let ((win (car lst)))
(dolist (x (cdr lst))
(if (funcall fn x win)
(setf win x)))
win)))
(defun mostn (fn lst)
"This function is to get the items and score which score is highest with funcall fn,like:
(mostn #'(lambda (x) (if (> x 0) x (- x))) '(1 -2 3 -4 4))"
(if (null lst)
(values nil nil)
(let ((result (list (car lst)))
(m-score (funcall fn (car lst))))
(dolist (item (cdr lst))
(let ((score (funcall fn item)))
(cond
((> score m-score) (setf m-score score) (setf result (list item)))
((= score m-score) (push item result)))))
(values (nreverse result) m-score))))
;;; ------ IO -------
(defun readlist (&rest args)
"This function is to readlist from (apply #'read-line args) and concatenate ( ),like:
(readlist t)"
(values (read-from-string (concatenate 'string "(" (apply #'read-line args) ")"))))
(defun prompt (&rest args)
"This function is to print msg and read item from *query-io*,like:
(prompt \"please input ~A number:\" 2)"
(apply #'format *query-io* args)
(read *query-io*))
(defun break-loop (fn quit &rest args)
"This function is to provide a env to read and exec,like:
(break-loop #'eval #'(lambda (x) (eq x :q)) \">> \")"
(format *query-io* "Entering break-loop '~%")
(loop
(let ((in (apply #'prompt args)))
(if (funcall quit in)
(return)
(format *query-io* "~A~%" (funcall fn in))))))
;;;------ STRING ------
(defun mkstr (&rest args)
"This function is to mk str by args,like:
(mkstr 'a '2 3)"
(with-output-to-string (s)
(dolist (a args) (princ a s))))
(defun symb (&rest args)
"This function is to provide a symbol from args,like:
(symb 'a 'b \"C\")"
(values (intern (apply #'mkstr args))))
(defun reread (&rest args)
"This function is to provide a lisp obj from args,like:
(reread 'a 'b 2)"
(values (read-from-string (apply #'mkstr args))))
(defun explode (sym)
"This function is to provide a list from symbol,like:
(explode 'abc)"
(map 'list #'(lambda (c) (intern (make-string 1 :initial-element c)))
(symbol-name sym)))
;;;------ MAP -------
(defun mapa-b (fn a b &optional (step 1))
"This function map fn from a to b by step,like:
(mapa-b #'1+ 5 10)"
(do ((i a (+ i step))
(result nil))
((> i b) (nreverse result))
(push (funcall fn i) result)))
(defun map0-n (fn n)
"This function map fn from 0 to n,like:
(map0-n #'1+ 5)"
(mapa-b fn 0 n))
(defun map1-n (fn n)
"This function map fn from 1 to n,like:
(map1-n #1+ 3)"
(mapa-b fn 1 n))
(defun map-> (fn start test-fn succ-fn)
"This function is to map fn from start to where test-fn step by succ-fn,like:
(map-> #'evenp 0 #'(lambda (x) (> x 5)) #'1+)"
(do ((i start (funcall succ-fn i)) (result nil))
((funcall test-fn i) (nreverse result))
(push (funcall fn i) result)))
(defun mappend (fn &rest lst)
"This is no destroy mapcan,like:
(mappend #'(lambda (x) (and (numberp x) (list x)))
'(a 1 b c 3 4 d 5))"
(apply #'append (apply #'mapcar fn lst)))
(defun mapcars (fn &rest lsts)
"This function like mapcar but can input some list,like:
(mapcars #'sqrt '(1 2 3) '(4 5))"
(let ((result nil))
(dolist (lst lsts)
(dolist (obj lst)
(push (funcall fn obj) result)))
(nreverse result)))
(defun rmapcar (fn &rest args)
"This function is recursive mapcar,like:
(rmapcar #'+ '(1 (2 (3) 4)) '(10 (20 (30) 40)))"
(if (some #'atom args)
(apply fn args)
(apply #'mapcar #'(lambda (&rest args) (apply #'rmapcar fn args))
args)))
;;;------ fun constructor ------
(defvar *!equivs* (make-hash-table))
(defun !! (fn)
"This function is to get !fn from *!equivs*"
(or (gethash fn *!equivs*) fn))
(defun def! (fn fn!)
"This function is to def !fn,like:
(def! #'+ #'-)"
(setf (gethash fn *!equivs*) fn!))
(defun memoize (fn)
"This function construct a function having result cache,like:
(setf m+ (memoize #'+))"
(let ((cache (make-hash-table :test #'equal)))
#'(lambda (&rest args)
(multiple-value-bind (val win) (gethash args cache)
(if win
val
(setf (gethash args cache) (apply fn args)))))))
(defun compose (&rest fns)
"This function construct a function compose fns by reduce,like:
(funcall (compose #'sqrt #'1+ #'1+) 2)"
(if fns
(let ((fun1 (car (last fns)))
(funs (butlast fns)))
#'(lambda (&rest args)
(reduce #'funcall funs
:from-end t
:initial-value (apply fun1 args))))
#'identity))
(defun fif (if then &optional else)
"This function is to construct a function do if then else,like:
(funcall (fif #'evenp #'print) 3)"
#'(lambda (x)
(if (funcall if x)
(funcall then x)
(if else (funcall else x)))))
;;function intersection (and)
(defun fint (fn &rest fns)
"This function is to provide a function which and fn fns,like:
(funcall (fint #'numberp #'evenp #'(lambda (x) (> x 5))) 6)"
(if (null fns)
fn
(let ((chain (apply #'fint fns)))
#'(lambda (x)
(and (funcall fn x) (funcall chain x))))))
;;function unintersrction (or)
(defun fun (fn &rest fns)
"This function construct a function which or fn fns,like:
(funcall (fun #'evenp #'(lambda (x) (> x 5))) 6)"
(if (null fns)
fn
(let ((chain (apply #'fint fns)))
#'(lambda (x)
(or (funcall fn x) (funcall chain x))))))
;;list recurse
(defun lrec (rec &optional base)
"This function construct a function recurse list,like:
(funcall (lrec #'(lambda (x f) (cons x (funcall f)))) '(1 2 3))"
(labels ((self (lst)
(if (null lst)
(if (functionp base)
(funcall base)
base)
(funcall rec (car lst)
#'(lambda ()
(self (cdr lst)))))))
#'self))
;;;tree traverser
(defun ttrav (rec &optional (base #'identity))
"This function construct a function traverser tree,like:
(funcall (ttrav #'nconc #'list) '(1 2 (3 4) 5))"
(labels ((self (tree)
(if (atom tree)
(if (functionp base)
(funcall base tree)
base)
(funcall rec (self (car tree))
(if (cdr tree)
(self (cdr tree)))))))
#'self))
(defun trec (rec &optional (base #'identity))
"This function construct a function traverser tree item,like:
(funcall (trec #'(lambda (o l r) (nconc (funcall l) (funcall r))) #'list) '(1 2 (3 4) 5))"
(labels ((self (tree)
(if (atom tree)
(if (functionp base)
(funcall base tree)
base)
(funcall rec tree
#'(lambda () (self (car tree)))
#'(lambda () (if (cdr tree) (self (cdr tree))))))))
#'self))
(defun as-keyword (sym)
"This function make sym to be a keyword"
(intern (string sym) :keyword))
| 14,728 | Common Lisp | .lisp | 384 | 31.979167 | 134 | 0.576219 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 92a9afc83a160e8c987690233b2010c280eaf3d634ad419015eb04e59d955091 | 31,994 | [
-1
] |
31,995 | lsql-util.lisp | LeZheng_l-lisp-tools/lsql-util.lisp | (defpackage :com.skyline.owl.lsql
(:use :COMMON-LISP)
(:nicknames "l-sql" l-sql :l-sql)
(:export :l-select
:l-selectr
:l-delete
:l-update
:l-insert))
(in-package :com.skyline.owl.lsql)
(defun l-select (&key (content #'(lambda (a) a)) (from nil) (where #'(lambda (a) t)))
"This function is to select something from list,like:
(l-select :CONTENT #'length
:FROM '(\"123456\" \"321\" \"444\")
:WHERE #'(lambda (x) (> (length x) 3)))"
(let ((r nil))
(dolist (obj from)
(if (funcall where obj)
(push (funcall content obj) r)))
(reverse r)))
(defun l-selectr (&key (content #'(lambda (a) a)) (from nil) (where #'(lambda (a) t)))
"This function is to select something from tree,like:
(l-selectr :FROM '((1 2 3 4) (5 6 7 8) (11 22 33))
:WHERE #'(lambda (x) (> x 6)))"
(let ((r nil))
(dolist (obj from)
(if (atom obj)
(if (funcall where obj)
(push (funcall content obj) r))
(push (l-selectr :content content :from obj :where where) r)))
(reverse r)))
(defun l-insert (item &key (to nil) (before #'(lambda (a) nil)) (after #'(lambda (a) nil)) (at nil))
"This function is to insert item into list,like:
(l-insert 333 :TO '(1 2 3 4 5 6 11 22 33) :AT 3)"
(let ((r nil))
(do ((i 0 (1+ i)) (obj to (cdr obj)))
((or (null obj)
(and at (>= i at) (push item r) (push (car obj) r))
(and (funcall before (car obj)) (push item r) (push (car obj) r))
(and (funcall after (car obj)) (push (car obj) r) (push item r)))
(and (not (null obj)) (not (null (cdr obj))) (setf r (append (reverse (cdr obj)) r))))
(push (car obj) r))
(reverse r)))
(defun l-update (lst &key (where #'(lambda (a) nil)) (todo #'(lambda (a) a)))
"This function is to update item in lst which test :WHERE ok using :TODO,like:
(l-update '(1 2 3 4 5 6 7 8) :WHERE #'evenp :TODO #'1+)"
(let ((r nil))
(dolist (obj lst)
(if (funcall where obj)
(push (funcall todo obj) r)
(push obj r)))
(reverse r)))
(defun l-delete (lst &key (where #'(lambda (a) nil)))
"This function is to delete item which test :WHERE ok from lst,like:
(l-delete '(1 2 3 4 5 6 7) :WHERE #'evenp)"
(let ((r nil))
(dolist (obj lst)
(if (funcall where obj)
nil
(push obj r)))
(reverse r)))
(defun prop-name (&rest props)
"This function is to provide a function get props from a list,like:
(prop-name :name :age :id)"
#'(lambda (lst)
(let ((r nil))
(dolist (prop props)
(push (getf lst prop) r))
(reverse r))))
| 2,701 | Common Lisp | .lisp | 68 | 33.147059 | 100 | 0.554244 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 1a21dcd8b8a9f9d1f6e6d6586665dfc8b1eb4ac8bb1dc7c898f55be237f39bc0 | 31,995 | [
-1
] |
31,996 | binary-analysis.lisp | LeZheng_l-lisp-tools/binary-analysis.lisp | (defpackage :com.skyline.owl.binary
(:use :COMMON-LISP :com.skyline.owl.lmacro)
(:export :define-binary-class
:define-tagged-binary-class
:define-binary-type
:read-value
:write-value
:*in-progress-objects*
:parent-of-type
:current-binary-object
:+null+))
(defconstant +null+ (code-char 0))
(defvar *in-progress-objects* nil)
(defun read-null-terminated-ascii (in)
(with-output-to-string (s)
(loop for char = (code-char (read-byte in))
until (char= +null+ char) do (write-char char s))))
(defun write-null-terminated-ascii (string out)
(loop for char across string
do (write-byte (char-code char) out))
(write-byte (char-code +null+) out))
(defun normalize-slot-spec (spec)
(list (first spec) (mklist (second spec))))
(defun mklist (x) (if (listp x) x (list x)))
(defun slot->defclass-slot (spec)
(let ((name (first spec)))
`(,name :initarg ,(as-keyword name) :accessor ,name)))
(defun slot->read-value (spec stream)
(destructuring-bind (name (type &rest args)) (normalize-slot-spec spec)
`(setf ,name (read-value ',type ,stream ,@args))))
(defun slot->write-value (spec stream)
(destructuring-bind (name (type &rest args)) (normalize-slot-spec spec)
`(write-value ',type ,stream ,name ,@args)))
(defun direct-slots (name)
(copy-list (get name 'slots)))
(defun inherited-slots (name)
(loop for super in (get name 'superclasses)
nconc (direct-slots super)
nconc (inherited-slots super)))
(defun all-slots (name)
(nconc (direct-slots name) inherited-slots))
(defun new-class-all-slots (slots superclasses)
(nconc (mapcan #'all-slots superclasses) (mapcar #'first slots)))
(defun slot->binding (spec stream)
(destructuring-bind (name (type &rest args)) (normalize-slot-spec spec)
`(,name (read-value ',type ,stream ,@args))))
(defun slot->keyword-arg (spec)
(let ((name (first spec)))
`(,(as-keyword name) ,name)))
(defun current-binary-object ()
(first *in-progress-objects*))
(defun parent-of-type (type)
(find-if #'(lambda (x) (typep x type)) *in-progress-objects*))
(defmacro define-generic-binary-class (name (&rest superclasses) slots read-method)
(l-macro:with-gensyms (objectvar streamvar)
`(progn
(eval-when (:compile-toplevel :load-toplevel :execute)
(setf (get ',name 'slots) ',(mapcar #'first slots))
(setf (get ',name 'superclasses) ',superclasses))
(defclass ,name ,superclasses
,(mapcar #'slot->defclass-slot slots))
,read-method
(defmethod write-object progn ((,objectvar ,name) ,streamvar)
(declare (ignorable ,streamvar))
(with-slots ,(new-class-all-slots slots superclasses) ,objectvar
,@(mapcar #'(lambda (x) (slot->write-value x streamvar)) slots))))))
(defmacro define-binary-class (name (&rest superclasses) slots)
(l-macro:with-gensyms (objectvar streamvar)
`(define-generic-binary-class ,name ,superclasses ,slots
(defmethod read-object progn ((,objectvar ,name) ,streamvar)
(declare (ignorable ,streamvar))
(with-slots ,(new-class-all-slots slots superclasses) ,objectvar
,@(mapcar #'(lambda (x) (slot->read-value x streamvar)) slots))))))
(defmacro define-tagged-binary-class (name (&rest superclasses) slots &rest options)
(l-macro:with-gensyms (typevar objectvar streamvar)
`(define-generic-binary-class ,name ,superclasses ,slots
(defmethod read-value ((,typevar (eql ',name)) ,streamvar &key)
(let* ,(mapcar #'(lambda (x) (slot->binding x streamvar)) slots)
(let ((,objectvar (make-instance
,@(or (cdr (assoc :dispatch options))
(error "Must supply :dispatch form."))
,@(mapcan #'slot->keyword-arg slots))))
(read-object ,objectvar ,streamvar)
,objectvar))))))
(defmacro define-binary-type (name (&rest args) &body spec)
(ecase (length spec)
(1
(l-macro:with-gensyms (type stream value)
(destructuring-bind (derived-from &rest derived-args) (mklist (first spec))
`(progn
(defmethod read-value ((,type (eql ',name)) ,stream ,value &key ,@args)
(write-value ',derived-from ,stream ,value ,@derived-args))))))
(2
(l-macro:with-gensyms (type)
`(progn
,(destructuring-bind ((in) &body body) (rest (assoc :reader spec))
`(defmethod read-value ((,type (eql ',name)) ,in &key ,@args)
,@body))
,(destructuring-bind ((out value) &body body) (rest (assoc :writer spec))
`(defmethod write-value ((,type (eql ',name)) ,out ,value &key ,@args)
,@body)))))))
(defgeneric read-value (type stream &key)
(:documentation "Read a value from given type from the stream."))
(defgeneric write-value (type stream value &key)
(:documentation "Write a value as given type to the stream."))
(defgeneric read-object (object stream)
(:method-combination progn :most-specific-last)
(:documentation "File in the slots of object form stream."))
(defgeneric write-object (object stream)
(:method-combination progn :most-specific-last)
(:documentation "Write out the slots of object to the stream."))
(defmethod read-value ((type symbol) stream &key)
(let ((object (make-instance type)))
(read-object object stream)
object))
(defmethod write-value ((type symbol) stream value &key)
(assert (typep value type))
(write-object value stream))
(defmethod read-object :around (object stream)
(declare (ignore stream))
(let ((*in-progress-objects* (cons object *in-progress-objects*)))
(call-next-method)))
(defmethod write-object :around (object stream)
(declare (ignore stream))
(let ((*in-progress-objects* (cons object *in-progress-objects*)))
(call-next-method)))
| 6,850 | Common Lisp | .lisp | 126 | 40.706349 | 117 | 0.564217 | LeZheng/l-lisp-tools | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 4388b49839220603907e4f9bffaa80ac884e3016cd352880c869dab8d7327248 | 31,996 | [
-1
] |
32,018 | exer02_04.lisp | dpritchLibre_Touretzky-Common-Lisp/chap02/exer02_04.lisp | ;; Page 35
;; What is the parenthesis notation for the cons cell structure figure shown on
;; page 35?
((BOWS ARROWS) (FLOWERS CHOCOLATES))
| 142 | Common Lisp | .lisp | 4 | 34 | 79 | 0.757353 | dpritchLibre/Touretzky-Common-Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | a2f1b83de707b6401ac5fe40dd2e63ac0f86824bd943f214fc182de6cb07f493 | 32,018 | [
-1
] |
32,019 | exer02_05.lisp | dpritchLibre_Touretzky-Common-Lisp/chap02/exer02_05.lisp | (LENGTH '(OPEN THE POD BAY DOORS HAL)) ;; length 6
(LENGTH '((OPEN) (THE POD BAY DOORS) HAL)) ;; length 3
(LENGTH '((1 2 3) (4 5 6) (7 8 9) (10 11 12))) ;; length 4
(LENGTH '((ONE) FOR ALL (AND (TWO (FOR ME))))) ;; length 4
(LENGTH '((Q SPADES)
(7 HEARTS)
(6 CLUBS)
(5 DIAMONDS)
(2 DIAMONDS))) ;; length 5
(LENGTH '((PENNSYLVANIA (THE KEYSTONE STATE))
(NEW-JERSEY (THE GARDEN STATE))
(MASSACHUSETTS (THE BAY STATE))
(FLORIDA (THE SUNSHINE STATE))
(NEW-YORK (THE EMPIRE STATE))
(INDIANA (THE HOOSIER STATE)))) ;; length 6
| 559 | Common Lisp | .lisp | 15 | 34.133333 | 59 | 0.619666 | dpritchLibre/Touretzky-Common-Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | 886b62eeba397978e75c9d90421c6495ab7a1f0e5c8824409c4f6884797ea8c0 | 32,019 | [
-1
] |
32,020 | exer02_06.lisp | dpritchLibre_Touretzky-Common-Lisp/chap02/exer02_06.lisp | ;; page 38
;; Match each list on the left with a corresponding list on the right by
;; substituting NIL for () wherever possible. Pay careful attention to levels
;; of parenthesization.
;;
;; () ((NIL))
;; (()) NIL
;; ((())) (NIL)
;; (() ()) (NIL (NIL))
;; (() (())) (NIL NIL)
;; The terms on the right-hand are rearranged to match those on the left
(EQUAL () NIL)
(EQUAL '(()) '(NIL))
(EQUAL '('(())) '((NIL)))
(EQUAL '(() ()) '(NIL NIL))
(EQUAL '(() '(())) '(NIL '(NIL)))
| 534 | Common Lisp | .lisp | 16 | 31.9375 | 78 | 0.516634 | dpritchLibre/Touretzky-Common-Lisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:49 AM (Europe/Amsterdam) | bbb7c1991df8886a43c3ff0eb7df1f2ecb6f71f8a0c8ae33b1e03b3483fa2251 | 32,020 | [
-1
] |
32,039 | infix.lisp | kybp_infix/infix.lisp | (defstruct parser tokens output operators)
(defun consume-token (parser)
(pop (parser-tokens parser)))
(defvar *synonyms* '((expt ^ **)))
(defvar *operators*
'((nil . 0)
(and . 1) (or . 1)
(= . 2) (< . 2) (> . 2) (<= . 2) (>= . 2)
(+ . 3) (- . 3)
(* . 4) (/ . 4)
(expt . 5)))
(defun precedence (operator)
(cdr (assoc operator *operators*)))
(defun operatorp (symbol)
(or (member symbol *operators* :key #'car)
(member symbol *synonyms* :key #'cdr :test #'member)))
(defun canonical-operator-name (operator)
(or (car (find operator *operators* :key #'car))
(car (find operator *synonyms* :key #'cdr :test #'member))))
(defun call-operator (operator parser)
(let* ((y (pop (parser-output parser)))
(x (pop (parser-output parser)))
(nils (count nil (list x y))))
(if (> nils 0)
(error "Operator ~s expected 2 arguments, but got ~s"
operator (- 2 nils))
(push (list operator x y) (parser-output parser)))))
(defun call-remaining-operators (parser)
(loop for operator = (pop (parser-operators parser))
while operator do (call-operator operator parser)
finally (return (first (parser-output parser)))))
(defun push-operator (operator parser)
(loop while (<= (precedence operator)
(precedence (first (parser-operators parser))))
do (call-operator (pop (parser-operators parser)) parser))
(push operator (parser-operators parser)))
(defun run-parser (parser)
(loop while (parser-tokens parser)
for token = (consume-token parser)
if (operatorp token) do
(push-operator (canonical-operator-name token) parser)
else do
(push token (parser-output parser))
finally (return (call-remaining-operators parser))))
(defmacro infix (&rest tokens)
(run-parser (make-parser :tokens tokens)))
(defun install-syntax ()
(set-macro-character #\] (get-macro-character #\)))
(set-macro-character
#\[ #'(lambda (stream char)
(declare (ignore char))
(cons 'infix (read-delimited-list #\] stream)))))
| 2,086 | Common Lisp | .lisp | 52 | 34.980769 | 66 | 0.635015 | kybp/infix | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:58 AM (Europe/Amsterdam) | c7ea55acc8f3f721d790afba765dcbe493ee8f54d6f65a364a8d09ac7f4c4839 | 32,039 | [
-1
] |
32,056 | checkoutkata.lisp | imjacobclark_cl-checkoutkata/checkoutkata.lisp | ;;;; checkoutkata.lisp
(defpackage checkoutkata
(:use :cl
:prove))
(in-package :checkoutkata)
(defparameter *items* (make-hash-table))
(setf (gethash 'A *items*) 50)
(setf (gethash 'B *items*) 30)
(setf (gethash 'C *items*) 20)
(setf (gethash 'D *items*) 15)
(defparameter *offers* (make-hash-table))
(setf (gethash 'A *offers*) '(3 130))
(setf (gethash 'B *offers*) '(2 45))
(defun calculate-discount(item basket discount-threshold discount-price count-in-basket)
(if
(and
(eq (member item basket) NIL)
(< count-in-basket discount-threshold))
0
(if
(eq
discount-threshold
count-in-basket)
discount-price
(calculate-discount
item
(remove item basket :count 1)
discount-threshold
discount-price
(+ count-in-basket 1)
)))
)
(defun discounted-price(item)
(first (last (gethash item *offers*)))
)
(defun discounted-offer(item)
(first (gethash item *offers*))
)
(defun apply-discount(item basket)
(if (eq (discounted-offer item) NIL)
0
(calculate-discount
item
basket
(discounted-offer item)
(discounted-price item)
0
)
)
)
(defun sum(items acumulator)
(let ((item (first items)))
(if (eq items NIL)
acumulator
(if
(eq
(apply-discount item items)
0)
(sum
(remove item items :count 1)
(+ (gethash item *items*) acumulator)
)
(sum
(remove item items :count (first (gethash item *offers*)))
(+ (apply-discount item items) acumulator)
)
)
)
)
)
(defun checkout(items)
(sum items 0)
)
(defun runtests()
(is (checkout '(A A)) 100 "checkout returns 100 for AA")
(is (checkout '(A A A)) 130 "checkout returns 130 for AAA")
(is (checkout '(A B C D)) 115 "checkout returns 115 for ABCD")
(is (checkout '(D A B A B A)) 190 "checkout returns 190 for DABABA")
(is (checkout '(A A A A A A)) 260 "checkout returns 260 for AAAAAA")
(is (apply-discount 'A '(A B A B A)) 130 "applies discount on valid basket and returns discount price")
(is (apply-discount 'A '(A B)) 0 "does not apply discount when discount is not relevant")
(is (apply-discount 'D '(D)) 0 "does not apply discount when discount is not relevant")
(is (calculate-discount 'A '(A A) 2 100 0) 100 "Calculate discount calculates some discount for valid basket")
(is (calculate-discount 'A '(A) 2 100 0) 0 "Calculate discount calculates no discount for invalid basket")
)
(runtests)
| 2,571 | Common Lisp | .lisp | 86 | 24.860465 | 112 | 0.636327 | imjacobclark/cl-checkoutkata | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:58 AM (Europe/Amsterdam) | acfed30cbbaa62e99589bf12c092d1eff0ae0236e4aaaa23d158744ab3c790ef | 32,056 | [
-1
] |
32,057 | checkoutkata.asd | imjacobclark_cl-checkoutkata/checkoutkata.asd | ;;;; checkoutkata.asd
(asdf:defsystem #:checkoutkata
:description "Describe checkoutkata here"
:author "Jacob Clark"
:license "LLGPL"
:depends-on (#:prove)
:serial t
:components ((:file "package")
(:file "checkoutkata")))
| 251 | Common Lisp | .asd | 9 | 23.666667 | 43 | 0.670833 | imjacobclark/cl-checkoutkata | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:58 AM (Europe/Amsterdam) | 8ffc12d5fc51c6b534520f8cc4e8b2160a29cfcadf3585aaba669a1500e6bad4 | 32,057 | [
-1
] |
32,075 | sensationIII-simulator.ros | tobbelobb_sensationIII-simulator/sensationIII-simulator.ros | #!/bin/sh
#|-*- mode:lisp -*-|#
#| Publish data from adjustable file pointer to MQTT broker at a configurable pace.
exec ros -Q -- $0 "$@"
|#
(progn
(ros:ensure-asdf)
;; local libs: https://github.com/ivan4th/i4-diet-utils.git
;; https://github.com/tobbelobb/cl-mqtt.git
;; Note that printv.lisp has a swank line tha can cause problems when loading:
;; cd ~/.roswell/lisp/quicklisp/dists/quicklisp/software/printv-20140714-git ; vim +248 printv.lisp
;;
;; You also need libuv for the async stuff to work...
;; https://github.com/libuv/libuv.git
#+quicklisp (ql:quickload '(:cl-mqtt
:cl-async
:cl-ppcre
:cl-json) :silent t))
(defpackage :sensationIII-simulator
(:use :cl))
(in-package :sensationIII-simulator)
;; Util macros binding the symbol it
(defmacro when-it (test &body then)
(let ((it (intern (string 'it))))
`(let ((,it ,test))
(when ,it ,@then))))
(defmacro if-it (test then &optional else)
(let ((it (intern (string 'it))))
`(let ((,it ,test))
(if ,it ,then ,else))))
(defun mqtt-read (msg)
"Decode the stuff that mqtt:subscribe gives us on message"
(babel:octets-to-string
(mqtt:mqtt-message-payload msg)
:encoding :utf-8))
(defun csv-string->list-of-strings (string)
(mapcar #'(lambda (str) (string-trim '(#\Space) str))
(cl-ppcre:split "," (string-right-trim '(#\Return) string))))
(defun csv-string->values (string)
"Keep the first value as it is, use lisp reader on the rest.
You must trust that the strings don't contain malicious lisp code when you use this function..."
(let ((strings (csv-string->list-of-strings string)))
(cons (first strings) (mapcar #'read-from-string (rest strings)))))
(defun lists->json (keys values)
(cl-json:encode-json-to-string (pairlis keys values)))
(defun find-key (key json-string)
"Searches for a key in a json string. Returns (key . val) on success."
(assoc key (cl-json:decode-json-from-string json-string)))
(defun main (&optional filename broker &rest argv)
"Publish data from adjustable file pointer to MQTT broker at a configurable pace.
File pointer and pace are controlled through topic-in via broker, using the keys
* line (sets the line in the file you want to read from)
* position (sets byte position you want to read from, rounded up to the next newline)
* delay-seconds (sets the seconds you want to pass between each send)
Usage:
./sensationIII-simulator.ros <filename> <broker> [--delay-seconds <number>] [--port <port>] [--topic-in <topic>] [--topic-out <topic>]
"
(unless (and filename broker)
(format t "Usage:~%./sensationIII-simulator.ros <filename> <broker> [--user <username>] [--password <password>] [--delay-seconds <number>] [--port <port>] [--topic-in <topic>] [--topic-out <topic>]~%")
(return-from main 0))
(let ((delay-seconds 10)
(port 1883)
(topic-in "sensationIII/cmd")
(topic-out "sensationIII/toungedata")
(user "")
(password ""))
(loop for option = (pop argv)
for value = (pop argv)
while option
do
(alexandria:switch (option :test #'string=)
("--delay-seconds" (setf delay-seconds (read-from-string value)))
("--port" (setf port (read-from-string value)))
("--topic-in" (setf topic-in value))
("--topic-out" (setf topic-out value))
("--user" (setf user value))
("--password" (setf password value))))
(format t "Starting MQTT connected sensor simulator~%")
(with-open-file (file-stream filename)
(defun pop-line ()
"Pop a line from the file, reset file pointer if necessary"
(if-it (read-line file-stream nil nil)
it
(progn (file-position file-stream 0)
(read-line file-stream nil nil)
(read-line file-stream nil nil))))
(defun handle-mqtt-cmd (message)
"Set delay between messages and file position according to received MQTT message."
(let ((decoded-message (mqtt-read message)))
(when-it (find-key :delay-seconds decoded-message)
(setf delay-seconds (cdr it)))
(when-it (find-key :position decoded-message)
(file-position file-stream (cdr it))
(pop-line))
(when-it (find-key :line decoded-message)
(file-position file-stream 0)
(dotimes (i (- (cdr it) 1))
(pop-line)))))
(defun periodically-publish (mqtt-connection keys)
"When called within an event loop publishes according to delay-seconds and file position."
(let (event)
(labels ((main ()
;; use mosquitto_pub here instead??
(mqtt:publish mqtt-connection topic-out
(lists->json keys (csv-string->values (pop-line))))
(when event
(setf event (as:delay #'main :time delay-seconds)))))
(setf event (as:delay #'main :time delay-seconds))
(lambda ()
(when event
(as:remove-event event)
(setf event nil))))))
;; Actual simulation starts here
(as:with-event-loop (:catch-app-errors nil)
(bb:alet ((keys (csv-string->list-of-strings (read-line file-stream nil)))
(mqtt-connection (mqtt:connect broker :port port :on-message #'handle-mqtt-cmd
:user user :password password)))
(mqtt:subscribe mqtt-connection topic-in)
(let ((periodic-event-lambda (periodically-publish mqtt-connection keys)))
(as:signal-handler as:+sigint+
(lambda (sig)
(declare (ignore sig))
(format t "Closing mqtt connection...~%")
(mqtt:disconnect mqtt-connection)
(funcall periodic-event-lambda)
(as:free-signal-handler as:+sigint+)))))))))
| 6,269 | Common Lisp | .l | 126 | 39.174603 | 205 | 0.588254 | tobbelobb/sensationIII-simulator | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:41:58 AM (Europe/Amsterdam) | 2239b38350dc83da5cae1cda3722205a4d055a0d2ae06343b1cbe30c1d83f021 | 32,075 | [
-1
] |
32,090 | copy7.cl | TomShultz_bird-simulation/copy7.cl | ;;;Copyright (C) Thomas Shultz
;;;
;;;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., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
;;;file: copy7.cl
;;;purpose: compare 3 copying algorithms: AM, AC, & CIU
;;;programmer: Tom Shultz
;;;started: 20 aug 2015
;;;current: 25 may 2016
;;;based on copy4s.cl
;;;new in copy4s: byzantine agents who stay in state b & thus never copy
;;; add conditions to interact-am, ac, & ciu to keep b agents in state b
;;; include b agents in initialize-array & make-agent-array
;;; add parameter for nb to all top & 2nd-level functions
;;; use run-to-cycle for diffusion & most conformity-bias simulations
;;; change run-to-cycle-switch & run1-to-cycle-switch to record every cycle
;;; default separator in lists->file is tab instead of space
;;;new in copy7
;;; calls to top-level functions are coordinated with Results sections in the 2017 paper
;;; specified software license
;;;globals
(defstruct agent
"Agent has id index & state."
id
state)
(defvar *agents* nil
"Array of agents.")
(defvar *array-size* 100
"Size of agent array.")
(defvar *path* nil
"Path for saving files.")
;;;random numbers
(defun call-random (m n)
"(m n)
Call (random n) m times. Used by seed-random."
(do ((i 0 (1+ i)))
((= i m) nil)
(if (zerop n)
(random 1)
(random n))))
(defun seed-random ()
"Seed random from the last 4 digits of time.
Useful for generating unique random sequences."
(let* ((time (get-internal-real-time))
(n (multiple-value-bind (x y) (floor time 100) (cadr (list x y))))
(hundreds (multiple-value-bind (x y) (floor time 100) (car (list x y))))
(m (multiple-value-bind (x y) (floor hundreds 100) (cadr (list x y)))))
(call-random m n)))
;;;make agents
(defun initialize-array (nu nx ny nb)
"(nu nx ny nb)
Set *array-size* to sum of numbers of agents.
Initialize *agents* array with nil elements."
(setf *array-size* (+ nu nx ny nb)
*agents* (make-array *array-size* :initial-element nil)))
;;;(initialize-array 5 1 0 0)
(defun make-1-agent (i s)
"(i s)
Make or change state of agent i to s."
(setf (aref *agents* i)
(make-agent :id i
:state s)))
;;;(make-1-agent 2 'u)
(defun make-agent-array (nu nx ny nb)
"(nu nx ny nb)
Make agent array."
(do ((i 0 (1+ i)))
((= i nu))
(make-1-agent i 'u))
(do ((i nu (1+ i)))
((= i (+ nu nx)))
(make-1-agent i 'x))
(do ((i (+ nu nx) (1+ i)))
((= i (+ nu nx ny)))
(make-1-agent i 'y))
(do ((i (+ nu nx ny) (1+ i)))
((= i (+ nu nx ny nb)))
(make-1-agent i 'b)))
;;;(make-agent-array 4 2 0 0)
;;;*agents*
;;;count states
(defun get-agent-state (a)
"(a)
Return state of agent at a."
(let ((agent (aref *agents* a)))
(agent-state agent)))
;;;(get-agent-state 3)
(defun count-state (state)
"(state)
Count state across agents."
(do ((i 0 (1+ i))
(n 0 (if (eq (get-agent-state i) state)
(1+ n)
n)))
((= i *array-size*) n)))
;;;(count-state 'u)
;;;(count-state 'x)
(defun count-states (states)
"(states)
Count each state across agents."
(do ((stts states (cdr stts))
(counts nil (cons (count-state (car stts))
counts)))
((null stts) (reverse counts))))
;;;(count-states '(u x y))
(defun count-state-section (state start end)
"(state start end)
Count state for array section from start up to but not including end index."
(do ((i start (1+ i))
(n 0 (if (eq (get-agent-state i) state)
(1+ n)
n)))
((= i end) n)))
;;;(count-state-section 'x 4 5)
;;;(count-state-section 'x 4 6)
;;;interact
(defun interact-am (agents p)
"(agents p)
Initiator i & recipient r interact in AM.
Decided i converts undecided u.
Decided i confuses decided r."
(let* ((i (first agents))
(r (second agents))
(r-agent (aref *agents* r))
(i-state (get-agent-state i))
(r-state (get-agent-state r)))
(cond
((and (eq r-state 'u)
(not (eq i-state 'u))
(not (eq i-state 'b))
(< (random 1.0) p))
(setf (agent-state r-agent) i-state))
((and (not (eq i-state 'u))
(not (eq i-state 'b))
(not (eq r-state 'u))
(not (eq r-state 'b))
(not (eq i-state r-state))
(< (random 1.0) p))
(setf (agent-state r-agent) 'u))
(t nil))))
(defun interact-ac (agents p)
"(agents p)
Recipient imitates decided initiator in AC."
(let* ((i (first agents))
(r (second agents))
(r-agent (aref *agents* r))
(i-state (get-agent-state i))
(r-state (get-agent-state r)))
(if (and (not (eq i-state 'u))
(not (eq i-state 'b))
(not (eq r-state 'b))
(not (eq i-state r-state))
(< (random 1.0) p))
(setf (agent-state r-agent) i-state))))
;;;(interact-ac '(4 0) 1.0)
(defun interact-ciu (agents p)
"(agents p)
Undecided recipient imitates decided initiator in CIU."
(let* ((i (first agents))
(r (second agents))
(r-agent (aref *agents* r))
(i-state (get-agent-state i))
(r-state (get-agent-state r)))
(if (and (not (eq i-state 'u))
(not (eq i-state 'b))
(eq r-state 'u)
(< (random 1.0) p))
(setf (agent-state r-agent) i-state))))
;;;(interact-ciu '(4 0) 1.0)
;;;get initiator & responder
(defun get-random-agent ()
"()
Get 1 random agent."
(random *array-size*))
;;;(get-random-agent)
(defun get-2-random-agents ()
(let* ((demonstrator (get-random-agent))
(observer (get-random-agent)))
(if (eq demonstrator observer)
(get-2-random-agents)
(list demonstrator observer))))
;;;(get-2-random-agents)
;;;Check for consensus
(defun consensusp (counts)
"(counts)
Consensus on x or y?
Ignores b."
(let ((nu (first counts))
(nx (second counts))
(ny (third counts)))
(and (= nu 0)
(or (zerop nx)
(zerop ny))
(not (and (zerop nx)
(zerop ny))))))
;;;(consensusp '(1 1 2))
;;;(consensusp '(0 0 0))
;;;(consensusp '(0 1 0))
;;;(consensusp '(0 0 1))
;;;store lists in file
(defun lists->file (lst file &optional (separator #\tab))
"(lst file &optional (separator #\tab))
Save reverse lst in file. Items in flat lst are printed 1 per line.
Separator is used to separate items on a line for embedded lst."
(with-open-file
(output-stream file :direction :output :if-exists :supersede)
(do ((items (reverse lst) (cdr items)))
((null items))
(let ((sub-item (car items)))
(if (listp sub-item)
(print-line sub-item separator output-stream)
(format output-stream "~a ~%"
sub-item))))))
(defun print-line (lst &optional (separator #\tab) output-stream)
"(lst &optional (separator #\tab) output-stream)
Print each item in list on a line separated by separator.
Then go to new line."
(do ((lst lst (cdr lst)))
((null lst) (terpri output-stream))
(princ (car lst) output-stream)
(princ separator output-stream)))
;;; rotate list-of-lists
(defun rotate (lists)
"(lists)
Rotate list of lists."
(apply #'mapcar #'list lists))
;;;(rotate '((1 2 3)
;;; (4 5 6)))
(defun winners (finishes)
"(finishes)
Compute winners from finishing counts of x & y."
(do ((fnshs finishes (cdr fnshs))
(xwins 0 (if (> (first (car fnshs)) (second (car fnshs)))
(1+ xwins)
xwins))
(ywins 0 (if (< (first (car fnshs)) (second (car fnshs)))
(1+ ywins)
ywins)))
((null fnshs) (list xwins ywins))))
;;;(winners '((0 20) (20 0) (20 0) (20 0) (20 0) (0 20) (20 0) (20 0) (20 0) (20 0) (20 0) (20 0) (20 0)
;;; (20 0) (20 0) (20 0) (20 0) (20 0) (20 0) (20 0)))
;;;call algorithm
(defun call-algorithm (algo p)
"(algo p)
Call a particular algorithm.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(case algo
(am (interact-am (get-2-random-agents) p))
(ac (interact-ac (get-2-random-agents) p))
(ciu (interact-ciu (get-2-random-agents) p))
(otherwise (error "Unknown algorithm"))))
;;;run simulation
(defun run1-saturation (nu nx ny nb p replication algo)
"(nu nx ny nb p replication algo)
Run simulation until consensus, recording counts at each cycle.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(initialize-array nu nx ny nb)
(make-agent-array nu nx ny nb)
(do ((cycles 0 (1+ cycles))
(ucount (list nu) (cons (count-state 'u)
ucount))
(xcount (list nx) (cons (count-state 'x)
xcount))
(ycount (list ny) (cons (count-state 'y)
ycount)))
((consensusp (list (first ucount) (first xcount) (first ycount)))
(progn
(lists->file ucount
(concatenate 'string *path* (princ-to-string replication) "ucount"))
(lists->file xcount
(concatenate 'string *path* (princ-to-string replication) "xcount"))
(lists->file ycount
(concatenate 'string *path* (princ-to-string replication) "ycount"))
(list (reverse ucount)
(reverse xcount)
(reverse ycount)
cycles
(list (first xcount) (first ycount)))))
(call-algorithm algo p)))
(defun run-saturation (n nu nx ny nb p algorithm)
"(n nu nx ny nb p algorithm)
Run n simulations, returning list of cycles required for consensus.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(seed-random)
(setq *path* "/Users/tom1/Documents/models m/copy/results/")
(do ((i 0 (1+ i))
(cycles nil)
(ucounts nil)
(xcounts nil)
(ycounts nil)
(finishes nil))
((= i n) (progn
(lists->file
cycles
(concatenate 'string *path* "cycles"))
(lists->file
(reverse (rotate (reverse ucounts)))
(concatenate 'string *path* "ucounts"))
(lists->file
(reverse (rotate (reverse xcounts)))
(concatenate 'string *path* "xcounts"))
(lists->file
(reverse (rotate (reverse ycounts)))
(concatenate 'string *path* "ycounts"))
(lists->file finishes (concatenate 'string *path* "finishes"))
(let ((winners (winners finishes)))
(with-open-file
(output-stream (concatenate 'string *path* "winners")
:direction :output)
(format output-stream "~a x ~a y"
(first winners) (second winners))))))
(let ((counts (run1-saturation nu nx ny nb p i algorithm)))
(setf
ucounts (cons (first counts)
ucounts)
xcounts (cons (second counts)
xcounts)
ycounts (cons (third counts)
ycounts)
cycles (cons (fourth counts)
cycles)
finishes (cons (fifth counts)
finishes)))))
;;;section 3.1 Time to Achieve Consensus
;;;(run-saturation 20 73 2 0 25 1.0 'am)
;;;(run-saturation 20 73 2 0 25 1.0 'ac)
;;;(run-saturation 20 73 2 0 25 1.0 'ciu)
;;;run each for about 1100 cycles
(defun run1-to-cycle (nu nx ny nb max p replication algo)
"(nu nx ny nb max p replication algo)
Run simulation until max cycle, record state counts per cycle, & return state counts at max cycle.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(initialize-array nu nx ny nb)
(make-agent-array nu nx ny nb)
(do ((i 0 (1+ i))
(ucount (list nu) (cons (count-state 'u)
ucount))
(xcount (list nx) (cons (count-state 'x)
xcount))
(ycount (list ny) (cons (count-state 'y)
ycount)))
((= i max) (progn
(lists->file ucount
(concatenate 'string *path* (princ-to-string replication) "ucount"))
(lists->file xcount
(concatenate 'string *path* (princ-to-string replication) "xcount"))
(lists->file ycount
(concatenate 'string *path* (princ-to-string replication) "ycount"))
(list (reverse ucount)
(reverse xcount)
(reverse ycount)
(list (first xcount) (first ycount)))))
(call-algorithm algo p)))
(defun run-to-cycle (n nu nx ny nb max p algorithm)
"(n nu nx ny nb max p algorithm)
Run n simulations to max cycle, recording cycle lists of state counts for each simulation
& simulation x cycle table of state counts at end.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(seed-random)
(setq *path* "/Users/tom1/Documents/models m/copy/results/")
(do ((i 0 (1+ i))
(ucounts nil)
(xcounts nil)
(ycounts nil)
(finishes nil))
((= i n) (progn
(lists->file
(reverse (rotate (reverse ucounts)))
(concatenate 'string *path* "ucounts"))
(lists->file
(reverse (rotate (reverse xcounts)))
(concatenate 'string *path* "xcounts"))
(lists->file
(reverse (rotate (reverse ycounts)))
(concatenate 'string *path* "ycounts"))
(lists->file finishes (concatenate 'string *path* "finishes"))
(let ((winners (winners finishes)))
(with-open-file
(output-stream (concatenate 'string *path* "winners")
:direction :output)
(format output-stream "~a x ~a y"
(first winners) (second winners))))))
(let ((counts (run1-to-cycle nu nx ny nb max p i algorithm)))
(setf
ucounts (cons (first counts)
ucounts)
xcounts (cons (second counts)
xcounts)
ycounts (cons (third counts)
ycounts)
finishes (cons (fourth counts)
finishes)))))
;;;section 3.2 Diffusion of Information
;;;treatment conditions
;;;(run-to-cycle 20 73 2 0 25 1100 1.0 'am)
;;;(run-to-cycle 20 73 2 0 25 1100 1.0 'ac)
;;;(run-to-cycle 20 73 2 0 25 1100 1.0 'ciu)
;;;control conditions
;;;(run-to-cycle 20 74 1 0 25 770 1.0 'am)
;;;(run-to-cycle 20 74 1 0 25 770 1.0 'ac)
;;;(run-to-cycle 20 74 1 0 25 770 1.0 'ciu)
;;;section 3.5 Groups with Two Behavioural Variants
;;;section 3.6 Proportion of the Seeded Behavioural Variant
;;;section 3.7 Percent Changes in Majority and Minority States
;;;(run-to-cycle 20 64 10 1 25 825 1.0 'am)
;;;(run-to-cycle 20 64 10 1 25 825 1.0 'ac)
;;;(run-to-cycle 20 64 10 1 25 825 1.0 'ciu)
(defun run1-to-cycle-switch (nu nx ny nb max p replication algo)
"(nu nx ny nb max p replication algo)
Run simulation until max cycle, record x, y, & u counts of newbie y section per cycle.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(initialize-array nu nx ny nb)
(make-agent-array nu nx ny nb)
(do ((i 0 (1+ i))
(ucount (list) (cons (count-state-section 'u 75 89)
ucount))
(xcount (list) (cons (count-state-section 'x 75 89)
xcount))
(ycount (list) (cons (count-state-section 'y 75 89)
ycount)))
((= i max) (progn
(lists->file ucount
(concatenate 'string *path* (princ-to-string replication) "ucount"))
(lists->file xcount
(concatenate 'string *path* (princ-to-string replication) "xcount"))
(lists->file ycount
(concatenate 'string *path* (princ-to-string replication) "ycount"))
(list (reverse ucount)
(reverse xcount)
(reverse ycount))))
(call-algorithm algo p)))
(defun run-to-cycle-switch (n nu nx ny nb max p algorithm)
"(n nu nx ny nb max p algorithm)
Run n simulations to max cycle,
recording cycle lists of x, y, & u counts of newbie y section per cycle for each simulation
& simulation x cycle table of state counts at end.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(seed-random)
(setq *path* "/Users/tom1/Documents/models m/copy/results/")
(do ((i 0 (1+ i))
(ucounts nil)
(xcounts nil)
(ycounts nil))
((= i n) (progn
(lists->file
(reverse (rotate (reverse ucounts)))
(concatenate 'string *path* "ucounts"))
(lists->file
(reverse (rotate (reverse xcounts)))
(concatenate 'string *path* "xcounts"))
(lists->file
(reverse (rotate (reverse ycounts)))
(concatenate 'string *path* "ycounts"))))
(let ((counts (run1-to-cycle-switch nu nx ny nb max p i algorithm)))
(setf
ucounts (cons (first counts)
ucounts)
xcounts (cons (second counts)
xcounts)
ycounts (cons (third counts)
ycounts)))))
;;;section 3.4 Agents Joining a Group with a Different Solution
;;;switch & record counts every cycle
;;;(run-to-cycle-switch 20 0 75 14 25 1100 1.0 'am)
;;;(run-to-cycle-switch 20 0 75 14 25 1100 1.0 'ac)
;;;(run-to-cycle-switch 20 0 75 14 25 1100 1.0 'ciu)
;;;persist over years
(defun run1-to-cycle-persist (nu nx ny nb max p replication algo)
"(nu nx ny nb max p replication algo)
Run simulation until max cycle, record state counts per cycle, & return state counts at max cycle.
p is probability of copying.
Algorithm is 'am, 'ac, or 'ciu."
(initialize-array nu nx ny nb)
(make-agent-array nu nx ny nb)
(do ((i 0 (1+ i))
(countx-newbies nil (cons (count-state-section 'x 0 45)
countx-newbies))
(countx-vets nil (cons (count-state-section 'x 45 75)
countx-vets)))
((= i max) (progn
(lists->file
countx-newbies
(concatenate 'string *path* (princ-to-string replication) "countx-newbies"))
(lists->file
countx-vets
(concatenate 'string *path* (princ-to-string replication) "countx-vets"))
(list (reverse countx-newbies) (reverse countx-vets))))
(call-algorithm algo p)))
(defun run-to-cycle-persist (n nu nx ny nb max p algorithm)
"(n nu nx ny nb max p algorithm)
Run n simulations to max cycle, recording cycle lists of nx for newbies & vets
for each simulation & simulation x cycle table of nx at end for newbies & vets.
p is probability of copying. Algorithm is 'am, 'ac, or 'ciu."
(seed-random)
(setq *path* "/Users/tom1/Documents/models m/copy/results/")
(do ((i 0 (1+ i))
(countx-newbies nil)
(countx-vets nil))
((= i n) (progn
(lists->file
(reverse (rotate (reverse countx-newbies)))
(concatenate 'string *path* "countx-newbies"))
(lists->file
(reverse (rotate (reverse countx-vets)))
(concatenate 'string *path* "countx-vets"))))
(let ((countx-both (run1-to-cycle-persist nu nx ny nb max p i algorithm)))
(setf
countx-newbies (cons (first countx-both)
countx-newbies)
countx-vets (cons (second countx-both)
countx-vets)))))
;;;section 3.3 Naïve Agents Joining an Experienced Group
;;;(run-to-cycle-persist 20 45 30 0 25 275 1.0 'am)
;;;(run-to-cycle-persist 20 45 30 0 25 275 1.0 'ac)
;;;(run-to-cycle-persist 20 45 30 0 25 275 1.0 'ciu)
| 20,915 | Common Lisp | .cl | 533 | 30.900563 | 104 | 0.573666 | TomShultz/bird-simulation | 0 | 0 | 0 | GPL-2.0 | 9/19/2024, 11:41:58 AM (Europe/Amsterdam) | 4a783e3b76f439acf14f230f79afc1feaaf667db24b840a983532ee2eaf5256e | 32,090 | [
-1
] |
32,107 | 13-beyond-lists.lisp | martinhomuth_clisp/13-beyond-lists.lisp | ;;; Trees
;; copy list does not copy the internal lists
(defparameter *inner1* (list (list 1 2) (list 3 4)))
(defparameter *inner2* (list (list 4 5) (list 6 7)))
(defparameter *outer* (append *inner1* *inner2*))
*outer*
(defparameter *list-copied* (copy-list *outer*))
*list-copied*
(setf (cadar *inner2*) 9)
*list-copied*
(subst 10 1 '(1 2 (3 2 1) ((1 1) (2 2))))
;; => (10 2 (3 2 10) ((10 10) (2 2)))
;; this does not work on lists itself?
(substitute 10 1 '(1 2 (3 2 1) ((1 1) (2 2))))
;; => (10 2 (3 2 1) ((1 1) (2 2)))
(defparameter *set* ())
*set*
(adjoin 1 *set*)
*set*
(setf *set* (adjoin 1 *set*))
*set*
(pushnew 2 *set*)
*set*
(pushnew 2 *set*)
*set*
(defparameter *membertest* (list 1 2 (list 3 4) (list 2 2)))
*membertest*
(member 2 *membertest*) ; returns cons from the first 2
(member 4 *membertest*) ; nil - does not search in sublists
(subsetp '(1 2 3) '(4 3 2 1)) ; => T
(subsetp '(2 4 2 1) '(3 2 1)) ; => NIL
;;; alists and plists
;; retrieve key given a value
;; shadow mapping which can be removed to reveal the original mapping
;; assoc - lookup
(assoc 'a '((a . 1) (b . 2) (c . 3)))
(assoc 'c '((a . 1) (b . 2) (c . 3)))
(assoc 'd '((a . 1) (b . 2) (c . 3)))
;; retrieve the value
(cdr (assoc 'a '((a . 1) (b . 2) (c . 3))))
(assoc "a" '(("a" . 1) ("b" . 2) ("c" . 3)) :test #'string=)
(assoc "a" '(("a" . 1) ("b" . 2) ("c" . 3))) ; => NIL
;; assoc iterates over the list from front to back
(assoc 'a '((a . 10) (b . 20) (a . 1) (c . 23))) ; => (A . 10)
;; add pair to the front
(cons (cons 'new-key 'new-value) alist)
(acons 'new-key 'new-value alist)
;; no modification to the list
(setf alist (acons 'new-key 'new-value alist))
;; or
(push (cons 'new-key 'new-value) alist)
;; reverse search for value
(car (rassoc 1 '((a . 1) (b . 2) (c . 3))))
(defparameter *alist-1* '((a . 1) (b . 2) (c . 3)))
(defparameter *alist-copied* (copy-alist *alist-1*))
(setf (cdr (assoc 'b *alist-1*)) 9)
*alist-1*
*alist-copied* ;; does not reference the same objects
(pairlis '(a b c) '(1 2 3))
;; plist
(defparameter *plist* '(A 1 B 2 C 3))
(getf *plist* 'b)
(defparameter *plist* ())
*plist*
(setf (getf *plist* :a) 1)
*plist*
(setf (getf *plist* :a) 2)
*plist*
(setf (getf *plist* :b) 3)
*plist*
(remf *plist* :a)
*plist*
(remf *plist* :z)
*plist*
;; !!! GETF and REMF always use EQ !!!
;; extract multiple properties
(defun process-properties (plist keys)
(loop while plist do
(multiple-value-bind (key value tail) (get-properties plist keys)
(when key (process-property key value))
(setf plist (cddr tail)))))
(get 'symbol 'key) === (getf (symbol-plist 'symbol) 'key)
(setf (get 'some-symbol 'my-key) "information")
(remprop 'symbol 'key) === (remf (symbol-plist 'symbol key))
;; destructuring-bind
(destructuring-bind (x y z) (list 1 2 3)
(list :x x :y y :z z))
(destructuring-bind (x y z) (list 1 (list 2 20) 3)
(list :x x :y y :z z))
| 2,887 | Common Lisp | .lisp | 89 | 31.044944 | 72 | 0.611871 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 55236c3394eec50f371dcfb6e0d1d67d8adc4b51ecdbd9b4f0f3d4b437ad5346 | 32,107 | [
-1
] |
32,108 | 11-collections.lisp | martinhomuth_clisp/11-collections.lisp |
;;; vectors
(vector)
(vector 1)
(vector 1 2)
#(1 2) ; literal notation for vectors, not defined to be modified
(make-array 0)
(make-array 5 :initial-element 3)
(make-array 5 :fill-pointer 0) ; appears empty but has space for 5 elements
(defparameter *x* (make-array 5 :fill-pointer 0))
(vector-push 'a *x*) ; => 0
*x*
(vector-push 'b *x*) ; => 1
*x*
(vector-push 'c *x*) ; => 2
(vector-push 'd *x*) ; => 3
(vector-push 'e *x*) ; => 4
(vector-push 'f *x*) ; => nil - full
(vector-pop *x*) ; => E
*x*
(defparameter *y* (make-array 5 :fill-pointer 0 :adjustable t))
(vector-push 'a *y*)
(vector-push-extend 'e *y*)
(vector-push-extend 'e *x*)
; VECTOR-PUSH-EXTEND works only on adjustable arrays, not on #(A B C D E)
(make-array 5 :fill-pointer 0 :adjustable t :element-type 'character)
(make-array 5 :fill-pointer 0 :adjustable t :element-type 'bit)
(defparameter *mystring* (vector 'a 'b 'c 'd))
*mystring*
(length *mystring*)
(elt *mystring* 1)
(elt *mystring* 2)
; elt is setf-able position
(setf (elt *mystring* 2) 'x)
*mystring*
;;; sequence functions
(count 1 #(1 2 1 2 3 1 2 3 4)) ; => 3
(remove 1 #(1 2 3 4 5 1 1 2 3)) ; => #(2 3 4 5 2 3)
(remove 1 '(1 2 1 2 3 1 2 3 4)) ; => (2 2 3 2 3 4)
(remove #\a "foobarbaz") ; => "foobrbz"
;;; specify the comparison function using :test keyword
(count 1 #(1 2 1 2 3 1 2 3 4) :test #'<)
;;; specify function to extract key from elements using :key keyword
(find 'c #((a 10) (b 20) (c 30) d(40)) :key 'first)
;;; :from-end t - search from the end
;;; :start x - starting index
;;; :end x - ending index
(defparameter *v* #((a 10) (b 20) (a 30) (b 40)))
(defun verbose-first (x) (format t "Looking at ~s~%" x) (first x))
(count 'a *v* :key 'verbose-first)
(count-if 'zerop #(0 1 2 3 4))
(remove-if 'numberp #(0 1 2 3 4 "hans"))
(position-if-not 'digit-char-p #(#\w #\b #\2 #\,))
(count-if 'evenp #((a 10) (b 25) (c 10) (d 43)) :key 'second)
(remove-if-not 'alpha-char-p #("foo" "bar" "1baz") :key #'(lambda (x) (elt x 0)))
(defparameter *someseq* #(1 2 3 4 5))
(defparameter *someotherseq* (copy-seq *someseq*))
(equalp *someseq* *someotherseq*)
(eql *someseq* *someotherseq*)
(reverse *someseq*)
(concatenate 'list #(1 2 3) #(3 4 5))
(concatenate 'string "abs" "olut" "egarbage")
(sort (vector "foo" "bar" "baz") 'string<)
(defparameter *somevec* (vector "foo" "bar" "baz"))
(sort *somevec* 'string>)
*somevec* ; modified
;;; better:
(defparameter *somevec* (vector "foo" "bar" "baz"))
(sort (copy-seq *somevec*) 'string>)
(merge 'string "asdj" "ertn" 'string<)
(subseq "thisissomething" 4)
(defparameter *x* "somethingsfishy")
(setf (subseq *x* 3 7) "xxxx")
*x*
(fill *x* #\w :start 7)
(mismatch "foobarbaz" "foom")
(mismatch #((a 10) (b 20) (c 30)) #((a 10) (b 30) (c 60)) :key 'second)
(every 'evenp #(1 2 3 4 5))
(every 'evenp #(2 2 4 6))
(some 'evenp #(1 2 3 4 5))
(notany 'evenp #(1 2 3 4 5))
(notany 'evenp #(1 3 5))
(notevery 'evenp #(2 4))
(every '< #(1 2 3 4) #(5 6 7 8))
(map 'vector '* #(1 2 3 4) #(5 6 7 8))
(defparameter a (vector 1 2 3))
(defparameter b (vector 4 3 2))
(defparameter c (vector 9 3 2))
(map-into a '+ a b c)
(reduce '+ #( 1 2 3 4 5 6 7 8))
(make-hash-table)
(make-hash-table :test 'equal) ; test can only be 'eq, 'eql, 'equal and 'equalp
(defparameter *h* (make-hash-table))
(gethash 'foo *h*)
(setf (gethash 'foo *h*) 'quux)
(gethash 'foo *h*) ; returns two values, the second whether the value was in the table
;;; example for multiple value handling
(defun show-value (key hash-table)
(multiple-value-bind (value present) (gethash key hash-table)
(if present
(format nil "Value ~a actually present." value)
(format nil "Value ~a because key not found." value))))
(setf (gethash 'bar *h*) nil)
(show-value 'foo *h*)
(show-value 'bar *h*)
(show-value 'baz *h*)
(remhash 'bar *h*)
(maphash #'(lambda (k v) (format t "~a => ~a~%" k v)) *h*)
(maphash #'(lambda (k v) (when (< v 10) (remhash k *h*))) *h*)
| 3,963 | Common Lisp | .lisp | 108 | 35.12037 | 86 | 0.633184 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 1fc98d7fe31c0b59613a7392735782e79071536b3ecd8cecbc1269fa35504863 | 32,108 | [
-1
] |
32,109 | 15-portable-pathname-library.lisp | martinhomuth_clisp/15-portable-pathname-library.lisp | ;;; Read Time Conditionalization
;; there is a global variable containing the implementation features
*FEATURES*
;; #+ someboolean => if someboolean is true, the next expression is
;; evaluated, otherwise treated as whitespace
;; #- the inverse
(defun foo()
#+allegro (format t "allegro stuff~%")
#+clisp (format t "clisp stuff~%")
#+cmu (format t "cmu stuff~%")
#+sbcl (format t "sbcl stuff~%")
#-(or allegro clisp cmu sbcl) (error "Not implemented"))
(foo)
(defun list-directory ()
"Portable wrapper around DIRECTORY."
(format t "peter~%"))
(list-directory)
(directory (make-pathname :name :wild :type :wild :defaults "/home/martin/"))
; Checks whether COMPONENT is neither NIL nor :UNSPECIFIC.
(defun component-present-p (_component)
(and _component (not (eql _component :unspecific))))
; Tests whether PATHNAME is already in directory form.
(defun directory-pathname-p (_pathname)
(and
(not (component-present-p (pathname-name _pathname)))
(not (component-present-p (pathname-type _pathname)))
_pathname))
; Converts any PATHNAME to a directory form pathname.
(defun pathname-as-directory (_pathname)
(let ((pathname (pathname _pathname))) ; yes, this looks weird
(when (wild-pathname-p pathname)
(error "Can't reliably convert wild pathnames"))
(if (not (directory-pathname-p _pathname))
(make-pathname
:directory (append (or (pathname-directory pathname) (list :relative))
(list (file-namestring pathname)))
:name nil
:type nil
:defaults pathname)
pathname)))
;; Returns proper wildcard for the given implementation
(defun directory-wildcard (_dirname)
(make-pathname
:name :wild
:type #-clisp :wild #+clisp nil
:defaults (pathname-as-directory _dirname)))
#+clisp
(defun clisp-subdirectories-wildcard (wildcard)
(make-pathname
:directory (append (pathname-directory wildcard) (list :wild))
:name nil
:type nil
:defaults wildcard))
(defun list-directory (_dirname)
(when (wild-pathname-p _dirname)
(error "Can only list concrete directory names."))
(let ((wildcard (directory-wildcard _dirname)))
#+(or sbcl cmu lispworks)
(directory wildcard)
#+openmcl
(directory wildcard :directories t)
#+allegro
(directory wildcard :directories-are-files nil)
#+clisp
(nconc
(directory wildcard)
(directory (clisp-subdirectories-wildcard wildcard)))
#-(or sbcl cmu lispworks openmcl allegro clisp)
(error "list-directory not implemented")))
(list-directory "/home/martin")
;;; file-exists-p (that also checks for directories)
;; sbcl, lispworks and openmcl already provide the exact feature
;; allegro and cmucl return the name in the same form as given as parameter
;; rather than returning a directory form
;; clisp throws error if given a directory
(defun file-exists-p (_pathname)
#+ (or sbcl lispworks openmcl)
(probe-file _pathname)
#+ (or allegro cmu)
(or (probe-file (pathname-as-directory _pathname))
(probe-file _pathname))
#+clisp
(or (ignore-errors
(probe-file (pathname-as-file _pathname)))
(ignore-errors
(let ((directory-form (pathname-as-directory _pathname)))
(when (ext:probe-directory directory-form)
directory-form))))
#- (or sbcl cmu lispworks openmcl allegro clisp)
(error "file-exists-p not implemented"))
(file-exists-p "/home/martin/.zshrc")
(defun pathname-as-file (_pathname)
(let ((pathname (pathname _pathname)))
(when (wild-pathname-p pathname)
(error "can't reliably convert wild pathnames."))
(if (directory-pathname-p _pathname)
(let* ((directory (pathname-directory pathname))
(name-and-type (pathname (first (last directory)))))
(make-pathname
:directory (butlast directory)
:name (pathname-name name-and-type)
:type (pathname-type name-and-type)
:defaults pathname))
pathname)))
| 3,862 | Common Lisp | .lisp | 104 | 33.701923 | 77 | 0.719914 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | fe58b699269932b764e88474f8497a7304f0f7e6f7a6ba8666167a185d286a7b | 32,109 | [
-1
] |
32,110 | 12-lists.lisp | martinhomuth_clisp/12-lists.lisp | (cons 1 2) ; first is CAR, second is CDR
(car (cons 1 2))
(cdr (cons 1 2))
;;; also SETFable
(defparameter *cons* (cons 1 2))
*cons*
(setf (car *cons*) 10)
*cons*
(cons 1 nil)
(cons 1 (cons 2 nil))
(cons 1 (cons 2 (cons 3 nil)))
(defparameter *list* (list 1 2 3 4))
*list*
(cdr *list*)
(rest *list*)
(car *list*)
(first *list*)
(second *list*)
(third *list*)
(defparameter *newlist* (list "foo" (list 1 2) 10))
(car *newlist*)
(car (cdr *newlist*))
(append (list 1 2) (list 3 4))
(defparameter *list-1* (list 1 2))
(defparameter *list-2* (list 3 4))
(defparameter *list-3* (append *list-1* *list-2*))
(setf (first *list-2*) 0)
*list-3*
(setf (first *list-1*) 9)
*list-3* ; only *list-2* is shared with the 'new' *list-3*
(setf *list* (list 1 2 3 4))
(setf *list* (reverse *list*))
*list* ; original cons cells are garbage collected
(setf *list* (list 1 2 3 4))
(setf *list* (nreverse *list*))
*list* ; no new cons cells allocation
(defparameter *list-1* (list 1 2))
(defparameter *list-2* (list 3 4))
(defparameter *list* (append *list-1* *list-2*))
*list*
(reverse *list*)
*list-2*
*list*
(nreverse *list*)
*list-2* ; magic
(defparameter *lelist* (list 1 2 3 4 5))
(delete 3 *lelist*)
*lelist*
(defparameter *lelist* (list 1 2 3 4 5))
(remove 3 *lelist*) ; non-destructive
*lelist*
(defun upto (max)
(let ((result nil))
(dotimes (i max)
(push i result))
(nreverse result)))
(upto 10)
(defparameter *list-1* (list 1 2))
(defparameter *list-2* (list 3 4))
(defparameter *list-3* (append *list-1* *list-2*))
(setf (first *list-2*) 0)
*list-2*
*list-3*
(setf *list-3* (delete 4 *list-3*))
(defparameter *list* (list 2 3 5 6 2 23))
(sort *list* '<)
*list* ; destructive
(defparameter *list* (list 2 3 5 6 2 23))
(defparameter *sorted-list* (sort (copy-list *list*) '<))
*list*
*sorted-list*
(defparameter *list* (list (list 1 2) 2 3 4 5 6))
(caar *list*) === (car (car *list*)) ; up to four As and Ds
(cadadr *list*) === (car (cdr (car (cdr *list*))))
(mapcar #'(lambda (x) (* 2 x)) (list 1 2 3))
(mapcar #'+ (list 1 2 3) (list 10 20 30))
(map 'vector #'+ (list 1 2 3) (list 10 20 30))
| 2,124 | Common Lisp | .lisp | 77 | 26.051948 | 59 | 0.639466 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | e02261fb33f9d25fdd202fe0369b01de760e83258d7fd3ab096cba738d056acd | 32,110 | [
-1
] |
32,111 | 10-numbers-characters-strings.lisp | martinhomuth_clisp/10-numbers-characters-strings.lisp |
1.0
(- 5 4)
(/ 3 2)
(mod 10 4)
(rem 10 4)
(setf a (1+ a))
(tan (max 3 5 43 344 34342 23442443 2))
(char= a b)
"foo\"bar"
(format t "foo\"bar")
(string= "foo" "FOO") ; nil
(string-equal "foo" "FOO") ; t
(string< "foo" "BAR")
(string-lessp "foo" "BAR")
;;; additional restriction arguments
(string= "thisisgod" "thatispeter" :start1 4 :start2 4 :end1 6 :end2 6)
(string<= "thisisgod" "thisisjack")
(string< "foobar" "baz" :start1 3) ;;; 5, not 2 as it's the index of the full word
| 495 | Common Lisp | .lisp | 18 | 25.722222 | 82 | 0.641469 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 4eb079341c8db5e79038180c7ccc6ff8bc4b6bea47a1859cb4148774cf66ae5a | 32,111 | [
-1
] |
32,112 | 14-file-io.lisp | martinhomuth_clisp/14-file-io.lisp | (let ((in (open "testfile")))
(format t "~a~%" (read-line in))
(close in))
(let ((in (open "not-existent" :if-does-not-exist nil)))
(when in
(format t "~a~%" (read-line in))
(close in)))
(let ((in (open "not-existent-will-create" :if-does-not-exist nil)))
(when in
(loop for line = (read-line in nil)
while line do (format t "~a~%" line))
(close in)))
(let ((in (open "not-existent-error" :if-does-not-exist :error)))
(format t "~a~%" (read-line in))
(close in))
;;; Output
(let ((out (open "newfile" :direction :output)))
(when out
(format t "got an out stream~%")))
(let ((out (open "testfile" :direction :output :if-exists 'nil))) ;
(when out
(format t "got an out stream~%")))
;; can be :supersede (overwrite) or :append
(let ((out (open "write-char-file" :direction :output)))
(when out
(write-char #\w out)) ; optional argument specifies stream
(close out))
(let ((out (open "write-line-file" :direction :output)))
(when out
(write-line "This is a total line" out)
(terpri out)
(close out)))
(let ((out (open "write-string-file" :direction :output)))
(when out
(write-string "This is a total line" out)
(close out)))
(let ((out (open "print-file2" :direction :output :if-exists :supersede))
(something (list 1 2 3 (list 3 4 5 "hans") #\b "flammenwerfer")))
(when out
(format t "printing: ")
(print something out)
(terpri out)
(princ something out)
(terpri out)
(pprint something out)
(close out)))
;;; automatic close of opened streams
(with-open-file (stream "testfile" :direction :output :if-exists :append)
(when stream
(write-line "this is an appended line" stream)))
;;; Filenames (or Lisps portable pathname objects
(pathname "/etc/resolv.conf")
(pathname-directory (pathname "/etc/resolv.conf"))
(pathname-name (pathname "/etc/resolv.conf"))
(pathname-type (pathname "/etc/resolv.conf"))
(pathname-version (pathname "/etc/resolv.conf"))
;; convert back
(defparameter *pname* (pathname "/etc/resolv.conf"))
(namestring *pname*)
(directory-namestring *pname*)
(file-namestring *pname*)
;;; Pathname Construction
(make-pathname
:directory '(:absolute "foo" "bar")
:type "txt"
:name "baz")
;; better not to build from scratch
(make-pathname :name "peter"
:defaults *pname*) ; copies from another file
(delete-file "testfile")
(let ((name "testfile"))
(with-open-file (out (ensure-directories-exist name)
:direction :output
:if-exists :append)
(write-line "this is a test line" out)
(format t "~a, ~a, ~a"
(file-write-date out)
(file-author out)
(file-length out))))
| 2,668 | Common Lisp | .lisp | 79 | 30.329114 | 73 | 0.656943 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 766f8b4abbaeed28bddff0578ea57e0d86f4da32d7caeda5c5c193f2acc40930 | 32,112 | [
-1
] |
32,119 | testfile | martinhomuth_clisp/testfile | This is a testfile line
This is the second line
This is a third line | 68 | Common Lisp | .l | 3 | 22 | 23 | 0.818182 | martinhomuth/clisp | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 9b11f4bb287b4e70b1164018e3cde6e6e90f0b0fa344bb151283a2a9e773dcfc | 32,119 | [
-1
] |
32,135 | cl-yaml-parser-fix.lisp | tpine_cl-base16/cl-yaml-parser-fix.lisp | ;;; cl-yaml picks up some of the base16 scheme values as floats instead of strings
;;; Until this is fixed patch the function so that it only parses strings
(in-package :yaml.scalar)
(defun parse-scalar (string &optional (style :plain-scalar-style))
"Return the string for all values."
string)
| 300 | Common Lisp | .lisp | 6 | 48 | 82 | 0.767123 | tpine/cl-base16 | 0 | 0 | 1 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 02cf541634a1cef3964cffc80f854fe28cac9b84747858e3b9ccd5afdd6c731f | 32,135 | [
-1
] |
32,136 | package.lisp | tpine_cl-base16/package.lisp | ;;;; package.lisp
(defpackage #:cl-base16
(:use #:cl)
(:export *base-dir*
*source-dir*
apply-scheme
update))
| 126 | Common Lisp | .lisp | 7 | 14.571429 | 23 | 0.618644 | tpine/cl-base16 | 0 | 0 | 1 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 51bf50400fa7019b7afddc0d96deaff64478fccb842d1af9075070e4d8e41d52 | 32,136 | [
-1
] |
32,137 | builder.lisp | tpine_cl-base16/builder.lisp | ;;; Functions for updating scheme and template files
(in-package #:cl-base16)
(defun clone-or-update-git-repo (repo url &optional (dir *source-dir*))
"As it says on the tin."
(trivial-shell:shell-command (format nil "git clone ~a \"~a/~a\"" url dir repo)))
(defun fetch-list-contents (source-name)
"Fetch the contents of source source-name and clone th git repo's it specifies."
(maphash (lambda (repo url) (clone-or-update-git-repo repo url
(merge-pathnames source-name *source-dir*)))
(yaml:parse (merge-pathnames (format nil "~a/list.yaml" source-name) *source-dir*))))
(defun update-sources ()
"Update sources
If sources is nil update *base-dir*/sources.yaml
If it has a value convert a string to yaml"
(let ((sources (merge-pathnames "sources.yaml" *base-dir*)))
(maphash (lambda (repo url)
(clone-or-update-git-repo repo url)
(fetch-list-contents repo))
(yaml:parse sources))))
(defun update ()
(update-sources)
;; There has to be a better way todo this
;; Its cleaner then the original attmpt in loop but not great
(maphash (lambda (key value)
(declare (ignore value))
(mapc (lambda (variant)
(maphash (lambda (template value)
(declare (ignore value))
(save-theme variant template))
(yaml:parse (merge-pathnames "templates/list.yaml" *source-dir*))))
(directory (merge-pathnames (concatenate 'string "schemes/" key "/*.yaml") *source-dir*))))
(yaml:parse (merge-pathnames "schemes/list.yaml" *source-dir*))))
| 1,522 | Common Lisp | .lisp | 32 | 43.25 | 96 | 0.692463 | tpine/cl-base16 | 0 | 0 | 1 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 09388c0db5f4717221ec22894d3f199a269e4b5a6ec2d8b23682e875c3de7d90 | 32,137 | [
-1
] |
32,138 | cl-base16.lisp | tpine_cl-base16/cl-base16.lisp | ;;;; cl-base16.lisp
;;; Contains main functions related to building a theme
(in-package #:cl-base16)
(defparameter *base-dir* (pathname (directory-namestring (asdf:system-relative-pathname :cl-base16 "package.lisp")))
"Base directory to expect input files from.
This is set to the base directory of the source files when loaded with asdf.
*base-dir* has to be of type pathname")
(defparameter *source-dir* (merge-pathnames "sources/" *base-dir*)
"Source directory.
This is set to *base-dir*/sources/ when loaded with asdf.
*source-dir* has to be of type pathname")
;;; Theme application and saving
(defun get-template-dir (template)
"Get the directory of template."
(merge-pathnames (format nil "templates/~a/" template) *source-dir*))
(flet ((open-yaml-file-or-nil (path)
"Open yaml file specified by path or return nil"
(if (probe-file path)
(yaml:parse path)
nil)))
(defun open-template-or-nil (template)
"Open template yaml file"
(open-yaml-file-or-nil (merge-pathnames
#p"templates/config.yaml" (get-template-dir template)))))
(defun make-keyword (key)
"Make string key into a keyword."
(multiple-value-bind (keyword ret) (intern (string-upcase key) "KEYWORD")
(declare (ignore ret))
keyword))
(defun load-scheme (scheme)
"Load Scheme scheme as a cons list."
(uiop:if-let ((scheme-yaml (yaml:parse scheme)))
;; cl-mustache wants its input in a cons list
;; build a cons list from the scheme yaml file
(let ((scheme-cons '()))
(flet ((add-to-scheme (key value)
(setf scheme-cons (append scheme-cons (list (cons
(make-keyword key)
value))))))
(add-to-scheme :scheme-author (gethash "author" scheme-yaml))
(add-to-scheme :scheme-name (gethash "scheme" scheme-yaml))
(add-to-scheme :scheme-slug (slug:slugify (pathname-name scheme)))
(loop for base in '("00" "01" "02" "03"
"04" "05" "06" "07"
"08" "09" "0A" "0B"
"0C" "0D" "0E" "0F")
do (let ((hex-value (let ((temp (gethash (concatenate'string "base" base) scheme-yaml)))
;; Some scheme like dracula use #
;; At the start of their values
;; Remove this from the value
(if (= (length temp) 7)
(subseq temp 1 7)
temp))))
;; Full hex string
(add-to-scheme (concatenate 'string "base" base "-hex")
hex-value)
;; Hex string split into rgb values
(add-to-scheme (concatenate 'string "base" base "-hex-r")
(subseq hex-value 0 2))
(add-to-scheme (concatenate 'string "base" base "-hex-g")
(subseq hex-value 2 4))
(add-to-scheme (concatenate 'string "base" base "-hex-b")
(subseq hex-value 4 6))
;; RGB values
(add-to-scheme (concatenate 'string "base" base "-rgb-r")
(parse-integer (subseq hex-value 0 2) :radix 16))
(add-to-scheme (concatenate 'string "base" base "-rgb-g")
(parse-integer (subseq hex-value 2 4) :radix 16))
(add-to-scheme (concatenate 'string "base" base "-rgb-b")
(parse-integer (subseq hex-value 4 6) :radix 16))
;; Dec Values
(add-to-scheme (concatenate 'string "base" base "-dec-r")
(/ (parse-integer (subseq hex-value 0 2) :radix 16) 255))
(add-to-scheme (concatenate 'string "base" base "-dec-g")
(/ (parse-integer (subseq hex-value 2 4) :radix 16) 255))
(add-to-scheme (concatenate 'string "base" base "-dec-b")
(/ (parse-integer (subseq hex-value 4 6) :radix 16) 255)))))
scheme-cons)
(error "Cannot load scheme ~a" scheme)))
(defun apply-scheme (scheme template mustache-filename)
"Apply Scheme scheme to Template template and return theme as a string."
(let ((template-path
(merge-pathnames (concatenate 'string "templates/" mustache-filename ".mustache") (get-template-dir template))))
(if (probe-file template-path)
(mustache:render* template-path (load-scheme scheme))
(error "Cannot find template: ~a" template))))
(defun save-theme (scheme template)
"Save theme specified by scheme after being applied to template.
Optionally specify:
The output path out to use"
(uiop:if-let ((template-yaml (open-template-or-nil template)))
(maphash (lambda (mustache-filename template-config)
(let ((template-output-path (merge-pathnames (pathname (concatenate 'string
(gethash "output" template-config) "/"
(uiop:split-name-type (file-namestring scheme))
(gethash "extension" template-config)))
(get-template-dir template))))
(uiop:ensure-all-directories-exist (list template-output-path))
(with-open-file (output-file template-output-path
:direction :output
:if-exists :supersede
:if-does-not-exist :create)
(format output-file "~a" (apply-scheme scheme template mustache-filename)))))
template-yaml)
(error "Could not find template: ~a" template)))
| 4,885 | Common Lisp | .lisp | 105 | 41.057143 | 116 | 0.667576 | tpine/cl-base16 | 0 | 0 | 1 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 416721654def8f9040b330a4aa26acd1bebe96b3446094e1122f56c4286489b8 | 32,138 | [
-1
] |
32,139 | cl-base16.asd | tpine_cl-base16/cl-base16.asd | ;;;; cl-base16.asd
(asdf:defsystem #:cl-base16
:description "Common Lisp implementation of base16"
:author "Thomas Atkinson <[email protected]>"
:license "GPLv2"
:serial t
:depends-on (:uiop
:cl-yaml
:cl-mustache
:cl-slug
:trivial-shell)
:components ((:file "package")
(:file "cl-base16")
(:file "builder")
(:file "cl-yaml-parser-fix")))
| 416 | Common Lisp | .asd | 15 | 21.666667 | 53 | 0.6025 | tpine/cl-base16 | 0 | 0 | 1 | GPL-3.0 | 9/19/2024, 11:42:06 AM (Europe/Amsterdam) | 369416415944295372e5c38fd15f1b14f0d51a41dad37b01c490e6b2d5cefd2e | 32,139 | [
-1
] |
32,160 | Problem3.lisp | programmerjerry_LispLearn/Project_Euler/Problem3/Problem3.lisp | ;;;; Problem 3 Largest prime factor
;;; 求一个数的最大的质数因子，也就是若干个不同的质数的乘积能得到这个数
;;; 判断是否是质数
(defun is-primer (n)
;; 如果是一些已知的质数直接返回t
(if (or
(= n 2)
(= n 3)
(= n 5)
(= n 7)
(= n 11)
(= n 13)
(= n 17)
(= n 19)
(= n 23)
(= n 29)
(= n 31)
(= n 37))
(return-from is-primer t))
;; 1到n之间随机取一个数字，如果能被这个数整除，那么这个数一定不是质数，
;; 这个是使用的概率算法，如果运气好，能非常快判断出该数字是非质数；
;; 运气不好时，这里取该数字的一半作为最大的测试次数，如果还是没法判断不是
;; 质数，就根据质数的定义一个数字挨一个数字的判断是否能整除
(dotimes (j (round (/ n 2.0)))
(if (> j 2)
(let ((r (random n)))
(if (> r 1)
(if (zerop (mod n r))
(return-from is-primer nil))))))
;; 根据质数定义判断是否是质数
(let ((i 3)) ; 除了2外的质数都不是偶数，这里直接从3开始
(loop while (<= i n)
do (if (zerop (mod n i))
(if (= i n)
(return t)
(return nil)))
(setf i (1+ i)))))
(defun largest-prime-factor (n)
(let ((i (round (sqrt n)))) ; 质数因子的平方小于等于n，所以这里从平方根后的数字开始计算，按指数减少运算量
(loop while (> i 2)
do (if (and
(not (zerop (mod i 2))) ; 除了2以外的偶数都是非质数，能减少一半的计算量
(zerop (mod n i)) ; 必须是整除才行
(is-primer i))
(return i))
(setf i (- i 1)))))
;;; CL-USER 49 > (largest-prime-factor 600851475143)
;;; 6857
| 1,930 | Common Lisp | .lisp | 48 | 20.270833 | 70 | 0.484043 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | f6178e5d4bc8e4f5e504cd49377b9b13f2b076307ac77a41755c8f3c1be20f84 | 32,160 | [
-1
] |
32,161 | Problem7.lisp | programmerjerry_LispLearn/Project_Euler/Problem7/Problem7.lisp | ;;;; Problem 7 10001st prime
;;;; 求第10001个质数
;;;; 解决办法：从1开始挨个测试是否是质数，由于 除了2以外的质数都是奇数，
;;;; 只要挨个测试奇数是否是质数就可以了。用了1分27秒，还可以接受。
;;; 判断是否是质数
(defun is-primer (n)
;; 如果是一些已知的质数直接返回t
(if (or
(= n 2)
(= n 3)
(= n 5)
(= n 7)
(= n 11)
(= n 13)
(= n 17)
(= n 19)
(= n 23)
(= n 29)
(= n 31)
(= n 37))
(return-from is-primer t))
;; 先用一些已知的质数测试下是否能整除，如果能整除则是非质数
(if (or
(zerop (mod n 2))
(zerop (mod n 3))
(zerop (mod n 5))
(zerop (mod n 7))
(zerop (mod n 11))
(zerop (mod n 13))
(zerop (mod n 17))
(zerop (mod n 19))
(zerop (mod n 23))
(zerop (mod n 29))
(zerop (mod n 31))
(zerop (mod n 37)))
(return-from is-primer nil))
;; 1到n之间随机取一个数字，如果能被这个数整除，那么这个数一定不是质数，
;; 这个是使用的概率算法，如果运气好，能非常快判断出该数字是非质数；
;; 运气不好时，这里取该数字的一半作为最大的测试次数，如果还是没法判断不是
;; 质数，就根据质数的定义一个数字挨一个数字的判断是否能整除
(dotimes (j (round (/ n 2.0)))
(if (> j 2)
(let ((r (random n)))
(if (> r 1)
(if (zerop (mod n r))
(return-from is-primer nil))))))
;; 根据质数定义判断是否是质数
(let ((i 2)) ; 这里直接从2开始
(loop while (<= i n)
do (if (zerop (mod n i))
(if (= i n)
(return t)
(return nil)))
(setf i (1+ i)))))
(defun 10001st-prime (n)
(let ((j 3) (i 2))
(loop while (<= i n) ;需要算上第n个质数
do (if (is-primer j)
(setf i (1+ i)))
(setf j (+ j 2)))
(- j 2))) ; 循环里面多加了2，需要减掉
;;; CL-USER 47 > (10001st-prime 10001)
;;; 104743
| 2,209 | Common Lisp | .lisp | 63 | 18.68254 | 50 | 0.476343 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 9b2237a5319e904ecc41d4556acea70340d7d7f417678da29b191d23fba95dea | 32,161 | [
-1
] |
32,162 | Problem4.lisp | programmerjerry_LispLearn/Project_Euler/Problem4/Problem4.lisp | ;;;;Problem 4 Largest palindrome product
;;;; 求2个三位数字的乘积构成的最大的回文
;;; 判断是否是回文，只要将字符串和反转后的一致就是回文
(defun is-palindrome (n)
(let ((s (write-to-string n)))
(if (equalp s (reverse s))
t
nil)))
(defun largest-palindrome-product (n)
(do ((n1 n (- n1 1))
(result 0)) ; 记录回文
((= n1 1) result)
(do ((n2 n (- n2 1)))
((= n2 1))
(let* ((prod (* n1 n2)))
(if (is-palindrome prod)
; 如果是回文并且新的值比记录的最大值大，，则这个是新的最大的回文
(if (> prod result)
(setf result prod)))))))
;;; CL-USER 82 > (largest-palindrome-product 999)
;;; 906609
| 773 | Common Lisp | .lisp | 21 | 23.095238 | 49 | 0.548061 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 723024800611aa8b28cab88264daa55eec467b83ba7bf7a4e33c7946454b5a81 | 32,162 | [
-1
] |
32,163 | Problem9.lisp | programmerjerry_LispLearn/Project_Euler/Problem9/Problem9.lisp | ;;;; Problem 9 Special Pythagorean triplet
;;;; 求满足条件的a、b、c的乘积，条件：a<b<c;a^2+b^2=c^2;a+b+c=1000
;;;; 直接根据条件挨个尝试即可，运算量不大很快就跑出来了
(defun special-pythagorean-triplet ()
(dotimes (a 1001)
(dotimes (b 1001)
(dotimes (c 1001)
(if (and (< a b) (< b c))
(if (= (+ a b c) 1000)
(if (=
(+ (expt a 2) (expt b 2))
(expt c 2))
(return-from special-pythagorean-triplet (* a b c)))))))))
;;; CL-USER 72 > (special-pythagorean-triplet)
;;; 31875000
| 625 | Common Lisp | .lisp | 15 | 27.733333 | 78 | 0.513308 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 2468330d45f9d20fab9d5c95aaf74e93820d9417135e44a7b7232ed64200d3e3 | 32,163 | [
-1
] |
32,164 | Problem5.lisp | programmerjerry_LispLearn/Project_Euler/Problem5/Problem5.lisp | ;;;; Problem 5 Smallest multiple
;;;;求1到20的最小公倍数
;;;;实现方案：1到20所有数字做乘积，会得到一个公倍数，但是不是最小的公倍数
;;;; 用这个数字依次去整除1到20之间的质数，每个质数做多次整除并测试得到的商是否
;;;; 满足公倍数.如果不满足，则用最后满足条件的商，去多次除以下一个质数并
;;;; 测试商是否满足公倍数的条件。最后会获得最小公倍数。
;;; 测试数字是否是1到n的公倍数
(defun is-evenly-divisible-by-all-of-the-numbers (n smallest-multiple)
(do ((i 1 (+ i 1)))
((> i n))
(unless (zerop (mod smallest-multiple i))
(return-from is-evenly-divisible-by-all-of-the-numbers nil)))
t)
;;; 判断是否是质数
(defun is-primer (n)
;; 如果是一些已知的质数直接返回t
(if (or
(= n 2)
(= n 3)
(= n 5)
(= n 7)
(= n 11)
(= n 13)
(= n 17)
(= n 19)
(= n 23)
(= n 29)
(= n 31)
(= n 37))
(return-from is-primer t))
;; 1到n之间随机取一个数字，如果能被这个数整除，那么这个数一定不是质数，
;; 这个是使用的概率算法，如果运气好，能非常快判断出该数字是非质数；
;; 运气不好时，这里取该数字的一半作为最大的测试次数，如果还是没法判断不是
;; 质数，就根据质数的定义一个数字挨一个数字的判断是否能整除
(dotimes (j (round (/ n 2.0)))
(if (> j 2)
(let ((r (random n)))
(if (> r 1)
(if (zerop (mod n r))
(return-from is-primer nil))))))
;; 根据质数定义判断是否是质数
(let ((i 2)) ; 除了2外的质数都不是偶数，这里直接从3开始
(loop while (<= i n)
do (if (zerop (mod n i))
(if (= i n)
(return t)
(return nil)))
(setf i (1+ i)))))
;;; 获得最小公倍数
(defun smallest-multiple (n)
(let ((result 1) (primer-list nil))
;; 获得1到n的乘积
(do ((i 1 (+ i 1)))
((> i n))
(progn
(if (is-primer i) ; 获得1到n之间的所有质数
(push i primer-list))
(setf result (* result i))))
(dolist (v1 primer-list)
(if (zerop (mod result v1))
(loop while (is-evenly-divisible-by-all-of-the-numbers n result)
do (let ((new-value (/ result v1)))
(if (is-evenly-divisible-by-all-of-the-numbers n new-value)
(setf result new-value)
(return result))))))
result))
;;; CL-USER 24 > (smallest-multiple 20)
;;; 232792560
| 2,722 | Common Lisp | .lisp | 68 | 22.397059 | 77 | 0.534536 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 061b03333ca6f2cb297abb1788a99c025011d132efe74be6378ba1c97859be35 | 32,164 | [
-1
] |
32,165 | Problem1.lisp | programmerjerry_LispLearn/Project_Euler/Problem1/Problem1.lisp | ;;;; Problem 1 Multiples of 3 and 5
;;; 1000以内，能被3或者5整除的自然数, 求这些自然数的和
(defun sum-of-multiple-3-5 (n)
(let ((result 0))
(dotimes (i n)
(if (or
(zerop (mod i 3))
(zerop (mod i 5)))
(setf result (+ result i))))
result))
;;; CL-USER 228 > (sum-of-multiple-3-5 1000)
;;; 233168
| 365 | Common Lisp | .lisp | 12 | 21.75 | 44 | 0.553398 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 91514b8cbad6d140b41db980211ac0d78e224f7f08b901b0eed42562cf51b953 | 32,165 | [
-1
] |
32,166 | Problem6.lisp | programmerjerry_LispLearn/Project_Euler/Problem6/Problem6.lisp | ;;;; Problem 6 Sum square difference
;;;; 求1到100的和的平方与1到100平方的和的差
;;; 平方的和
(defun sum-of-squares (n)
(let ((result 0))
(dotimes (i n)
(setf result (+ result (expt (1+ i) 2))))
result))
;;; 和的平方
(defun square-of-sum (n)
(let ((result 0))
(dotimes (i n)
(setf result (+ result (1+ i))))
(setf result (expt result 2))
result))
;;; 求差
(defun difference-sumofsquares-squareofsum (n)
(- (square-of-sum n) (sum-of-squares n)))
;;; CL-USER 34 > (difference-sumofsquares-squareofsum 100)
;;; 25164150
| 599 | Common Lisp | .lisp | 20 | 23.6 | 58 | 0.616412 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 47cf13bdcd476e5a6fce71f66c9bb4b54025e564cda08c83ed79377e02d72eb2 | 32,166 | [
-1
] |
32,167 | Problem10.lisp | programmerjerry_LispLearn/Project_Euler/Problem10/Problem10.lisp | ;;;; Problem 10 Summation of primes
;;;; 求1到2百万之间的所有质数的和
;;; 判断是否是质数
(defun is-primer (n)
(let ((i 2))
(loop while (<= i (round (sqrt n))) ; 计算到n的平方根就可以了
do (if (zerop (mod n i))
(if (= i n)
(return-from is-primer t)
(return-from is-primer nil)))
(setf i (+ i 1)))) ; max-primer 到了这里肯定是奇数
t)
(defun summation-of-primes (n)
(let ((result 2))
(do ((i 3 (+ i 2))) ; 除了2，质数都是奇数
((>= i n) result)
(if (is-primer i)
(setf result (+ result i))))
result))
;;; CL-USER 277 > (summation-of-primes 2000000)
;;; 142913828922
| 742 | Common Lisp | .lisp | 21 | 23.428571 | 54 | 0.520458 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 115bfded9dc1a354846c610bfdb2629f6e48b22757a830b86fb6cbeafe481a76 | 32,167 | [
-1
] |
32,168 | Problem8.lisp | programmerjerry_LispLearn/Project_Euler/Problem8/Problem8.lisp | ;;;; Problem 8 Largest product in a series
;;;; 题目要求：在1000个数字中找到n个连续的数字并且乘积是最大的
;;; 注意: 是找挨着的n个数字，而不是要求n个数字内部是连续的（例如：123、323）
;;; 例如:开始的5个数字73167 就是连续的5个数字
;;; 计算字符串中的一系列数字的乘积
(defun get-product-from-string (str)
(let ((result 1))
(dotimes (i (length str))
(setf result (* result (parse-integer (subseq str i (1+ i))))))
result))
(defun largest-product-in-a-series (n)
(let ((s "73167176531330624919225119674426574742355349194934
96983520312774506326239578318016984801869478851843
85861560789112949495459501737958331952853208805511
12540698747158523863050715693290963295227443043557
66896648950445244523161731856403098711121722383113
62229893423380308135336276614282806444486645238749
30358907296290491560440772390713810515859307960866
70172427121883998797908792274921901699720888093776
65727333001053367881220235421809751254540594752243
52584907711670556013604839586446706324415722155397
53697817977846174064955149290862569321978468622482
83972241375657056057490261407972968652414535100474
82166370484403199890008895243450658541227588666881
16427171479924442928230863465674813919123162824586
17866458359124566529476545682848912883142607690042
24219022671055626321111109370544217506941658960408
07198403850962455444362981230987879927244284909188
84580156166097919133875499200524063689912560717606
05886116467109405077541002256983155200055935729725
71636269561882670428252483600823257530420752963450"))
; (print s)
(setf s (remove #\newline s)) ; 去掉回车换行符
; (print s)
(let ((max-product 0))
(dotimes (i (- (length s) n))
(let ((new-str (subseq s i (+ i n)))) ; 每次取5位
(let ((new-product (get-product-from-string new-str))); 计算乘积
(if (> new-product max-product)
(setf max-product new-product))))) ; 每次将最大的乘积保存
max-product)))
;;; CL-USER 280 > (largest-product-in-a-series 13)
;;; 23514624000
| 2,129 | Common Lisp | .lisp | 43 | 40.651163 | 74 | 0.819166 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | d467dc1adfb7e38237e6aec01a92d5e3dcb2fc12b27b4548542130995a87214d | 32,168 | [
-1
] |
32,169 | Problem2.lisp | programmerjerry_LispLearn/Project_Euler/Problem2/Problem2.lisp | ;;;; Project Euler Problem 2 Even Fibonacci numbers
;;; 最大值不超过4百万的斐波那契数列，求所有偶数的斐波那契数之和
(defun sum-even-fib (max-value)
(let ((result 2) (fib1 1) (fib2 2))
(dotimes (i max-value)
(let ((next-fib (+ fib1 fib2)))
(if (evenp next-fib)
(setf result (+ result next-fib)))
(if (> next-fib max-value)
(return result))
(setf fib1 fib2)
(setf fib2 next-fib)))))
;;; CL-USER 227 > (sum-even-fib 4000000)
;;; 4613732
| 533 | Common Lisp | .lisp | 14 | 27.928571 | 51 | 0.592593 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 3b8e13539ce03d9742c3ee78493078f3437d6bbc9a75ff50364f36de62c7a31a | 32,169 | [
-1
] |
32,170 | 1_TwoSum.lisp | programmerjerry_LispLearn/leetcode/1_TwoSum/1_TwoSum.lisp | ;;;; leetcode 1 Two Sum
;;; 题目说明：从整型数组找到2个数字，它们的和等于目标数字，返回这2个数字在数组中的下标，假设输入的数组里面只能有一组符合条件的数字，数组下标从0开始。
;; 实现方法：list的第一个元素依次与这个元素后面的元素计算和，如果符合条件直接退出
;; 否则，list的第二个元素依次与后面的元素计算和，直到找到符合条件的元素或者循环结束
(defun two-sum (nums-list target)
(do* ((i 0 (+ i 1))
(j (+ i 1) (+ j 1)))
((= i (1- (length nums-list))) nil)
(if (= target
(+
(nth i nums-list)
(nth j nums-list)))
(return (list i j)))))
;;; CL-USER 173 > (two-sum '(2 2 11 15) 9)
;;; NIL
;;; CL-USER 174 > (two-sum '(2 7 11 15) 9)
;;; (0 1)
| 849 | Common Lisp | .lisp | 17 | 27.647059 | 78 | 0.580524 | programmerjerry/LispLearn | 0 | 0 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | e2188db2b348fe2b5d2fc2cfdbffc649412f550051eb6fde580f592b4c2a5ed6 | 32,170 | [
-1
] |
32,197 | downloaded-complete-code-from-the-book-acl2.lisp | andlys_ansi-common-lisp/paul-graham/downloaded-complete-code-from-the-book-acl2.lisp | ; The code in this file was mechanically extracted from the TeX
; source files of _Ansi Common Lisp_, except for bst-remove and
; bst-delete and their subroutines, which replace broken versions
; in the book.
; If you have questions or comments about this code, or you want
; something I didn't include, send mail to [email protected].
; This code is copyright 1995 by Paul Graham, but anyone who wants
; to use it is free to do so.
; *** list ***
(defun compress (x)
(if (consp x)
(compr (car x) 1 (cdr x))
x))
(defun compr (elt n lst)
(if (null lst)
(list (n-elts elt n))
(let ((next (car lst)))
(if (eql next elt)
(compr elt (+ n 1) (cdr lst))
(cons (n-elts elt n)
(compr next 1 (cdr lst)))))))
(defun n-elts (elt n)
(if (> n 1)
(list n elt)
elt))
(defun uncompress (lst)
(if (null lst)
nil
(let ((elt (car lst))
(rest (uncompress (cdr lst))))
(if (consp elt)
(append (apply #'list-of elt)
rest)
(cons elt rest)))))
(defun list-of (n elt)
(if (zerop n)
nil
(cons elt (list-of (- n 1) elt))))
(defun mirror? (s)
(let ((len (length s)))
(and (evenp len)
(let ((mid (/ len 2)))
(equal (subseq s 0 mid)
(reverse (subseq s mid)))))))
(defun shortest-path (start end net)
(bfs end (list (list start)) net))
(defun bfs (end queue net)
(if (null queue)
nil
(let ((path (car queue)))
(let ((node (car path)))
(if (eql node end)
(reverse path)
(bfs end
(append (cdr queue)
(new-paths path node net))
net))))))
(defun new-paths (path node net)
(mapcar #'(lambda (n)
(cons n path))
(cdr (assoc node net))))
; *** dat ***
(defun bin-search (obj vec)
(let ((len (length vec)))
(and (not (zerop len))
(finder obj vec 0 (- len 1)))))
(defun finder (obj vec start end)
(let ((range (- end start)))
(if (zerop range)
(if (eql obj (aref vec start))
obj
nil)
(let ((mid (+ start (round (/ range 2)))))
(let ((obj2 (aref vec mid)))
(if (< obj obj2)
(finder obj vec start (- mid 1))
(if (> obj obj2)
(finder obj vec (+ mid 1) end)
obj)))))))
(defun mirror? (s)
(let ((len (length s)))
(and (evenp len)
(do ((forward 0 (+ forward 1))
(back (- len 1) (- back 1)))
((or (> forward back)
(not (eql (elt s forward)
(elt s back))))
(> forward back))))))
(defun second-word (str)
(let ((p1 (+ (position #\ str) 1)))
(subseq str p1 (position #\ str :start p1))))
(defun tokens (str test start)
(let ((p1 (position-if test str :start start)))
(if p1
(let ((p2 (position-if #'(lambda (c)
(not (funcall test c)))
str :start p1)))
(cons (subseq str p1 p2)
(if p2
(tokens str test p2)
nil)))
nil)))
(defun constituent (c)
(and (graphic-char-p c)
(not (char= c #\ ))))
(defun parse-date (str)
(let ((toks (tokens str #'constituent 0)))
(list (parse-integer (first toks))
(parse-month (second toks))
(parse-integer (third toks)))))
(defconstant month-names
#("jan" "feb" "mar" "apr" "may" "jun"
"jul" "aug" "sep" "oct" "nov" "dec"))
(defun parse-month (str)
(let ((p (position str month-names
:test #'string-equal)))
(if p
(+ p 1)
nil)))
(defun read-integer (str)
(if (every #'digit-char-p str)
(let ((accum 0))
(dotimes (pos (length str))
(setf accum (+ (* accum 10)
(digit-char-p (char str pos)))))
accum)
nil))
(defstruct (node (:print-function
(lambda (n s d)
(format s "#<~A>" (node-elt n)))))
elt (l nil) (r nil))
(defun bst-insert (obj bst <)
(if (null bst)
(make-node :elt obj)
(let ((elt (node-elt bst)))
(if (eql obj elt)
bst
(if (funcall < obj elt)
(make-node
:elt elt
:l (bst-insert obj (node-l bst) <)
:r (node-r bst))
(make-node
:elt elt
:r (bst-insert obj (node-r bst) <)
:l (node-l bst)))))))
(defun bst-find (obj bst <)
(if (null bst)
nil
(let ((elt (node-elt bst)))
(if (eql obj elt)
bst
(if (funcall < obj elt)
(bst-find obj (node-l bst) <)
(bst-find obj (node-r bst) <))))))
(defun bst-min (bst)
(and bst
(or (bst-min (node-l bst)) bst)))
(defun bst-max (bst)
(and bst
(or (bst-max (node-r bst)) bst)))
(defun bst-traverse (fn bst)
(when bst
(bst-traverse fn (node-l bst))
(funcall fn (node-elt bst))
(bst-traverse fn (node-r bst))))
; >>> Replaces bst-remove from book, which was broken.
(defun bst-remove (obj bst <)
(if (null bst)
nil
(let ((elt (node-elt bst)))
(if (eql obj elt)
(percolate bst)
(if (funcall < obj elt)
(make-node
:elt elt
:l (bst-remove obj (node-l bst) <)
:r (node-r bst))
(make-node
:elt elt
:r (bst-remove obj (node-r bst) <)
:l (node-l bst)))))))
(defun percolate (bst)
(let ((l (node-l bst)) (r (node-r bst)))
(cond ((null l) r)
((null r) l)
(t (if (zerop (random 2))
(make-node :elt (node-elt (bst-max l))
:r r
:l (bst-remove-max l))
(make-node :elt (node-elt (bst-min r))
:r (bst-remove-min r)
:l l))))))
(defun bst-remove-min (bst)
(if (null (node-l bst))
(node-r bst)
(make-node :elt (node-elt bst)
:l (bst-remove-min (node-l bst))
:r (node-r bst))))
(defun bst-remove-max (bst)
(if (null (node-r bst))
(node-l bst)
(make-node :elt (node-elt bst)
:l (node-l bst)
:r (bst-remove-max (node-r bst)))))
; *** con ***
(defun read-integer (str)
(let ((accum 0))
(dotimes (pos (length str))
(let ((i (digit-char-p (char str pos))))
(if i
(setf accum (+ (* accum 10) i))
(return-from read-integer nil))))
accum))
(defun factorial (n)
(do ((j n (- j 1))
(f 1 (* j f)))
((= j 0) f)))
(defconstant month
#(0 31 59 90 120 151 181 212 243 273 304 334 365))
(defconstant yzero 2000)
(defun leap? (y)
(and (zerop (mod y 4))
(or (zerop (mod y 400))
(not (zerop (mod y 100))))))
(defun date->num (d m y)
(+ (- d 1) (month-num m y) (year-num y)))
(defun month-num (m y)
(+ (svref month (- m 1))
(if (and (> m 2) (leap? y)) 1 0)))
(defun year-num (y)
(let ((d 0))
(if (>= y yzero)
(dotimes (i (- y yzero) d)
(incf d (year-days (+ yzero i))))
(dotimes (i (- yzero y) (- d))
(incf d (year-days (+ y i)))))))
(defun year-days (y) (if (leap? y) 366 365))
(defun num->date (n)
(multiple-value-bind (y left) (num-year n)
(multiple-value-bind (m d) (num-month left y)
(values d m y))))
(defun num-year (n)
(if (< n 0)
(do* ((y (- yzero 1) (- y 1))
(d (- (year-days y)) (- d (year-days y))))
((<= d n) (values y (- n d))))
(do* ((y yzero (+ y 1))
(prev 0 d)
(d (year-days y) (+ d (year-days y))))
((> d n) (values y (- n prev))))))
(defun num-month (n y)
(if (leap? y)
(cond ((= n 59) (values 2 29))
((> n 59) (nmon (- n 1)))
(t (nmon n)))
(nmon n)))
(defun nmon (n)
(let ((m (position n month :test #'<)))
(values m (+ 1 (- n (svref month (- m 1)))))))
(defun date+ (d m y n)
(num->date (+ (date->num d m y) n)))
; *** fn ***
(defun single? (lst)
(and (consp lst) (null (cdr lst))))
(defun append1 (lst obj)
(append lst (list obj)))
(defun map-int (fn n)
(let ((acc nil))
(dotimes (i n)
(push (funcall fn i) acc))
(nreverse acc)))
(defun filter (fn lst)
(let ((acc nil))
(dolist (x lst)
(let ((val (funcall fn x)))
(if val (push val acc))))
(nreverse acc)))
(defun most (fn lst)
(if (null lst)
(values nil nil)
(let* ((wins (car lst))
(max (funcall fn wins)))
(dolist (obj (cdr lst))
(let ((score (funcall fn obj)))
(when (> score max)
(setf wins obj
max score))))
(values wins max))))
(defun make-adder (n)
#'(lambda (x)
(+ x n)))
(let ((counter 0))
(defun reset ()
(setf counter 0))
(defun stamp ()
(setf counter (+ counter 1))))
(defun compose (&rest fns)
(destructuring-bind (fn1 . rest) (reverse fns)
#'(lambda (&rest args)
(reduce #'(lambda (v f) (funcall f v))
rest
:initial-value (apply fn1 args)))))
(defun disjoin (fn &rest fns)
(if (null fns)
fn
(let ((disj (apply #'disjoin fns)))
#'(lambda (&rest args)
(or (apply fn args) (apply disj args))))))
(defun conjoin (fn &rest fns)
(if (null fns)
fn
(let ((conj (apply #'conjoin fns)))
#'(lambda (&rest args)
(and (apply fn args) (apply conj args))))))
(defun curry (fn &rest args)
#'(lambda (&rest args2)
(apply fn (append args args2))))
(defun rcurry (fn &rest args)
#'(lambda (&rest args2)
(apply fn (append args2 args))))
(defun always (x) #'(lambda (&rest args) x))
(defun fib (n)
(if (<= n 1)
1
(+ (fib (- n 1))
(fib (- n 2)))))
(defun fib (n)
(do ((i n (- i 1))
(f1 1 (+ f1 f2))
(f2 1 f1))
((<= i 1) f1)))
; *** io ***
(defun pseudo-cat (file)
(with-open-file (str file :direction :input)
(do ((line (read-line str nil 'eof)
(read-line str nil 'eof)))
((eql line 'eof))
(format t "~A~%" line))))
(defstruct buf
vec (start -1) (used -1) (new -1) (end -1))
(defun bref (buf n)
(svref (buf-vec buf)
(mod n (length (buf-vec buf)))))
(defun (setf bref) (val buf n)
(setf (svref (buf-vec buf)
(mod n (length (buf-vec buf))))
val))
(defun new-buf (len)
(make-buf :vec (make-array len)))
(defun buf-insert (x b)
(setf (bref b (incf (buf-end b))) x))
(defun buf-pop (b)
(prog1
(bref b (incf (buf-start b)))
(setf (buf-used b) (buf-start b)
(buf-new b) (buf-end b))))
(defun buf-next (b)
(when (< (buf-used b) (buf-new b))
(bref b (incf (buf-used b)))))
(defun buf-reset (b)
(setf (buf-used b) (buf-start b)
(buf-new b) (buf-end b)))
(defun buf-clear (b)
(setf (buf-start b) -1 (buf-used b) -1
(buf-new b) -1 (buf-end b) -1))
(defun buf-flush (b str)
(do ((i (1+ (buf-used b)) (1+ i)))
((> i (buf-end b)))
(princ (bref b i) str)))
(defun file-subst (old new file1 file2)
(with-open-file (in file1 :direction :input)
(with-open-file (out file2 :direction :output
:if-exists :supersede)
(stream-subst old new in out))))
(defun stream-subst (old new in out)
(let* ((pos 0)
(len (length old))
(buf (new-buf len))
(from-buf nil))
(do ((c (read-char in nil :eof)
(or (setf from-buf (buf-next buf))
(read-char in nil :eof))))
((eql c :eof))
(cond ((char= c (char old pos))
(incf pos)
(cond ((= pos len) ; 3
(princ new out)
(setf pos 0)
(buf-clear buf))
((not from-buf) ; 2
(buf-insert c buf))))
((zerop pos) ; 1
(princ c out)
(when from-buf
(buf-pop buf)
(buf-reset buf)))
(t ; 4
(unless from-buf
(buf-insert c buf))
(princ (buf-pop buf) out)
(buf-reset buf)
(setf pos 0))))
(buf-flush buf out)))
; *** sym ***
(defparameter *words* (make-hash-table :size 10000))
(defconstant maxword 100)
(defun read-text (pathname)
(with-open-file (s pathname :direction :input)
(let ((buffer (make-string maxword))
(pos 0))
(do ((c (read-char s nil :eof)
(read-char s nil :eof)))
((eql c :eof))
(if (or (alpha-char-p c) (char= c #\'))
(progn
(setf (aref buffer pos) c)
(incf pos))
(progn
(unless (zerop pos)
(see (intern (string-downcase
(subseq buffer 0 pos))))
(setf pos 0))
(let ((p (punc c)))
(if p (see p)))))))))
(defun punc (c)
(case c
(#\. '|.|) (#\, '|,|) (#\; '|;|)
(#\! '|!|) (#\? '|?|) ))
(let ((prev `|.|))
(defun see (symb)
(let ((pair (assoc symb (gethash prev *words*))))
(if (null pair)
(push (cons symb 1) (gethash prev *words*))
(incf (cdr pair))))
(setf prev symb)))
(defun generate-text (n &optional (prev '|.|))
(if (zerop n)
(terpri)
(let ((next (random-next prev)))
(format t "~A " next)
(generate-text (1- n) next))))
(defun random-next (prev)
(let* ((choices (gethash prev *words*))
(i (random (reduce #'+ choices
:key #'cdr))))
(dolist (pair choices)
(if (minusp (decf i (cdr pair)))
(return (car pair))))))
; *** num ***
(defun palindrome? (x)
(let ((mid (/ (length x) 2)))
(equal (subseq x 0 (floor mid))
(reverse (subseq x (ceiling mid))))))
(defun sq (x) (* x x))
(defun mag (x y z)
(sqrt (+ (sq x) (sq y) (sq z))))
(defun unit-vector (x y z)
(let ((d (mag x y z)))
(values (/ x d) (/ y d) (/ z d))))
(defstruct (point (:conc-name nil))
x y z)
(defun distance (p1 p2)
(mag (- (x p1) (x p2))
(- (y p1) (y p2))
(- (z p1) (z p2))))
(defun minroot (a b c)
(if (zerop a)
(/ (- c) b)
(let ((disc (- (sq b) (* 4 a c))))
(unless (minusp disc)
(let ((discrt (sqrt disc)))
(min (/ (+ (- b) discrt) (* 2 a))
(/ (- (- b) discrt) (* 2 a))))))))
(defstruct surface color)
(defparameter *world* nil)
(defconstant eye (make-point :x 0 :y 0 :z 200))
(defun tracer (pathname &optional (res 1))
(with-open-file (p pathname :direction :output)
(format p "P2 ~A ~A 255" (* res 100) (* res 100))
(let ((inc (/ res)))
(do ((y -50 (+ y inc)))
((< (- 50 y) inc))
(do ((x -50 (+ x inc)))
((< (- 50 x) inc))
(print (color-at x y) p))))))
(defun color-at (x y)
(multiple-value-bind (xr yr zr)
(unit-vector (- x (x eye))
(- y (y eye))
(- 0 (z eye)))
(round (* (sendray eye xr yr zr) 255))))
(defun sendray (pt xr yr zr)
(multiple-value-bind (s int) (first-hit pt xr yr zr)
(if s
(* (lambert s int xr yr zr) (surface-color s))
0)))
(defun first-hit (pt xr yr zr)
(let (surface hit dist)
(dolist (s *world*)
(let ((h (intersect s pt xr yr zr)))
(when h
(let ((d (distance h pt)))
(when (or (null dist) (< d dist))
(setf surface s hit h dist d))))))
(values surface hit)))
(defun lambert (s int xr yr zr)
(multiple-value-bind (xn yn zn) (normal s int)
(max 0 (+ (* xr xn) (* yr yn) (* zr zn)))))
(defstruct (sphere (:include surface))
radius center)
(defun defsphere (x y z r c)
(let ((s (make-sphere
:radius r
:center (make-point :x x :y y :z z)
:color c)))
(push s *world*)
s))
(defun intersect (s pt xr yr zr)
(funcall (typecase s (sphere #'sphere-intersect))
s pt xr yr zr))
(defun sphere-intersect (s pt xr yr zr)
(let* ((c (sphere-center s))
(n (minroot (+ (sq xr) (sq yr) (sq zr))
(* 2 (+ (* (- (x pt) (x c)) xr)
(* (- (y pt) (y c)) yr)
(* (- (z pt) (z c)) zr)))
(+ (sq (- (x pt) (x c)))
(sq (- (y pt) (y c)))
(sq (- (z pt) (z c)))
(- (sq (sphere-radius s)))))))
(if n
(make-point :x (+ (x pt) (* n xr))
:y (+ (y pt) (* n yr))
:z (+ (z pt) (* n zr))))))
(defun normal (s pt)
(funcall (typecase s (sphere #'sphere-normal))
s pt))
(defun sphere-normal (s pt)
(let ((c (sphere-center s)))
(unit-vector (- (x c) (x pt))
(- (y c) (y pt))
(- (z c) (z pt)))))
(defun ray-test (&optional (res 1))
(setf *world* nil)
(defsphere 0 -300 -1200 200 .8)
(defsphere -80 -150 -1200 200 .7)
(defsphere 70 -100 -1200 200 .9)
(do ((x -2 (1+ x)))
((> x 2))
(do ((z 2 (1+ z)))
((> z 7))
(defsphere (* x 200) 300 (* z -400) 40 .75)))
(tracer (make-pathname :name "spheres.pgm") res))
; *** mac ***
(defmacro nil! (x)
`(setf ,x nil))
(defmacro while (test &rest body)
`(do ()
((not ,test))
,@body))
(defun quicksort (vec l r)
(let ((i l)
(j r)
(p (svref vec (round (+ l r) 2)))) ; 1
(while (<= i j) ; 2
(while (< (svref vec i) p) (incf i))
(while (> (svref vec j) p) (decf j))
(when (<= i j)
(rotatef (svref vec i) (svref vec j))
(incf i)
(decf j)))
(if (> (- j l) 1) (quicksort vec l j)) ; 3
(if (> (- r i) 1) (quicksort vec i r)))
vec)
(defmacro ntimes (n &rest body)
(let ((g (gensym))
(h (gensym)))
`(let ((,h ,n))
(do ((,g 0 (+ ,g 1)))
((>= ,g ,h))
,@body))))
(define-modify-macro append1f (val)
(lambda (lst val) (append lst (list val))))
(defmacro for (var start stop &body body)
(let ((gstop (gensym)))
`(do ((,var ,start (1+ ,var))
(,gstop ,stop))
((> ,var ,gstop))
,@body)))
(defmacro in (obj &rest choices)
(let ((insym (gensym)))
`(let ((,insym ,obj))
(or ,@(mapcar #'(lambda (c) `(eql ,insym ,c))
choices)))))
(defmacro random-choice (&rest exprs)
`(case (random ,(length exprs))
,@(let ((key -1))
(mapcar #'(lambda (expr)
`(,(incf key) ,expr))
exprs))))
(defmacro avg (&rest args)
`(/ (+ ,@args) ,(length args)))
(defmacro with-gensyms (syms &body body)
`(let ,(mapcar #'(lambda (s)
`(,s (gensym)))
syms)
,@body))
(defmacro aif (test then &optional else)
`(let ((it ,test))
(if it ,then ,else)))
; *** mod ***
(defun make-queue () (cons nil nil))
(defun enqueue (obj q)
(if (null (car q))
(setf (cdr q) (setf (car q) (list obj)))
(setf (cdr (cdr q)) (list obj)
(cdr q) (cdr (cdr q))))
(car q))
(defun dequeue (q)
(pop (car q)))
(defun mappend (fn &rest lsts)
(apply #'append (apply #'mapcar fn lsts)))
(defun bst-insert! (obj bst <)
(if (null bst)
(make-node :elt obj)
(progn (bsti obj bst <)
bst)))
(defun bsti (obj bst <)
(let ((elt (node-elt bst)))
(if (eql obj elt)
bst
(if (funcall < obj elt)
(let ((l (node-l bst)))
(if l
(bsti obj l <)
(setf (node-l bst)
(make-node :elt obj))))
(let ((r (node-r bst)))
(if r
(bsti obj r <)
(setf (node-r bst)
(make-node :elt obj))))))))
; >>> Replaces bst-delete from book, which was broken.
(defun bst-delete (obj bst <)
(if (null bst)
nil
(if (eql obj (node-elt bst))
(del-root bst)
(progn
(if (funcall < obj (node-elt bst))
(setf (node-l bst) (bst-delete obj (node-l bst) <))
(setf (node-r bst) (bst-delete obj (node-r bst) <)))
bst))))
(defun del-root (bst)
(let ((l (node-l bst)) (r (node-r bst)))
(cond ((null l) r)
((null r) l)
(t (if (zerop (random 2))
(cutnext r bst nil)
(cutprev l bst nil))))))
(defun cutnext (bst root prev)
(if (node-l bst)
(cutnext (node-l bst) root bst)
(if prev
(progn
(setf (node-elt root) (node-elt bst)
(node-l prev) (node-r bst))
root)
(progn
(setf (node-l bst) (node-l root))
bst))))
(defun cutprev (bst root prev)
(if (node-r bst)
(cutprev (node-r bst) root bst)
(if prev
(progn
(setf (node-elt root) (node-elt bst)
(node-r prev) (node-l bst))
root)
(progn
(setf (node-r bst) (node-r root))
bst))))
(defun replace-node (old new)
(setf (node-elt old) (node-elt new)
(node-l old) (node-l new)
(node-r old) (node-r new)))
(defun cutmin (bst par dir)
(if (node-l bst)
(cutmin (node-l bst) bst :l)
(progn
(set-par par dir (node-r bst))
(node-elt bst))))
(defun cutmax (bst par dir)
(if (node-r bst)
(cutmax (node-r bst) bst :r)
(progn
(set-par par dir (node-l bst))
(node-elt bst))))
(defun set-par (par dir val)
(case dir
(:l (setf (node-l par) val))
(:r (setf (node-r par) val))))
(defstruct (dl (:print-function print-dl))
prev data next)
(defun print-dl (dl stream depth)
(declare (ignore depth))
(format stream "#<DL ~A>" (dl->list dl)))
(defun dl->list (lst)
(if (dl-p lst)
(cons (dl-data lst) (dl->list (dl-next lst)))
lst))
(defun dl-insert (x lst)
(let ((elt (make-dl :data x :next lst)))
(when (dl-p lst)
(if (dl-prev lst)
(setf (dl-next (dl-prev lst)) elt
(dl-prev elt) (dl-prev lst)))
(setf (dl-prev lst) elt))
elt))
(defun dl-list (&rest args)
(reduce #'dl-insert args
:from-end t :initial-value nil))
(defun dl-remove (lst)
(if (dl-prev lst)
(setf (dl-next (dl-prev lst)) (dl-next lst)))
(if (dl-next lst)
(setf (dl-prev (dl-next lst)) (dl-prev lst)))
(dl-next lst))
(defun circular (lst)
(setf (cdr (last lst)) lst))
; *** speed ***
(defun length/tr (lst)
(labels ((len (lst acc)
(if (null lst)
acc
(len (cdr lst) (1+ acc)))))
(len lst 0)))
(setf a (make-array '(1000 1000)
:element-type 'single-float
:initial-element 1.0s0))
(defun sum-elts (a)
(declare (type (simple-array single-float (1000 1000))
a))
(let ((sum 0.0s0))
(declare (type single-float sum))
(dotimes (r 1000)
(dotimes (c 1000)
(incf sum (aref a r c))))
sum))
(defconstant dict (make-array 25000 :fill-pointer 0))
(defun read-words (from)
(setf (fill-pointer dict) 0)
(with-open-file (in from :direction :input)
(do ((w (read-line in nil :eof)
(read-line in nil :eof)))
((eql w :eof))
(vector-push w dict))))
(defun xform (fn seq) (map-into seq fn seq))
(defun write-words (to)
(with-open-file (out to :direction :output
:if-exists :supersede)
(map nil #'(lambda (x)
(fresh-line out)
(princ x out))
(xform #'nreverse
(sort (xform #'nreverse dict)
#'string<)))))
(defparameter *harbor* nil)
(defstruct ship
name flag tons)
(defun enter (n f d)
(push (make-ship :name n :flag f :tons d)
*harbor*))
(defun find-ship (n)
(find n *harbor* :key #'ship-name))
(defun leave (n)
(setf *harbor*
(delete (find-ship n) *harbor*)))
(defconstant pool (make-array 1000 :fill-pointer t))
(dotimes (i 1000)
(setf (aref pool i) (make-ship)))
(defconstant harbor (make-hash-table :size 1100
:test #'eq))
(defun enter (n f d)
(let ((s (if (plusp (length pool))
(vector-pop pool)
(make-ship))))
(setf (ship-name s) n
(ship-flag s) f
(ship-tons s) d
(gethash n harbor) s)))
(defun find-ship (n) (gethash n harbor))
(defun leave (n)
(let ((s (gethash n harbor)))
(remhash n harbor)
(vector-push s pool)))
; *** web ***
(defmacro as (tag content)
`(format t "<~(~A~)>~A</~(~A~)>"
',tag ,content ',tag))
(defmacro with (tag &rest body)
`(progn
(format t "~&<~(~A~)>~%" ',tag)
,@body
(format t "~&</~(~A~)>~%" ',tag)))
(defun brs (&optional (n 1))
(fresh-line)
(dotimes (i n)
(princ "<br>"))
(terpri))
(defun html-file (base)
(format nil "~(~A~).html" base))
(defmacro page (name title &rest body)
(let ((ti (gensym)))
`(with-open-file (*standard-output*
(html-file ,name)
:direction :output
:if-exists :supersede)
(let ((,ti ,title))
(as title ,ti)
(with center
(as h2 (string-upcase ,ti)))
(brs 3)
,@body))))
(defmacro with-link (dest &rest body)
`(progn
(format t "<a href=\"~A\">" (html-file ,dest))
,@body
(princ "</a>")))
(defun link-item (dest text)
(princ "<li>")
(with-link dest
(princ text)))
(defun button (dest text)
(princ "[ ")
(with-link dest
(princ text))
(format t " ]~%"))
(defun map3 (fn lst)
(labels ((rec (curr prev next left)
(funcall fn curr prev next)
(when left
(rec (car left)
curr
(cadr left)
(cdr left)))))
(when lst
(rec (car lst) nil (cadr lst) (cdr lst)))))
(defparameter *sections* nil)
(defstruct item
id title text)
(defstruct section
id title items)
(defmacro defitem (id title text)
`(setf ,id
(make-item :id ',id
:title ,title
:text ,text)))
(defmacro defsection (id title &rest items)
`(setf ,id
(make-section :id ',id
:title ,title
:items (list ,@items))))
(defun defsite (&rest sections)
(setf *sections* sections))
(defconstant contents "contents")
(defconstant index "index")
(defun gen-contents (&optional (sections *sections*))
(page contents contents
(with ol
(dolist (s sections)
(link-item (section-id s) (section-title s))
(brs 2))
(link-item index (string-capitalize index)))))
(defun gen-index (&optional (sections *sections*))
(page index index
(with ol
(dolist (i (all-items sections))
(link-item (item-id i) (item-title i))
(brs 2)))))
(defun all-items (sections)
(let ((is nil))
(dolist (s sections)
(dolist (i (section-items s))
(setf is (merge 'list (list i) is #'title<))))
is))
(defun title< (x y)
(string-lessp (item-title x) (item-title y)))
(defun gen-site ()
(map3 #'gen-section *sections*)
(gen-contents)
(gen-index))
(defun gen-section (sect <sect sect>)
(page (section-id sect) (section-title sect)
(with ol
(map3 #'(lambda (item <item item>)
(link-item (item-id item)
(item-title item))
(brs 2)
(gen-item sect item <item item>))
(section-items sect)))
(brs 3)
(gen-move-buttons (if <sect (section-id <sect))
contents
(if sect> (section-id sect>)))))
(defun gen-item (sect item <item item>)
(page (item-id item) (item-title item)
(princ (item-text item))
(brs 3)
(gen-move-buttons (if <item (item-id <item))
(section-id sect)
(if item> (item-id item>)))))
(defun gen-move-buttons (back up forward)
(if back (button back "Back"))
(if up (button up "Up"))
(if forward (button forward "Forward")))
; *** inf ***
(defun match (x y &optional binds)
(cond
((eql x y) (values binds t))
((assoc x binds) (match (binding x binds) y binds))
((assoc y binds) (match x (binding y binds) binds))
((var? x) (values (cons (cons x y) binds) t))
((var? y) (values (cons (cons y x) binds) t))
(t
(when (and (consp x) (consp y))
(multiple-value-bind (b2 yes)
(match (car x) (car y) binds)
(and yes (match (cdr x) (cdr y) b2)))))))
(defun var? (x)
(and (symbolp x)
(eql (char (symbol-name x) 0) #\?)))
(defun binding (x binds)
(let ((b (assoc x binds)))
(if b
(or (binding (cdr b) binds)
(cdr b)))))
(defvar *rules* (make-hash-table))
(defmacro <- (con &optional ant)
`(length (push (cons (cdr ',con) ',ant)
(gethash (car ',con) *rules*))))
(defun prove (expr &optional binds)
(case (car expr)
(and (prove-and (reverse (cdr expr)) binds))
(or (prove-or (cdr expr) binds))
(not (prove-not (cadr expr) binds))
(t (prove-simple (car expr) (cdr expr) binds))))
(defun prove-simple (pred args binds)
(mapcan #'(lambda (r)
(multiple-value-bind (b2 yes)
(match args (car r)
binds)
(when yes
(if (cdr r)
(prove (cdr r) b2)
(list b2)))))
(mapcar #'change-vars
(gethash pred *rules*))))
(defun change-vars (r)
(sublis (mapcar #'(lambda (v) (cons v (gensym "?")))
(vars-in r))
r))
(defun vars-in (expr)
(if (atom expr)
(if (var? expr) (list expr))
(union (vars-in (car expr))
(vars-in (cdr expr)))))
(defun prove-and (clauses binds)
(if (null clauses)
(list binds)
(mapcan #'(lambda (b)
(prove (car clauses) b))
(prove-and (cdr clauses) binds))))
(defun prove-or (clauses binds)
(mapcan #'(lambda (c) (prove c binds))
clauses))
(defun prove-not (clause binds)
(unless (prove clause binds)
(list binds)))
(defmacro with-answer (query &body body)
(let ((binds (gensym)))
`(dolist (,binds (prove ',query))
(let ,(mapcar #'(lambda (v)
`(,v (binding ',v ,binds)))
(vars-in query))
,@body))))
; *** ob ***
(defmacro parents (v) `(svref ,v 0))
(defmacro layout (v) `(the simple-vector (svref ,v 1)))
(defmacro preclist (v) `(svref ,v 2))
(defmacro class (&optional parents &rest props)
`(class-fn (list ,@parents) ',props))
(defun class-fn (parents props)
(let* ((all (union (inherit-props parents) props))
(obj (make-array (+ (length all) 3)
:initial-element :nil)))
(setf (parents obj) parents
(layout obj) (coerce all 'simple-vector)
(preclist obj) (precedence obj))
obj))
(defun inherit-props (classes)
(delete-duplicates
(mapcan #'(lambda (c)
(nconc (coerce (layout c) 'list)
(inherit-props (parents c))))
classes)))
(defun precedence (obj)
(labels ((traverse (x)
(cons x
(mapcan #'traverse (parents x)))))
(delete-duplicates (traverse obj))))
(defun inst (parent)
(let ((obj (copy-seq parent)))
(setf (parents obj) parent
(preclist obj) nil)
(fill obj :nil :start 3)
obj))
;(declaim (inline lookup (setf lookup)))
(defun rget (prop obj next?)
(let ((prec (preclist obj)))
(if prec
(dolist (c (if next? (cdr prec) prec) :nil)
(let ((val (lookup prop c)))
(unless (eq val :nil) (return val))))
(let ((val (lookup prop obj)))
(if (eq val :nil)
(rget prop (parents obj) nil)
val)))))
(defun lookup (prop obj)
(let ((off (position prop (layout obj) :test #'eq)))
(if off (svref obj (+ off 3)) :nil)))
(defun (setf lookup) (val prop obj)
(let ((off (position prop (layout obj) :test #'eq)))
(if off
(setf (svref obj (+ off 3)) val)
(error "Can't set ~A of ~A." val obj))))
(declaim (inline run-methods))
(defmacro defprop (name &optional meth?)
`(progn
(defun ,name (obj &rest args)
,(if meth?
`(run-methods obj ',name args)
`(rget ',name obj nil)))
(defun (setf ,name) (val obj)
(setf (lookup ',name obj) val))))
(defun run-methods (obj name args)
(let ((meth (rget name obj nil)))
(if (not (eq meth :nil))
(apply meth obj args)
(error "No ~A method for ~A." name obj))))
(defmacro defmeth (name obj parms &rest body)
(let ((gobj (gensym)))
`(let ((,gobj ,obj))
(defprop ,name t)
(setf (lookup ',name ,gobj)
(labels ((next () (rget ,gobj ',name t)))
#'(lambda ,parms ,@body))))))
; *** adv ***
(defun copy-file (from to)
(with-open-file (in from :direction :input
:element-type 'unsigned-byte)
(with-open-file (out to :direction :output
:element-type 'unsigned-byte)
(do ((i (read-byte in nil -1)
(read-byte in nil -1)))
((minusp i))
(declare (fixnum i))
(write-byte i out)))))
(set-dispatch-macro-character #\# #\?
#'(lambda (stream char1 char2)
(list 'quote
(let ((lst nil))
(dotimes (i (+ (read stream t nil t) 1))
(push i lst))
(nreverse lst)))))
(set-macro-character #\} (get-macro-character #\)))
(set-dispatch-macro-character #\# #\{
#'(lambda (stream char1 char2)
(let ((accum nil)
(pair (read-delimited-list #\} stream t)))
(do ((i (car pair) (+ i 1)))
((> i (cadr pair))
(list 'quote (nreverse accum)))
(push i accum)))))
(defun even/odd (ns)
(loop for n in ns
if (evenp n)
collect n into evens
else collect n into odds
finally (return (values evens odds))))
(defun user-input (prompt)
(format t prompt)
(let ((str (read-line)))
(or (ignore-errors (read-from-string str))
nil)))
; *** notes ***
(defun float-limits ()
(dolist (m '(most least))
(dolist (s '(positive negative))
(dolist (f '(short single double long))
(let ((n (intern (string-upcase
(format nil "~A-~A-~A-float"
m s f)))))
(format t "~30A ~A~%" n (symbol-value n)))))))
(defmacro bst-push (obj bst <)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion bst)
(let ((g (gensym)))
`(let* ((,g ,obj)
,@(mapcar #'list vars forms)
(,(car var) (bst-insert! ,g ,access ,<)))
,set))))
(defmacro with-type (type expr)
`(the ,type ,(if (atom expr)
expr
(expand-call type (binarize expr)))))
(defun expand-call (type expr)
`(,(car expr) ,@(mapcar #'(lambda (a)
`(with-type ,type ,a))
(cdr expr))))
(defun binarize (expr)
(if (and (nthcdr 3 expr)
(member (car expr) '(+ - * /)))
(destructuring-bind (op a1 a2 . rest) expr
(binarize `(,op (,op ,a1 ,a2) ,@rest)))
expr))
(defmacro with-slotref ((name prop class) &rest body)
(let ((g (gensym)))
`(let ((,g (+ 3 (position ,prop (layout ,class)
:test #'eq))))
(macrolet ((,name (obj) `(svref ,obj ,',g)))
,@body))))
(defun eval2 (expr)
(case (and (consp expr) (car expr))
(comma (error "unmatched comma"))
(bq (eval-bq (second expr) 1))
(t (eval expr))))
(defun eval-bq (expr n)
(cond ((atom expr)
expr)
((eql (car expr) 'comma)
(if (= n 1)
(eval2 (second expr))
(list 'comma (eval-bq (second expr)
(1- n)))))
((eql (car expr) 'bq)
(list 'bq (eval-bq (second expr) (1+ n))))
(t
(cons (eval-bq (car expr) n)
(eval-bq (cdr expr) n)))))
; *** lib ***
(defun -abs (n)
(if (typep n 'complex)
(sqrt (+ (expt (realpart n) 2) (expt (imagpart n) 2)))
(if (< n 0) (- n) n)))
(defun -adjoin (obj lst &rest args)
(if (apply #'member obj lst args) lst (cons obj lst)))
(defmacro -and (&rest args)
(cond ((null args) t)
((cdr args) `(if ,(car args) (-and ,@(cdr args))))
(t (car args))))
(defun -append (&optional first &rest rest)
(if (null rest)
first
(nconc (copy-list first) (apply #'-append rest))))
(defun -atom (x) (not (consp x)))
(defun -butlast (lst &optional (n 1))
(nreverse (nthcdr n (reverse lst))))
(defun -cadr (x) (car (cdr x)))
(defmacro -case (arg &rest clauses)
(let ((g (gensym)))
`(let ((,g ,arg))
(cond ,@(mapcar #'(lambda (cl)
(let ((k (car cl)))
`(,(cond ((member k '(t otherwise))
t)
((consp k)
`(member ,g ',k))
(t `(eql ,g ',k)))
(progn ,@(cdr cl)))))
clauses)))))
(defun -cddr (x) (cdr (cdr x)))
(defun -complement (fn)
#'(lambda (&rest args) (not (apply fn args))))
(defmacro -cond (&rest args)
(if (null args)
nil
(let ((clause (car args)))
(if (cdr clause)
`(if ,(car clause)
(progn ,@(cdr clause))
(-cond ,@(cdr args)))
`(or ,(car clause)
(-cond ,@(cdr args)))))))
(defun -consp (x) (typep x 'cons))
(defun -constantly (x) #'(lambda (&rest args) x))
(defun -copy-list (lst)
(labels ((cl (x)
(if (atom x)
x
(cons (car x)
(cl (cdr x))))))
(cons (car lst)
(cl (cdr lst)))))
(defun -copy-tree (tr)
(if (atom tr)
tr
(cons (-copy-tree (car tr))
(-copy-tree (cdr tr)))))
(defmacro -defun (name parms &rest body)
(multiple-value-bind (dec doc bod) (analyze-body body)
`(progn
(setf (fdefinition ',name)
#'(lambda ,parms
,@dec
(block ,(if (atom name) name (second name))
,@bod))
(documentation ',name 'function)
,doc)
',name)))
(defun analyze-body (body &optional dec doc)
(let ((expr (car body)))
(cond ((and (consp expr) (eq (car expr) 'declare))
(analyze-body (cdr body) (cons expr dec) doc))
((and (stringp expr) (not doc) (cdr body))
(if dec
(values dec expr (cdr body))
(analyze-body (cdr body) dec expr)))
(t (values dec doc body)))))
; This definition is not strictly correct; see let.
(defmacro -do (binds (test &rest result) &rest body)
(let ((fn (gensym)))
`(block nil
(labels ((,fn ,(mapcar #'car binds)
(cond (,test ,@result)
(t (tagbody ,@body)
(,fn ,@(mapcar #'third binds))))))
(,fn ,@(mapcar #'second binds))))))
(defmacro -dolist ((var lst &optional result) &rest body)
(let ((g (gensym)))
`(do ((,g ,lst (cdr ,g)))
((atom ,g) (let ((,var nil)) ,result))
(let ((,var (car ,g)))
,@body))))
(defun -eql (x y)
(typecase x
(character (and (typep y 'character) (char= x y)))
(number (and (eq (type-of x) (type-of y))
(= x y)))
(t (eq x y))))
(defun -evenp (x)
(typecase x
(integer (= 0 (mod x 2)))
(t (error "non-integer argument"))))
(defun -funcall (fn &rest args) (apply fn args))
(defun -identity (x) x)
; This definition is not strictly correct: the expression
; (let ((&key 1) (&optional 2))) is legal, but its expansion
; is not.
(defmacro -let (parms &rest body)
`((lambda ,(mapcar #'(lambda (x)
(if (atom x) x (car x)))
parms)
,@body)
,@(mapcar #'(lambda (x)
(if (atom x) nil (cadr x)))
parms)))
(defun -list (&rest elts) (copy-list elts))
(defun -listp (x) (or (consp x) (null x)))
(defun -mapcan (fn &rest lsts)
(apply #'nconc (apply #'mapcar fn lsts)))
(defun -mapcar (fn &rest lsts)
(cond ((member nil lsts) nil)
((null (cdr lsts))
(let ((lst (car lsts)))
(cons (funcall fn (car lst))
(-mapcar fn (cdr lst)))))
(t
(cons (apply fn (-mapcar #'car lsts))
(apply #'-mapcar fn
(-mapcar #'cdr lsts))))))
(defun -member (x lst &key test test-not key)
(let ((fn (or test
(if test-not
(complement test-not))
#'eql)))
(member-if #'(lambda (y)
(funcall fn x y))
lst
:key key)))
(defun -member-if (fn lst &key (key #'identity))
(cond ((atom lst) nil)
((funcall fn (funcall key (car lst))) lst)
(t (-member-if fn (cdr lst) :key key))))
(defun -mod (n m)
(nth-value 1 (floor n m)))
(defun -nconc (&optional lst &rest rest)
(if rest
(let ((rest-conc (apply #'-nconc rest)))
(if (consp lst)
(progn (setf (cdr (last lst)) rest-conc)
lst)
rest-conc))
lst))
(defun -not (x) (eq x nil))
(defun -nreverse (seq)
(labels ((nrl (lst)
(let ((prev nil))
(do ()
((null lst) prev)
(psetf (cdr lst) prev
prev lst
lst (cdr lst)))))
(nrv (vec)
(let* ((len (length vec))
(ilimit (truncate (/ len 2))))
(do ((i 0 (1+ i))
(j (1- len) (1- j)))
((>= i ilimit) vec)
(rotatef (aref vec i) (aref vec j))))))
(if (typep seq 'vector)
(nrv seq)
(nrl seq))))
(defun -null (x) (eq x nil))
(defmacro -or (&optional first &rest rest)
(if (null rest)
first
(let ((g (gensym)))
`(let ((,g ,first))
(if ,g
,g
(-or ,@rest))))))
; Not in CL, but needed in several definitions here.
(defun pair (lst)
(if (null lst)
nil
(cons (cons (car lst) (cadr lst))
(pair (cddr lst)))))
(defun -pairlis (keys vals &optional alist)
(unless (= (length keys) (length vals))
(error "mismatched lengths"))
(nconc (mapcar #'cons keys vals) alist))
(defmacro -pop (place)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
(let ((g (gensym)))
`(let* (,@(mapcar #'list vars forms)
(,g ,access)
(,(car var) (cdr ,g)))
(prog1 (car ,g)
,set)))))
(defmacro -prog1 (arg1 &rest args)
(let ((g (gensym)))
`(let ((,g ,arg1))
,@args
,g)))
(defmacro -prog2 (arg1 arg2 &rest args)
(let ((g (gensym)))
`(let ((,g (progn ,arg1 ,arg2)))
,@args
,g)))
(defmacro -progn (&rest args) `(let nil ,@args))
(defmacro -psetf (&rest args)
(unless (evenp (length args))
(error "odd number of arguments"))
(let* ((pairs (pair args))
(syms (mapcar #'(lambda (x) (gensym))
pairs)))
`(let ,(mapcar #'list
syms
(mapcar #'cdr pairs))
(setf ,@(mapcan #'list
(mapcar #'car pairs)
syms)))))
(defmacro -push (obj place)
(multiple-value-bind (vars forms var set access)
(get-setf-expansion place)
(let ((g (gensym)))
`(let* ((,g ,obj)
,@(mapcar #'list vars forms)
(,(car var) (cons ,g ,access)))
,set))))
(defun -rem (n m)
(nth-value 1 (truncate n m)))
(defmacro -rotatef (&rest args)
`(psetf ,@(mapcan #'list
args
(append (cdr args)
(list (car args))))))
(defun -second (x) (cadr x))
(defmacro -setf (&rest args)
(if (null args)
nil
`(setf2 ,@args)))
(defmacro setf2 (place val &rest args)
(multiple-value-bind (vars forms var set)
(get-setf-expansion place)
`(progn
(let* (,@(mapcar #'list vars forms)
(,(car var) ,val))
,set)
,@(if args `((setf2 ,@args)) nil))))
(defun -signum (n)
(if (zerop n) 0 (/ n (abs n))))
(defun -stringp (x) (typep x 'string))
(defun -tailp (x y)
(or (eql x y)
(and (consp y) (-tailp x (cdr y)))))
(defun -third (x) (car (cdr (cdr x))))
(defun -truncate (n &optional (d 1))
(if (> n 0) (floor n d) (ceiling n d)))
(defmacro -typecase (arg &rest clauses)
(let ((g (gensym)))
`(let ((,g ,arg))
(cond ,@(mapcar #'(lambda (cl)
`((typep ,g ',(car cl))
(progn ,@(cdr cl))))
clauses)))))
(defmacro -unless (arg &rest body)
`(if (not ,arg)
(progn ,@body)))
(defmacro -when (arg &rest body)
`(if ,arg (progn ,@body)))
(defun -1+ (x) (+ x 1))
(defun -1- (x) (- x 1))
(defun ->= (first &rest rest)
(or (null rest)
(and (or (> first (car rest)) (= first (car rest)))
(apply #'->= rest))))
| 46,631 | Common Lisp | .lisp | 1,430 | 24.122378 | 68 | 0.48722 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | ca8fdb8b5aac8cd81be87f96134153c6f84b1f28fd27f1ba592ee9bc45566123 | 32,197 | [
235175,
329933,
402803
] |
32,198 | chapter-6.lisp | andlys_ansi-common-lisp/chapters/chapter-6.lisp | ;
(labels ((add2 (x) (+ x 2)))
(add2 5))
(defun philosoph (thing &optional property)
(list thing 'is property))
(philosoph 'death)
(defun philosoph (thing &optional (property 'fun))
(list thing 'is property))
(philosoph 'death)
(defun keylist (a &key x y z)
(list a x y z))
(keylist 1 :y 2)
(defun map-int (fn n)
(let (acc)
(dotimes (i n)
(let ((val (funcall fn i)))
(push val acc)))
(nreverse acc)))
(map-int #'identity 10)
(map-int #'(lambda (x) (random 100))
10)
;;; generalized version of remove-if
(defun filter (fn lst)
(let ((acc nil))
(dolist (x lst)
(let ((val (funcall fn x)))
(if val (push val acc))))
(nreverse acc)))
(filter #'(lambda (x)
(and (evenp x) (+ x 10)))
'(1 2 3 4 5 6 7))
(defun combiner (x)
(typecase x
(number #'+)
(list #'append)
(t #'list)))
(defun combine (&rest args)
(apply (combiner (car args))
args))
(combine 2 3)
(combine '(a b) '(c d))
(destructuring-bind (obj1 . rest) (list 'a 'b 'c 'd 'e)
(values obj1 rest))
(funcall (constantly 42) '(1 2 3 4) 5 6 7)
(defun our-complement (func)
#'(lambda (&rest args)
(not (apply func args))))
(mapcar (our-complement #'oddp) '(1 2 3 4 5 6))
;; several closures that share a variable
(let ((counter 0))
(defun my-reset ()
(setf counter 0))
(defun my-inc()
(incf counter)))
(list (my-inc) (my-inc) (my-reset) (my-inc))
(mapcar (complement #'oddp) '(1 2 3 4 5 6))
;; compose function returns a function that calls sequentially a set of
;; functions on some data
;; works like reduce. implemented by reduce
;; (compose #'f1 #'f2 #'f3 data)
;; is equivalent to
;; (lambda (data) (f1 (f2 (f3 data))))
(defun compose (&rest funcs)
#'(lambda (&rest args)
(reduce #'(lambda (v f) (funcall f v))
(cdr (reverse funcs))
:initial-value (apply (car (reverse funcs)) args))))
(mapcar (compose #'list #'round #'sqrt)
'(4 9 16 25))
(mapcar (compose #'oddp #'car #'list #'round #'sqrt)
'(4 9 16 25))
(defun get-last (lst)
(funcall (compose #'car #'reverse) lst))
(get-last '(a b c d e f))
;; curry function returns a function that calls some function to which
;; many (nested) arguments are applied
(defun curry (fn &rest args)
#'(lambda (&rest args2)
(apply fn (append args args2))))
(funcall (curry #'list 'a 'b 'c) 'd)
(defun disjoin (fn &rest fns)
(if (null fns)
fn
(let ((disj (apply #'disjoin fns)))
#'(lambda (&rest args)
(or (apply fn args) (apply disj args))))))
(funcall (disjoin #'< #'=) 3 5)
(funcall (disjoin #'< #'=) 5 5)
(funcall (disjoin #'< #'=) 6 5)
(mapcar (disjoin #'integerp #'symbolp)
'(a "a" 2 3 (a b c)))
(let ((*print-base* 16))
(princ 32))
(defun foo (x) (+ x 1))
(compiled-function-p #'foo)
(compile 'foo)
| 2,915 | Common Lisp | .lisp | 96 | 26.0625 | 71 | 0.588024 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 256527ee4e0d737acecda18bfaf98d36fb611f7f6a61dc686140420f4c50f3b9 | 32,198 | [
-1
] |
32,199 | chapter-4-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-4-ex.lisp | ;;; ex-2B
(defun my-copy-list (lst)
(reduce #'(lambda (a b) (cons a b))
lst
:from-end t
:initial-value nil))
(my-copy-list '(a b c d))
;;; ex-2B
(defun my-reverse (lst)
(reduce #'(lambda (a b) (append b (list a)))
lst
:from-end t
:initial-value nil))
(my-reverse '(a b c d))
;;; ex-4
(load "ch4-tree.lisp")
(defparameter tree nil)
(dolist (n '(5 8 4 2 1 9 6 3))
(setf tree (bst-insert n tree #'<)))
(defun run (tree)
(if tree
(let ((lst nil))
(setf lst (append
(run (node-right tree))
(list (node-value tree))
(run (node-left tree))))
lst)))
(run tree)
;;; ex-6 A & B
(defun print-hash-entry (key value)
(format t "~S -> ~S~%" key value))
(defun assoc2hash (assoc-list)
(let ((res (make-hash-table :size (length assoc-list))))
(dolist (pair assoc-list)
(setf (gethash (first pair) res) (cdr pair)))
res))
(defun hash2assoc (hash)
(let ((tmp nil))
(maphash #'(lambda (k v)
(setf tmp (append tmp (list (cons k v)))))
hash)
tmp))
(defparameter assoc-list '(("Andrii" . 19) ("Bob" . 27) ("Alice" . 16)))
(defparameter ht (assoc2hash assoc-list))
(print assoc-list)
(terpri)
(maphash #'print-hash-entry ht)
(print (hash2assoc ht))
| 1,396 | Common Lisp | .lisp | 48 | 22.458333 | 72 | 0.533683 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | bb98773b28b6f125df95cefb47dfd1f87f60869e31905e54f6df30f614d3ea46 | 32,199 | [
-1
] |
32,200 | chapter-3-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-3-ex.lisp | ;;; ex-2
(defun new-union (lst1 lst2)
(let ((new nil))
(dolist (elem lst1)
(setf new (append new (list elem))))
(if (not (car new)) (pop new))
(dolist (elem lst2)
(if (not (member elem new))
(setf new (append new (list elem)))))
new))
(print (new-union '(a b c) '(b a d)))
;;; ex-3
(defun occurrences (lst)
(let ((new nil))
(dolist (elem lst)
(if (null (assoc elem new))
(setf new (append
new
(list (cons elem 1))))
(setf (cdr (assoc elem new))
(+ (cdr (assoc elem new)) 1))))
(sort new #'(lambda (pair1 pair2)
(>= (cdr pair1) (cdr pair2))))))
(print (occurrences '(a b a d a c d c a)))
;;; ex-4
(member '(a) '((a) (b)) :test #'equal)
;;; ex-5
;(pos+ '(7 5 1 4))
(defun pos+itr (lst)
(let ((new (copy-list lst)))
(dotimes (n (length lst))
(setf (nth n new) (+ (nth n new) n)))
new))
(print (pos+itr '(7 5 1 4)))
(defun pos+rec (lst &optional depth)
(when (null depth) (setq depth 0))
(if (null lst)
nil
(cons (+ (car lst) depth)
(pos+rec (cdr lst) (+ depth 1)))))
(print (pos+rec '(7 5 1 4)))
(defun pos+mpc (lst)
(mapcar #'(lambda (elem)
(+ elem (position elem lst)))
lst))
(print (pos+mpc '(7 5 1 4)))
| 1,465 | Common Lisp | .lisp | 46 | 23 | 55 | 0.459632 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | e77719ce98b158cb14e353df02c495f061fce9fc33a230edfa968d94f956d78d | 32,200 | [
-1
] |
32,201 | chapter-5.lisp | andlys_ansi-common-lisp/chapters/chapter-5.lisp | (block head
(format t "Here we go")
(return-from head 'idea)
(format t "We'll never see this."))
(defun our-member (obj lst)
(if (atom lst)
nil
(if (eql obj (car lst))
lst
(our-member obj (cdr lst)))))
(defun our-member2 (obj lst)
(cond ((atom lst) nil)
((eql obj (car lst)) lst)
(t (our-member2 obj (cdr lst)))))
(defun month-length (mon)
(case mon
((jam mar may jul aug oct dec) 31)
((apr jun sept nov) 30)
(feb (if (leap-year) 29 28))
(otherwise "unknown month")))
(defun leap-year () nil)
(month-length 'apr)
(dolist (x '(a b c d e) 'done)
(format t "~A " x))
(dotimes (x 5 x)
(format t "~A " x))
(defun factorial (n)
(do ((j n (- j 1))
(f 1 (* f j)))
((= j 0) f)))
(factorial 5)
(mapc #'(lambda (x y)
(format t "~A ~A " x y))
'(hip flip slip)
'(hop flop slop))
(get-decoded-time)
(values 'a nil (+ 2 4))
(multiple-value-bind (x y z) (values 1 2)
(list x y z))
(multiple-value-bind (s m h day month year) (get-decoded-time)
(format t "Today it's ~A-~A-~A ~%" year month day))
(multiple-value-call #'* (values 1 2 3 4))
(multiple-value-list (values 'a 'b 'c))
(defun super ()
(catch 'abort
(sub)
(format t "We'll never see this.")))
(defun sub ()
(throw 'abort 99))
(progn
(error "Oos!")
(format t "After the error."))
(defparameter x 1)
(catch 'abort
(unwind-protect
(throw 'abort 99)
(setf x 2)))
x
(defparameter mon '(31 28 31 30 31 30 31 31 30 31 30 31))
(apply #'+ mon)
(defun my-sum (lst) (apply #'+ lst))
;; java
;int[] mon = {31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
;int total = 0;
;(for days : mon)
;total += days;
(defparameter nom (reverse mon))
(defparameter sums (maplist #'(lambda (x)
(apply #'+ x))
nom))
(defparameter month (make-array 13 :initial-element 0))
(do ((i 1 (+ i 1))
(j 11 (- j 1)))
((= i 13) month)
(setf (aref month i) (nth j sums)))
(defconstant yzero 2000)
(defun leap? (y)
(and (zerop (mod y 4))
(or (zerop (mod y 400))
(not (zerop (mod y 100))))))
(defun date->num (d m y)
(+ (- d 1) (month-num m y) (year-num y)))
(defun month-num (m y)
(+ (svref month (- m 1))
(if (and (> m 2) (leap? y)) 1 0)))
(defun year-num (y)
(let ((d 0))
(if (>= y yzero)
(dotimes (i (- y yzero) d)
(incf d (year-days (+ yzero i))))
(dotimes (i (- yzero y) (- d))
(incf d ((year-days (+ y i))))))))
(defun year-days (y) (if (leap? y) 366 365))
(mapcar #'leap? '(1904 1900 1600))
;(multiple-value-list (date+ 17 12 1997 60))
| 2,799 | Common Lisp | .lisp | 95 | 23.705263 | 62 | 0.527068 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 93613552dadfc63bca546ac93e1d16f244909e1bc45e8f18cfcdf680d6134fb3 | 32,201 | [
-1
] |
32,202 | chapter-5-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-5-ex.lisp | ;;; ex-1a
(defparameter y '(a b c))
(let ((x (car y)))
(cons x x))
(do ((x (car y)))
(t (cons x x)))
;;; ex-1b
(defparameter x '(10 20 30))
(defparameter z 100)
(let* ((w (car x))
(y (+ w z)))
(cons w y))
(do* ((w (car x))
(y (+ w z)))
(t (cons w y)))
;;; ex-2
;;; old
(defun mystery (x y)
(if (null y)
nil
(if (eql (car y) x)
0
(let ((z (mystery x (cdr y))))
(and z (+ z 1))))))
;;; new
(defun mystery (obj lst)
(cond ((null lst) nil)
((eql (car lst) obj) 0)
(t (let ((z (mystery obj (cdr lst))))
(and z (+ z 1))))))
(mystery 5 '(1 2 3))
(mystery 5 '(1 2 5))
;;; ex-3
(defun square (n)
(cond ((and (<= n 5)
(>= n 0)) n)
(t (expt n 2))))
(square 4)
(square 5)
(square 6)
(square 7)
(square -4)
;;; ex-5
(defun precedes-iter (x v)
(do ((i (- (length v) 1) (- i 1))
(j (- (length v) 2) (- j 1))
(res nil))
((< i 1) res)
(when (eq x (aref v i))
(setf res (adjoin (aref v j) res)))))
(defun precedes-rec (x v &key (res nil) (i (- (length v) 1)))
(cond ((< i 1) res)
((eq x (aref v i))
(precedes-rec x v
:res (adjoin (aref v (- i 1)) res)
:i (- i 1)))
(t (precedes-rec x v
:res res
:i (- i 1)))))
(precedes-rec #\a "abracadabra")
(precedes-iter #\a "abracadabra")
;;; ex-6
(defun intersperse-iter (obj lst)
(let (res)
(dolist (elt lst)
(setf res (append res (list elt) (list obj))))
(butlast res)))
(defun intersperse-rec (obj lst)
(if (consp (cdr lst))
(cons (car lst)
(cons obj
(intersperse-rec obj (cdr lst))))
(cons (car lst) nil)))
(intersperse-rec '- '(a b c d))
(intersperse-iter '- '(a b c d))
;;; ex-7a
(defun diff-rec (lst)
(cond ((not (consp (cdr lst))) t)
((/= 1 (abs (- (first lst) (second lst))))
nil)
(t (diff-rec (cdr lst)))))
(diff-rec '(3 4 5 6))
(diff-rec '(6 5 4 3))
(diff-rec '(3 4 5 7))
(diff-rec '(7 5 4 3))
;;; ex-7b
(defun diff-do (lst)
(do ((tmp lst (cdr tmp)))
((not (consp (cdr tmp)))
t)
(if (/= 1 (abs (- (first tmp) (second tmp))))
(return-from diff-do nil))))
(diff-do '(3 4 5 6))
(diff-do '(6 5 4 3))
(diff-do '(3 4 5 7))
(diff-do '(7 5 4 3))
;;; ex-7c
(defun diff-mapc (lst)
(mapc #'(lambda (x y)
(when (/= 1 (abs (- x y)))
(return-from diff-mapc nil)))
(butlast lst)
(cdr lst))
t)
(diff-mapc '(3 4 5 6))
(diff-mapc '(6 5 4 3))
(diff-mapc '(3 4 5 7))
(diff-mapc '(7 5 4 3))
;;; ex-8
(defun minmax (v &key (i 0) (min (aref v 0)) (max (aref v 0)))
(if (>= i (length v))
(values min max)
(let ((elt (aref v i)))
(when (> elt max)
(setf max elt))
(when (< elt min)
(setf min elt))
(minmax v :i (+ i 1) :min min :max max))))
(minmax #(6 3 7 2 8 1 3 -1 0))
| 3,138 | Common Lisp | .lisp | 119 | 19.831933 | 62 | 0.44838 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 655212334b3f36e1c746de9a9e824ce75d6bc242093f1b7227abcb0f26a114ad | 32,202 | [
-1
] |
32,203 | chapter-10-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-10-ex.lisp | ;; ex-1
(let ((x 'a)
(y 'b)
(z '(c d)))
(list `(,z ,x z)
`(x ,y ,@z)
`((,@z ,x) z)))
;; ex-2
(defmacro iff (test then &optional else)
`(let ((val ,test))
(cond (val ,then)
(t ,else))))
(pprint (macroexpand-1
(iff (/= 2 2)
(oddp 2)
(oddp 3))))
;; variable capture example
(iff (find 'a '(a b c))
val ; captured from macro
'nothing-found)
(iff (= 2 3)
'success)
(iff (= 2 3)
'success
'failure)
;; ex-3
(defmacro nth-expr (n &rest args)
`(case ,n
,@(let ((i 0))
(mapcar #'(lambda (expr)
`(,(incf i) ,expr))
args)))))
(defun watch () (print 'evaluated!))
(let ((y 2))
(macroexpand-1 '(nth-expr y (watch) (+ 1 3) 'value)))
(let ((x 2))
(nth-expr x (watch) (+ 1 3) (watch) 'value))
(let ((n 2))
;; this evaluates without any errors despite division by zero
;; the division is not evaluated because we are interested only
;; in n-th expression!
(nth-expr n (/ 1 0) (+ 1 2) (/ 1 0)))
;; ex-4
(defmacro ntimes (n &rest body)
(if (>= n 1)
`(progn (ntimes ,(1- n) ,@body)
,@body)))
(macroexpand-1 '(ntimes 3 (print 'hello)))
(ntimes 5 (print "<br"))
(let ((n 10))
(ntimes 5
(print (incf n))))
;; ex-5
(defmacro n-of (n expr)
(let ((i (gensym))
(expr2 (gensym)))
`(loop for ,i from 0 to ,n
until (> (setf ,expr2 ,expr)
,n)
collect ,expr2))))
(let ((i 0)
(n 4))
(macroexpand-1 '(n-of n (incf i))))
(let ((i 0)
(n 4))
(n-of n (incf i)))
;; ex-6
(defmacro save-vars (vars &rest body)
`(let (,@(mapcar #'(lambda (var)
`(,var ,var))
vars))
,@body))
(let ((var 'some-symbol)
(n 42)
(fun (lambda (n) (+ n 1))))
(macroexpand-1 '(save-vars (var n)
(setf var 'qwe)
(setf n 0))))
(let ((var 'some-symbol)
(n 42)
(fun (lambda (n) (+ n 1)))
(unsaved 'possession))
(save-vars (var n fun)
(setf var 'qwe)
(setf n 0)
(dotimes (n 5)
(incf n))
(setf fun 'hiking)
(setf unsaved 'redefined)
(format t "inside block of code: n = ~A; fun = ~A ~%" n fun))
(values var n fun unsaved))
;; ex-7
;; TODO find the reason why this definition is bad compared to the real push
;; The only difference I noticed so far is using setf vs setq...
(defmacro my-push (obj lst)
`(setf ,lst (cons ,obj ,lst)))
lst
(defparameter lst (list 'b 'c))
(cons lst (cons lst nil))
(setf lst (cons lst lst))
(macroexpand-1 '(my-push 'a lst))
(my-push 'a (cdr lst))
(push 'a (cdr lst))
(macroexpand-1 '(push 'a lst))
lst
;; ex-8
(defmacro my-double (x)
`(setf ,x (* 2 ,x)))
(let ((x -21))
(my-double x)
x)
| 2,621 | Common Lisp | .lisp | 111 | 20.108108 | 76 | 0.555288 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | 8edffcac6b491609271713d92d9c62ed89050296815ba0bff1a0a2fe37a46f51 | 32,203 | [
-1
] |
32,204 | chapter-3.lisp | andlys_ansi-common-lisp/chapters/chapter-3.lisp | (nthcdr 3 '(a b c d e))
(reverse '(a b c))
(sort '(2 5 3 1 4) #'<)
(subseq '(a b c) 1)
(every #'oddp '(1 3 5))
(some #'evenp '(1 2 3))
(every #'> '(1 3 5) '(0 2 4))
(defun every-odd (lst) (every #'oddp lst))
(every-odd '(1 3 5 7 8))
;stacks
(defparameter lst (list 'a))
(push 'b lst)
(pop lst)
(cons 'a 'b)
(defparameter trans '((+ . "add") (* . "multiply")))
(assoc '+ trans)
'(node . (neigh bours)) ;???
(defun shortest-path (start end net)
(bfs end (list (list start)) net))
(defun bfs (end queue net)
(if (null queue)
nil
(let ((path (car queue)))
(let ((node (car path)))
(if (eql node end)
(reverse path)
(bfs end
(append (cdr queue)
(new-paths path node net))
net))))))
(defun new-paths (path node net)
(mapcar #'(lambda (n)
(cons n path))
(cdr (assoc node net))))
(defparameter min-net '((a b c) (b c) (c d)))
(cdr (assoc 'a min-net))
(shortest-path 'a 'd min-net)
| 1,081 | Common Lisp | .lisp | 37 | 22.594595 | 58 | 0.493269 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | f600e5bbf270ba3dbd0478334e2c3699bacce8278702461d67af2ca65314234f | 32,204 | [
-1
] |
32,205 | chapter-2-ex.lisp | andlys_ansi-common-lisp/chapters/chapter-2-ex.lisp | ;access the third element of list
(defvar lst (list 'a 'b 'c 'd 'e))
(defvar x)
(setq x (third lst))
(print x)
(setq x (car (cdr (cdr lst))))
(print x)
(setq x (caddr lst))
(print x)
;;; ex-1.c
(list (and (listp 3) t) (+ 1 2))
;;; ex-2
(cons 'a '(b c))
(cons 'a (cons 'b '(c)))
(cons 'a (cons 'b (cons 'c nil)))
;;; ex-3
(defun my-fourth (lst) (cadddr lst))
(my-fourth '(1 2 3 4 5))
;;; ex-4
(defun bigger (a b)
(if (> a b)
a
b))
(bigger 4 5)
(bigger -30 -20)
;;; ex-5a
;;; checks whether a list x is not empty and contains at least one NIL value
(defun enigma (x)
(and (not (null x))
(or (null (car x))
(enigma (cdr x)))))
(enigma '())
(enigma '(a))
(enigma '(a b))
(enigma '(nil))
(enigma '(nil nil))
(enigma '(a nil))
(enigma '(nil a))
(enigma '(a b c nil))
;;; ex-5b
;;; returns index number of an object x from a list y
;;; if nothing found returns nil
(defun mystery (x y)
(if (null y)
nil
(if (eql (car y) x)
0
(let ((z (mystery x (cdr y))))
(and z (+ z 1))))))
;;; ex-6.a
(car (car (cdr '(a (b c) d))))
;;; ex-6.b
(or 13 (/ 1 0))
;;; ex-6.c
(apply #'list 1 nil)
;;; ex-7
(defun check (lst)
(if (null lst)
nil
(or (listp (car lst))
(check (cdr lst)))))
(check (list 'a 'b 'c))
(check nil)
(check (list 'a '(b) 'c))
(check (list '(a) 'b 'c))
(check (list 'a 'b '(c)))
;;; ex-8.a
(defun commas-rec (n)
(when (> n 0)
(format t ", ")
(commas-rec (- n 1))))
(defun dots-iter (n)
(loop for i from 1 to n do
(format t ". ")))
(defun test (lim &rest fnames)
(dolist (fun fnames)
(dotimes (n lim)
(print n)
(funcall fun n))))
(test 5 #'dots-iter
#'commas-rec)
;;; ex-9
(defun summit (lst)
(let ((new (remove-if #'null lst)))
(apply #'+ new)))
(summit '(nil 1 nil 2 nil 3 nil))
(defun summit (lst)
(when (null lst) (return-from summit 0))
(let ((x (car lst)))
(if (null x)
(summit (cdr lst))
(+ x (summit (cdr lst))))))
(summit '(1))
(summit '(nil 1 nil 2 nil 3 nil))
| 2,143 | Common Lisp | .lisp | 94 | 18.840426 | 76 | 0.518409 | andlys/ansi-common-lisp | 0 | 1 | 0 | GPL-3.0 | 9/19/2024, 11:42:22 AM (Europe/Amsterdam) | d955a3bdb707b7cf9ab8e2a26526c9c2ca62cd1b82d7ce4e3cfe781614866efb | 32,205 | [
-1
] |
Subsets and Splits
No saved queries yet
Save your SQL queries to embed, download, and access them later. Queries will appear here once saved.