  S-Lang GSL Module Reference
  John E. Davis, jed@jedsoft.org
  Jan 19, 2021
  ____________________________________________________________


  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  gslmatrix A set of GSL routines that deal with matrices. These
     include eigenvalue, eigenvector, and a number of other linear
     algebra functions.

  o  gsldwt The GSL Discrete Wavelet Transform module

  o  gslinteg The GSL numerical integration module

  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, the module must
  first be loaded using the require function. For example, to load the
  GSL special function module, use

          require ("gslsf");

  The gsl.sl file exists as a convenient way to load all GSL modules
  (gslsf, gslrand, etc.), e.g.,

           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

          require ("gsl", "G")

  Then to access, e.g., the hypot function, use the GSL->hypot. See the
  S-Lang documentation <http://www.jed-
  soft.org/slang/doc/html/slang.html> for more information about name-
  spaces.

  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 gsl 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 in-
  terp_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_akima_periodic_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
        integral = interp_eval_integ (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. Functions
  that do not take the optional mode argument will always be computed 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.7.5.  debye_5

      Synopsis
        S-Lang version of gsl_sf_debye_5

      Usage
        Double_Type[] debye_5 (Double_Type[] x)

  5.7.6.  debye_6

      Synopsis
        S-Lang version of gsl_sf_debye_6

      Usage
        Double_Type[] debye_6 (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

      Synopsis
        S-Lang version of gsl_sf_psi_1

      Usage
        Double_Type[] psi_1 (Double_Type[] x)

  5.8.3.  psi_1_int

      Synopsis
        S-Lang version of gsl_sf_psi_1_int

      Usage
        Double_Type[] psi_1_int (Int_Type[] n)

  5.8.4.  psi_1piy

      Synopsis
        S-Lang version of gsl_sf_psi_1piy

      Usage
        Double_Type[] psi_1piy (Double_Type[] y)

  5.8.5.  psi_int

      Synopsis
        S-Lang version of gsl_sf_psi_int

      Usage
        Double_Type[] psi_int (Int_Type[] n)

  5.8.6.  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 [,mode])

            Double_Type[] phi
            Double_Type[] k
            Int_Type mode

  5.9.2.  ellint_Dcomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Dcomp

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

  5.9.3.  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.4.  ellint_Ecomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Ecomp

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

  5.9.5.  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.6.  ellint_Kcomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Kcomp

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

  5.9.7.  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.8.  ellint_Pcomp

      Synopsis
        S-Lang version of gsl_sf_ellint_Pcomp

      Usage
        Double_Type[] ellint_Pcomp (k, n [,mode])

            Double_Type[] k
            Double_Type[] n
            Int_Type mode

  5.9.9.  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.10.  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.11.  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.12.  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.11.6.  zetam1

      Synopsis
        S-Lang version of gsl_sf_zetam1

      Usage
        Double_Type[] zetam1 (Double_Type[] s)

  5.11.7.  zetam1_int

      Synopsis
        S-Lang version of gsl_sf_zetam1_int

      Usage
        Double_Type[] zetam1_int (Int_Type[] s)

  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.  expint_En

      Synopsis
        S-Lang version of gsl_sf_expint_En

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

  5.12.10.  expint_En_scaled

      Synopsis
        S-Lang version of gsl_sf_expint_En_scaled

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

  5.12.11.  expm1

      Synopsis
        S-Lang version of gsl_sf_expm1

      Usage
        Double_Type[] expm1 (Double_Type[] x)

  5.12.12.  exprel

      Synopsis
        S-Lang version of gsl_sf_exprel

      Usage
        Double_Type[] exprel (Double_Type[] x)

  5.12.13.  exprel_2

      Synopsis
        S-Lang version of gsl_sf_exprel_2

      Usage
        Double_Type[] exprel_2 (Double_Type[] x)

  5.12.14.  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.  mathieu_a

      Synopsis
        S-Lang version of gsl_sf_mathieu_a

      Usage
        Double_Type[] mathieu_a (Int_Type[] order, Double_Type[] qq)

  5.22.14.  mathieu_b

      Synopsis
        S-Lang version of gsl_sf_mathieu_b

      Usage
        Double_Type[] mathieu_b (Int_Type[] order, Double_Type[] qq)

  5.22.15.  mathieu_ce

      Synopsis
        S-Lang version of gsl_sf_mathieu_ce

      Usage
        Double_Type[] mathieu_ce (order, qq, zz)

            Int_Type[] order
            Double_Type[] qq
            Double_Type[] zz

  5.22.16.  mathieu_Mc

      Synopsis
        S-Lang version of gsl_sf_mathieu_Mc

      Usage
        Double_Type[] mathieu_Mc (kind, order, qq, zz)

            Int_Type[] kind
            Int_Type[] order
            Double_Type[] qq
            Double_Type[] zz

  5.22.17.  mathieu_Ms

      Synopsis
        S-Lang version of gsl_sf_mathieu_Ms

      Usage
        Double_Type[] mathieu_Ms (kind, order, qq, zz)

            Int_Type[] kind
            Int_Type[] order
            Double_Type[] qq
            Double_Type[] zz

  5.22.18.  mathieu_se

      Synopsis
        S-Lang version of gsl_sf_mathieu_se

      Usage
        Double_Type[] mathieu_se (order, qq, zz)

            Int_Type[] order
            Double_Type[] qq
            Double_Type[] zz

  5.22.19.  poch

      Synopsis
        S-Lang version of gsl_sf_poch

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

  5.22.20.  pochrel

      Synopsis
        S-Lang version of gsl_sf_pochrel

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

  5.22.21.  Shi

      Synopsis
        S-Lang version of gsl_sf_Shi

      Usage
        Double_Type[] Shi (Double_Type[] x)

  5.22.22.  Si

      Synopsis
        S-Lang version of gsl_sf_Si

      Usage
        Double_Type[] Si (Double_Type[] x)

  5.22.23.  sinc

      Synopsis
        S-Lang version of gsl_sf_sinc

      Usage
        Double_Type[] sinc (Double_Type[] x)

  5.22.24.  synchrotron_1

      Synopsis
        S-Lang version of gsl_sf_synchrotron_1

      Usage
        Double_Type[] synchrotron_1 (Double_Type[] x)

  5.22.25.  synchrotron_2

      Synopsis
        S-Lang version of gsl_sf_synchrotron_2

      Usage
        Double_Type[] synchrotron_2 (Double_Type[] x)

  5.22.26.  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_al-
  loc function. As stated above, there are more than 60 generators 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 exam-
  ple,

          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''

  7.1.3.  convolve

      Synopsis
        Perform a convolution

      Usage
        b = convolve (array, kernel)

      Description
        This function performs a convolution of the specified array and
        kernel using FFTs. One of the following qualifiers may be used
        to indicate how the overlap of the kernel with the edges of the
        array are to be handled:

              pad=value        Pad the array with the specified value
              wrap             Use periodic boundary-conditions
              reflect          Reflect the pixels at the boundary
              nearest          Use the value of the nearest edge pixel

     The default behavior is to use pad=0.0.

      Notes
        The current implementation utilizes ffts and will expand the
        array to the nearest multiple of small primes for run-time
        efficiency. A future version may allow different methods to be
        used.

      See Also
        ``fft'', ``correlate''

  7.1.4.  correlate

      Synopsis
        Perform a correlation

      Usage
        b = correlate (array, kernel)

      Description
        This function performs a correlation of the specified array and
        kernel using FFTs. One of the following qualifiers may be used
        to indicate how the overlap of the kernel with the edges of the
        array are to be handled:

              pad=value        Pad the array with the specified value
              wrap             Use periodic boundary-conditions
              reflect          Reflect the pixels at the boundary
              nearest          Use the value of the nearest edge pixel

     The default behavior is to use pad=0.0.

      Notes
        The current implementation utilizes ffts and will expand the
        array to the nearest multiple of small primes for run-time
        efficiency. A future version may allow different methods to be
        used.

      See Also
        ``fft'', ``convolve''

  8.  gsldwt: The GSL Discrete Wavelet Transform module

  The gsldwt may be used to perform discrete wavelet transforms (DWT)
  for real data in both one and two dimensions. The module itself
  currently provides a single function called dwt that performs a
  forward or backward n-dimensional DWT.

  8.1.  Discrete Wavelet Transform Routines

  8.1.1.  wavelet_transform

      Synopsis
        Perform an N-d Discrete Wavelet Transform

      Usage
        w = wavelet_transform (x, dir)

      Description
        This routine computes the DWT of an array x and returns the
        result. The optional dir parameter specifies the direction of
        the transform. A forward transform will be produced for positive
        values of dir (default value) and a reverse transform will be
        computed for negative values. Array dimension(s) must be an
        integer power of two.

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

        The following qualifiers may be used :

              type = DWT_HAAR|DWT_DAUBECHIES|DWT_BSPLINE
              k = value          Selects the specific member of the wavelet
                                 family.
              centered           The centered forms of the wavelets align the
                                 coefficients of the various sub-bands on edges.
              nsf                Choose the "non-standard" forms ordering of the
                                 rows and columns in the two-dimensional wavelet
                                 transform.

     The following wavelet types are implemented : Daubechies (k = 4, 6,
     ..., 20, with k even), Haar (k = 2), bsplines (k = 100*i + j are
     103, 105, 202, 204, 206, 208, 301, 303, 305 307, 309).

  9.  gslmatrix: A Collection of Matrix-Oriented GSL functions

  The S-lang interpreter has wide-spread native support for manipulating
  arrays and matrices. The gslmatrix supplements this by adding some
  linear algebra routines such LU decomposition as well as routines for
  dealing with eigenvalues and eigenvectors.

  GSL <http://www.gnu.org/software/gsl/> has separate functions for
  complex numbers. Rather than creating separate wrappers for each of
  these functions, the complex-valued routines have been incorporated
  into single wrappers that support for both real and complex numbers.
  In this way the interface is polymorphic.

  9.1.  Linear Algebra and Matrix-Oriented Routines

  9.1.1.  linalg_LU_decomp

      Synopsis
        Factorize a square matrix into its LU decomposition

      Usage
        (LU,p) = linalg_LU_decomp (A [,&signum])

      Description
        This routines returns the LU decomposition of the square matrix
        A such that P#A == LU. See the corresponding GSL documentation
        for how L and U are stored in LU, and how the permutation matrix
        P is defined. For many applications, it is unnecessary to unpack
        the matrix LU into its separate components.

        If the optional argument &signum is given, upon return signum
        will be set to the sign of the permutation that relates P to the
        identity matrix.

      See Also
        ``linalg_LU_det'', ``linalg_LU_invert'', ``linalg_LU_solve''

  9.1.2.  linalg_LU_det

      Synopsis
        Compute the determinant of a matrix from its LU decomposition

      Usage
        det = linalg_LU_det (LU, signum)

      Description
        This function computes the determinant of a matrix from its LU
        decomposition. In the LU form, determinant is given by the
        product of the diagonal elements with the sign of the
        permutation.

               require ("gslmatrix");
               define determinant (A)
               {
                  variable LU, sig;
                  (LU,) = linalg_LU_decomp (A, &sig);
                  return linalg_LU_det (LU,sig);
               }

      See Also
        ``linalg_LU_lndet'', ``linalg_LU_decomp'', ``linalg_LU_invert'',
        ``linalg_LU_solve''

  9.1.3.  linalg_LU_lndet

      Synopsis
        Compute the log of a determinant using LU decomposition

      Usage
        det = linalg_LU_lndet (LU)

      Description
        This function computes the natural logarithm of the determinant
        of a matrix from its LU decomposition. In the LU form,
        determinant is given by the product of the diagonal elements
        with the sign of the permutation. This function is useful for
        cases where the product of the diagonal elements would overflow.

      See Also
        ``linalg_LU_det'', ``linalg_LU_decomp'', ``linalg_LU_solve'',
        ``linalg_LU_invert''

  9.1.4.  linalg_LU_invert

      Synopsis
        Compute the inverse of a matrix via its LU decomposition

      Usage
        inv = linalg_LU_invert (LU, p)

      Description
        This function may be used to compute the inverse of a matrix
        from its LU decomposition. For the purposes of inverting a set
        of linear equations, it is preferable to use the linalg_LU_solve
        function rather than inverting the equations via the inverse.

              define matrix_inverse (A)
              {
                 return linalg_LU_invert (linalg_LU_decomp (A));
              }

      See Also
        ``linalg_LU_decomp'', ``linalg_LU_solve'', ``linalg_LU_det''

  9.1.5.  linalg_LU_solve

      Synopsis
        Solve a set of linear equations using LU decomposition

      Usage
        x = linalg_LU_solve (LU, p, b)

      Description
        This function solves the square linear system of equations A#x=b
        for the vector x via the LU decomposition of A.

             define solve_equations (A, b)
             {
                return linalg_LU_solve (linalg_LU_decomp (A), b);
             }

      See Also
        ``linalg_LU_decomp'', ``linalg_LU_det'', ``linalg_LU_invert''

  9.1.6.  linalg_QR_decomp

      Synopsis
        Factor a matrix into its QR form

      Usage
        (QR, tau) = linalg_QR_decomp(A)

      Description
        This function may be used to decompose a rectangular matrix into
        its so-called QR such that A=Q#R where Q is a square orthogonal
        matrix and R is a rectangular right-triangular matrix.

        The factor R encoded in the diagonal and upper-triangular
        elements of the first return value QR. The matrix Q is encoded
        in the lower triangular part of QR and the vector tau via
        Householder vectors and coefficients.  See the corresponding GSL
        <http://www.gnu.org/software/gsl/> documentation for the details
        of the encoding. For most uses encoding details are not
        required.

      See Also
        ``linalg_QR_solve''

  9.1.7.  linalg_QR_solve

      Synopsis
        Solve a system of linear equations using QR decomposition

      Usage
        x = linalg_QR_solve(QR, tau, b [,&residual])

      Description
        This function may be used to solve the linear system A#x=b using
        the QR decomposition of A.

        If the optional fourth argument is present (&residual), or if QR
        is not a square matrix, then the linear system will be solved in
        the least-squares sense by minimizing the (Euclidean) norm of
        A#x-b. Upon return, the value of the variable residual is set to
        the the norm of A#x-b.

      Notes
        GSL <http://www.gnu.org/software/gsl/> has a separate function
        called gsl_linalg_QR_lssolve for computing this least-squares
        solution. The linalg_QR_solve combines both
        gsl_linalg_QR_lssolve and gsl_linalg_QR_solve into a single
        routine.

      See Also
        ``linalg_QR_decomp''

  9.1.8.  linalg_SV_decomp

      Synopsis
        Perform a singular-value decomposition on a matrix

      Usage
        (U,S,V) = linalg_SV_decomp(A)

      Description
        This function factors a MxN (M>=N) rectangular matrix A into
        three factors such that A = U#S#transpose(V), where S is
        diagonal matrix containing the singular values of A and V is a
        square orthogonal matrix. Since S is diagonal, it is returned as
        a 1-d array.

      See Also
        ``linalg_SV_solve''

  9.1.9.  linalg_SV_solve

      Synopsis
        Solve a linear system using Singular-Value Decomposition

      Usage
        x = linalg_SV_solve (U,V,S,b)

      Description
        This function ``solves'' the linear system A#x=b using the SVD
        form of A.

      Example

             define svd_solve (A, b)
             {
                variable U, V, S;
                (U,V,S) = linalg_SV_decomp (A);
                return linalg_SV_solve (U,V,S,b);
             }

      See Also
        ``linalg_SV_decomp'', ``linalg_QR_solve'', ``linalg_LU_solve''

  9.1.10.  eigen_symmv

      Synopsis
        Compute the eigenvalues and eigenvectors of a Hermitian matrix

      Usage
        (eigvecs, eigvals)=eigen_symmv(A)

      Description
        This function computes the eigenvalues and eigenvectors of a
        Hermitian (or real-symmetric) square matrix A. The eigenvalues
        are returned sorted on their absolute value (or norm) in
        descending order.

      See Also
        ``eigen_nonsymmv''

  9.1.11.  eigen_nonsymmv

      Synopsis
        Compute the eigenvalues and eigenvectors of a matrix

      Usage
        (eigvecs, eigvals)=eigen_nonsymmv(A)

      Description
        This function returns the eigenvalues and eigenvectors of a real
        non-symmetric matrix A. As such quantities are in general
        complex, complex-valued arrays will be returned. The eigenvalues
        are returned in descending order sorted upon norm.

      See Also
        ``eigen_symmv''

  10.  gslcdf: The GSL Cumulative Distribution Function Module

  The gslcdf module wraps the GSL cumulative distribution functions.

  10.1.  CDF Functions

  10.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

  10.1.2.  cdf_beta_Pinv

      Synopsis
        S-Lang version of gsl_cdf_beta_Pinv

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

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

  10.1.3.  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

  10.1.4.  cdf_beta_Qinv

      Synopsis
        S-Lang version of gsl_cdf_beta_Qinv

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

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

  10.1.5.  cdf_cauchy_P

      Synopsis
        S-Lang version of gsl_cdf_cauchy_P

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

  10.1.6.  cdf_cauchy_Pinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Pinv

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

  10.1.7.  cdf_cauchy_Q

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Q

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

  10.1.8.  cdf_cauchy_Qinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Qinv

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

  10.1.9.  cdf_chisq_P

      Synopsis
        S-Lang version of gsl_cdf_chisq_P

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

  10.1.10.  cdf_chisq_Pinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Pinv

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

  10.1.11.  cdf_chisq_Q

      Synopsis
        S-Lang version of gsl_cdf_chisq_Q

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

  10.1.12.  cdf_chisq_Qinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Qinv

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

  10.1.13.  cdf_exponential_P

      Synopsis
        S-Lang version of gsl_cdf_exponential_P

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

  10.1.14.  cdf_exponential_Pinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Pinv

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

  10.1.15.  cdf_exponential_Q

      Synopsis
        S-Lang version of gsl_cdf_exponential_Q

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

  10.1.16.  cdf_exponential_Qinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Qinv

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

  10.1.17.  cdf_exppow_P

      Synopsis
        S-Lang version of gsl_cdf_exppow_P

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

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

  10.1.18.  cdf_exppow_Q

      Synopsis
        S-Lang version of gsl_cdf_exppow_Q

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

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

  10.1.19.  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

  10.1.20.  cdf_fdist_Pinv

      Synopsis
        S-Lang version of gsl_cdf_fdist_Pinv

      Usage
        Double_Type[] cdf_fdist_Pinv (P, nu1, nu2)

            Double_Type[] P
            Double_Type[] nu1
            Double_Type[] nu2

  10.1.21.  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

  10.1.22.  cdf_fdist_Qinv

      Synopsis
        S-Lang version of gsl_cdf_fdist_Qinv

      Usage
        Double_Type[] cdf_fdist_Qinv (Q, nu1, nu2)

            Double_Type[] Q
            Double_Type[] nu1
            Double_Type[] nu2

  10.1.23.  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

  10.1.24.  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

  10.1.25.  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

  10.1.26.  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

  10.1.27.  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

  10.1.28.  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

  10.1.29.  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

  10.1.30.  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

  10.1.31.  cdf_gaussian_P

      Synopsis
        S-Lang version of gsl_cdf_gaussian_P

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

  10.1.32.  cdf_gaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Pinv

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

  10.1.33.  cdf_gaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Q

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

  10.1.34.  cdf_gaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Qinv

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

  10.1.35.  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

  10.1.36.  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

  10.1.37.  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

  10.1.38.  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

  10.1.39.  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

  10.1.40.  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

  10.1.41.  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

  10.1.42.  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

  10.1.43.  cdf_laplace_P

      Synopsis
        S-Lang version of gsl_cdf_laplace_P

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

  10.1.44.  cdf_laplace_Pinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Pinv

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

  10.1.45.  cdf_laplace_Q

      Synopsis
        S-Lang version of gsl_cdf_laplace_Q

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

  10.1.46.  cdf_laplace_Qinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Qinv

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

  10.1.47.  cdf_logistic_P

      Synopsis
        S-Lang version of gsl_cdf_logistic_P

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

  10.1.48.  cdf_logistic_Pinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Pinv

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

  10.1.49.  cdf_logistic_Q

      Synopsis
        S-Lang version of gsl_cdf_logistic_Q

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

  10.1.50.  cdf_logistic_Qinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Qinv

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

  10.1.51.  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

  10.1.52.  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

  10.1.53.  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

  10.1.54.  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

  10.1.55.  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

  10.1.56.  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

  10.1.57.  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

  10.1.58.  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

  10.1.59.  cdf_rayleigh_P

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_P

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

  10.1.60.  cdf_rayleigh_Pinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Pinv

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

  10.1.61.  cdf_rayleigh_Q

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Q

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

  10.1.62.  cdf_rayleigh_Qinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Qinv

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

  10.1.63.  cdf_tdist_P

      Synopsis
        S-Lang version of gsl_cdf_tdist_P

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

  10.1.64.  cdf_tdist_Pinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Pinv

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

  10.1.65.  cdf_tdist_Q

      Synopsis
        S-Lang version of gsl_cdf_tdist_Q

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

  10.1.66.  cdf_tdist_Qinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Qinv

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

  10.1.67.  cdf_ugaussian_P

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_P

      Usage
        Double_Type[] cdf_ugaussian_P (Double_Type[] x)

  10.1.68.  cdf_ugaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Pinv

      Usage
        Double_Type[] cdf_ugaussian_Pinv (Double_Type[] P)

  10.1.69.  cdf_ugaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Q

      Usage
        Double_Type[] cdf_ugaussian_Q (Double_Type[] x)

  10.1.70.  cdf_ugaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Qinv

      Usage
        Double_Type[] cdf_ugaussian_Qinv (Double_Type[] Q)

  10.1.71.  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

  10.1.72.  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

  10.1.73.  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

  10.1.74.  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

  11.  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.

  11.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_DEBYE

  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_STEFAN_BOLTZMANN_CONSTANT

  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_THOMSON_CROSS_SECTION

  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

  11.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_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_STEFAN_BOLTZMANN_CONSTANT

  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_THOMSON_CROSS_SECTION

  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

  12.  gslcdf: The GSL Cumulative Distribution Function Module

  The gslcdf module wraps the GSL cumulative distribution functions.

  12.1.  CDF Functions

  12.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

  12.1.2.  cdf_beta_Pinv

      Synopsis
        S-Lang version of gsl_cdf_beta_Pinv

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

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

  12.1.3.  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

  12.1.4.  cdf_beta_Qinv

      Synopsis
        S-Lang version of gsl_cdf_beta_Qinv

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

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

  12.1.5.  cdf_cauchy_P

      Synopsis
        S-Lang version of gsl_cdf_cauchy_P

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

  12.1.6.  cdf_cauchy_Pinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Pinv

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

  12.1.7.  cdf_cauchy_Q

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Q

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

  12.1.8.  cdf_cauchy_Qinv

      Synopsis
        S-Lang version of gsl_cdf_cauchy_Qinv

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

  12.1.9.  cdf_chisq_P

      Synopsis
        S-Lang version of gsl_cdf_chisq_P

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

  12.1.10.  cdf_chisq_Pinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Pinv

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

  12.1.11.  cdf_chisq_Q

      Synopsis
        S-Lang version of gsl_cdf_chisq_Q

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

  12.1.12.  cdf_chisq_Qinv

      Synopsis
        S-Lang version of gsl_cdf_chisq_Qinv

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

  12.1.13.  cdf_exponential_P

      Synopsis
        S-Lang version of gsl_cdf_exponential_P

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

  12.1.14.  cdf_exponential_Pinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Pinv

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

  12.1.15.  cdf_exponential_Q

      Synopsis
        S-Lang version of gsl_cdf_exponential_Q

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

  12.1.16.  cdf_exponential_Qinv

      Synopsis
        S-Lang version of gsl_cdf_exponential_Qinv

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

  12.1.17.  cdf_exppow_P

      Synopsis
        S-Lang version of gsl_cdf_exppow_P

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

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

  12.1.18.  cdf_exppow_Q

      Synopsis
        S-Lang version of gsl_cdf_exppow_Q

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

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

  12.1.19.  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

  12.1.20.  cdf_fdist_Pinv

      Synopsis
        S-Lang version of gsl_cdf_fdist_Pinv

      Usage
        Double_Type[] cdf_fdist_Pinv (P, nu1, nu2)

            Double_Type[] P
            Double_Type[] nu1
            Double_Type[] nu2

  12.1.21.  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

  12.1.22.  cdf_fdist_Qinv

      Synopsis
        S-Lang version of gsl_cdf_fdist_Qinv

      Usage
        Double_Type[] cdf_fdist_Qinv (Q, nu1, nu2)

            Double_Type[] Q
            Double_Type[] nu1
            Double_Type[] nu2

  12.1.23.  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

  12.1.24.  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

  12.1.25.  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

  12.1.26.  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

  12.1.27.  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

  12.1.28.  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

  12.1.29.  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

  12.1.30.  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

  12.1.31.  cdf_gaussian_P

      Synopsis
        S-Lang version of gsl_cdf_gaussian_P

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

  12.1.32.  cdf_gaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Pinv

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

  12.1.33.  cdf_gaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Q

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

  12.1.34.  cdf_gaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_gaussian_Qinv

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

  12.1.35.  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

  12.1.36.  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

  12.1.37.  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

  12.1.38.  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

  12.1.39.  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

  12.1.40.  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

  12.1.41.  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

  12.1.42.  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

  12.1.43.  cdf_laplace_P

      Synopsis
        S-Lang version of gsl_cdf_laplace_P

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

  12.1.44.  cdf_laplace_Pinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Pinv

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

  12.1.45.  cdf_laplace_Q

      Synopsis
        S-Lang version of gsl_cdf_laplace_Q

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

  12.1.46.  cdf_laplace_Qinv

      Synopsis
        S-Lang version of gsl_cdf_laplace_Qinv

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

  12.1.47.  cdf_logistic_P

      Synopsis
        S-Lang version of gsl_cdf_logistic_P

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

  12.1.48.  cdf_logistic_Pinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Pinv

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

  12.1.49.  cdf_logistic_Q

      Synopsis
        S-Lang version of gsl_cdf_logistic_Q

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

  12.1.50.  cdf_logistic_Qinv

      Synopsis
        S-Lang version of gsl_cdf_logistic_Qinv

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

  12.1.51.  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

  12.1.52.  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

  12.1.53.  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

  12.1.54.  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

  12.1.55.  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

  12.1.56.  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

  12.1.57.  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

  12.1.58.  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

  12.1.59.  cdf_rayleigh_P

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_P

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

  12.1.60.  cdf_rayleigh_Pinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Pinv

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

  12.1.61.  cdf_rayleigh_Q

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Q

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

  12.1.62.  cdf_rayleigh_Qinv

      Synopsis
        S-Lang version of gsl_cdf_rayleigh_Qinv

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

  12.1.63.  cdf_tdist_P

      Synopsis
        S-Lang version of gsl_cdf_tdist_P

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

  12.1.64.  cdf_tdist_Pinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Pinv

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

  12.1.65.  cdf_tdist_Q

      Synopsis
        S-Lang version of gsl_cdf_tdist_Q

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

  12.1.66.  cdf_tdist_Qinv

      Synopsis
        S-Lang version of gsl_cdf_tdist_Qinv

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

  12.1.67.  cdf_ugaussian_P

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_P

      Usage
        Double_Type[] cdf_ugaussian_P (Double_Type[] x)

  12.1.68.  cdf_ugaussian_Pinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Pinv

      Usage
        Double_Type[] cdf_ugaussian_Pinv (Double_Type[] P)

  12.1.69.  cdf_ugaussian_Q

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Q

      Usage
        Double_Type[] cdf_ugaussian_Q (Double_Type[] x)

  12.1.70.  cdf_ugaussian_Qinv

      Synopsis
        S-Lang version of gsl_cdf_ugaussian_Qinv

      Usage
        Double_Type[] cdf_ugaussian_Qinv (Double_Type[] Q)

  12.1.71.  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

  12.1.72.  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

  12.1.73.  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

  12.1.74.  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

  13.  gslinteg: The GSL Numerical Integration Module

  The gslinteg wraps the GSL 1-d numerical integration of functions of
  the form

  \int_a^b dx\;w(x)f(x;p)

  ,

  where w(x) is a weight function whose form depends upon the specific
  integration routine, and p represents an optional set of paramters
  that the function depends upon. The function f(x;p) must be supplied
  by the user in one of the following forms, depending upon the
  existence of the optional parameters.

          define func (x) { ...; return f };
          define func (x, parms) { ...; return f; }

  The parms variable in the second form is the list of optional parame-
  ters represented by p. For example, consider the function

  f(x;a,b) = (x-a)^b

  It may be coded as

          define func (x,parms)
          {
             variable a = parms[0], b = parms[1];
             return (x-a)^b;
          }

  To illustrate the use of module, the example for the
  gsl_integration_fixed function that appears in the GSL documentation.
  <https://www.gnu.org/software/gsl/doc/html/integration.html#c.gsl_integration_fixed_workspace>
  will be given:

          define example_func (x, parms)
          {
             return x^parms[0] + 1.0;
          }
          define slsh_main ()
          {
             variable m = 10, n = 6;
             variable w = integration_fixed_alloc ("hermite", n, 0, 1, 0, 0);

             variable parms = {m};  % parms is a list of optional parameters
             variable res = integration_fixed (&example_func, parms, w);

             vmessage ("Result = %S", res.result);
             vmessage ("Function calls: %S", res.neval);
             vmessage ("Status: %S", res.status);
             vmessage ("Abserror: %S", res.abserr);
          }

  As the example illustrates, the integration function returns a struc-
  ture with the following fields:

            result  : The value computed by the integrator
            abserr  : An estimate the absolute error
            neval   : The number of function evaluations
            status  : The status value returned from the integrator

  Not all of the integration routines return a meaningful value of the
  abserr.

  Many of the underlying integration routines require a workspace to be
  allocated. For such cases, the module handles handles this internally.
  Compare the following with the corresponding example given in the GSL
  documentation that utilizes the gsl_integration_qags integrator:

          define example_func (x, parms)
          {
             variable alpha = parms[0];
             return log (alpha*x)/sqrt(x);
          }
          define slsh_main ()
          {
             variable alpha = 1.0;
             variable parms = {alpha};
             variable res
                = integration_qags (&example_func, parms, 0, 1, 0, 1e-7, 1000);

             vmessage ("Result = %S", res.result);
             vmessage ("Function calls: %S", res.neval);
             vmessage ("Status: %S", res.status);
             vmessage ("Abserror: %S", res.abserr);
          }

  13.1.  Numerical Integration Routines

  13.1.1.  integration_qng

      Synopsis
        non-adaptive Gauss-Kronrod integration

      Usage
        res = integration_qng (&func, [optargs-list,] a, b, epsabs,
        relabs

      Description
        This function wraps the gsl_integration_qng function.  See the
        GSL documentation for more information.

  13.1.2.  integration_qag

      Synopsis
        Adaptive integration

      Usage
        res = integration_qag (&func, [optargs_list,] a, b, epsabs,
        relabs, limit, key)

      Description
        This function wraps the gsl_integration_qag function.  See the
        GSL documentation for more information.

  13.1.3.  integration_qags

      Synopsis
        Adaptive integration with singularities

      Usage
        res = integration_qags (&func, [optargs_list,] a, b, epsabs,
        relabs, limit, key)

      Description
        This function wraps the gsl_integration_qags function.  See the
        GSL documentation for more information.

  13.1.4.  integration_qagp

      Synopsis
        Adaptive integration with known singular points

      Usage
        res = integration_qagp (&func, [optargs_list, pts, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_qagp function.  See the
        GSL documentation for more information.

  13.1.5.  integration_qagi

      Synopsis
        Adaptive integration on infinite intervals

      Usage
        res = integration_qagi (&func, [optargs_list,] epsabs, epsrel,
        limit)

      Description
        This function wraps the gsl_integration_qagi function.  See the
        GSL documentation for more information.

  13.1.6.  integration_qagiu

      Synopsis
        Adaptive integration on semi-infinite intervals

      Usage
        res = integration_qagiu (&func, [optargs_list,] a, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_qagiu function.  See the
        GSL documentation for more information.

  13.1.7.  integration_qagil

      Synopsis
        Adaptive integration on semi-infinite intervals

      Usage
        res = integration_qagil (&func, [optargs_list,] b, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_qagil function.  See the
        GSL documentation for more information.

  13.1.8.  integration_qawc

      Synopsis
        Adaptive integration for Cauchy principal values

      Usage
        res = integration_qawc (&func, [optargs_list,] a, b, c, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_qawc function.  See the
        GSL documentation for more information.  #%

      See Also

  13.1.9.  integration_cquad

      Synopsis
        Doubly-adaptive integration

      Usage
        res = integration_cquad (&func, [optargs_list,] a, b, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_cquad function.  See the
        GSL documentation for more information.  #%

      See Also

  13.1.10.  integration_romberg

      Synopsis
        Romberg integration

      Usage
        res = integration_romberg (&func, [optargs_list,] a, b, epsabs,
        epsrel, limit)

      Description
        This function wraps the gsl_integration_romberg function.  See
        the GSL documentation for more information.  #%

      See Also

  13.1.11.  integration_fixed_alloc

      Synopsis
        Create a workspace for the integration_fixed function

      Usage
        fixedobj = integration_fixed_alloc (typestr, n, a, b, alpha,
        beta)

      Description
        This function wraps the gsl_integration_fixed_alloc function.
        It return a workspace that is to be passed to the
        integration_fixed function. The typestr parameter is used to
        specify the weighting functions using by the integrator. It must
        be one of the following: #v+ "legendre", "chebyshev",
        "gegenbauer", "jacobi", "laguerre", "hermite", "exponential",
        "rational", "chebyshev2" #v- See the GSL documentation for more
        information.  #%

      See Also

  13.1.12.  integration_fixed

      Synopsis
        Fixed point quadrature integration

      Usage
        res = integration_fixed (&func, [optargs_list,] fixedobj)

      Description
        This function wraps the gsl_integration_fixed function. Here,
        fixedobj is the workspace returned by the
        integration_fixed_alloc function.  See the GSL documentation for
        more information.  #%

      See Also

  13.1.13.  integration_glfixed_alloc

      Synopsis
        Create a table of precomputed values for the integration_fixed
        function

      Usage
        glfixed_table = integration_glfixed_alloc (n)

      Description
        This function wraps the gsl_integration_glfixed_table_alloc
        function. It returns a table of values that is to be passed to
        the integration_glfixed function to perform an n-point fixed
        order integration.

        See the GSL documentation for more information.  #%

      See Also

  13.1.14.  integration_glfixed

      Synopsis
        Gauss-Legendre integration

      Usage
        res = integration_glfixed (&func, [optargs_list,] a, b,
        glfixed_table)

      Description
        This function wraps the gsl_integration_glfixed function. The
        glfixed_table represents the precomputed values returned by the
        integration_glfixed_alloc function.

        See the GSL documentation for more information.  #%

      See Also

  13.1.15.  integration_qaws_alloc

      Synopsis
        Create a table of precomputed values for the integration_qaws
        function

      Usage
        qaws_table = integration_qaws_alloc (alpha, beta, mu, nu)

      Description
        This function wraps the gsl_integration_qaws_table_alloc
        function. It returns a precomputed table of values that is to be
        passed to the integration_qaws function.

        See the GSL documentation for more information.  #%

      See Also

  13.1.16.  integration_qaws

      Synopsis
        Adaptive integration for singular functions

      Usage
        res = integration_qaws (&func, [optargs_list,] a, b, epsabs,
        epsrel, limit, qaws_table)

      Description
        This function wraps the gsl_integration_qaws function.  Here,
        qaws_table represents the pre-computed values returned by the
        integration_qaws_alloc function.

        See the GSL documentation for more information.  #%

      See Also

  13.1.17.  integration_qawo_alloc

      Synopsis
        Create a table of precomputed values for the integration_qawo
        function

      Usage
        res = integration_qawo_alloc (omega, L, type, n)

      Description
        This function wraps the gsl_integration_qawo_table_alloc
        function. It returns a precomputed table of Chebyshev moments
        that is to be passed to the integration_qawo function. Here,
        type must be one of the symbolic constants GSL_INTEG_COSINE or
        GSL_INTEG_SINE.

        See the GSL documentation for more information.  #%

      See Also

  13.1.18.  integration_qawo

      Synopsis
        Adaptive integration for oscillatory functions

      Usage
        res = integration_qawo (&func, [optargs_list,] a, epsabs,
        epsrel, limit, qawo_table)

      Description
        This function wraps the gsl_integration_qawo function. Here,
        qawo_table is to be precomputed using the integration_qawo_alloc
        function.

        See the GSL documentation for more information.  #%

      See Also

  13.1.19.  integration_qawf

      Synopsis
        Adaptive integration for Fourier integrals

      Usage
        res = integration_qawf (&func, [optargs_list, a, epsabs, limit,
        qawo_table] )

      Description
        This function wraps the gsl_integration_qawf function.  Here,
        qawo_table is to be precomputed using the integration_qawo_alloc
        function.  See the GSL documentation for more information.  #%

      See Also

