Differential equation solving capabilities (for exact and numeric solutions) have been greatly enhanced by new algorithms. To learn about the DE updates, including the dsolve and pdsolve commands, see updates,Maple8,differential_equations.

A flexible conversion facility in the mathematical language is as important as a dictionary in spoken languages. Maple 8 introduces such a tool in a computer algebra system for the first time, implemented as a net of conversion routines permitting the expression of any mathematical function in terms of another one, whenever that is possible as a finite sum of terms. When the parameters of the functions being converted depend on symbols in a rational manner, any assumptions on these symbols made by the user are taken into account at the time of performing the conversions (see assuming).

Example:

ee := exp(1/2*z)* WhittakerM(0,1/2,z);

convert( (1), MeijerG );

convert( (2), exp );

convert( (3), hypergeom, include=exp );

Converting the original expression  directly to hypergeom we arrive at an identity for hypergeometric functions

(4) = convert(ee, hypergeom);

simplify( (lhs-rhs)((5)) );

The main idea behind the Maple 8 conversion network is to split the set of mathematical functions into three main subsets, according to their hypergeometric representation as 2F1, 1F1 and 0F1 hypergeometric functions. Then, generally speaking, conversions - when possible - can be performed among functions of the same class. The Maple 8 routines allow you to convert to any of 58 mathematical functions, including all the elementary transcendental ones and most of the special functions of mathematical physics:

Example: Conversions between 2F1 functions

JacobiP(1/2,0,-1,z);

convert((7),EllipticE);

convert((8),LegendreP);

convert((9),GegenbauerC);

convert((10),hypergeom);

Example: Conversions between 1F1 functions

erf(z);

convert((12),HermiteH);

convert((13),KummerU);

normal(convert((14),WhittakerW));

Taking into account the possible split of the set of mathematical functions into hypergeometric classes as well as their classification found in typical handbooks like Abramowitz and Stegun, the Maple 8 routines also permits converting to a function class; that is, attempting to rewrite a given expression by using any of the functions of a specified class.

Example:

1/2*LegendreP(-1/2,-1/2,-1-2*z^2+4*z)*(-2*z^2+4*z)^(1/4)/(-2-2*z^2+4*z)^(1/4)*(z-1);

convert((16),arctrig);

The function classes understood by the Maple 8 mathematical function conversion network are:

The new conversion routines also introduce the concept of "rule conversion", that is, a conversion where the input and output are expressed using the same function but applying identity rules to it. For example, the HermiteH function

H1 := HermiteH(a,z);

can have its (first) parameter raised or lowered by one. Below, "raise a" stands for "raise the first parameter":

H2 := convert(H1, HermiteH, "raise a");

For functions depending on more parameters, for example, LegendreP or JacobiP, you can raise the second or third parameters using "raise b" or "raise c". The rules known by the Maple 8 conversion routines are:

The mathematical identities which can be derived using the new conversion routines can be checked visually in Maple 8 using the new plotcompare routine, which draws four 3-D plots, comparing the real and imaginary parts of two expressions when evaluated over a complex variable .

All the Maple 8 conversion routines listed in the tables above understand a uniform set of optional arguments for restricting the conversion process in varied manners, for example, performing (or excluding) the conversion process only for some functions (see convert,to_special_function), therefore providing the necessary flexibility for optimal symbolic manipulation.

More Maple functions now take assumptions into account (see assuming).

binomial(a,b) assuming a::fraction, b::integer, b<0;

binomial(a,2) assuming a::fraction;

GAMMA(a,z) assuming a=1/2;

We have made two improvements to sqrt simplification. One is to take the square root of an exponential. The other is to simplify square roots of integers by, without factoring the integers, pulling out squares of small primes and taking the exact square root of the other component. This significantly reduces the size of the formulae computed by solve.

sqrt(exp(2));

sqrt(exp(2*x)) assuming x > 0;

sqrt(3^2*997);

sqrt(997^2*3);

q5 := x^5-10*x^4+9*x^3-4*x^2-1;

sol := solve(q5): sol[1];

convert(sol[1],radical);

A new Matrix indexing function, index/Circulant, for circulant matrices (which are diagonalizable by the Fourier matrix of the appropriate size, and thus easy to use) has been added.  Also, index/Vandermonde has been improved to handle the confluent Vandermonde matrix case. By default, a Vandermonde matrix with repeated interpolation points is singular (because this is what is needed in teaching), but with the option confluent, a nonsingular matrix that demands derivative data is produced.

Procedure hasassumptions has been added to the assume facility. It can be used to check whether some assumptions were made on a variable.

a := 'a';

hasassumptions(a);

assume(a, real);

hasassumptions(a);

a := 'a';

hasassumptions(a);

assume(a+b, real);

hasassumptions(a);

Symbolic summation capabilities have been enhanced by algorithms based on ideas from integral representations. Maple can now handle new types of sums, for example Abel-type definite sums and some hypergeometric sums involving polynomials of unknown degree.

Examples:

F:=(x+k)^(k-1)*(y+n-k-a)^(n-k-1)*binomial(n,k);

sum(F,k=1..n);

F:=(2+k)^(k-2)*(1+n-k)^(n-k)/(k!*(n-k)!);

sum(F,k=0..n);

F:=(-1)^x/x!/(y-x)!*(x^n)/(x+1)/(x+7);

sum(F,x=0..y) assuming n::posint;

F:=(-1)^x/x!/(y-x)!*ChebyshevU(2*n-1,x)/(x^2+3*x+2);

sum(F,x=1..y) assuming n::posint;

Both parfrac and fullparfrac partial fraction conversions have been enhanced.

The  routine has been rewritten. Additional detail on the new routine can be found in updates/Maple8/efficiency.

  has been modified to be able to produce full partial fraction decompositions in a new form that is far more efficient when additional variables (other than the main variable) are present in the input. The default has also changed for this class of problems. Additional detail can be found in convert,fullparfrac.

The division procedure , when called as a function, now accepts 1 argument, in which case it returns the reciprocal of that argument. When used as an operator, however, two operands are still required.

s / t;

`/`( s, t );

`/`( t );