GNU Scientific Library for Lisp

[1]GSLL

     * [2]About
     * [3]Examples
     * [4]Requirements
     * [5]Download
     * [6]Documentation
     * [7]Status
     * [8]Contact

About

   The GNU Scientific Library for Lisp (GSLL) allows you to use the [9]GNU
   Scientific Library (GSL) from [10]Common Lisp. 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.

   Topics include: polynomials, special functions, vectors and matrices,
   permutations, sorting, linear algebra including BLAS, eigensystems, fast Fourier
   transforms (FFT), quadrature, random numbers, 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 [11]missing-features.text on the status of some
   incomplete topics.

Examples

   The [12]Jacobian elliptic functions sn, cn, and dn are special functions (Chapter
   7):
(jacobian-elliptic-functions 0.2d0 0.81d0)
0.19762082367187703d0
0.9802785369736752d0
0.9840560289645665d0

   which returns as multiple values the three function values. The functions are
   defined only if the second argument m is not greater than 1, so an error is
   signalled if this parameter is out of range:
(jacobian-elliptic-functions 0.61802d0 1.5d0)
Input domain error |m| > 1.0 in elljac.c at line 46
   [Condition of type INPUT-DOMAIN]

   This is an ordinary Lisp error which may be handled with standard definitions
   available in Lisp. To take the [13]complex conjugate scalar product of two
   complex vectors of length 3:
(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)

   There are over 1500 examples available from within GSLL with the function
   examples. There is also a suite of over 4000 tests; many of the examples also
   serve as tests, and most others are ported from GSL's tests.

Download and Install

Download

   Use [14]quicklisp and follow the instructions. You will need to make sure that
   the libraries and header files associated with [15]GNU Scientific Library (GSL)
   and [16]libffi are installed; your distribution may name these libgsl0-dev and
   libffi-dev. Once they are installed and you have loaded the quicklisp file:
   (ql:quickload "gsll")

   To test your installation:
   (asdf:test-system :gsll)

   The result should look something like:
Unit Test Summary
 | 3997 assertions total
 | 3992 passed
 | 5 failed
 | 6 execution errors
 | 0 missing tests

   You may see more failures; if you are not on a 64 bit platform you will see fewer
   assertions.

License

   This software is distributed under the [17]GPL ; see the file COPYING. There is
   absolutely no warranty.

Documentation

General Advice

   The following techniques for using the API are advised:
     * Find the appropriate function(s) in the [18]GSL documentation.
     * Use the GSLL function gsl-lookup to find the equivalent GSLL function, for
       example
(gsl-lookup "gsl_sf_elljac_e")
JACOBIAN-ELLIPTIC-FUNCTIONS
T

       to find that the Lisp function name is #'jacobian-elliptic-functions.
     * Look at the documentation for that Lisp function, e.g.
(documentation #'jacobian-elliptic-functions 'function)
"The Jacobian elliptic functions sn(u|m),
  cn(u|m), dn(u|m) computed by descending Landen transformations".

       to get an explanation of the arguments etc.
     * Use the function (examples) 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 (examples
       'higher-moments). The result will be a list of forms, each providing an
       example of usage in the relevant topic. If the [19]GSL documentation provides
       an example, there will usually be the same or similar example provided in
       GSLL. Note: Some of the examples are intentionally designed to signal an
       error, because the examples also serve as a regression (unit) test suite for
       GSLL.

   Some examples are not yet present in, or are too complicated for, the function
   #'examples. In this case, you need to look in the relevant source file; they are
   in either a separate file of 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).

Arrays

   GSLL has many functions that work on vectors (one-dimensional arrays) and
   matrices (two-dimensional arrays). Foreign arrays are defined and manipulated
   using the [20]Antik which defines generic operations on array-like objects; see
   the Antik documentation for more information. GSLL supports all array element
   types that are supported by CFFI, the CL implementation, GSL, and the platform.
   This list is available in the variable grid:*array-element-types*.

Passing functions

   Functions that are passed to GSL functions (known as callbacks in C) are
   specified with a [21]function designator for the CL function, that is, either the
   function object itself or a symbol denoting the function. There is usually an
   option scalarsp 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.

GSL objects

   There are a number of GSL objects other than arrays that can be created:
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
qaws-table qawo-table
eigen-symm eigen-symmv eigen-herm eigen-hermv
eigen-nonsymm eigen-nonsymmv eigen-gensymm eigen-gensymmv
eigen-gen eigen-genv
monte-carlo-plain monte-carlo-miser monte-carlo-vegas
ode-stepper ode-evolution standard-control y-control
yp-control scaled-control
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

   An instance may be created with a function whose name is "make-" followed by the
   class name, e.g. make-histogram. The arguments that the function takes depends on
   the class.

Additional definitions

   Some definitions are provided because of their usefulness, even though GSL
   doesn't have them.
     * invert-matrix finds the inverse of a matrix and uses GSL's LU decomposition
       functions.
     * IEEE floating point number analysis.
     * fft-frequency-vector 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.
     * fft-shift 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.
     * fft-inverse-shift 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.

Status

   GSLL is largely complete and usable, with functioning interfaces to most of GSL.
   Some functionality is not yet ported; see [22]missing-features.text for more
   details. Known bugs are documented in [23]status.text. 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.

Contact

   There is a [24]mailing list for all aspects of this project, including bug
   reports. See also the [25]archives. In addition, I am frequently on #lisp IRC
   channel as LiamH. For bug reports, please use the mailing list. The
   [26]development site for GSLL has the git repository. If you have patch(es),
   please commit your changes and do:
git format-patch origin

   This will produce one or more files whose names start with a four-digit number;
   please attach them all to your email.
     ____________________________________________________________________________


    [27]Liam Healy

   Time-stamp: 

References

   1. https://gsll.common-lisp.dev/index.html
   2. https://gsll.common-lisp.dev/#about
   3. https://gsll.common-lisp.dev/#examples
   4. https://gsll.common-lisp.dev/#require
   5. https://gsll.common-lisp.dev/#getit
   6. https://gsll.common-lisp.dev/#documentation
   7. https://gsll.common-lisp.dev/#status
   8. https://gsll.common-lisp.dev/#contact
   9. http://www.gnu.org/software/gsl/
  10. http://www.lisp.org/
  11. https://gsll.common-lisp.dev/missing-features.text
  12. http://www.gnu.org/software/gsl/manual/html_node/Elliptic-Functions-_0028Jacobi_0029.html
  13. file:///usr/share/doc/gsl-ref-html/Level-1-GSL-BLAS-Interface.html
  14. http://www.quicklisp.org/
  15. http://www.gnu.org/software/gsl/
  16. http://sourceware.org/libffi/
  17. http://www.gnu.org/licenses/gpl.html
  18. http://www.gnu.org/software/gsl/manual/
  19. http://www.gnu.org/software/gsl/manual/
  20. http://www.common-lisp.net/project/antik/
  21. http://www.lispworks.com/documentation/HyperSpec/Body/26_glo_f.htm#function_designator
  22. https://gsll.common-lisp.dev/missing-features.text
  23. https://gsll.common-lisp.dev/status.text
  24. https://mailman.common-lisp.net/listinfo/gsll-devel
  25. https://mailman.common-lisp.net/pipermail/gsll-devel/
  26. https://gitlab.common-lisp.net/antik/gsll
  27. mailto:gsll-devel@common-lisp.net