   Maxima 5.17 change log for special functions
   Compiled 2008-12-08
   by Dieter Kaiser

--------------------------------------------------------------------------------
Extensions and changes to the Factorial function:

 Maxima User function:     factorial(z)
 New Maxima User variable: factorial_expand

 - Complex float and complex bigfloat support added
 - Check for a negative integer or a real representation of an integer
 - Set $factlim to the value 100,000 to avoid unintentional overflow
 - Implementation of mirror symmetry
 - Expand factorial(n+m) where m is an integer
   The expansion depends on the Maxima User variable $factorial_expand.
   The functionality is comparable with the function minfactorial.
   But because the expansion is done by the simplifier we have no
   problems with nested expression.

 Related bugs:
 SF[1571099] handling of large factorials
 SF[1486452] minfactorial doesn't look inside "!"

--------------------------------------------------------------------------------
Changes to General factorial:

 Maxima User function: genfact(x,y,z):

 - Adding tests for the arguments of genfact(x,y,z).
   The algorithm of genfact(x,y,z) only works for the following range
   of the arguments: x, y, z positive integer and z <= x and y <= x/z.
   The tests for this range of values have been added. For integer
   values beyond this range a Maxima error is thrown. For all other
   numbers Maxima returns  a noun form.

 Related bug:
 SF [1093138] double factorial defn incorrect for noninteger operand

--------------------------------------------------------------------------------
Implementation of Double factorial

 New Maxima User function: double_factorial(z)
 New Maxima User variable: factorial_expand

 double_factorial is a generalization of genfact(x,y,z) for real and
 complex values. For an integer argument to double_factorial the
 function genfact(x,y,z) is called.

 - Numerical evaluation for integer, real and complex values in float
   and bigfloat precision
 - Implementation of the derivative
 - Mirror symmetry
 - Maxima Error for even negative integer
 - When $factorial_expand T expansion for factorial_double(2*k+z)
   and k an integer
 - Transformation to a Gamma function with $makegamma

 Related bug:
 SF [1093138] double factorial defn incorrect for noninteger operand

--------------------------------------------------------------------------------
Extensions and improvements of the Gamma function

 Maxima User function:     gamma(z)
 New Maxima User variable: gamma_expand

 - Adding code to evaluate complex bigfloats using the routine cbffac.
 - Detect a float or bigfloat representation of a negative integer.
 - Adding a test to check an overflow in the numerical routine
   gamma-lanczos.
 - Adding code for autoloading cbffac in max_ext.lisp
 - Simplify gamma(z+n) when n an integer e.g.
   gamma(z+1) = n * gamma(z)
   gamma(z+2) = n * (z+1) * gamma(z)
   gamma(z-1) = - gamma(z) / (1-n)
   gamma(z-2) = gamma(z) / ((1-n) * (2-n))
 - Do the extraction of the realpart and imagpart when we know we
   have a complex number.
 - Improved accuracy for float, bigfloat and complex bigfloat values.
 - reduce the default value of $gammalim to 10,000
 - $gammalim and $factlim now work independently

 Related bugs:
 SF [2013650] gamma(250.0) returns non-number; gamma(-1.0) finite
 SF [2134791] Gamma ask for the sign of an expression

--------------------------------------------------------------------------------
Implementation of the Incomplete Gamma function

 New Maxima User function: gamma_incomplete(a,z)

 The following features are implemented:

 - Evaluation for real and complex numbers in double float and
   bigfloat precision
 - Special values for gamma_incomplete(a,0) and gamma_incomplete(a,inf)
 - When $gamma_expand T expand the following expressions:
   gamma_incomplete(0,z)
   gamma_incomplete(n+1/2)
   gamma_incomplete(1/2-n)
   gamma_incomplete(n,z)
   gamma_incomplete(-n,z)
   gamma_incomplete(a+n,z)
   gamma_incomplete(a-n,z)
 - Mirror symmetry
 - Derivative wrt the arguments a and z

--------------------------------------------------------------------------------
Implementation of the Generalized Incomplete Gamma function

 New Maxima User function: gamma_incomplete_generalized(a,z1,z2)

 The following features are implemented:

 - Evaluation for real and complex numbers in double float and
   bigfloat precision
 - Special values for:
   gamma_incomplete_generalized(a,z1,0)
   gamma_incomplete_generalized(a,0,z2),
   gamma_incomplete_generalized(a,z1,inf)
   gamma_incomplete_generalized(a,inf,z2)
   gamma_incomplete_generalized(a,0,inf)
   gamma_incomplete_generalized(a,x,x)
 - When $gamma_expand T and n an integer expand
   gamma_incomplete_generalized(a+n,z1,z2)
 - Implementation of Mirror symmetry
 - Derivative wrt the arguments a, z1 and z2

--------------------------------------------------------------------------------
Implementation of the Regularized Incomplete Gamma function

 New Maxima User function: gamma_incomplete_regularized(a,z)

 The following features are implemented:

 - Evaluation for real and complex numbers in double float and
   bigfloat precision
 - Special values for:
   gamma_incomplete_regularized(a,0)
   gamma_incomplete_regularized(0,z)
   gamma_incomplete_regularized(a,inf)
 - When $gamma_expand T and n a positive integer expansions for
   gamma_incomplete_regularized(n+1/2,z)
   gamma_incomplete_regularized(1/2-n,z)
   gamma_incomplete_regularized(n,z)
   gamma_incomplete_regularized(a+n,z)
   gamma_incomplete_regularized(a-n,z)
 - Derivative wrt the arguments a and z
 - Implementation of Mirror symmetry

--------------------------------------------------------------------------------
Implementation of the Logarithm of the Gamma function

 New Maxima User function: log_gamma(z).

 The following features are implemented:

 - Evaluation for real and complex values in float and bigfloat
   precision.
 - For positive integer values n transformation to log(factorial(n)).
 - Check for negative integers, float or bigfloat representation.
 - Simplify gamma_log(inf) -> inf

--------------------------------------------------------------------------------
Extension and implementation of the Error functions

 New Maxima User functions: erf(z)
                            erfc(z)
                            erfc(z)
                            erfi(z)
                            erf_generalized(z1,z2)

 New Maxima User flag: erf_representation

 The following features are implemented:

 - Real and complex evaluation in double float and bigfloat precision.
 - For numerical evaluation in double float precision the slatec
   routine slatec:derf is called. In all other cases the numerical
   routines of the Incomplete Gamma function are called.
 - Specific values for zero, one, inf and minf
 - Implementation of mirror symmetry
 - Transform into a representation in terms of the Error function erf
   when erf_representation is T
 - Odd reflection symmetry is implemented for the Error function erf

