index.html 19.5 KB
Newer Older
1
<!-- -*- mode: HTML; time-stamp-line-limit: -18; -*- -->
Liam Healy's avatar
Liam Healy committed
2
3
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0//EN">
<html>
4
  <head>
Liam Healy's avatar
Liam Healy committed
5
6
7
8
9
10
11
    <title>GSLL, the GNU Scientific Library for Lisp
</title>
    <meta name="generator" content="muse.el">
    <meta http-equiv="Content-Type"
          content="text/html; charset=iso-8859-1">
    <link rev="made" href="mailto:lhealy@common-lisp.net">
    <link rel="stylesheet" type="text/css" href="site.css">
12
13
  </head>
  <body>
Liam Healy's avatar
Liam Healy committed
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
    <div id="banner">
      <h1>GNU Scientific Library for Lisp</h1>
      <h2><a href="index.html">GSLL</a> &nbsp;
    </div>
    <div id="sidebar">
    <ul>
      <li><a href="#about">About</a></li>
      <li><a href="#examples">Examples</a></li>
      <li><a href="#require">Requirements</a></li>
      <li><a href="#getit">Download</a></li>
      <li><a href="#documentation">Documentation</a></li>
      <li><a href="#status">Status</a></li>
      <li><a href="#contact">Contact</a></li>
    </ul>
    <!-- Insertion Mark -->
    </div>
    <div id="content">
    <!-- Page published by Emacs Muse begins here -->
<h2>About</h2>
<a name="about"/>
<p class="first">
35
36


Liam Healy's avatar
Liam Healy committed
37
38
39
40
41
42
43
44
45
46
47
48
49
50
<p>The GNU Scientific Library for Lisp (GSLL) allows you to use
the <a href="http://www.gnu.org/software/gsl/">GNU Scientific Library
(GSL)</a> from <a href="http://www.lisp.org">Common Lisp</a>.  This
library provides a full range of common mathematical operations useful
to scientific and engineering applications.  The design of the GSLL
interface is such that access to most of the GSL library is possible
in a Lisp-natural way; the intent is that the user not be hampered by
the restrictions of the C language in which GSL has been written.
GSLL thus provides interactive use of GSL for getting quick answers,
even for someone not intending to program in Lisp.
</p>

<p>Topics include: polynomials, special functions, vectors and
matrices, permutations, sorting, linear algebra including BLAS,
51
eigensystems, fast Fourier transforms (FFT), quadrature, random numbers,
Liam Healy's avatar
Liam Healy committed
52
53
54
55
56
57
58
quasi-random sequences, random distributions, statistics, histograms,
N-tuples, Monte Carlo integration, simulated annealing, ordinary
differential equations, interpolation, numerical integration,
numerical differentiation, Chebyshev approximation, series
acceleration, discrete Hankel transforms, root-finding, minimization,
least-squares fitting, IEEE floating-point, discrete wavelet
transforms, basis splines, physical constants.  See
Liam Healy's avatar
Liam Healy committed
59
60
<a href="missing-features.text">missing-features.text</a>
on the status of some incomplete topics.
Liam Healy's avatar
Liam Healy committed
61
62
63
64
</p>

<h2>Examples</h2>
<a name="examples"/>
65
66
67
68
69
70
71
72
73
74
75
 <p>The <a href="http://www.gnu.org/software/gsl/manual/html_node/Elliptic-Functions-_0028Jacobi_0029.html">Jacobian elliptic functions</a> <i>sn</i>, <i>cn</i>, and
 <i>dn</i> are special functions (Chapter 7):</p> 
