# [Maxima] Maxima 5.17.0 release

Dieter Kaiser drdieterkaiser at web.de
Mon Dec 8 13:11:08 CST 2008

```Am Donnerstag, den 04.12.2008, 17:56 -0500 schrieb Raymond Toy:
> Robert Dodier wrote:
> >
> > Please give it a try and let us know how it works out.
> >
> I notice there's no Changelog-5.17.  Was that an oversight?  (Ok if you
> didn't want to make one.)
>
> Maybe we should require developers to add changelog entries (easy to do
> with emacs) when they commit changes?  I'd rather not, but many other
> projects require it.

Perhaps it is useful for a changelog. I have collected the last
contributions to the project we have done and where I was involved:

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

--------------------------------------------------------------------------------
At this time the following is not part of the release 5.17:
--------------------------------------------------------------------------------

Extending the integrator

Extending the integrator to get more integrals with power functions.
These are the patterns added (n is an integer, sometimes a positive
integer):

Type 1: a^(b*(z^r)^p+d)
Type 2: z^v*a^(b*z^r+d)
Type 3: (a*z+b)^p*%e^(c*z+d)
Type 4: d^(a*z^2+b/z^2+c)
Type 4-1: z^(2*n)*d^(a*z^2+b/z^2+c)
Type 5: z^n*d^(a*z^2+b*z+c)
Type 6: z^n*d^(a*sqrt(z)+b*z+c)
Type 7: z^n*a^(b*z^r+e)*h^(c*z^r+g)
Type 8: a^(b*sqrt(z)+d*z+e)*h^(c*sqrt(z)+f*z+g)
Type 9: z^n*a^(b*z^2+d*z+e)*h^(c*z^2+f*z+g)
Type 10: z^n*a^(b*sqrt(z)+d*z+e)*h^(c*sqrt(z)+f*z+g)

The solutions are in terms of the gamma_incomplete, expintegral_e or
error functions.

--------------------------------------------------------------------------------
Integration of special functions

Adding code to support the integration of special functions.
Short description of the modifications:

- Put the integral of the elementary function on the property list.
- Extend the routine integrallookups with an algorithm to look up
the integral from the property list.
- Write a more general routine to do a partial integration and call
this routine in the routine intform.
- Generalize diffdiv to support the integration of functions with more
than one argument (e.g. for gamma_incomplete and expintegral_e).

In a first step the following functions can be integrated:

gamma_incomplete
expintegral_e
expintegral_e1
expintegral_ei
expintegral_li
expintegral_si and expintegral_ci
expintegral_shi and expintegral_chi
erf, erfc and erfi

--------------------------------------------------------------------------------

Dieter Kaiser

```