  S-Lang GSL Module Reference
  John E. Davis, davis@space.mit.edu
  May 24, 2005
  ____________________________________________________________

                            Table of Contents

  1. Introduction to GSL
  2. Using the GSL Modules
  3. Error Handling
  4. gslinterp: The GSL Interpolation Module
  4.1. Interpolation Routines
  4.2. First Derivative via Interpolation
  4.3. Second Derivative via Interpolation
  4.4. Integration via Interpolation
  4.5. Low-level Interpolation Routines
  5. gslsf: The GSL Special Functions Module
  5.1. Airy Functions
  5.2. Bessel Functions
  5.3. Beta Functions
  5.4. Clausen Functions
  5.5. Conical Functions
  5.6. Coulomb Functions
  5.7. Debye Functions
  5.8. Di/Tri and Polygamma Functions
  5.9. Elliptic Integrals
  5.10. Error Functions
  5.11. Eta/Zeta Functions
  5.12. Exponential Functions and Integrals
  5.13. Fermi-Dirac Functions
  5.14. Gamma Functions
  5.15. Gegenbauer Functions
  5.16. Hypergeometric Functions
  5.17. Laguerre Functions
  5.18. Lambert Functions
  5.19. Legendre Functions and Spherical Harmonics
  5.20. Logarithm and Related Functions
  5.21. Transport Functions
  5.22. Miscellaneous Functions
  6. gslrand: The GSL Random Number Module
  6.1. Random Number Generation Routines
  6.2. Random Number Distributions
  6.3. PDF Functions
  7. gslfft: The GSL FFT module
  7.1. Fast Fourier Transform Routines
  8. gslcdf: The GSL Cumulative Distribution Function Module
  8.1. CDF Functions
  9. gslconst: The GSL Constants Module
  9.1. MKSA Constants
  9.2. CGSM Constants


  1.  Introduction to GSL

  The GNU Scientific Library (GSL <http://www.gnu.org/software/gsl/>) is
  a vast collection of robust and well documented numerical functions.
  It includes support for many special functions, random numbers,
  interpolation and integration routines, and much more.  For more
  information about GSL, visit  <http://www.gnu.org/software/gsl/>.

  Many of the routines in the GSL may be made available to the S-lang
  interpreter via the GSL modules described by this document, whose most
  recent version may be found at
  <http://space.mit.edu/CXC/software/slang/modules/gsl/>.

  At the moment, the following GSL modules are available:

  o  gslsf: The GSL special function module.  Currently, this module
     provides an interface to nearly 200 GSL special functions.

  o  gslconst: The GSL constants module.  This module defines many
     constants such as CONST_MKSA_SPEED_OF_LIGHT, CONST_CGSM_BOLTZMANN,
     etc.

  o  gslinterp: The GSL interpolation module, which includes routines
     for linear interpolation, cubic splines, etc.

  o  gslrand: The GSL random number module.  This module supports most
     of GSL's random number generators and distributions.

  o  gslcdf The GSL cumulative distribution function module.

  o  gslfft  The GSL fast-fourier transform module.

  o  gslcore: This is a module that must be loaded before any of the
     above modules can be loaded.  Its main purpose is to provide
     support functions for the other GSL modules.

  There are many functions that are not yet wrapped.  For example, none
  of GSL's ODE functions have been wrapped.  Future releases of the GSL
  module will include more functionality.  Nevertheless, what has been
  implemented should prove useful.

  2.  Using the GSL Modules

  To use one of the GSL modules in a S-lang script, it is first
  necessary to import the gslcore module before importing the desired
  GSL module.  For example, to load the GSL special function module, use

           import ("gslcore");
           import ("gslsf");

  Failure to first load the gslcore module may result in an error mes-
  sage such as

           Error linking to gslsf-module.so

  Another alternative is to load the gslsf.sl via

           () = evalfile ("gsl.sl");

  or, if the application supports the require function, via

           require ("gslsf");

  Similarly, the gsl.sl file exists as a convenient way to load all GSL
  modules (gslcore, gslsf, gslrand, gslconst, and gslinterp), i.e.,

           require ("gsl");

  Finally, it may be desirable to import the GSL module into a separate
  namespace.  For example, to load the GSL special function module gslsf
  into a namespace called gsl, use

           import ("gslcore", "gsl");
           import ("gslsf", "gsl");

  Then to access, e.g., the hypot function, use the gsl->hypot.  See the
  S-Lang documentation <http://www.s-lang.org/doc/html/slang.html> for
  more information about namespaces.

  Once the desired module has been loaded, intrinsics functions and
  variables defined by the module may be used in the usual way, e.g.,

      require ("gslsf");
          .
          .
      % Use the GSL hypot function to filter a list of (x,y) pairs
      % to those values that fall in a circle of radius R centered
      % on (0,0)
      define filter_region_in_circle (x, y, R)
      {
         variable i = where (hypot (x,y) < R);
         return (x[i], y[i]);
      }

  3.  Error Handling

  This section describes how the GSL modules handle errors reported by
  the GSL library.

  The following GSL error codes are defined by the gslcore module:

          GSL_EDOM        input domain error, e.g sqrt(-1)
          GSL_ERANGE      output range error, e.g. exp(1e100)
          GSL_EFAULT      invalid pointer
          GSL_EINVAL      invalid argument supplied by user
          GSL_EFAILED     generic failure
          GSL_EFACTOR     factorization failed
          GSL_ESANITY     sanity check failed - shouldn't happen
          GSL_ENOMEM      malloc failed
          GSL_EBADFUNC    problem with user-supplied function
          GSL_ERUNAWAY    iterative process is out of control
          GSL_EMAXITER    exceeded max number of iterations
          GSL_EZERODIV    tried to divide by zero
          GSL_EBADTOL     user specified an invalid tolerance
          GSL_ETOL        failed to reach the specified tolerance
          GSL_EUNDRFLW    underflow
          GSL_EOVRFLW     overflow
          GSL_ELOSS       loss of accuracy
          GSL_EROUND      failed because of roundoff error
          GSL_EBADLEN     matrix, vector lengths are not conformant
          GSL_ENOTSQR     matrix not square
          GSL_ESING       apparent singularity detected
          GSL_EDIVERGE    integral or series is divergent
          GSL_EUNSUP      requested feature is not supported by the hardware
          GSL_EUNIMPL     requested feature not (yet) implemented
          GSL_ECACHE      cache limit exceeded
          GSL_ETABLE      table limit exceeded
          GSL_ENOPROG     iteration is not making progress towards solution
          GSL_ENOPROGJ    jacobian evaluations are not improving the solution
          GSL_ETOLF       cannot reach the specified tolerance in F
          GSL_ETOLX       cannot reach the specified tolerance in X
          GSL_ETOLG       cannot reach the specified tolerance in gradient
          GSL_EOF         end of file

  The gsl_set_error_disposition function may be used to indicate how the
  module is to handle a specified error. It takes two arguments: an
  error code and a value controlling how the error is to be handled:

           gsl_set_error_disposition (error_code, control_value)

  If the control value is 0, the error will be ignored by the module.
  If the control value is 1, the module will print a warning message
  when the specified error is encountered.  If the control value is -1,
  the module will generate an exception when the error is encountered.
  For example,

           gsl_set_error_disposition (GSL_EDOM, -1);

  will cause domain errors to generate an exception, whereas

           gsl_set_error_disposition (GSL_EUNDRFLW, 0);

  will cause the GSL modules to ignore underflow errors.

  Alternatively, the control value may be the reference to a function to
  be called when the specified error occurs.  The function will be
  passed two arguments: a string whose value is the function name
  generating the error and the error code itself, e.g.,

           static define edom_callback (fname, err_code)
           {
              vmessage ("%s: domain error.", fname);
           }
           gsl_set_error_disposition (GSL_EDOM, &edom_callback);

           y = log_1plusx (-10);

  will result in the message "log_1plusx: domain error.".

  By default, all errors will generate exceptions except for the
  following, which will generate warnings:

          GSL_EDOM
          GSL_ERANGE
          GSL_EUNDRFLW
          GSL_EOVRFLW

  4.  gslinterp: The GSL Interpolation Module

  The gslinterp module provides S-Lang interpreter access to GSL's
  interpolations routines.  The interpolation methods include linear,
  polynomial, and spline interpolation.  Both Cubic and Akima splines
  are supported with normal or periodic boundary conditions. In
  addition, routines for computing first and second order derivatives,
  as well as integrals based upon these interpolation methods are
  included.

  The wrapping of these functions differs somewhat from the interface
  provided by the GSL API in the interest of ease of use.  The gslinterp
  modules actual defines two interfaces to the underlying GSL routines.

  The higher-level interface is the simplest to use and should suffice
  for most applications.  As an example of its use, suppose one has a
  set of (x,y) pairs represented by the arrays xa and ya that one wants
  to use for interpolation.  Then

           y = interp_cspline (x, xa, ya);

  will fit a cubic spline to the points and return the of the spline at
  the point x.  If x is an array, then the spline will be evaluated at
  each of the points in the array returning an array of the same shape.

  The low-level interface consists of several method-specific
  initialization functions and functions that carry out the actual
  interpolation.  The above example may be written in terms of this
  interface as

           c = interp_cspline_init (xa, ya);
           y = interp_eval (c, x);

  Here interp_cspline_init returns an object of type GSL_Interp_Type
  that represents the spline function.  It is then passed to the
  interp_eval function to evaluate the spline at x.

  The advantage of the lower level interface is that it moves the
  overhead associated with the computation of the interpolating function
  (the spline in the above example) out of the function that performs
  the interpolation.  This means that code such as

           c = interp_cspline_init (xa, ya);
           y0 = interp_eval (c, x0);
           y1 = interp_eval (c, x1);

  will execute in less time than

           y0 = interp_cspline (x0, xa, ya);
           y1 = interp_cspline (x1, xa, ya);

  4.1.  Interpolation Routines

  4.1.1.  interp_linear

      Synopsis
        Linear Interpolation

      Usage
        y = interp_linear (x, Double_Type xa[], Double_Type ya[])

      Description
        Use linear interpolation to determine the value at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_polynomial'', ``interp_cspline'',
        ``interp_cspline_periodic'', ``interp_akima'',
        ``interp_akima_periodic''

  4.1.2.  interp_polynomial

      Synopsis
        Polynomial Interpolation

      Usage
        y = interp_polynomial (x, Double_Type xa[], Double_Type ya[])

      Description
        Use polynomial interpolation to determine the value at x given
        the points (xa, ya).  The first argument, x, may be either a
        scalar or an array, and a result of the corresponding type will
        be returned.

        The degree of the interpolating polynomial is given by one less
        than the number of points in the xa array.  For example, if
        length(xa) is 3, then a quadratic polynomial will be used.

      See Also
        ``interp_linear'', ``interp_cspline'',
        ``interp_cspline_periodic'', ``interp_akima'',
        ``interp_akima_periodic''

  4.1.3.  interp_cspline

      Synopsis
        Cubic Spline Interpolation

      Usage
        y = interp_cspline (x, Double_Type xa[], Double_Type ya[])

      Description
        Use cubic spline interpolation with natural boundary conditions
        to determine the value at x given the points (xa, ya).  The
        first argument, x, may be either a scalar or an array, and a
        result of the corresponding type will be returned.
      See Also
        ``interp_linear'', ``interp_polynomial'',
        ``interp_cspline_periodic'', ``interp_akima'',
        ``interp_akima_periodic''

  4.1.4.  interp_cspline_periodic

      Synopsis
        Cubic spline interpolation with periodic boundary conditions

      Usage
        y = interp_cspline_periodic (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use cubic spline interpolation with periodic boundary conditions
        to determine the value at x given the points (xa, ya).  The
        first argument, x, may be either a scalar or an array, and a
        result of the corresponding type will be returned.

      See Also
        ``interp_linear'', ``interp_polynomial'', ``interp_cspline'',
        ``interp_akima'', ``interp_akima_periodic''

  4.1.5.  interp_akima

      Synopsis
        Akima spline interpolation

      Usage
        y = interp_akima (x, Double_Type xa[], Double_Type ya[])

      Description
        Use an Akima spline with natural boundary conditions to
        determine the value at x given the points (xa, ya).  The first
        argument, x, may be either a scalar or an array, and a result of
        the corresponding type will be returned.

      See Also
        ``interp_linear'', ``interp_polynomial'', ``interp_cspline'',
        ``interp_cspline_periodic'', ``interp_akima_periodic''

  4.1.6.  interp_akima_periodic

      Synopsis
        Akima spline interpolation with periodic boundary conditions

      Usage
        y = interp_akima_periodic (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use an Akima spline with periodic boundary conditions to
        determine the value at x given the points (xa, ya).  The first
        argument, x, may be either a scalar or an array, and a result of
        the corresponding type will be returned.

      See Also
        ``interp_linear'', ``interp_polynomial'', ``interp_cspline'',
        ``interp_cspline_periodic'', ``interp_akima''

  4.2.  First Derivative via Interpolation

  4.2.1.  interp_linear_deriv

      Synopsis
        Compute derivative using linear interpolation

      Usage
        y = interp_linear_deriv (x, Double_Type xa[], Double_Type ya[])

      Description
        Use linear interpolation to determine the value of the first
        derivative at x given the points (xa, ya).  The first argument,
        x, may be either a scalar or an array, and a result of the
        corresponding type will be returned.

      See Also
        ``interp_polynomial_deriv'', ``interp_cspline_deriv'',
        ``interp_cspline_periodic_deriv'', ``interp_akima_deriv'',
        ``interp_akima_periodic_deriv''

  4.2.2.  interp_polynomial_deriv

      Synopsis
        Compute derivative using polynomial interpolation

      Usage
        y = interp_polynomial_deriv (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use polynomial interpolation to determine the value of the first
        derivative at x given the points (xa, ya).  The first argument,
        x, may be either a scalar or an array, and a result of the
        corresponding type will be returned.

        The degree of the interpolating polynomial is given by one less
        than the number of points in the xa array.  For example, if
        length(xa) is 3, then a quadratic polynomial will be used.

      See Also
        ``interp_linear_deriv'', ``interp_cspline_deriv'',
        ``interp_cspline_periodic_deriv'', ``interp_akima_deriv'',
        ``interp_akima_periodic_deriv''

  4.2.3.  interp_cspline_deriv

      Synopsis
        Compute derivative using a cubic spline

      Usage
        y = interp_cspline_deriv (x, Double_Type xa[], Double_Type ya[])

      Description
        Use cubic spline interpolation with natural boundary conditions
        to determine the value of the first derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv'', ``interp_polynomial_deriv'',
        ``interp_cspline_periodic_deriv'', ``interp_akima_deriv'',
        ``interp_akima_periodic_deriv''

  4.2.4.  interp_cspline_periodic_deriv

      Synopsis
        Compute derivative using a cubic spline

      Usage
        y = interp_cspline_periodic_deriv (x, Double_Type xa[],
        Double_Type ya[])

      Description
        Use cubic spline interpolation with periodic boundary conditions
        to determine the value of the first derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv'', ``interp_polynomial_deriv'',
        ``interp_cspline_deriv'', ``interp_akima_deriv'',
        ``interp_akima_periodic_deriv''

  4.2.5.  interp_akima_deriv

      Synopsis
        Compute derivative using an Akima spline

      Usage
        y = interp_akima_deriv (x, Double_Type xa[], Double_Type ya[])

      Description
        Use Akima spline interpolation with natural boundary conditions
        to determine the value of the first derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv'', ``interp_polynomial_deriv'',
        ``interp_cspline_deriv'', ``interp_cspline_periodic_deriv'',
        ``interp_akima_periodic_deriv''

  4.2.6.  interp_akima_periodic_deriv

      Synopsis
        Compute derivative using an Akima spline

      Usage
        y = interp_cspline_deriv (x, Double_Type xa[], Double_Type ya[])

      Description
        Use Akima spline interpolation with periodic boundary conditions
        to determine the value of the first derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv'', ``interp_polynomial_deriv'',
        ``interp_cspline_deriv'', ``interp_cspline_periodic_deriv'',
        ``interp_akima_deriv''

  4.3.  Second Derivative via Interpolation

  4.3.1.  interp_linear_deriv2

      Synopsis
        Compute second derivative using linear interpolation

      Usage
        y = interp_linear_deriv2 (x, Double_Type xa[], Double_Type ya[])

      Description
        Use linear interpolation to determine the value of the second
        derivative at x given the points (xa, ya).  The first argument,
        x, may be either a scalar or an array, and a result of the
        corresponding type will be returned.

      See Also
        ``interp_polynomial_deriv2'', ``interp_cspline_deriv2'',
        ``interp_cspline_periodic_deriv2'', ``interp_akima_deriv2'',
        ``interp_akima_periodic_deriv2''

  4.3.2.  interp_polynomial_deriv2

      Synopsis
        Compute second derivative using polynomial interpolation

      Usage
        y = interp_polynomial_deriv2 (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use polynomial interpolation to determine the value of the
        second derivative at x given the points (xa, ya).  The first
        argument, x, may be either a scalar or an array, and a result of
        the corresponding type will be returned.
        The degree of the interpolating polynomial is given by one less
        than the number of points in the xa array.  For example, if
        length(xa) is 3, then a quadratic polynomial will be used.

      See Also
        ``interp_linear_deriv2'', ``interp_cspline_deriv2'',
        ``interp_cspline_periodic_deriv2'', ``interp_akima_deriv2'',
        ``interp_akima_periodic_deriv2''

  4.3.3.  interp_cspline_deriv2

      Synopsis
        Compute second derivative using a cubic spline

      Usage
        y = interp_cspline_deriv2 (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use cubic spline interpolation with natural boundary conditions
        to determine the value of the second derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv2'', ``interp_polynomial_deriv2'',
        ``interp_cspline_periodic_deriv2'', ``interp_akima_deriv2'',
        ``interp_akima_periodic_deriv2''

  4.3.4.  interp_cspline_periodic_deriv2

      Synopsis
        Compute second derivative using a cubic spline

      Usage
        y = interp_cspline_periodic_deriv2 (x, Double_Type xa[],
        Double_Type ya[])

      Description
        Use cubic spline interpolation with periodic boundary conditions
        to determine the value of the second derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv2'', ``interp_polynomial_deriv2'',
        ``interp_cspline_deriv2'', ``interp_akima_deriv2'',
        ``interp_akima_periodic_deriv2''

  4.3.5.  interp_akima_deriv2

      Synopsis
        Compute second derivative using an Akima spline

      Usage
        y = interp_akima_deriv2 (x, Double_Type xa[], Double_Type ya[])

      Description
        Use Akima spline interpolation with natural boundary conditions
        to determine the value of the second derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv2'', ``interp_polynomial_deriv2'',
        ``interp_cspline_deriv2'', ``interp_cspline_periodic_deriv2'',
        ``interp_akima_periodic_deriv2''

  4.3.6.  interp_akima_periodic_deriv2

      Synopsis
        Compute second derivative using an Akima spline

      Usage
        y = interp_cspline_deriv2 (x, Double_Type xa[], Double_Type
        ya[])

      Description
        Use Akima spline interpolation with periodic boundary conditions
        to determine the value of the second derivative at x given the
        points (xa, ya).  The first argument, x, may be either a scalar
        or an array, and a result of the corresponding type will be
        returned.

      See Also
        ``interp_linear_deriv2'', ``interp_polynomial_deriv2'',
        ``interp_cspline_deriv2'', ``interp_cspline_periodic_deriv2'',
        ``interp_akima_deriv2'', ``interp_akima_periodic_deriv2''

  4.4.  Integration via Interpolation

  4.4.1.  interp_linear_integ

      Synopsis
        Compute an integral using linear interpolation

      Usage
        y = interp_linear_integ (Double_Type xa[], Double_Type ya[], a,
        b)

      Description
        This function computes the integral from a to b of the linear
        interpolating function associated with the set of points (xa,
        ya).  See interp_linear for more information about the
        interpolating function.

      See Also
        ``interp_polynomial_integ'', ``interp_cspline_integ'',
        ``interp_cspline_periodic_integ'', ``interp_akima_integ'',
        ``interp_akima_periodic_integ''
  4.4.2.  interp_polynomial_integ

      Synopsis
        Compute an integral using polynomial interpolation

      Usage
        y = interp_polynomial_integ (Double_Type xa[], Double_Type ya[],
        a, b)

      Description
        This function computes the integral from a to b of the
        polynomial interpolating function associated with the set of
        points (xa, ya).  See interp_polynomial for more information
        about the interpolating function.

      See Also
        ``interp_linear_integ'', ``interp_cspline_integ'',
        ``interp_cspline_periodic_integ'', ``interp_akima_integ'',
        ``interp_akima_periodic_integ''

  4.4.3.  interp_cspline_integ

      Synopsis
        Compute an integral using a cubic spline

      Usage
        y = interp_cspline_integ (Double_Type xa[], Double_Type ya[], a,
        b)

      Description
        This function computes the integral from a to b of the cubic
        spline interpolating function associated with the set of points
        (xa, ya).  See interp_cspline for more information about the
        interpolating function.

      See Also
        ``interp_linear_integ'', ``interp_polynomial_integ'',
        ``interp_cspline_periodic_integ'', ``interp_akima_integ'',
        ``interp_akima_periodic_integ''

  4.4.4.  interp_cspline_periodic_integ

      Synopsis
        Compute an integral using a cubic spline

      Usage
        y = interp_cspline_periodic_integ (Double_Type xa[], Double_Type
        ya[], a, b)

      Description
        This function computes the integral from a to b of the cubic
        spline interpolating function associated with the set of points
        (xa, ya).  See interp_cspline_periodic for more information
        about the interpolating function.

      See Also
        ``interp_linear_integ'', ``interp_polynomial_integ'',
        ``interp_cspline_integ'', ``interp_akima_integ'',
        ``interp_akima_periodic_integ''
  4.4.5.  interp_akima_integ

      Synopsis
        Compute an integral using an Akima spline

      Usage
        y = interp_akima_integ (Double_Type xa[], Double_Type ya[], a,
        b)

      Description
        This function computes the integral from a to b of the Akima
        spline interpolating function associated with the set of points
        (xa, ya).  See interp_akima for more information about the
        interpolating function.

      See Also
        ``interp_linear_integ'', ``interp_polynomial_integ'',
        ``interp_cspline_integ'', ``interp_cspline_periodic_integ'',
        ``interp_akima_periodic_integ''

  4.4.6.  interp_akima_periodic_integ

      Synopsis
        Compute an integral using an Akima spline

      Usage
        y = interp_cspline_integ (Double_Type xa[], Double_Type ya[], a,
        b)

      Description
        This function computes the integral from a to b of the Akima
        spline interpolating function associated with the set of points
        (xa, ya).  See interp_akima_periodic for more information about
        the interpolating function.

      See Also
        ``interp_linear_integ'', ``interp_polynomial_integ'',
        ``interp_cspline_integ'', ``interp_cspline_periodic_integ'',
        ``interp_akima_integ''

  4.5.  Low-level Interpolation Routines

  4.5.1.  interp_linear_init

      Synopsis
        Compute a linear interpolation object

      Usage
        GSL_Interp_Type interp_linear_init (Double_Type_Type xa[],
        Double_Type_Type ya[])

      Description
        This function computes an interpolation object appropriate for
        linear interpolation on the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_polynomial_init'',
        ``interp_cspline_init'', ``interp_cspline_periodic_init'',
        ``interp_akima_init'', ``interp_akima_periodic_init''

  4.5.2.  interp_polynomial_init

      Synopsis
        Compute a polynomial interpolation object

      Usage
        GSL_Interp_Type interp_polynomial_init (Double_Type xa[],
        Double_Type ya[])

      Description
        This function computes an interpolation object appropriate for
        polynomial interpolation on the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_linear_init'',
        ``interp_cspline_init'', ``interp_cspline_periodic_init'',
        ``interp_akima_init'', ``interp_akima_periodic_init''

  4.5.3.  interp_cspline_init

      Synopsis
        Compute a cubic spline Interpolation object

      Usage
        GSL_Interp_Type interp_cspline_init (Double_Type xa[],
        Double_Type ya[])

      Description
        This function computes an interpolation object appropriate for
        cubic spline interpolation with natural boundary conditions on
        the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_linear_init'',
        ``interp_polynomial_init'', ``interp_cspline_periodic_init'',
        ``interp_akima_init'', ``interp_akima_periodic_init''

  4.5.4.  interp_cspline_periodic_init

      Synopsis
        Compute a cubic spline interpolation object

      Usage
        GSL_Interp_Type interp_cspline_periodic_init (Double_Type xa[],
        Double_Type ya[])

      Description
        This function computes an interpolation object appropriate for
        cubic spline interpolation with periodic boundary conditions on
        the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_linear_init'',
        ``interp_polynomial_init'', ``interp_cspline_init'',
        ``interp_akima_init'', ``interp_akima_periodic_init''

  4.5.5.  interp_akima_init

      Synopsis
        Compute an Akima spline interpolation object

      Usage
        GSL_Interp_Type interp_akima_init (Double_Type xa[], Double_Type
        ya[])

      Description
        This function computes an interpolation object appropriate for
        Akima spline interpolation with natural boundary conditions on
        the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_linear_init'',
        ``interp_polynomial_init'', ``interp_cspline_init'',
        ``interp_cspline_periodic_init'', ``interp_akima_periodic_init''

  4.5.6.  interp_akima_periodic_init

      Synopsis
        Compute an Akima spline interpolation object

      Usage
        GSL_Interp_Type interp_akima_periodic_init (Double_Type xa[],
        Double_Type ya[])

      Description
        This function computes an interpolation object appropriate for
        Akima spline interpolation with periodic boundary conditions on
        the specified xa and ya arrays.

      See Also
        ``interp_eval'', ``interp_linear_init'',
        ``interp_polynomial_init'', ``interp_cspline_init'',
        ``interp_cspline_periodic_init'', ``interp_akima_periodic''

  4.5.7.  interp_eval

      Synopsis
        Evaluate an interpolation object

      Usage
        y = interp_eval (GSL_Interp_Type c, x)

      Description
        Use the precomputed interpolation object c to interpolate its
        value at x, which may be either a scalar or an array.  An
        interpolated value of the corresponding shape will be returned.

      See Also
        ``interp_linear_init'', ``interp_eval_deriv'',
        ``interp_eval_deriv2'', ``interp_eval_integ''

  4.5.8.  interp_eval_deriv

      Synopsis
        Evaluate the derivative of an interpolation object

      Usage
        dydx = interp_eval_deriv (GSL_Interp_Type c, x)

      Description
        Use the precomputed interpolation object c to interpolate its
        first derivative at x, which may be either a scalar or an array.
        An interpolated value of the corresponding shape will be
        returned.

      See Also
        ``interp_linear_init'', ``interp_eval'', ``interp_eval_deriv2'',
        ``interp_eval_integ''

  4.5.9.  interp_eval_deriv2

      Synopsis
        Evaluate the derivative of an interpolation object

      Usage
        d2ydx2 = interp_eval_deriv2 (GSL_Interp_Type c, x)

      Description
        Use the precomputed interpolation object c to interpolate its
        second derivative at x, which may be either a scalar or an
        array.  An interpolated value of the corresponding shape will be
        returned.

      See Also
        ``interp_linear_init'', ``interp_eval'', ``interp_eval_deriv'',
        ``interp_eval_integ''

  4.5.10.  interp_eval_integ

      Synopsis
        Compute the integral of an interpolation object

      Usage
        d2ydx2 = interp_eval_deriv2 (GSL_Interp_Type c, a, b)

      Description
        Use the precomputed interpolation object c to interpolate its
        integral from a to b.

      See Also
        ``interp_linear_init'', ``interp_eval'', ``interp_eval_deriv'',
        ``interp_eval_deriv2''

  5.  gslsf: The GSL Special Functions Module

  The special function module, gslsf, wraps nearly 200 GSL special
  functions.  Since the special functions are described in detail in the
  documentation for the GSL library
  <http://www.gnu.org/software/gsl/manual/gsl-ref_toc.html>, no attempt
  will be made here to duplicate the main documentation.  Rather, a
  description of how the special functions have been wrapped by the
  module is given.

  GSL prefixes the special functions with the string gsl_sf_.  This
  prefix is omitted from the corresponding intrinsic functions of the
  gslsf module.  For example, the GSL function that computes spherical
  harmonics is called gsl_sf_legendre_sphPlm.  However, it is
  represented in the module by simply legendre_sphPlm.

  Most of GSL's special functions take scalar arguments and returns a
  scalar.  For example, gsl_sf_legendre_sphPlm takes three arguments
  (int, int, and a double) and returns a double, e.g.,

           int l = 5, m = 0;
           double x = 0.5;
           double y = gsl_sf_legendre_sphPlm (l, m, x);

  While the module supports the scalar usage, e.g,

           variable l = 5, m = 0, x = 0.5;
           variable y = legendre_sphPlm (l, m, x);

  it also supports vector arguments, e.g.,

           variable l = 5, m = 0, x = [-1:1:0.1];
           variable y = legendre_sphPlm (l, m, x);

  and

           variable l = 5, m = [0:l], x = 0.5;
           variable y = legendre_sphPlm (l, m, x);

  Some of the functions are expensive to compute to full double
  precision accuracy.  In the interest of speed, it may want to perform
  perform the computation with less precision.  Hence, several of the
  special functions take an optional mode argument that specifies the
  desired precision: GSL_PREC_DOUBLE for double precision accuracy,
  GSL_PREC_SINGLE for single precision accuracy, and GSL_PREC_APPROX for
  a relative accuracy of 5e-4.  For example, to compute the Airy
  function to double precision accuracy use:

       y = airy_Ai (x, GSL_PREC_DOUBLE);

  If called without the mode argument, i.e.,

            y = airy_Ai (x);

  the function will be computed to a default precision of GSL_PREC_SIN-
  GLE.  The default precision can be set and queried by the
  gslsf_set_precision and gslsf_get_precision functions, resp.  Func-
  tions that do not take the optional mode argument will always be com-
  puted at full precision.

  5.1.  Airy Functions

  5.1.1.  airy_Ai

      Synopsis
        S-Lang version of gsl_sf_airy_Ai

      Usage
        Double_Type[] airy_Ai (Double_Type[] x [,Int_Type mode])

  5.1.2.  airy_Ai_deriv

      Synopsis
        S-Lang version of gsl_sf_airy_Ai_deriv

      Usage
        Double_Type[] airy_Ai_deriv (Double_Type[] x [,Int_Type mode])

  5.1.3.  airy_Ai_deriv_scaled

      Synopsis
        S-Lang version of gsl_sf_airy_Ai_deriv_scaled

      Usage
        Double_Type[] airy_Ai_deriv_scaled (Double_Type[] x [,Int_Type
        mode])

  5.1.4.  airy_Ai_scaled

      Synopsis
        S-Lang version of gsl_sf_airy_Ai_scaled

      Usage
        Double_Type[] airy_Ai_scaled (Double_Type[] x [,Int_Type mode])

  5.1.5.  airy_Bi

      Synopsis
        S-Lang version of gsl_sf_airy_Bi

      Usage
        Double_Type[] airy_Bi (Double_Type[] x [,Int_Type mode])

  5.1.6.  airy_Bi_deriv

      Synopsis
        S-Lang version of gsl_sf_airy_Bi_deriv

      Usage
        Double_Type[] airy_Bi_deriv (Double_Type[] x [,Int_Type mode])

  5.1.7.  airy_Bi_deriv_scaled

      Synopsis
        S-Lang version of gsl_sf_airy_Bi_deriv_scaled

      Usage
        Double_Type[] airy_Bi_deriv_scaled (Double_Type[] x [,Int_Type
        mode])

  5.1.8.  airy_Bi_scaled

      Synopsis
        S-Lang version of gsl_sf_airy_Bi_scaled

      Usage
        Double_Type[] airy_Bi_scaled (Double_Type[] x [,Int_Type mode])

  5.2.  Bessel Functions

  5.2.1.  bessel_I0

      Synopsis
        S-Lang version of gsl_sf_bessel_I0

      Usage
        Double_Type[] bessel_I0 (Double_Type[] x)

  5.2.2.  bessel_I0_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_I0_scaled

      Usage
        Double_Type[] bessel_I0_scaled (Double_Type[] x)

  5.2.3.  bessel_i0_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_i0_scaled

      Usage
        Double_Type[] bessel_i0_scaled (Double_Type[] x)

  5.2.4.  bessel_I1

      Synopsis
        S-Lang version of gsl_sf_bessel_I1

      Usage
        Double_Type[] bessel_I1 (Double_Type[] x)

  5.2.5.  bessel_i1_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_i1_scaled

      Usage
        Double_Type[] bessel_i1_scaled (Double_Type[] x)

  5.2.6.  bessel_I1_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_I1_scaled

      Usage
        Double_Type[] bessel_I1_scaled (Double_Type[] x)

  5.2.7.  bessel_i2_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_i2_scaled

      Usage
        Double_Type[] bessel_i2_scaled (Double_Type[] x)

  5.2.8.  bessel_il_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_il_scaled

      Usage
        Double_Type[] bessel_il_scaled (Int_Type[] l, Double_Type[] x)

  5.2.9.  bessel_In

      Synopsis
        S-Lang version of gsl_sf_bessel_In

      Usage
        Double_Type[] bessel_In (Int_Type[] n, Double_Type[] x)

  5.2.10.  bessel_In_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_In_scaled

      Usage
        Double_Type[] bessel_In_scaled (Int_Type[] n, Double_Type[] x)

  5.2.11.  bessel_Inu

      Synopsis
        S-Lang version of gsl_sf_bessel_Inu

      Usage
        Double_Type[] bessel_Inu (Double_Type[] nu, Double_Type[] x)

  5.2.12.  bessel_Inu_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_Inu_scaled

      Usage
        Double_Type[] bessel_Inu_scaled (Double_Type[] nu, Double_Type[]
        x)

  5.2.13.  bessel_J0

      Synopsis
        S-Lang version of gsl_sf_bessel_J0

      Usage
        Double_Type[] bessel_J0 (Double_Type[] x)

  5.2.14.  bessel_j0

      Synopsis
        S-Lang version of gsl_sf_bessel_j0
      Usage
        Double_Type[] bessel_j0 (Double_Type[] x)

  5.2.15.  bessel_j1

      Synopsis
        S-Lang version of gsl_sf_bessel_j1

      Usage
        Double_Type[] bessel_j1 (Double_Type[] x)

  5.2.16.  bessel_J1

      Synopsis
        S-Lang version of gsl_sf_bessel_J1

      Usage
        Double_Type[] bessel_J1 (Double_Type[] x)

  5.2.17.  bessel_j2

      Synopsis
        S-Lang version of gsl_sf_bessel_j2

      Usage
        Double_Type[] bessel_j2 (Double_Type[] x)

  5.2.18.  bessel_jl

      Synopsis
        S-Lang version of gsl_sf_bessel_jl

      Usage
        Double_Type[] bessel_jl (Int_Type[] l, Double_Type[] x)

  5.2.19.  bessel_Jn

      Synopsis
        S-Lang version of gsl_sf_bessel_Jn

      Usage
        Double_Type[] bessel_Jn (Int_Type[] n, Double_Type[] x)

  5.2.20.  bessel_Jnu

      Synopsis
        S-Lang version of gsl_sf_bessel_Jnu

      Usage
        Double_Type[] bessel_Jnu (Double_Type[] nu, Double_Type[] x)

  5.2.21.  bessel_K0

      Synopsis
        S-Lang version of gsl_sf_bessel_K0

      Usage
        Double_Type[] bessel_K0 (Double_Type[] x)

  5.2.22.  bessel_K0_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_K0_scaled

      Usage
        Double_Type[] bessel_K0_scaled (Double_Type[] x)

  5.2.23.  bessel_k0_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_k0_scaled

      Usage
        Double_Type[] bessel_k0_scaled (Double_Type[] x)

  5.2.24.  bessel_K1

      Synopsis
        S-Lang version of gsl_sf_bessel_K1

      Usage
        Double_Type[] bessel_K1 (Double_Type[] x)

  5.2.25.  bessel_K1_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_K1_scaled

      Usage
        Double_Type[] bessel_K1_scaled (Double_Type[] x)

  5.2.26.  bessel_k1_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_k1_scaled

      Usage
        Double_Type[] bessel_k1_scaled (Double_Type[] x)

  5.2.27.  bessel_k2_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_k2_scaled

      Usage
        Double_Type[] bessel_k2_scaled (Double_Type[] x)

  5.2.28.  bessel_kl_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_kl_scaled

      Usage
        Double_Type[] bessel_kl_scaled (Int_Type[] l, Double_Type[] x)

  5.2.29.  bessel_Kn

      Synopsis
        S-Lang version of gsl_sf_bessel_Kn

      Usage
        Double_Type[] bessel_Kn (Int_Type[] n, Double_Type[] x)

  5.2.30.  bessel_Kn_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_Kn_scaled

      Usage
        Double_Type[] bessel_Kn_scaled (Int_Type[] n, Double_Type[] x)

  5.2.31.  bessel_Knu

      Synopsis
        S-Lang version of gsl_sf_bessel_Knu

      Usage
        Double_Type[] bessel_Knu (Double_Type[] nu, Double_Type[] x)

  5.2.32.  bessel_Knu_scaled

      Synopsis
        S-Lang version of gsl_sf_bessel_Knu_scaled

      Usage
        Double_Type[] bessel_Knu_scaled (Double_Type[] nu, Double_Type[]
        x)

  5.2.33.  bessel_lnKnu

      Synopsis
        S-Lang version of gsl_sf_bessel_lnKnu

      Usage
        Double_Type[] bessel_lnKnu (Double_Type[] nu, Double_Type[] x)

  5.2.34.  bessel_Y0

      Synopsis
        S-Lang version of gsl_sf_bessel_Y0

      Usage
        Double_Type[] bessel_Y0 (Double_Type[] x)

  5.2.35.  bessel_y0

      Synopsis
        S-Lang version of gsl_sf_bessel_y0

      Usage
        Double_Type[] bessel_y0 (Double_Type[] x)

  5.2.36.  bessel_y1

      Synopsis
        S-Lang version of gsl_sf_bessel_y1

      Usage
        Double_Type[] bessel_y1 (Double_Type[] x)

  5.2.37.  bessel_Y1

      Synopsis
        S-Lang version of gsl_sf_bessel_Y1

      Usage
        Double_Type[] bessel_Y1 (Double_Type[] x)

  5.2.38.  bessel_y2

      Synopsis
        S-Lang version of gsl_sf_bessel_y2
      Usage
        Double_Type[] bessel_y2 (Double_Type[] x)

  5.2.39.  bessel_yl

      Synopsis
        S-Lang version of gsl_sf_bessel_yl

      Usage
        Double_Type[] bessel_yl (Int_Type[] l, Double_Type[] x)

  5.2.40.  bessel_Yn

      Synopsis
        S-Lang version of gsl_sf_bessel_Yn

      Usage
        Double_Type[] bessel_Yn (Int_Type[] n, Double_Type[] x)

  5.2.41.  bessel_Ynu

      Synopsis
        S-Lang version of gsl_sf_bessel_Ynu

      Usage
        Double_Type[] bessel_Ynu (Double_Type[] nu, Double_Type[] x)

  5.3.  Beta Functions

  5.3.1.  beta

      Synopsis
        S-Lang version of gsl_sf_beta

      Usage
        Double_Type[] beta (Double_Type[] a, Double_Type[] b)

  5.3.2.  beta_inc

      Synopsis
        S-Lang version of gsl_sf_beta_inc

      Usage
        Double_Type[] beta_inc (Double_Type[] a, Double_Type[] b,
        Double_Type[] x)

  5.3.3.  lnbeta

      Synopsis
        S-Lang version of gsl_sf_lnbeta

      Usage
        Double_Type[] lnbeta (Double_Type[] a, Double_Type[] b)

  5.4.  Clausen Functions

  5.4.1.  clausen

      Synopsis
        S-Lang version of gsl_sf_clausen

      Usage
        Double_Type[] clausen (Double_Type[] x)

  5.5.  Conical Functions

  5.5.1.  conicalP_0

      Synopsis
        S-Lang version of gsl_sf_conicalP_0

      Usage
        Double_Type[] conicalP_0 (Double_Type[] lambda, Double_Type[] x)

  5.5.2.  conicalP_1

      Synopsis
        S-Lang version of gsl_sf_conicalP_1

      Usage
        Double_Type[] conicalP_1 (Double_Type[] lambda, Double_Type[] x)

  5.5.3.  conicalP_cyl_reg

      Synopsis
        S-Lang version of gsl_sf_conicalP_cyl_reg

      Usage
        Double_Type[] conicalP_cyl_reg (m, lambda, x)

            Int_Type[] m
            Double_Type[] lambda
            Double_Type[] x

  5.5.4.  conicalP_half

      Synopsis
        S-Lang version of gsl_sf_conicalP_half

      Usage
        Double_Type[] conicalP_half (Double_Type[] lambda, Double_Type[]
        x)

  5.5.5.  conicalP_mhalf

      Synopsis
        S-Lang version of gsl_sf_conicalP_mhalf

      Usage
        Double_Type[] conicalP_mhalf (Double_Type[] lambda,
        Double_Type[] x)

  5.5.6.  conicalP_sph_reg

      Synopsis
        S-Lang version of gsl_sf_conicalP_sph_reg

      Usage
        Double_Type[] conicalP_sph_reg (l, lambda, x)

            Int_Type[] l
            Double_Type[] lambda
            Double_Type[] x

  5.6.  Coulomb Functions

  5.6.1.  hydrogenicR

      Synopsis
        S-Lang version of gsl_sf_hydrogenicR

      Usage
        Double_Type[] hydrogenicR (n, l, Z, r)

            Int_Type[] n
            Int_Type[] l
            Double_Type[] Z
            Double_Type[] r

  5.6.2.  hydrogenicR_1

      Synopsis
        S-Lang version of gsl_sf_hydrogenicR_1

      Usage
        Double_Type[] hydrogenicR_1 (Double_Type[] Z, Double_Type[] r)

  5.7.  Debye Functions

  5.7.1.  debye_1

      Synopsis
        S-Lang version of gsl_sf_debye_1

      Usage
        Double_Type[] debye_1 (Double_Type[] x)

  5.7.2.  debye_2

      Synopsis
        S-Lang version of gsl_sf_debye_2

      Usage
        Double_Type[] debye_2 (Double_Type[] x)

  5.7.3.  debye_3

      Synopsis
        S-Lang version of gsl_sf_debye_3

      Usage
        Double_Type[] debye_3 (Double_Type[] x)

  5.7.4.  debye_4

      Synopsis
        S-Lang version of gsl_sf_debye_4

      Usage
        Double_Type[] debye_4 (Double_Type[] x)

  5.8.  Di/Tri and Polygamma Functions

  5.8.1.  psi

      Synopsis
        S-Lang version of gsl_sf_psi
      Usage
        Double_Type[] psi (Double_Type[] x)

  5.8.2.  psi_1_int

      Synopsis
        S-Lang version of gsl_sf_psi_1_int

      Usage
        Double_Type[] psi_1_int (Int_Type[] n)

  5.8.3.  psi_1piy

      Synopsis
        S-Lang version of gsl_sf_psi_1piy

      Usage
        Double_Type[] psi_1piy (Double_Type[] y)

  5.8.4.  psi_int

      Synopsis
        S-Lang version of gsl_sf_psi_int

      Usage
        Double_Type[] psi_int (Int_Type[] n)

  5.8.5.  psi_n

      Synopsis
        S-Lang version of gsl_sf_psi_n

      Usage
        Double_Type[] psi_n (Int_Type[] n, Double_Type[] x)

  5.9.  Elliptic Integrals

  5.9.1.  ellint_D

      Synopsis
        S-Lang version of gsl_sf_ellint_D

      Usage
        Double_Type[] ellint_D (phi, k, n [,mode])

       Double_Type[] phi
       Double_Type[] k
       Double_Type[] n
       Int_Type mode

  5.9.2.  ellint_E

      Synopsis
        S-Lang version of gsl_sf_ellint_E

      Usage
        Double_Type[] ellint_E (phi, k [,mode])

            Double_Type[] phi
            Double_Type[] k
            Int_Type mode

  5.9.3.  ellint_Ecomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Ecomp

      Usage
        Double_Type[] ellint_Ecomp (Double_Type[] k [,Int_Type mode])

  5.9.4.  ellint_F

      Synopsis
        S-Lang version of gsl_sf_ellint_F

      Usage
        Double_Type[] ellint_F (phi, k [,mode])

            Double_Type[] phi
            Double_Type[] k
            Int_Type mode

  5.9.5.  ellint_Kcomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Kcomp

      Usage
        Double_Type[] ellint_Kcomp (Double_Type[] k [,Int_Type mode])

  5.9.6.  ellint_P

      Synopsis
        S-Lang version of gsl_sf_ellint_P

      Usage
        Double_Type[] ellint_P (phi, k, n [,mode])

            Double_Type[] phi
            Double_Type[] k
            Double_Type[] n
            Int_Type mode

  5.9.7.  ellint_RC

      Synopsis
        S-Lang version of gsl_sf_ellint_RC

      Usage
        Double_Type[] ellint_RC (Double_Type[] x, Double_Type[] y
        [,Int_Type mode])

  5.9.8.  ellint_RD

      Synopsis
        S-Lang version of gsl_sf_ellint_RD

      Usage
        Double_Type[] ellint_RD (x, y, z [,mode])

            Double_Type[] x
            Double_Type[] y
            Double_Type[] z
            Int_Type mode

  5.9.9.  ellint_RF

      Synopsis
        S-Lang version of gsl_sf_ellint_RF

      Usage
        Double_Type[] ellint_RF (x, y, z [,mode])

       Double_Type[] x
       Double_Type[] y
       Double_Type[] z
       Int_Type mode

  5.9.10.  ellint_RJ

      Synopsis
        S-Lang version of gsl_sf_ellint_RJ

      Usage
        Double_Type[] ellint_RJ (x, y, z, p [,mode])

            Double_Type[] x
            Double_Type[] y
            Double_Type[] z
            Double_Type[] p
            Int_Type mode

  5.10.  Error Functions

  5.10.1.  erf

      Synopsis
        S-Lang version of gsl_sf_erf

      Usage
        Double_Type[] erf (Double_Type[] x)

  5.10.2.  erf_Q

      Synopsis
        S-Lang version of gsl_sf_erf_Q

      Usage
        Double_Type[] erf_Q (Double_Type[] x)

  5.10.3.  erf_Z

      Synopsis
        S-Lang version of gsl_sf_erf_Z

      Usage
        Double_Type[] erf_Z (Double_Type[] x)

  5.10.4.  erfc

      Synopsis
        S-Lang version of gsl_sf_erfc

      Usage
        Double_Type[] erfc (Double_Type[] x)

  5.10.5.  log_erfc

      Synopsis
        S-Lang version of gsl_sf_log_erfc

      Usage
        Double_Type[] log_erfc (Double_Type[] x)

  5.11.  Eta/Zeta Functions

  5.11.1.  eta

      Synopsis
        S-Lang version of gsl_sf_eta

      Usage
        Double_Type[] eta (Double_Type[] s)

  5.11.2.  eta_int

      Synopsis
        S-Lang version of gsl_sf_eta_int

      Usage
        Double_Type[] eta_int (Int_Type[] n)

  5.11.3.  hzeta

      Synopsis
        S-Lang version of gsl_sf_hzeta

      Usage
        Double_Type[] hzeta (Double_Type[] s, Double_Type[] q)

  5.11.4.  zeta

      Synopsis
        S-Lang version of gsl_sf_zeta

      Usage
        Double_Type[] zeta (Double_Type[] s)
  5.11.5.  zeta_int

      Synopsis
        S-Lang version of gsl_sf_zeta_int

      Usage
        Double_Type[] zeta_int (Int_Type[] n)

  5.12.  Exponential Functions and Integrals

  5.12.1.  exp_mult

      Synopsis
        S-Lang version of gsl_sf_exp_mult

      Usage
        Double_Type[] exp_mult (Double_Type[] x, Double_Type[] y)

  5.12.2.  expint_3

      Synopsis
        S-Lang version of gsl_sf_expint_3

      Usage
        Double_Type[] expint_3 (Double_Type[] x)

  5.12.3.  expint_E1

      Synopsis
        S-Lang version of gsl_sf_expint_E1

      Usage
        Double_Type[] expint_E1 (Double_Type[] x)

  5.12.4.  expint_E1_scaled

      Synopsis
        S-Lang version of gsl_sf_expint_E1_scaled

      Usage
        Double_Type[] expint_E1_scaled (Double_Type[] x)

  5.12.5.  expint_E2

      Synopsis
        S-Lang version of gsl_sf_expint_E2

      Usage
        Double_Type[] expint_E2 (Double_Type[] x)
  5.12.6.  expint_E2_scaled

      Synopsis
        S-Lang version of gsl_sf_expint_E2_scaled

      Usage
        Double_Type[] expint_E2_scaled (Double_Type[] x)

  5.12.7.  expint_Ei

      Synopsis
        S-Lang version of gsl_sf_expint_Ei

      Usage
        Double_Type[] expint_Ei (Double_Type[] x)

  5.12.8.  expint_Ei_scaled

      Synopsis
        S-Lang version of gsl_sf_expint_Ei_scaled

      Usage
        Double_Type[] expint_Ei_scaled (Double_Type[] x)

  5.12.9.  expm1

      Synopsis
        S-Lang version of gsl_sf_expm1

      Usage
        Double_Type[] expm1 (Double_Type[] x)

  5.12.10.  exprel

      Synopsis
        S-Lang version of gsl_sf_exprel

      Usage
        Double_Type[] exprel (Double_Type[] x)

  5.12.11.  exprel_2

      Synopsis
        S-Lang version of gsl_sf_exprel_2

      Usage
        Double_Type[] exprel_2 (Double_Type[] x)

  5.12.12.  exprel_n

      Synopsis
        S-Lang version of gsl_sf_exprel_n

      Usage
        Double_Type[] exprel_n (Int_Type[] n, Double_Type[] x)

  5.13.  Fermi-Dirac Functions

  5.13.1.  fermi_dirac_0

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_0

      Usage
        Double_Type[] fermi_dirac_0 (Double_Type[] x)

  5.13.2.  fermi_dirac_1

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_1

      Usage
        Double_Type[] fermi_dirac_1 (Double_Type[] x)

  5.13.3.  fermi_dirac_2

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_2

      Usage
        Double_Type[] fermi_dirac_2 (Double_Type[] x)

  5.13.4.  fermi_dirac_3half

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_3half

      Usage
        Double_Type[] fermi_dirac_3half (Double_Type[] x)

  5.13.5.  fermi_dirac_half

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_half

      Usage
        Double_Type[] fermi_dirac_half (Double_Type[] x)
  5.13.6.  fermi_dirac_inc_0

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_inc_0

      Usage
        Double_Type[] fermi_dirac_inc_0 (Double_Type[] x, Double_Type[]
        b)

  5.13.7.  fermi_dirac_int

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_int

      Usage
        Double_Type[] fermi_dirac_int (Int_Type[] j, Double_Type[] x)

  5.13.8.  fermi_dirac_m1

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_m1

      Usage
        Double_Type[] fermi_dirac_m1 (Double_Type[] x)

  5.13.9.  fermi_dirac_mhalf

      Synopsis
        S-Lang version of gsl_sf_fermi_dirac_mhalf

      Usage
        Double_Type[] fermi_dirac_mhalf (Double_Type[] x)

  5.14.  Gamma Functions

  5.14.1.  gamma

      Synopsis
        S-Lang version of gsl_sf_gamma

      Usage
        Double_Type[] gamma (Double_Type[] x)

  5.14.2.  gamma_inc

      Synopsis
        S-Lang version of gsl_sf_gamma_inc

      Usage
        Double_Type[] gamma_inc (Double_Type[] a, Double_Type[] x)

  5.14.3.  gamma_inc_P

      Synopsis
        S-Lang version of gsl_sf_gamma_inc_P

      Usage
        Double_Type[] gamma_inc_P (Double_Type[] a, Double_Type[] x)

  5.14.4.  gamma_inc_Q

      Synopsis
        S-Lang version of gsl_sf_gamma_inc_Q

      Usage
        Double_Type[] gamma_inc_Q (Double_Type[] a, Double_Type[] x)

  5.14.5.  gammainv

      Synopsis
        S-Lang version of gsl_sf_gammainv

      Usage
        Double_Type[] gammainv (Double_Type[] x)

  5.14.6.  gammastar

      Synopsis
        S-Lang version of gsl_sf_gammastar

      Usage
        Double_Type[] gammastar (Double_Type[] x)

  5.14.7.  lngamma

      Synopsis
        S-Lang version of gsl_sf_lngamma

      Usage
        Double_Type[] lngamma (Double_Type[] x)

  5.15.  Gegenbauer Functions

  5.15.1.  gegenpoly_1

      Synopsis
        S-Lang version of gsl_sf_gegenpoly_1

      Usage
        Double_Type[] gegenpoly_1 (Double_Type[] lambda, Double_Type[]
        x)

  5.15.2.  gegenpoly_2

      Synopsis
        S-Lang version of gsl_sf_gegenpoly_2

      Usage
        Double_Type[] gegenpoly_2 (Double_Type[] lambda, Double_Type[]
        x)

  5.15.3.  gegenpoly_3

      Synopsis
        S-Lang version of gsl_sf_gegenpoly_3

      Usage
        Double_Type[] gegenpoly_3 (Double_Type[] lambda, Double_Type[]
        x)

  5.15.4.  gegenpoly_n

      Synopsis
        S-Lang version of gsl_sf_gegenpoly_n

      Usage
        Double_Type[] gegenpoly_n (n, lambda, x)

            Int_Type[] n
            Double_Type[] lambda
            Double_Type[] x

  5.16.  Hypergeometric Functions

  5.16.1.  hyperg_0F1

      Synopsis
        S-Lang version of gsl_sf_hyperg_0F1

      Usage
        Double_Type[] hyperg_0F1 (Double_Type[] c, Double_Type[] x)
  5.16.2.  hyperg_1F1

      Synopsis
        S-Lang version of gsl_sf_hyperg_1F1

      Usage
        Double_Type[] hyperg_1F1 (a, b, x)

            Double_Type[] a
            Double_Type[] b
            Double_Type[] x

  5.16.3.  hyperg_1F1_int

      Synopsis
        S-Lang version of gsl_sf_hyperg_1F1_int

      Usage
        Double_Type[] hyperg_1F1_int (Int_Type[] m, Int_Type[] n,
        Double_Type[] x)

  5.16.4.  hyperg_2F0

      Synopsis
        S-Lang version of gsl_sf_hyperg_2F0

      Usage
        Double_Type[] hyperg_2F0 (a, b, x)

            Double_Type[] a
            Double_Type[] b
            Double_Type[] x

  5.16.5.  hyperg_2F1

      Synopsis
        S-Lang version of gsl_sf_hyperg_2F1

      Usage
        Double_Type[] hyperg_2F1 (a, b, c, x)

            Double_Type[] a
            Double_Type[] b
            Double_Type[] c
            Double_Type[] x

  5.16.6.  hyperg_2F1_conj

      Synopsis
        S-Lang version of gsl_sf_hyperg_2F1_conj

      Usage
        Double_Type[] hyperg_2F1_conj (aR, aI, c, x)

            Double_Type[] aR
            Double_Type[] aI
            Double_Type[] c
            Double_Type[] x

  5.16.7.  hyperg_2F1_conj_renorm

      Synopsis
        S-Lang version of gsl_sf_hyperg_2F1_conj_renorm

      Usage
        Double_Type[] hyperg_2F1_conj_renorm (aR, aI, c, x)

            Double_Type[] aR
            Double_Type[] aI
            Double_Type[] c
            Double_Type[] x

  5.16.8.  hyperg_2F1_renorm

      Synopsis
        S-Lang version of gsl_sf_hyperg_2F1_renorm

      Usage
        Double_Type[] hyperg_2F1_renorm (a, b, c, x)

            Double_Type[] a
            Double_Type[] b
            Double_Type[] c
            Double_Type[] x

  5.16.9.  hyperg_U

      Synopsis
        S-Lang version of gsl_sf_hyperg_U

      Usage
        Double_Type[] hyperg_U (Double_Type[] a, Double_Type[] b,
        Double_Type[] x)

  5.16.10.  hyperg_U_int

      Synopsis
        S-Lang version of gsl_sf_hyperg_U_int

      Usage
        Double_Type[] hyperg_U_int (Int_Type[] m, Int_Type[] n,
        Double_Type[] x)

  5.17.  Laguerre Functions

  5.17.1.  laguerre_1

      Synopsis
        S-Lang version of gsl_sf_laguerre_1

      Usage
        Double_Type[] laguerre_1 (Double_Type[] a, Double_Type[] x)

  5.17.2.  laguerre_2

      Synopsis
        S-Lang version of gsl_sf_laguerre_2

      Usage
        Double_Type[] laguerre_2 (Double_Type[] a, Double_Type[] x)

  5.17.3.  laguerre_3

      Synopsis
        S-Lang version of gsl_sf_laguerre_3

      Usage
        Double_Type[] laguerre_3 (Double_Type[] a, Double_Type[] x)

  5.17.4.  laguerre_n

      Synopsis
        S-Lang version of gsl_sf_laguerre_n

      Usage
        Double_Type[] laguerre_n (Int_Type[] n, Double_Type[] a,
        Double_Type[] x)

  5.18.  Lambert Functions

  5.18.1.  lambert_W0

      Synopsis
        S-Lang version of gsl_sf_lambert_W0

      Usage
        Double_Type[] lambert_W0 (Double_Type[] x)

  5.18.2.  lambert_Wm1

      Synopsis
        S-Lang version of gsl_sf_lambert_Wm1

      Usage
        Double_Type[] lambert_Wm1 (Double_Type[] x)

  5.19.  Legendre Functions and Spherical Harmonics

  5.19.1.  legendre_H3d

      Synopsis
        S-Lang version of gsl_sf_legendre_H3d

      Usage
        Double_Type[] legendre_H3d (l, lambda, eta)

            Int_Type[] l
            Double_Type[] lambda
            Double_Type[] eta

  5.19.2.  legendre_H3d_0

      Synopsis
        S-Lang version of gsl_sf_legendre_H3d_0

      Usage
        Double_Type[] legendre_H3d_0 (Double_Type[] lambda,
        Double_Type[] eta)

  5.19.3.  legendre_H3d_1

      Synopsis
        S-Lang version of gsl_sf_legendre_H3d_1

      Usage
        Double_Type[] legendre_H3d_1 (Double_Type[] lambda,
        Double_Type[] eta)

  5.19.4.  legendre_P1

      Synopsis
        S-Lang version of gsl_sf_legendre_P1

      Usage
        Double_Type[] legendre_P1 (Double_Type[] x)

  5.19.5.  legendre_P2

      Synopsis
        S-Lang version of gsl_sf_legendre_P2

      Usage
        Double_Type[] legendre_P2 (Double_Type[] x)

  5.19.6.  legendre_P3

      Synopsis
        S-Lang version of gsl_sf_legendre_P3

      Usage
        Double_Type[] legendre_P3 (Double_Type[] x)

  5.19.7.  legendre_Pl

      Synopsis
        S-Lang version of gsl_sf_legendre_Pl

      Usage
        Double_Type[] legendre_Pl (Int_Type[] l, Double_Type[] x)

  5.19.8.  legendre_Plm

      Synopsis
        S-Lang version of gsl_sf_legendre_Plm

      Usage
        Double_Type[] legendre_Plm (Int_Type[] l, Int_Type[] m,
        Double_Type[] x)

  5.19.9.  legendre_Q0

      Synopsis
        S-Lang version of gsl_sf_legendre_Q0

      Usage
        Double_Type[] legendre_Q0 (Double_Type[] x)

  5.19.10.  legendre_Q1

      Synopsis
        S-Lang version of gsl_sf_legendre_Q1

      Usage
        Double_Type[] legendre_Q1 (Double_Type[] x)

  5.19.11.  legendre_Ql

      Synopsis
        S-Lang version of gsl_sf_legendre_Ql

      Usage
        Double_Type[] legendre_Ql (Int_Type[] l, Double_Type[] x)

  5.19.12.  legendre_sphPlm

      Synopsis
        S-Lang version of gsl_sf_legendre_sphPlm

      Usage
        Double_Type[] legendre_sphPlm (Int_Type[] l, Int_Type[] m,
        Double_Type[] x)

  5.20.  Logarithm and Related Functions

  5.20.1.  log_1plusx

      Synopsis
        S-Lang version of gsl_sf_log_1plusx

      Usage
        Double_Type[] log_1plusx (Double_Type[] x)

  5.20.2.  log_1plusx_mx

      Synopsis
        S-Lang version of gsl_sf_log_1plusx_mx

      Usage
        Double_Type[] log_1plusx_mx (Double_Type[] x)

  5.20.3.  log_abs

      Synopsis
        S-Lang version of gsl_sf_log_abs

      Usage
        Double_Type[] log_abs (Double_Type[] x)

  5.21.  Transport Functions

  5.21.1.  transport_2

      Synopsis
        S-Lang version of gsl_sf_transport_2

      Usage
        Double_Type[] transport_2 (Double_Type[] x)

  5.21.2.  transport_3

      Synopsis
        S-Lang version of gsl_sf_transport_3

      Usage
        Double_Type[] transport_3 (Double_Type[] x)

  5.21.3.  transport_4

      Synopsis
        S-Lang version of gsl_sf_transport_4

      Usage
        Double_Type[] transport_4 (Double_Type[] x)

  5.21.4.  transport_5

      Synopsis
        S-Lang version of gsl_sf_transport_5

      Usage
        Double_Type[] transport_5 (Double_Type[] x)

  5.22.  Miscellaneous Functions

  5.22.1.  angle_restrict_pos

      Synopsis
        S-Lang version of gsl_sf_angle_restrict_pos
      Usage
        Double_Type[] angle_restrict_pos (Double_Type[] theta)

  5.22.2.  angle_restrict_symm

      Synopsis
        S-Lang version of gsl_sf_angle_restrict_symm

      Usage
        Double_Type[] angle_restrict_symm (Double_Type[] theta)

  5.22.3.  atanint

      Synopsis
        S-Lang version of gsl_sf_atanint

      Usage
        Double_Type[] atanint (Double_Type[] x)

  5.22.4.  Chi

      Synopsis
        S-Lang version of gsl_sf_Chi

      Usage
        Double_Type[] Chi (Double_Type[] x)

  5.22.5.  Ci

      Synopsis
        S-Lang version of gsl_sf_Ci

      Usage
        Double_Type[] Ci (Double_Type[] x)

  5.22.6.  dawson

      Synopsis
        S-Lang version of gsl_sf_dawson

      Usage
        Double_Type[] dawson (Double_Type[] x)

  5.22.7.  dilog

      Synopsis
        S-Lang version of gsl_sf_dilog

      Usage
        Double_Type[] dilog (Double_Type[] x)

  5.22.8.  hazard

      Synopsis
        S-Lang version of gsl_sf_hazard

      Usage
        Double_Type[] hazard (Double_Type[] x)

  5.22.9.  hypot

      Synopsis
        S-Lang version of gsl_sf_hypot

      Usage
        Double_Type[] hypot (Double_Type[] x, Double_Type[] y)

  5.22.10.  lncosh

      Synopsis
        S-Lang version of gsl_sf_lncosh

      Usage
        Double_Type[] lncosh (Double_Type[] x)

  5.22.11.  lnpoch

      Synopsis
        S-Lang version of gsl_sf_lnpoch

      Usage
        Double_Type[] lnpoch (Double_Type[] a, Double_Type[] x)

  5.22.12.  lnsinh

      Synopsis
        S-Lang version of gsl_sf_lnsinh

      Usage
        Double_Type[] lnsinh (Double_Type[] x)

  5.22.13.  poch

      Synopsis
        S-Lang version of gsl_sf_poch

      Usage
        Double_Type[] poch (Double_Type[] a, Double_Type[] x)

  5.22.14.  pochrel

      Synopsis
        S-Lang version of gsl_sf_pochrel

      Usage
        Double_Type[] pochrel (Double_Type[] a, Double_Type[] x)

  5.22.15.  Shi

      Synopsis
        S-Lang version of gsl_sf_Shi

      Usage
        Double_Type[] Shi (Double_Type[] x)

  5.22.16.  Si

      Synopsis
        S-Lang version of gsl_sf_Si

      Usage
        Double_Type[] Si (Double_Type[] x)

  5.22.17.  sinc

      Synopsis
        S-Lang version of gsl_sf_sinc

      Usage
        Double_Type[] sinc (Double_Type[] x)

  5.22.18.  synchrotron_1

      Synopsis
        S-Lang version of gsl_sf_synchrotron_1

      Usage
        Double_Type[] synchrotron_1 (Double_Type[] x)

  5.22.19.  synchrotron_2

      Synopsis
        S-Lang version of gsl_sf_synchrotron_2

      Usage
        Double_Type[] synchrotron_2 (Double_Type[] x)

  5.22.20.  taylorcoeff

      Synopsis
        S-Lang version of gsl_sf_taylorcoeff

      Usage
        Double_Type[] taylorcoeff (Int_Type[] n, Double_Type[] x)

  6.  gslrand: The GSL Random Number Module

  GSL provides more than 60 types of random number generators and about
  40 random number distributions.   The gslrand module provides access
  to all of the GSL random number generators and to nearly all of its
  random number distributions.

  Using the gslrand module is rather straightforward.  First, import the
  module into the interpreter as described above via a statement such as

          require ("gslrand");

  The next step is to allocate a random number generator via the
  rng_alloc function.  As stated above, there are more than 60 genera-
  tors to choose from.  To allocate an instance of the default generator
  ("mt19937"), use

           r = rng_alloc ();

  Or to allocate an instance of some other generator, e.g., the lagged-
  fibonacci generator "gfsr4", use

           r = rng_alloc ("gfsr4");

  Once the generator has been allocated, it may be used to construct
  random number sequences from a specific random distribution.  For
  example,

          x = ran_flat (r, 0, 1);

  may be used to obtain a random number uniformly distributed between 0
  and 1.  In a similar vein,

          x = ran_gaussian (r, 2.0);

  will produce a gaussian distributed random number with a sigma of 2.0.

  For many applications, it is desirable to be able to produce arrays of
  random numbers.  This may be accomplished by passing an addition
  argument to the random number distribution function that specifies how
  many random numbers to produce.  For example,

     a = ran_gaussian (r, 2.0, 10000);

  will create an array of 10000 gaussian distributed random numbers with
  a sigma of 2.0.

  If the random generator is omitted from the call to the random number
  distribution routines, then a default generator will be used.  For
  example,

          x = ran_gaussian (2.0);

  will generate a gaussian distributed random number with a sigma of 2.0
  using the default generator.

  6.1.  Random Number Generation Routines

  6.1.1.  rng_alloc

      Synopsis
        Allocate an instance of a random number generator

      Usage
        Rand_Type rng_alloc ([generator])

  6.1.2.  rng_set

      Synopsis
        Seed a random number generator

      Usage
        rng_set ([Rand_Type gen,] ULong_Type seed)

  6.1.3.  rng_get

      Synopsis
        rng_get

      Usage
        x = rng_get ([Rand_Type gen] [, Int_Type num])

  6.1.4.  rng_get_rng_types

      Synopsis
        Get a list of all supported generators

      Usage
        String_Type[] = rng_get_rng_types ()

  6.1.5.  rng_uniform

      Synopsis
        Get a uniformly distributed random number

      Usage
        x = rng_uniform ([Rand_Type gen] [, Int_Type num])

  6.1.6.  rng_uniform_pos

      Synopsis
        Generate a uniformly distributed non-zero random number

      Usage
        x = rng_uniform_pos ([Rand_Type gen] [, Int_Type num])

  6.1.7.  rng_max

      Synopsis
        Obtain the maximum value produced by a random number generator

      Usage
        ULong_Type rng_max (Rand_Type gen)

  6.1.8.  rng_min

      Synopsis
        Obtain the minimum value produced by a random number generator

      Usage
        ULong_Type rng_min (Rand_Type gen)

  6.2.  Random Number Distributions

  6.2.1.  ran_bernoulli

      Synopsis
        Produce Bernoulli distributed random numbers

      Usage
        x = ran_bernoulli ([Rand_Type gen,] Double_Type p [,Int_Type
        num]

  6.2.2.  ran_beta

      Synopsis
        Produce distributed random numbers

      Usage
        x = ran_beta ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.3.  ran_binomial

      Synopsis
        Produce random numbers from the binomial distribution

      Usage
        x = ran_binomial ([Rand_Type gen,] Double_Type p, Int_Type n
        [,Int_Type num])

  6.2.4.  ran_cauchy

      Synopsis
        Produce random numbers from the Cauchy distribution

      Usage
        x = ran_cauchy ([Rand_Type gen,] Double_Type mu [,Int_Type num])

  6.2.5.  ran_chisq

      Synopsis
        Produce chi-squared distributed random numbers

      Usage
        x = ran_chisq ([Rand_Type gen,] Double_Type nu [,Int_Type num])

  6.2.6.  ran_exponential

      Synopsis
        Produce exponentially distributed random numbers

      Usage
        x = ran_exponential ([Rand_Type gen,] Double_Type mu [,Int_Type
        num])

  6.2.7.  ran_exppow

      Synopsis
        Produce random numbers from the exponential power distribution

      Usage
        x = ran_exppow ([Rand_Type gen,] Double_Type mu, Double_Type a
        [,Int_Type num])

  6.2.8.  ran_fdist

      Synopsis
        Produce F-distributed random numbers

      Usage
        x = ran_fdist ([Rand_Type gen,] Double_Type nu1, Double_Type nu2
        [,Int_Type num])

  6.2.9.  ran_flat

      Synopsis
        Produce uniformly distributed random numbers

      Usage
        x = ran_flat ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.10.  ran_gamma

      Synopsis
        Produce a random number from the gamma distribution

      Usage
        x = ran_gamma ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.11.  ran_gaussian

      Synopsis
        Produce gaussian distributed random numbers

      Usage
        x = ran_gaussian ([Rand_Type gen,] Double_Type sigma [,Int_Type
        num])

  6.2.12.  ran_gaussian_ratio_method

      Synopsis
        Produce gaussian distributed random numbers

      Usage
        x = ran_gaussian_ratio_method ([Rand_Type gen,] Double_Type
        sigma [,Int_Type num])

  6.2.13.  ran_gaussian_tail

      Synopsis
        Produce gaussian distributed random numbers from the tail

      Usage
        x = ran_gaussian_tail ([Rand_Type gen,] Double_Type a,
        Double_Type sigma [,Int_Type num])

  6.2.14.  ran_geometric

      Synopsis
        Produce random integers from the geometric distribution

      Usage
        x = ran_geometric ([Rand_Type gen,] Double_Type p [,Int_Type
        num])

  6.2.15.  ran_gumbel1

      Synopsis
        Produce random numbers from the type-1 Gumbel distribution

      Usage
        x = ran_gumbel1 ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.16.  ran_gumbel2

      Synopsis
        Produce random numbers from the type-2 Gumbel distribution

      Usage
        x = ran_gumbel2 ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.17.  ran_laplace

      Synopsis
        Produce random numbers from the Laplace distribution

      Usage
        x = ran_laplace ([Rand_Type gen,] Double_Type mu [,Int_Type
        num])

  6.2.18.  ran_levy

      Synopsis
        Produce random numbers from the Levy distribution
      Usage
        x = ran_levy ([Rand_Type gen,] Double_Type mu, Double_Type a
        [,Int_Type num])

  6.2.19.  ran_logarithmic

      Synopsis
        Produce random numbers from the logarithmic distribution

      Usage
        x = ran_logarithmic ([Rand_Type gen,] Double_Type p [,Int_Type
        num])

  6.2.20.  ran_logistic

      Synopsis
        Produce random numbers from the logistic distribution

      Usage
        x = ran_logistic ([Rand_Type gen,] Double_Type mu [,Int_Type
        num])

  6.2.21.  ran_lognormal

      Synopsis
        Produce random numbers from the lognormal distribution

      Usage
        x = ran_lognormal ([Rand_Type gen,] Double_Type zeta,
        Double_Type sigma [,Int_Type num])

  6.2.22.  ran_negative_binomial

      Synopsis
        Produce random numbers from the negative binomial distribution

      Usage
        x = ran_negative_binomial ([Rand_Type gen,] Double_Type p,
        Double_Type n [,Int_Type num])

  6.2.23.  ran_pareto

      Synopsis
        Produce random numbers from the Pareto distribution

      Usage
        x = ran_pareto ([Rand_Type gen,] Double_Type a, Double_Type b
        [,Int_Type num])

  6.2.24.  ran_pascal

      Synopsis
        Produce random numbers from the Pascal distribution

      Usage
        x = ran_pascal ([Rand_Type gen,] Double_Type p, Int_Type k
        [,Int_Type num])

  6.2.25.  ran_poisson

      Synopsis
        Produce random numbers from the Poisson distribution

      Usage
        x = ran_poisson ([Rand_Type gen,] Double_Type mu [,Int_Type
        num])

  6.2.26.  ran_rayleigh

      Synopsis
        Produce random numbers from the Rayleigh distribution

      Usage
        x = ran_rayleigh ([Rand_Type gen,] Double_Type sigma [,Int_Type
        num])

  6.2.27.  ran_rayleigh_tail

      Synopsis
        Produce random numbers from the tail of the Rayleigh
        distribution

      Usage
        x = ran_rayleigh_tail ([Rand_Type gen,] Double_Type a,
        Double_Type sigma [,Int_Type num])

  6.2.28.  ran_tdist

      Synopsis
        Produce random numbers from the t-distribution

      Usage
        x = ran_tdist ([Rand_Type gen,] Double_Type nu [,Int_Type num])

  6.2.29.  ran_ugaussian

      Synopsis
        Produce random numbers from the gaussian distribution

      Usage
        x = ran_ugaussian ([Rand_Type gen] [,Int_Type num])

  6.2.30.  ran_ugaussian_ratio_method

      Synopsis
        Produce random numbers from the gaussian distribution

      Usage
        x = ran_ugaussian_ratio_method ([Rand_Type gen] [,Int_Type num])

  6.2.31.  ran_ugaussian_tail

      Synopsis
        Produce random numbers from the tail of the gaussian
        distribution

      Usage
        x = ran_ugaussian_tail ([Rand_Type gen,] Double_Type a
        [,Int_Type num])

  6.2.32.  ran_weibull

      Synopsis
        Produce random numbers from the Weibull distribution

      Usage
        x = ran_weibull ([Rand_Type gen,] Double_Type mu, Double_Type a
        [,Int_Type num])

  6.3.  PDF Functions

  6.3.1.  ran_beta_pdf

      Synopsis
        S-Lang version of gsl_ran_beta_pdf

      Usage
        Double_Type[] ran_beta_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  6.3.2.  ran_cauchy_pdf

      Synopsis
        S-Lang version of gsl_ran_cauchy_pdf

      Usage
        Double_Type[] ran_cauchy_pdf (Double_Type[] x, Double_Type[] a)

  6.3.3.  ran_chisq_pdf

      Synopsis
        S-Lang version of gsl_ran_chisq_pdf

      Usage
        Double_Type[] ran_chisq_pdf (Double_Type[] x, Double_Type[] nu)

  6.3.4.  ran_erlang_pdf

      Synopsis
        S-Lang version of gsl_ran_erlang_pdf

      Usage
        Double_Type[] ran_erlang_pdf (x, a, n)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] n

  6.3.5.  ran_exponential_pdf

      Synopsis
        S-Lang version of gsl_ran_exponential_pdf

      Usage
        Double_Type[] ran_exponential_pdf (Double_Type[] x,
        Double_Type[] mu)

  6.3.6.  ran_exppow_pdf

      Synopsis
        S-Lang version of gsl_ran_exppow_pdf

      Usage
        Double_Type[] ran_exppow_pdf (x, a, b)

       Double_Type[] x
       Double_Type[] a
       Double_Type[] b

  6.3.7.  ran_fdist_pdf

      Synopsis
        S-Lang version of gsl_ran_fdist_pdf

      Usage
        Double_Type[] ran_fdist_pdf (x, nu1, nu2)

            Double_Type[] x
            Double_Type[] nu1
            Double_Type[] nu2

  6.3.8.  ran_flat_pdf

      Synopsis
        S-Lang version of gsl_ran_flat_pdf

      Usage
        Double_Type[] ran_flat_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  6.3.9.  ran_gamma_pdf

      Synopsis
        S-Lang version of gsl_ran_gamma_pdf

      Usage
        Double_Type[] ran_gamma_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  6.3.10.  ran_gaussian_pdf

      Synopsis
        S-Lang version of gsl_ran_gaussian_pdf

      Usage
        Double_Type[] ran_gaussian_pdf (Double_Type[] x, Double_Type[]
        sigma)

  6.3.11.  ran_gaussian_tail_pdf

      Synopsis
        S-Lang version of gsl_ran_gaussian_tail_pdf

      Usage
        Double_Type[] ran_gaussian_tail_pdf (x, a, sigma)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] sigma

  6.3.12.  ran_gumbel1_pdf

      Synopsis
        S-Lang version of gsl_ran_gumbel1_pdf

      Usage
        Double_Type[] ran_gumbel1_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  6.3.13.  ran_gumbel2_pdf

      Synopsis
        S-Lang version of gsl_ran_gumbel2_pdf

      Usage
        Double_Type[] ran_gumbel2_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  6.3.14.  ran_landau_pdf

      Synopsis
        S-Lang version of gsl_ran_landau_pdf

      Usage
        Double_Type[] ran_landau_pdf (Double_Type[] x)

  6.3.15.  ran_laplace_pdf

      Synopsis
        S-Lang version of gsl_ran_laplace_pdf

      Usage
        Double_Type[] ran_laplace_pdf (Double_Type[] x, Double_Type[] a)

  6.3.16.  ran_logistic_pdf

      Synopsis
        S-Lang version of gsl_ran_logistic_pdf

      Usage
        Double_Type[] ran_logistic_pdf (Double_Type[] x, Double_Type[]
        a)

  6.3.17.  ran_lognormal_pdf

      Synopsis
        S-Lang version of gsl_ran_lognormal_pdf

      Usage
        Double_Type[] ran_lognormal_pdf (x, zeta, sigma)

            Double_Type[] x
            Double_Type[] zeta
            Double_Type[] sigma

  6.3.18.  ran_pareto_pdf

      Synopsis
        S-Lang version of gsl_ran_pareto_pdf

      Usage
        Double_Type[] ran_pareto_pdf (x, a, b)

       Double_Type[] x
       Double_Type[] a
       Double_Type[] b

  6.3.19.  ran_rayleigh_pdf

      Synopsis
        S-Lang version of gsl_ran_rayleigh_pdf

      Usage
        Double_Type[] ran_rayleigh_pdf (Double_Type[] x, Double_Type[]
        sigma)

  6.3.20.  ran_rayleigh_tail_pdf

      Synopsis
        S-Lang version of gsl_ran_rayleigh_tail_pdf

      Usage
        Double_Type[] ran_rayleigh_tail_pdf (x, a, sigma)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] sigma

  6.3.21.  ran_tdist_pdf

      Synopsis
        S-Lang version of gsl_ran_tdist_pdf

      Usage
        Double_Type[] ran_tdist_pdf (Double_Type[] x, Double_Type[] nu)

  6.3.22.  ran_ugaussian_pdf

      Synopsis
        S-Lang version of gsl_ran_ugaussian_pdf

      Usage
        Double_Type[] ran_ugaussian_pdf (Double_Type[] x)

  6.3.23.  ran_ugaussian_tail_pdf

      Synopsis
        S-Lang version of gsl_ran_ugaussian_tail_pdf

      Usage
        Double_Type[] ran_ugaussian_tail_pdf (Double_Type[] x,
        Double_Type[] a)

  6.3.24.  ran_weibull_pdf

      Synopsis
        S-Lang version of gsl_ran_weibull_pdf

      Usage
        Double_Type[] ran_weibull_pdf (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  7.  gslfft: The GSL FFT module

  The gslfft may be used to compute N dimensional fast fourier
  transforms (FFT).  The module itself currently provides a single
  function called _gsl_fft_complex that performs a forward or backward
  n-dimensional FFT.  The underlying GSL routines used by this function
  are the Swarztrauber mixed-radix routines from FFTPACK and the more
  general Singleton routine.

  The _gsl_fft_complex function is not meant to be called directly;
  rather the user should call the fft function, which provides a
  convenient wrapper for the _gsl_fft_complex function.

  7.1.  Fast Fourier Transform Routines

  7.1.1.  _gsl_fft_complex

      Synopsis
        Perform an N-d FFT

      Usage
        y = _gsl_fft_complex (x, dir)

      Description
        This routine computes the FFT of an array x and returns the
        result.  The integer-valued parameter dir parameter specifies
        the direction of the transform.  A forward transform will be
        produced for positive values of dir and a reverse transform will
        be computed for negative values.

        The result will be a complex array of the same size and
        dimensionality as the the input array.

      Notes
        It is better to call this routine indirectly using the fft
        function.

      See Also
        ``fft''

  7.1.2.  fft

      Synopsis
        Perform an N-d FFT

      Usage
        y = fft (x, dir)

      Description
        This routine computes the FFT of an array x and returns the
        result.  The integer-valued parameter dir parameter specifies
        the direction of the transform.  A forward transform will be
        produced for positive values of dir and a reverse transform will
        be computed for negative values.

        The result will be a complex array of the same size and
        dimensionality as the the input array.
      Notes
        This routine is currently a wrapper for the _gsl_fft_complex
        function.

      See Also
        ``_gsl_fft_complex''

  8.  gslcdf: The GSL Cumulative Distribution Function Module

  The gslcdf module wraps the GSL cumulative distribution functions.

  8.1.  CDF Functions

  8.1.1.  cdf_beta_P

      Synopsis
        S-Lang version of gsl_cdf_beta_P

      Usage
        Double_Type[] cdf_beta_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.2.  cdf_beta_Q

      Synopsis
        S-Lang version of gsl_cdf_beta_Q

      Usage
        Double_Type[] cdf_beta_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.3.  cdf_cauchy_P

      Synopsis
        S-Lang version of gsl_cdf_cauchy_P

      Usage
        Double_Type[] cdf_cauchy_P (Double_Type[] x, Double_Type[] a)

  8.1.4.  cdf_cauchy_Pinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Pinv

      Usage
        Double_Type[] cdf_cauchy_Pinv (Double_Type[] P, Double_Type[] a)

  8.1.5.  cdf_cauchy_Q

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Q

      Usage
        Double_Type[] cdf_cauchy_Q (Double_Type[] x, Double_Type[] a)

  8.1.6.  cdf_cauchy_Qinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Qinv

      Usage
        Double_Type[] cdf_cauchy_Qinv (Double_Type[] Q, Double_Type[] a)

  8.1.7.  cdf_chisq_P

      Synopsis
        S-Lang version of gsl_cdf_chisq_P

      Usage
        Double_Type[] cdf_chisq_P (Double_Type[] x, Double_Type[] nu)

  8.1.8.  cdf_chisq_Pinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Pinv

      Usage
        Double_Type[] cdf_chisq_Pinv (Double_Type[] P, Double_Type[] nu)

  8.1.9.  cdf_chisq_Q

      Synopsis
        S-Lang version of gsl_cdf_chisq_Q

      Usage
        Double_Type[] cdf_chisq_Q (Double_Type[] x, Double_Type[] nu)

  8.1.10.  cdf_chisq_Qinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Qinv

      Usage
        Double_Type[] cdf_chisq_Qinv (Double_Type[] Q, Double_Type[] nu)

  8.1.11.  cdf_exponential_P

      Synopsis
        S-Lang version of gsl_cdf_exponential_P

      Usage
        Double_Type[] cdf_exponential_P (Double_Type[] x, Double_Type[]
        mu)

  8.1.12.  cdf_exponential_Pinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Pinv

      Usage
        Double_Type[] cdf_exponential_Pinv (Double_Type[] P,
        Double_Type[] mu)

  8.1.13.  cdf_exponential_Q

      Synopsis
        S-Lang version of gsl_cdf_exponential_Q

      Usage
        Double_Type[] cdf_exponential_Q (Double_Type[] x, Double_Type[]
        mu)

  8.1.14.  cdf_exponential_Qinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Qinv

      Usage
        Double_Type[] cdf_exponential_Qinv (Double_Type[] Q,
        Double_Type[] mu)

  8.1.15.  cdf_fdist_P

      Synopsis
        S-Lang version of gsl_cdf_fdist_P

      Usage
        Double_Type[] cdf_fdist_P (x, nu1, nu2)

            Double_Type[] x
            Double_Type[] nu1
            Double_Type[] nu2

  8.1.16.  cdf_fdist_Q

      Synopsis
        S-Lang version of gsl_cdf_fdist_Q

      Usage
        Double_Type[] cdf_fdist_Q (x, nu1, nu2)

            Double_Type[] x
            Double_Type[] nu1
            Double_Type[] nu2

  8.1.17.  cdf_flat_P

      Synopsis
        S-Lang version of gsl_cdf_flat_P

      Usage
        Double_Type[] cdf_flat_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.18.  cdf_flat_Pinv

      Synopsis
        S-Lang version of gsl_cdf_flat_Pinv

      Usage
        Double_Type[] cdf_flat_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.19.  cdf_flat_Q

      Synopsis
        S-Lang version of gsl_cdf_flat_Q

      Usage
        Double_Type[] cdf_flat_Q (x, a, b)

       Double_Type[] x
       Double_Type[] a
       Double_Type[] b

  8.1.20.  cdf_flat_Qinv

      Synopsis
        S-Lang version of gsl_cdf_flat_Qinv

      Usage
        Double_Type[] cdf_flat_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  8.1.21.  cdf_gamma_P

      Synopsis
        S-Lang version of gsl_cdf_gamma_P

      Usage
        Double_Type[] cdf_gamma_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.22.  cdf_gamma_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gamma_Pinv

      Usage
        Double_Type[] cdf_gamma_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.23.  cdf_gamma_Q

      Synopsis
        S-Lang version of gsl_cdf_gamma_Q

      Usage
        Double_Type[] cdf_gamma_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.24.  cdf_gamma_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gamma_Qinv

      Usage
        Double_Type[] cdf_gamma_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  8.1.25.  cdf_gaussian_P

      Synopsis
        S-Lang version of gsl_cdf_gaussian_P

      Usage
        Double_Type[] cdf_gaussian_P (Double_Type[] x, Double_Type[]
        sigma)

  8.1.26.  cdf_gaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Pinv

      Usage
        Double_Type[] cdf_gaussian_Pinv (Double_Type[] P, Double_Type[]
        sigma)

  8.1.27.  cdf_gaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Q

      Usage
        Double_Type[] cdf_gaussian_Q (Double_Type[] x, Double_Type[]
        sigma)

  8.1.28.  cdf_gaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Qinv

      Usage
        Double_Type[] cdf_gaussian_Qinv (Double_Type[] Q, Double_Type[]
        sigma)

  8.1.29.  cdf_gumbel1_P

      Synopsis
        S-Lang version of gsl_cdf_gumbel1_P

      Usage
        Double_Type[] cdf_gumbel1_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.30.  cdf_gumbel1_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gumbel1_Pinv

      Usage
        Double_Type[] cdf_gumbel1_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.31.  cdf_gumbel1_Q

      Synopsis
        S-Lang version of gsl_cdf_gumbel1_Q

      Usage
        Double_Type[] cdf_gumbel1_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.32.  cdf_gumbel1_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gumbel1_Qinv

      Usage
        Double_Type[] cdf_gumbel1_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  8.1.33.  cdf_gumbel2_P

      Synopsis
        S-Lang version of gsl_cdf_gumbel2_P

      Usage
        Double_Type[] cdf_gumbel2_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.34.  cdf_gumbel2_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gumbel2_Pinv

      Usage
        Double_Type[] cdf_gumbel2_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.35.  cdf_gumbel2_Q

      Synopsis
        S-Lang version of gsl_cdf_gumbel2_Q

      Usage
        Double_Type[] cdf_gumbel2_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.36.  cdf_gumbel2_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gumbel2_Qinv

      Usage
        Double_Type[] cdf_gumbel2_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  8.1.37.  cdf_laplace_P

      Synopsis
        S-Lang version of gsl_cdf_laplace_P

      Usage
        Double_Type[] cdf_laplace_P (Double_Type[] x, Double_Type[] a)

  8.1.38.  cdf_laplace_Pinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Pinv

      Usage
        Double_Type[] cdf_laplace_Pinv (Double_Type[] P, Double_Type[]
        a)

  8.1.39.  cdf_laplace_Q

      Synopsis
        S-Lang version of gsl_cdf_laplace_Q
      Usage
        Double_Type[] cdf_laplace_Q (Double_Type[] x, Double_Type[] a)

  8.1.40.  cdf_laplace_Qinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Qinv

      Usage
        Double_Type[] cdf_laplace_Qinv (Double_Type[] Q, Double_Type[]
        a)

  8.1.41.  cdf_logistic_P

      Synopsis
        S-Lang version of gsl_cdf_logistic_P

      Usage
        Double_Type[] cdf_logistic_P (Double_Type[] x, Double_Type[] a)

  8.1.42.  cdf_logistic_Pinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Pinv

      Usage
        Double_Type[] cdf_logistic_Pinv (Double_Type[] P, Double_Type[]
        a)

  8.1.43.  cdf_logistic_Q

      Synopsis
        S-Lang version of gsl_cdf_logistic_Q

      Usage
        Double_Type[] cdf_logistic_Q (Double_Type[] x, Double_Type[] a)

  8.1.44.  cdf_logistic_Qinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Qinv

      Usage
        Double_Type[] cdf_logistic_Qinv (Double_Type[] Q, Double_Type[]
        a)

  8.1.45.  cdf_lognormal_P

      Synopsis
        S-Lang version of gsl_cdf_lognormal_P

      Usage
        Double_Type[] cdf_lognormal_P (x, zeta, sigma)

            Double_Type[] x
            Double_Type[] zeta
            Double_Type[] sigma

  8.1.46.  cdf_lognormal_Pinv

      Synopsis
        S-Lang version of gsl_cdf_lognormal_Pinv

      Usage
        Double_Type[] cdf_lognormal_Pinv (P, zeta, sigma)

            Double_Type[] P
            Double_Type[] zeta
            Double_Type[] sigma

  8.1.47.  cdf_lognormal_Q

      Synopsis
        S-Lang version of gsl_cdf_lognormal_Q

      Usage
        Double_Type[] cdf_lognormal_Q (x, zeta, sigma)

            Double_Type[] x
            Double_Type[] zeta
            Double_Type[] sigma

  8.1.48.  cdf_lognormal_Qinv

      Synopsis
        S-Lang version of gsl_cdf_lognormal_Qinv

      Usage
        Double_Type[] cdf_lognormal_Qinv (Q, zeta, sigma)

       Double_Type[] Q
       Double_Type[] zeta
       Double_Type[] sigma

  8.1.49.  cdf_pareto_P

      Synopsis
        S-Lang version of gsl_cdf_pareto_P

      Usage
        Double_Type[] cdf_pareto_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.50.  cdf_pareto_Pinv

      Synopsis
        S-Lang version of gsl_cdf_pareto_Pinv

      Usage
        Double_Type[] cdf_pareto_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.51.  cdf_pareto_Q

      Synopsis
        S-Lang version of gsl_cdf_pareto_Q

      Usage
        Double_Type[] cdf_pareto_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.52.  cdf_pareto_Qinv

      Synopsis
        S-Lang version of gsl_cdf_pareto_Qinv

      Usage
        Double_Type[] cdf_pareto_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  8.1.53.  cdf_rayleigh_P

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_P

      Usage
        Double_Type[] cdf_rayleigh_P (Double_Type[] x, Double_Type[]
        sigma)

  8.1.54.  cdf_rayleigh_Pinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Pinv

      Usage
        Double_Type[] cdf_rayleigh_Pinv (Double_Type[] P, Double_Type[]
        sigma)

  8.1.55.  cdf_rayleigh_Q

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Q

      Usage
        Double_Type[] cdf_rayleigh_Q (Double_Type[] x, Double_Type[]
        sigma)

  8.1.56.  cdf_rayleigh_Qinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Qinv

      Usage
        Double_Type[] cdf_rayleigh_Qinv (Double_Type[] Q, Double_Type[]
        sigma)

  8.1.57.  cdf_tdist_P

      Synopsis
        S-Lang version of gsl_cdf_tdist_P

      Usage
        Double_Type[] cdf_tdist_P (Double_Type[] x, Double_Type[] nu)

  8.1.58.  cdf_tdist_Pinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Pinv

      Usage
        Double_Type[] cdf_tdist_Pinv (Double_Type[] P, Double_Type[] nu)

  8.1.59.  cdf_tdist_Q

      Synopsis
        S-Lang version of gsl_cdf_tdist_Q

      Usage
        Double_Type[] cdf_tdist_Q (Double_Type[] x, Double_Type[] nu)

  8.1.60.  cdf_tdist_Qinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Qinv

      Usage
        Double_Type[] cdf_tdist_Qinv (Double_Type[] Q, Double_Type[] nu)

  8.1.61.  cdf_ugaussian_P

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_P

      Usage
        Double_Type[] cdf_ugaussian_P (Double_Type[] x)

  8.1.62.  cdf_ugaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Pinv

      Usage
        Double_Type[] cdf_ugaussian_Pinv (Double_Type[] P)

  8.1.63.  cdf_ugaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Q

      Usage
        Double_Type[] cdf_ugaussian_Q (Double_Type[] x)

  8.1.64.  cdf_ugaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Qinv

      Usage
        Double_Type[] cdf_ugaussian_Qinv (Double_Type[] Q)

  8.1.65.  cdf_weibull_P

      Synopsis
        S-Lang version of gsl_cdf_weibull_P

      Usage
        Double_Type[] cdf_weibull_P (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.66.  cdf_weibull_Pinv

      Synopsis
        S-Lang version of gsl_cdf_weibull_Pinv

      Usage
        Double_Type[] cdf_weibull_Pinv (P, a, b)

            Double_Type[] P
            Double_Type[] a
            Double_Type[] b

  8.1.67.  cdf_weibull_Q

      Synopsis
        S-Lang version of gsl_cdf_weibull_Q

      Usage
        Double_Type[] cdf_weibull_Q (x, a, b)

            Double_Type[] x
            Double_Type[] a
            Double_Type[] b

  8.1.68.  cdf_weibull_Qinv

      Synopsis
        S-Lang version of gsl_cdf_weibull_Qinv

      Usage
        Double_Type[] cdf_weibull_Qinv (Q, a, b)

            Double_Type[] Q
            Double_Type[] a
            Double_Type[] b

  9.  gslconst: The GSL Constants Module

  The GSL constants module gslconst defines about 200 physical constants
  such as the speed of light (CONST_MKSA_SPEED_OF_LIGHT) and Boltzmann's
  constant (CONST_MKSA_BOLTZMANN).  In addition to providing values in
  the MKSA (meters, kilograms, seconds, amperes) system, the module also
  includes CGSM (centimeters, grams, seconds, gauss) versions, e.g.,
  CONST_CGSM_SPEED_OF_LIGHT.

  9.1.  MKSA Constants

  o  CONST_MKSA_ACRE

  o  CONST_MKSA_ANGSTROM

  o  CONST_MKSA_ASTRONOMICAL_UNIT

  o  CONST_MKSA_BAR

  o  CONST_MKSA_BARN

  o  CONST_MKSA_BOHR_MAGNETON

  o  CONST_MKSA_BOHR_RADIUS

  o  CONST_MKSA_BOLTZMANN

  o  CONST_MKSA_BTU

  o  CONST_MKSA_CALORIE

  o  CONST_MKSA_CANADIAN_GALLON

  o  CONST_MKSA_CARAT

  o  CONST_MKSA_CUP

  o  CONST_MKSA_CURIE

  o  CONST_MKSA_DAY

  o  CONST_MKSA_DYNE

  o  CONST_MKSA_ELECTRON_CHARGE

  o  CONST_MKSA_ELECTRON_MAGNETIC_MOMENT

  o  CONST_MKSA_ELECTRON_VOLT

  o  CONST_MKSA_ERG

  o  CONST_MKSA_FARADAY

  o  CONST_MKSA_FATHOM

  o  CONST_MKSA_FLUID_OUNCE

  o  CONST_MKSA_FOOT

  o  CONST_MKSA_FOOTCANDLE

  o  CONST_MKSA_FOOTLAMBERT

  o  CONST_MKSA_GAUSS

  o  CONST_MKSA_GRAM_FORCE

  o  CONST_MKSA_GRAVITATIONAL_CONSTANT

  o  CONST_MKSA_GRAV_ACCEL

  o  CONST_MKSA_HECTARE

  o  CONST_MKSA_HORSEPOWER

  o  CONST_MKSA_HOUR

  o  CONST_MKSA_INCH

  o  CONST_MKSA_INCH_OF_MERCURY

  o  CONST_MKSA_INCH_OF_WATER

  o  CONST_MKSA_JOULE

  o  CONST_MKSA_KILOMETERS_PER_HOUR

  o  CONST_MKSA_KILOPOUND_FORCE

  o  CONST_MKSA_KNOT

  o  CONST_MKSA_LAMBERT

  o  CONST_MKSA_LIGHT_YEAR

  o  CONST_MKSA_LITER

  o  CONST_MKSA_LUMEN

  o  CONST_MKSA_LUX

  o  CONST_MKSA_MASS_ELECTRON

  o  CONST_MKSA_MASS_MUON

  o  CONST_MKSA_MASS_NEUTRON

  o  CONST_MKSA_MASS_PROTON

  o  CONST_MKSA_METER_OF_MERCURY

  o  CONST_MKSA_METRIC_TON

  o  CONST_MKSA_MICRON

  o  CONST_MKSA_MIL

  o  CONST_MKSA_MILE

  o  CONST_MKSA_MILES_PER_HOUR

  o  CONST_MKSA_MINUTE

  o  CONST_MKSA_MOLAR_GAS

  o  CONST_MKSA_NAUTICAL_MILE

  o  CONST_MKSA_NEWTON

  o  CONST_MKSA_NUCLEAR_MAGNETON

  o  CONST_MKSA_OUNCE_MASS

  o  CONST_MKSA_PARSEC

  o  CONST_MKSA_PHOT

  o  CONST_MKSA_PINT

  o  CONST_MKSA_PLANCKS_CONSTANT_H

  o  CONST_MKSA_PLANCKS_CONSTANT_HBAR

  o  CONST_MKSA_POINT

  o  CONST_MKSA_POISE

  o  CONST_MKSA_POUNDAL

  o  CONST_MKSA_POUND_FORCE

  o  CONST_MKSA_POUND_MASS

  o  CONST_MKSA_PROTON_MAGNETIC_MOMENT

  o  CONST_MKSA_PSI

  o  CONST_MKSA_QUART

  o  CONST_MKSA_RAD

  o  CONST_MKSA_ROENTGEN

  o  CONST_MKSA_RYDBERG

  o  CONST_MKSA_SOLAR_MASS

  o  CONST_MKSA_SPEED_OF_LIGHT

  o  CONST_MKSA_STANDARD_GAS_VOLUME

  o  CONST_MKSA_STD_ATMOSPHERE

  o  CONST_MKSA_STILB

  o  CONST_MKSA_STOKES

  o  CONST_MKSA_TABLESPOON

  o  CONST_MKSA_TEASPOON

  o  CONST_MKSA_TEXPOINT

  o  CONST_MKSA_THERM

  o  CONST_MKSA_TON

  o  CONST_MKSA_TORR

  o  CONST_MKSA_TROY_OUNCE

  o  CONST_MKSA_UK_GALLON

  o  CONST_MKSA_UK_TON

  o  CONST_MKSA_UNIFIED_ATOMIC_MASS

  o  CONST_MKSA_US_GALLON

  o  CONST_MKSA_VACUUM_PERMEABILITY

  o  CONST_MKSA_VACUUM_PERMITTIVITY

  o  CONST_MKSA_WEEK

  o  CONST_MKSA_YARD

  9.2.  CGSM Constants

  o  CONST_CGSM_ACRE

  o  CONST_CGSM_ANGSTROM

  o  CONST_CGSM_ASTRONOMICAL_UNIT

  o  CONST_CGSM_BAR

  o  CONST_CGSM_BARN

  o  CONST_CGSM_BOHR_MAGNETON

  o  CONST_CGSM_BOHR_RADIUS

  o  CONST_CGSM_BOLTZMANN

  o  CONST_CGSM_BTU

  o  CONST_CGSM_CALORIE

  o  CONST_CGSM_CANADIAN_GALLON

  o  CONST_CGSM_CARAT

  o  CONST_CGSM_CUP

  o  CONST_CGSM_CURIE

  o  CONST_CGSM_DAY

  o  CONST_CGSM_DYNE

  o  CONST_CGSM_ELECTRON_CHARGE

  o  CONST_CGSM_ELECTRON_MAGNETIC_MOMENT

  o  CONST_CGSM_ELECTRON_VOLT

  o  CONST_CGSM_ERG

  o  CONST_CGSM_FARADAY

  o  CONST_CGSM_FATHOM

  o  CONST_CGSM_FLUID_OUNCE

  o  CONST_CGSM_FOOT

  o  CONST_CGSM_FOOTCANDLE

  o  CONST_CGSM_FOOTLAMBERT

  o  CONST_CGSM_GAUSS

  o  CONST_CGSM_GRAM_FORCE

  o  CONST_CGSM_GRAVITATIONAL_CONSTANT

  o  CONST_CGSM_GRAV_ACCEL

  o  CONST_CGSM_HECTARE

  o  CONST_CGSM_HORSEPOWER

  o  CONST_CGSM_HOUR

  o  CONST_CGSM_INCH

  o  CONST_CGSM_INCH_OF_MERCURY

  o  CONST_CGSM_INCH_OF_WATER

  o  CONST_CGSM_JOULE

  o  CONST_CGSM_KILOMETERS_PER_HOUR

  o  CONST_CGSM_KILOPOUND_FORCE

  o  CONST_CGSM_KNOT

  o  CONST_CGSM_LAMBERT

  o  CONST_CGSM_LIGHT_YEAR

  o  CONST_CGSM_LITER

  o  CONST_CGSM_LUMEN

  o  CONST_CGSM_LUX

  o  CONST_CGSM_MASS_ELECTRON

  o  CONST_CGSM_MASS_MUON

  o  CONST_CGSM_MASS_NEUTRON

  o  CONST_CGSM_MASS_PROTON

  o  CONST_CGSM_METER_OF_MERCURY

  o  CONST_CGSM_METRIC_TON

  o  CONST_CGSM_MICRON

  o  CONST_CGSM_MIL

  o  CONST_CGSM_MILE

  o  CONST_CGSM_MILES_PER_HOUR

  o  CONST_CGSM_MINUTE

  o  CONST_CGSM_MOLAR_GAS

  o  CONST_CGSM_NAUTICAL_MILE

  o  CONST_CGSM_NEWTON

  o  CONST_CGSM_NUCLEAR_MAGNETON

  o  CONST_CGSM_OUNCE_MASS

  o  CONST_CGSM_PARSEC

  o  CONST_CGSM_PHOT

  o  CONST_CGSM_PINT

  o  CONST_CGSM_PLANCKS_CONSTANT_H

  o  CONST_CGSM_PLANCKS_CONSTANT_HBAR

  o  CONST_CGSM_POINT

  o  CONST_CGSM_POISE

  o  CONST_CGSM_POUNDAL

  o  CONST_CGSM_POUND_FORCE

  o  CONST_CGSM_POUND_MASS

  o  CONST_CGSM_PROTON_MAGNETIC_MOMENT

  o  CONST_CGSM_PSI

  o  CONST_CGSM_QUART

  o  CONST_CGSM_RAD

  o  CONST_CGSM_ROENTGEN

  o  CONST_CGSM_RYDBERG

  o  CONST_CGSM_SOLAR_MASS

  o  CONST_CGSM_SPEED_OF_LIGHT

  o  CONST_CGSM_STANDARD_GAS_VOLUME

  o  CONST_CGSM_STD_ATMOSPHERE

  o  CONST_CGSM_STILB

  o  CONST_CGSM_STOKES

  o  CONST_CGSM_TABLESPOON

  o  CONST_CGSM_TEASPOON

  o  CONST_CGSM_TEXPOINT

  o  CONST_CGSM_THERM

  o  CONST_CGSM_TON

  o  CONST_CGSM_TORR

  o  CONST_CGSM_TROY_OUNCE

  o  CONST_CGSM_UK_GALLON

  o  CONST_CGSM_UK_TON

  o  CONST_CGSM_UNIFIED_ATOMIC_MASS

  o  CONST_CGSM_US_GALLON

  o  CONST_CGSM_WEEK

  o  CONST_CGSM_YARD