<pre>
(jacobian-elliptic-functions 0.2d0 0.81d0)
0.19762082367187703d0
0.9802785369736752d0
0.9840560289645665d0
1.828927267118668d-318
1.4821969375237396d-321
2.023692885365746d-320
</pre>
Liam Healy's avatar
Liam Healy committed
76
77
78
79
<p>which returns as multiple values the three function values, along
with the estimated errors of each.  The functions are defined
only if the second argument <i>m</i> is not greater than 1,
so an error is signalled if this parameter is out of range:
80
81
<pre>
(jacobian-elliptic-functions 0.61802d0 1.5d0)
82
Input domain error |m| > 1.0 in elljac.c at line 46
83
   [Condition of type INPUT-DOMAIN]
84
</pre>
Liam Healy's avatar
Liam Healy committed
85
86
87
88
89
90
91
92
93
<p>This is an ordinary Lisp error which may be handled with standard
definitions available in Lisp.  To take the
<a href="file:///usr/share/doc/gsl-ref-html/Level-1-GSL-BLAS-Interface.html">
complex conjugate scalar product</a> of two complex vectors of length 3:
<pre>
(cdot #2m(#c(-34.5d0 8.24d0) #c(3.29d0 -8.93d0) #c(34.12d0 -6.15d0))
      #2m(#c(49.27d0 -13.49d0) #c(32.5d0 42.73d0) #c(-17.24d0 43.31d0)))
#C(-2940.2118d0 1861.9380999999998d0)
</pre>
Liam Healy's avatar
Liam Healy committed
94
<p>or equivalently the vector arguments may be specified with reals,
Liam Healy's avatar
Liam Healy committed
95
96
97
98
99
<pre>
(cdot #2m(-34.5d0 8.24d0 3.29d0 -8.93d0 34.12d0 -6.15d0)
      #2m(49.27d0 -13.49d0 32.5d0 42.73d0 -17.24d0 43.31d0))
#C(-2940.2118d0 1861.9380999999998d0)
</pre>
100
<p>There are over 1500 examples available from within GSLL with the
Liam Healy's avatar
Liam Healy committed
101
102
function <code>examples</code>.  These examples also serve
as a test suite for GSLL.
103

Liam Healy's avatar
Liam Healy committed
104
105
106
107
108
109
110
111
<h2>Requirements</h2>
<a name="require"/>
<p>
GSLL should work in any Common Lisp implementation and platform
combination for which the following are supported:</p>
<ul>
<li><a href="http://www.gnu.org/software/gsl/">GSL</a>
</li>
112
<li><a href="http://common-lisp.net/project/cffi/">CFFI</a> and cffi-grovel,
Liam Healy's avatar
Liam Healy committed
113
  version 0.10.5 or newer; callbacks and <code>foreign-funcall</code> 
114
  must be supported.
Liam Healy's avatar
Liam Healy committed
115
116
</li>
<li><a href="http://www.cliki.net/trivial-garbage">trivial-garbage</a>
117
118
<li><a href="http://common-lisp.net/project/cl-utilities/">cl-utilities</a>
</li>
119
120
121
<li><a href="http://www.cliki.net/asdf">ASDF</a></li>
<li><a href="http://repo.or.cz/w/lisp-unit.git">lisp-unit</a>, <i>(Optional)</i> necessary 
   to run <code>gsll-tests</code>
122
</li>
Liam Healy's avatar
Liam Healy committed
123
<li><a href="http://repo.or.cz/w/fsbv.git">FSBV</a>, <i>(Optional)</i> necessary 
124
   for functions using complex scalars or simulated annealing
125
</li>
126
127
128
129
130
131
132
<li>
  <a href="http://common-lisp.net/project/iterate/">iterate</a>
  and
  <a href="http://common-lisp.net/project/asdf-system-connections/">asdf-system-connnections</a>,
  <i>(Optional)</i> 
  provides a convenient way to iterate over elements or indices of
  vectors or matrices.
133
</ul>
Liam Healy's avatar
Liam Healy committed
134
135
136
137
138
139
140
141
142

<p>GSLL has been tested with
  <a href="http://sbcl.sourceforge.net/">SBCL</a>
  and
  <a href="http://trac.clozure.com/openmcl">CCL</a>
  on Debian amd64, and
  <a href="http://sbcl.sourceforge.net/">SBCL</a>
  and
  <a href="http://clisp.cons.org/">CLISP</a> on Debian i386.  There
Liam Healy's avatar
Liam Healy committed
143
  are some known failures; see <a href="status.text">status.text</a>.
Liam Healy's avatar
Liam Healy committed
144
</p>
145

146
<h2>Download and Install</h2>
Liam Healy's avatar
Liam Healy committed
147
 <h3>With <a href="http://git.or.cz">git</a> and asdf</h3>
Liam Healy's avatar
Liam Healy committed
148
<a name="getit"/>
Liam Healy's avatar
Liam Healy committed
149
150
151
<p>Download/update:
  <ul>
    <li><code>git clone git://repo.or.cz/gsll.git</code></li>
Liam Healy's avatar
Liam Healy committed
152
    <li><code>git clone git://repo.or.cz/fsbv.git</code></li>
153
    <li><code>darcs get http://common-lisp.net/~loliveira/darcs/trivial-garbage</code></li>
Liam Healy's avatar
Liam Healy committed
154
155
    <li><code>git pull</code> in the <code>gsll</code> and
      <code>fsbv</code> directories
Liam Healy's avatar
Liam Healy committed
156
157
    afterwards to update</li> 
  </ul>
Liam Healy's avatar
Liam Healy committed
158
159
<p>The <a href="http://repo.or.cz/w/gsll.git"> repository web page</a>
can be used to browse or retrieve a compressed tarball (click the most
160
161
162
163
recent "snapshot" link).
You will need to make a link of <code>gsll.asd</code> and
optionally <code>gsll-tests.asd</code> to some directory known to ASDF.
Then in Lisp, load the system:
Liam Healy's avatar
Liam Healy committed
164
165
166
  <ul>
    <li><code>(asdf:operate 'asdf:load-op :gsll)</code></li>
  </ul>
Liam Healy's avatar
Liam Healy committed
167
168
169
170
171
172
173
174
175
176
177
178
 <p>If you wish to run the test suite, you must get lisp-unit and make
 it known to ASDF:
  <ul>
    <li><code>git clone git://repo.or.cz/lisp-unit.git</code></li>
  </ul>
  <p>The test suite may be run with
  <ul>
    <li><code>(asdf:operate 'asdf:load-op :gsll-tests)</code></li>
    <li><code>(in-package :gsl)</code></li>
    <li><code>(lisp-unit:run-tests)</code></li>
  </ul>
  <p>Please see <a href="status.text">status.text</a> for known failures.
Liam Healy's avatar
Liam Healy committed
179
 <h3>With <a href="http://common-lisp.net/project/clbuild/">clbuild</a></h3>
180
181
182
183
<p>
  First, make sure that the development versions of GSL and libffi are
 loaded, e.g. in Debian/Ubuntu <code>libgsl0-dev</code>
 and <code>libffi-dev</code>. 
Liam Healy's avatar
Liam Healy committed
184
185
186
187
<p>
 Add the following to <code>wnpp-projects</code>:
  <ul>
    <li><code>gsll get_git git://repo.or.cz/gsll.git</code></li>
Liam Healy's avatar
Liam Healy committed
188
    <li><code>fsbv get_git git://repo.or.cz/fsbv.git</code></li>
189
    <li><code>lisp-unit get_git git://repo.or.cz/lisp-unit.git</code></li>
Liam Healy's avatar
Liam Healy committed
190
191
192
  </ul>
<p>and add
  <ul>
193
    <li><code>gsll cffi trivial-garbage cl-utilities lisp-unit fsbv iterate asdf-system-connections</code></li>
Liam Healy's avatar
Liam Healy committed
194
195
196
197
198
199
200
201
202
  </ul>
<p>
to <code>dependencies</code> and execute
from within the clbuild directory:
  <ul>
    <li><code>sudo ./clbuild update gsll</code></li>
  </ul>
 <h3>With Debian or Ubuntu</h3>
  <ul>
203
    <li><code>sudo aptitude install libgsl0-dev cl-cffi cl-utilities libffi-dev cl-iterate</code></li>
Liam Healy's avatar
Liam Healy committed
204
    <li><code>git clone git://repo.or.cz/gsll.git</code></li>
Liam Healy's avatar
Liam Healy committed
205
    <li><code>git clone git://repo.or.cz/fsbv.git</code></li>
Liam Healy's avatar
Liam Healy committed
206
    <li><code>darcs get http://common-lisp.net/~loliveira/darcs/trivial-garbage</code></li>
207
    <li><code>darcs get http://common-lisp.net/project/asdf-system-connections</code></li>
Liam Healy's avatar
Liam Healy committed
208
209
    <li><code>clc-register-user-package gsll/gsll.asd</code></li>
    <li><code>clc-register-user-package gsll/gsll-tests.asd</code></li>
210
    <li><code>clc-register-user-package trivial-garbage/trivial-garbage.asd</code></li>
Liam Healy's avatar
Liam Healy committed
211
    <li><code>clc-register-user-package fsbv/fsbv.asd</code></li>
212
    <li><code>clc-register-user-package asdf-system-connections/asdf-system-connections.asd</li>
Liam Healy's avatar
Liam Healy committed
213
214
215
216
  </ul>
<p>
  After starting your Lisp implementation,
  <ul>
Liam Healy's avatar
Liam Healy committed
217
    <li><code>(clc:clc-require :gsll-tests)</code></li>
Liam Healy's avatar
Liam Healy committed
218
219
  </ul>
 <h3>License</h3>
220
221
<p>
This software is distributed under
Liam Healy's avatar
Liam Healy committed
222
223
224
225
226
227
228
229
the <a href="http://www.cliki.net/LLGPL">LLGPL</a>
and <a href="http://www.gnu.org/copyleft/fdl.html">FDL</a>; see
the file COPYING.  There is absolutely no warranty.</p>

<h2>Documentation</h2>
<a name="documentation"/>
 <h3>General Advice</h3>
 <p>The following techniques for using the API are advised:</p>
230
 <ul>
Liam Healy's avatar
Liam Healy committed
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
 <li>Find the appropriate function(s) in the <a
 href="http://www.gnu.org/software/gsl/manual/">GSL
 documentation</a>.</li>
 <li>Use the GSLL function <code>gsl-lookup</code>
  to find the equivalent GSLL function, for example
<pre>
(gsl-lookup "gsl_sf_elljac_e")
JACOBIAN-ELLIPTIC-FUNCTIONS
T
</pre>
   <p>
     to find that the Lisp function name is <code>#'jacobian-elliptic-functions</code>.  
  </li>
 <li>Look at the documentation for that Lisp function, e.g.
   <pre>(documentation #'jacobian-elliptic-functions 'function)
"The Jacobian elliptic functions sn(u|m),
  cn(u|m), dn(u|m) computed by descending Landen transformations."
   </pre>
   <p>
   to get an explanation of the arguments etc.
 </li>
 <li>Use the function <code>(examples)</code> without an argument to
 get a list of example categories.  Then use the function with a
 category name as the argument to get a list of examples under that
 category, for example
   <code>(examples 'higher-moments)</code>.  The result will be a list
   of forms, each providing an example of usage in the relevant topic.
   If the
 <a href="http://www.gnu.org/software/gsl/manual/">GSL
 documentation</a> provides an example, there will usually be the same
 or similar example provided in GSLL. <i>Note:</i> Some of the
 examples are intentionally designed to signal an error, because the
 examples also serve as a regression (unit) test suite for GSLL.</li>
264
 </ul>
Liam Healy's avatar
Liam Healy committed
265
 <p>
Liam Healy's avatar
Liam Healy committed
266
   Some examples are not yet present in, or are too complicated for, the
Liam Healy's avatar
Liam Healy committed
267
 function <code>#'examples</code>.  In this case, you need to look in
268
 the relevant source file; they are in either a separate file of
Liam Healy's avatar
Liam Healy committed
269
270
271
272
 examples, or at the end of the file of definitions.
 It is advisable to look at the examples first for calculations that
 require more complex setup (generally, the later chapters in the GSL
 manual).
liam's avatar
liam committed
273

Liam Healy's avatar
Liam Healy committed
274
275
276
277
 <h3>Arrays</h3>
<p>
GSLL has many functions that work on vectors (one-dimensional arrays)
and matrices (two-dimensional arrays).  GSLL supports all array
278
279
280
element types that are supported by CFFI, the CL implementation,
GSL, and the platform.  This list is available in the
variable <code>*array-element-types*</code>.  On implementations that
Liam Healy's avatar
Liam Healy committed
281
282
283
284
285
286
287
288
289
290
support it (currently only SBCL), the contents are directly available
to the GSL functions without copying between the Lisp area and the C
area of memory.</p>
<p>
 Common Lisp arrays should be created with <code>make-marray</code> or
 <code>#m</code>:
 The #m reader macro in the default form creates a vector or matrix of
 element type double-float, which is the most common type needed for
 GSL functions.  It optionally takes a numeric argument prefix as in
 the example above to make an array with a different element type; a
291
292
293
294
 guide to the numeric argument is given below.  It should be 
 followed by a list; this list will be evaluated.  If the list
 contains <code>^</code>, the object created will be a matrix
 and each row is ended with that symbol.
Liam Healy's avatar
Liam Healy committed
295
 <p>
296
 Classes of vectors and matrices are named by appending the element
Liam Healy's avatar
Liam Healy committed
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
 type as hypenated words to "vector" or "matrix".  The following table
 shows the classes available on a 64-bit platform:
 <center>
  <table border=5 frame=all cellpadding=4 cellspacing=4 cols=6>
    <caption align=top>Element types, vector and matrix
    classes</caption>
    <thead>
      <tr><th><b>Element type</b><td><b>Vector class name</b>
	  <td><b>Matrix class name</b><td><b>#m prefix</b></thead>
	<tbody>
	  <tr><td>double-float<td>vector-double-float<td>matrix-double-float
	    <td>1 or empty
	  <tr><td>(complex double-float)<td>vector-complex-double-float<td>matrix-complex-double-float<td>2
	  <tr><td>single-float<td>vector-single-float<td>matrix-single-float<td>3
	  <tr><td>(complex single-float)<td>vector-complex-single-float<td>matrix-complex-single-float<td>4
	  <tr><td>(signed-byte 8)<td>vector-signed-byte-8<td>matrix-signed-byte-8<td>7
	  <tr><td>(unsigned-byte 8)<td>vector-unsigned-byte-8<td>matrix-unsigned-byte-8<td>8
	  <tr><td>(signed-byte 16)<td>vector-signed-byte-16<td>matrix-signed-byte-16<td>15
	  <tr><td>(unsigned-byte 16)<td>vector-unsigned-byte-16<td>matrix-unsigned-byte-16<td>16
	  <tr><td>(signed-byte 32)<td>vector-signed-byte-32<td>matrix-signed-byte-32<td>31
	  <tr><td>(unsigned-byte 32)<td>vector-unsigned-byte-32<td>matrix-unsigned-byte-32<td>32
	  <tr><td>(signed-byte 64)<td>vector-signed-byte-64<td>matrix-signed-byte-64<td>63
	  <tr><td>(unsigned-byte 64)<td>vector-unsigned-byte-64<td>matrix-unsigned-byte-64<td>64
	</tbody>
      </table>
    </center>
<p>
 Individual elements are obtained using <code>maref</code> (analogous
 to Lisp's <code>aref</code>), and are set
 with <code>setf maref</code>.  A complete CL array may
 be extracted with the function <code>#'cl-array</code>.
</p>
329
330
331
332
333
334
<p>Copying marrays is performed with the function <code>copy</code>.
  This works between marrays, pointers, and CL arrays.  It is useful
  for functions intended to be passed to GSL functions (for
  e.g. solving, minimizing or fitting) that need to set a GSL vector
  or matrix, because one can simply copy into the passed-in pointer.
</p>
335
336
337
338
<p>There are two functions provided to extract the dimensions of a
  vector or array: <code>dim0</code> and <code>dim1</code>; the latter
  is applicable only for matrices.
</p>  
339
340
341
342
<p>If you
  use <a href="http://common-lisp.net/project/iterate/">iterate</a>,
  there are extensions defined that make it easier to iterate over
  marrays.  These are:
343
344
345
346
347
348
349
350
  <ul>
    <li><code>matrix-row</code>, <code>matrix-row-index</code></li>
    <li><code>matrix-column</code>, <code>matrix-column-index</code></li>
    <li><code>vector-element</code>, <code>vector-element-index</code></li>
    <li><code>matrix-element</code>, <code>matrix-element-index</code></li>
  </ul>
  <p>For example,
<pre>
Liam Healy's avatar
Liam Healy committed
351
(defparameter m1 #m(1 2 3 ^ 0 6 8))
352
353
354
(iter:iter (iter:for e :matrix-element m1) (princ e) (princ " "))
1.0 2.0 3.0 0.0 0.0 6.0 8.0
</pre>
Liam Healy's avatar
Liam Healy committed
355
356
357
 <h3>Passing functions</h3>
 <p>
 Functions that are passed to GSL functions (known as <i>callbacks</i>
Liam Healy's avatar
Liam Healy committed
358
359
360
361
 in C) are specified with a
 <a href="http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator">function
 designator</a> for the CL function, that is, either the function
 object itself or a symbol denoting the function.
362
363
364
365
 There is usually an option <code>scalarsp</code> for functions
 that take or return arrays that, if true, will
 send the user function the argument element by element, and expect
 the return values to be the individual elements. 
366
 </p>
Liam Healy's avatar
Liam Healy committed
367

Liam Healy's avatar
Liam Healy committed
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
 <h3>GSL objects</h3>
<p>
There are a number of GSL objects other than arrays that can be
created: 
<pre>
acceleration interpolation levin levin-truncated spline
nonlinear-ffit nonlinear-fdffit
one-dimensional-root-solver-f one-dimensional-root-solver-fdf
multi-dimensional-minimizer-f multi-dimensional-minimizer-fdf
fit-workspace one-dimensional-minimizer
multi-dimensional-root-solver-f multi-dimensional-root-solver-fdf
histogram histogram2d histogram-pdf histogram2d-pdf
basis-spline chebyshev hankel wavelet wavelet-workspace
random-number-generator quasi-random-number-generator discrete-random
polynomial-complex-workspace integration-workspace
383
qaws-table qawo-table
Liam Healy's avatar
Liam Healy committed
384
eigen-symm eigen-symmv eigen-herm eigen-hermv
385
386
eigen-nonsymm eigen-nonsymmv eigen-gensymm eigen-gensymmv
eigen-gen eigen-genv
Liam Healy's avatar
Liam Healy committed
387
monte-carlo-plain monte-carlo-miser monte-carlo-vegas
388
389
ode-stepper ode-evolution standard-control y-control
yp-control scaled-control
390
391
392
393
394
fft-real-wavetable-double-float fft-real-wavetable-single-float
fft-real-workspace-double-float fft-real-workspace-single-float
fft-complex-wavetable-double-float fft-complex-wavetable-single-float
fft-complex-workspace-double-float fft-complex-workspace-single-float
fft-half-complex-wavetable-double-float fft-half-complex-wavetable-single-float
Liam Healy's avatar
Liam Healy committed
395
396
</pre>
<p>
Liam Healy's avatar
Liam Healy committed
397
398
399
An instance may be created with a function whose name is "make-"
followed by the class name, e.g. <code>make-histogram</code>.  The
arguments that the function takes depends on the class.
Liam Healy's avatar
Liam Healy committed
400
401
402
403
404
405
406
407
408
409
</p>

 <h3>Additional definitions</h3>
<p>
Some definitions are provided because of their usefulness, even though
GSL doesn't have them.  
<ul>
  <li><code>invert-matrix</code> finds the inverse of a matrix and uses
  GSL's LU decomposition functions.</li>
  <li>IEEE floating point number analysis.</li>
410
411
412
413
414
415
416
417
418
419
420
421
422
  <li><code>fft-frequency-vector</code> returns a vector where the sample
  frequencies are contained. If you perform an FFT on a vector of a given size
  and :sample-size, this vector will contain the sample frequencies in order.
  If the :shifted keyword is T, then the frequencies are ordered in ascending
  order.</li>
  <li><code>fft-shift</code> returns a copy of a vector where the zero
  frequency has been shifted to the center; the frequency components will be
  sorted according to their frequency, in ascending order. Optionally, a
  :stride can be provided.</li>
  <li><code>fft-inverse-shift</code> performs the inverse action of fft-shift;
  the zero and positive frequency components are shifted to the beginning,
  so that the resulting vector is suitable for an inverse FFT. Optionally, a
  :stride can be provided.</li>
Liam Healy's avatar
Liam Healy committed
423
424
425
426
427
428
</ul>

<h2>Status</h2>
<a name="status"/>
<p>
GSLL is largely complete and usable, with functioning interfaces to
429
most of GSL.  Some functionality is not yet ported; see
Liam Healy's avatar
Liam Healy committed
430
431
432
433
434
435
436
<a href="missing-features.text">missing-features.text</a>
for more details.  Known bugs are documented in
<a href="status.text">status.text</a>.  Work is ongoing to both
remedy those deficiencies and to simplify the user interface by
changing more required arguments into optional or key arguments with
useful default values.  Typically, these arguments bind GSL objects
and arrays used internally or for function return.
Liam Healy's avatar
Liam Healy committed
437
438
439
440
441
442
443
444
445
446
447
448
449

<h2>Contact</h2>
<a name="contact"/>
<p>There is a <a
 href="http://common-lisp.net/cgi-bin/mailman/listinfo/gsll-devel">mailing
 list</a> for all aspects of this project, including bug reports.  In
 addition, I am frequently on #lisp IRC channel as LiamH.
</p>
</div>
<!-- Page published by Emacs Muse ends here -->
<div class="footer">
<hr>
<address><a href="mailto:gsll-devel@common-lisp.net">Liam Healy</a></address>
450
451
<!-- Created: Feb 25 2005 -->
<!-- hhmts start -->
Liam Healy's avatar
Liam Healy committed
452
<small>
453
Time-stamp: <2009-11-09 15:27:51EST index.html>
Liam Healy's avatar
Liam Healy committed
454
</small>
455
456
457
458
459
460
461
462
463
464
465
<!-- hhmts end -->
 </div>
<script type="text/javascript">
var gaJsHost = (("https:" == document.location.protocol) ? "https://ssl." : "http://www.");
document.write(unescape("%3Cscript src='" + gaJsHost + "google-analytics.com/ga.js' type='text/javascript'%3E%3C/script%3E"));
</script>
<script type="text/javascript">
var pageTracker = _gat._getTracker("UA-3669275-1");
pageTracker._initData();
pageTracker._trackPageview();
</script>
Liam Healy's avatar
Liam Healy committed
466
  </body>
467
</html>