## [fc9ff5]: ChangeLog-5.17-special-functions Maximize Restore History

### ChangeLog-5.17-special-functions    188 lines (148 with data), 7.1 kB

```   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.
- 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 indepently

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

```