The diff command can now compute derivatives of abstract order for varied expressions, returning results in closed form or as finite sums. Similarly, a new fracdiff command computes derivatives of non-integral order.

Examples

For arbitrary values of , a positive integer,

Diff(sin(x), x$n);

value((1));

The new routines can compute the symbolic order derivative of most mathematical functions and of some of their compositions with other functions or algebraic expressions. To compute the nth integral, that is, the inverse operation, differentiate " times".

diff((2), x$(-n));

A more involved example:

Diff(exp(x^2), x$n);

value((4));

The Leibniz rule for the derivative of a product:

Diff(f(x)*g(x), x$n);

value((6));

The fractional derivative of the exponential function and the general formula (see fracdiff) for an arbitrary

fracdiff(exp(x), x, 1/2);

fracdiff(f(x), x, 1/2);

An number of new formulas, some of them original, were added for the differentiation of special functions with respect to parameters.

Examples

Differentiating Bessel functions with respect to the first parameter (assuming the first parameter is a positive integer):

Diff(BesselJ(n,z),n) = diff(BesselJ(n,z),n) assuming n::posint;

Maple can perform the derivative above for any of the four Bessel functions and also when  is a negative integer.

Diff(BesselK(n,z),n) = diff(BesselK(n,z),n) assuming n::negint;

Similar formulas are implemented for the Struve functions, with results expressed in terms of the MeijerG and Bessel functions.

Diff(StruveH(n,z),n) = diff(StruveH(n,z),n) assuming n::negint;

For Chebyshev functions, the formulas are valid for arbitrary values of the first parameter.

Diff(ChebyshevT(a,z),a) = diff(ChebyshevT(a,z),a);

A new fdiff command, to compute derivatives numerically, was added to the library (see the Numerics Updates in Maple 10 help page). This command is used to compute the value of derivatives when the exact differentiation rule is not known and is tightly integrated with the symbolic differentiation commands.

Examples

eval( Diff(exp(x),x), x=1) = fdiff(exp(x), x=1);

The differentiation rule of  with respect to the first parameter is not known in general.

eval(diff(LegendreP(a,1/3), a), a=1/2+I);

The numerical value of this derivate is computed using fdiff.

evalf( (15) );

fdiff(LegendreP(a,1/3), a=1/2+I);

In Maple 10, fdiff is also used to numerically evaluate symbolic derivatives evaluated at a point, constructed using the D operator.

D[1](LegendreP)(1/2+I,1/3);

evalf((18));

The routines for simplifying the size of a mathematical expression were rewritten, resulting in more powerful, flexible, and efficient simplification. For details, see the simplify,size help page.

Example

Consider the following large symbolic expression, with rational subexpressions and exponential and trigonometric functions, which appeared as part of the solution of a differential equation problem.

eq:=-r*h*m*K*(K*exp(K*t/(A + Ab))*cos((h*C/(A + Ab) + h*Ab/(A + Ab))*t)/(A + Ab)/(K^2/(A + Ab)^2 + (h*C/(A + Ab) + h*Ab/(A + Ab))^2)-(-h*C/(A + Ab)-h*Ab/(A + Ab))*exp(K*t/(A + Ab))*sin((h*C/(A + Ab) + h*Ab/(A + Ab))*t)/(K^2/(A + Ab)^2 + (h*C/(A + Ab) + h*Ab/(A + Ab))^2)) + r*h*m*K*(K*exp(K*t/(A + Ab))*cos((-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))*t)/(A + Ab)/(K^2/(A + Ab)^2 + (-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))^2)-(h*C/(A + Ab)-2*h*A/(A + Ab)-h*Ab/(A + Ab))*exp(K*t/(A + Ab))*sin((-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))*t)/(K^2/(A + Ab)^2 + (-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))^2))-Ab*m*h^2*r*((h*C/(A + Ab)-2*h*A/(A + Ab)-h*Ab/(A + Ab))*exp(K*t/(A + Ab))*cos((-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))*t)/(K^2/(A + Ab)^2 + (-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))^2) + K*exp(K*t/(A + Ab))*sin((-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))*t)/(A + Ab)/(K^2/(A + Ab)^2 + (-h*C/(A + Ab) + 2*h*A/(A + Ab) + h*Ab/(A + Ab))^2)) + Ab*m*h^2*r*((-h*C/(A + Ab)-h*Ab/(A + Ab))*exp(K*t/(A + Ab))*cos((h*C/(A + Ab) + h*Ab/(A + Ab))*t)/(K^2/(A + Ab)^2 + (h*C/(A + Ab) + h*Ab/(A + Ab))^2)
 + K*exp(K*t/(A + Ab))*sin((h*C/(A + Ab) + h*Ab/(A + Ab))*t)/(A + Ab)/(K^2/(A + Ab)^2 + (h*C/(A + Ab) + h*Ab/(A + Ab))^2)):

Try different methods of simplifying its size, such as converting to horner form, factoring, directly simplifying, or simplifying and combining. Measure the length of the resulting expression and compare with the expression obtained by simplification by size.

`starting length` = length(eq), `converting to horner`=length(convert(eq,horner)),  factoring=length(factor(eq)), simplifying=length(simplify(eq)), `simplifying and combining` = length(combine(simplify(eq)));

`using simplify/size`=length(simplify(eq,size));

By performing simple manipulations (simplify,size), it is possible to rewrite the expression in a more compact form than by applying other specific mathematical simplification algorithms.

Simplifying expressions involving the new Wrightomega function:

Wrightomega(ln(2)+ln(ln(2)));

simplify((30));

For expressions involving RootOf, the simplification is more efficient and sophisticated, finding simplifications in cases where previously none was found, and terminating more quickly when no simplification is possible.

Examples

Zeta(0,n,x+a)-Zeta(0,RootOf(-Zeta(0,n,a)+Zeta(0,_Z,A)),x+A);

simplify( (32) );

a*RootOf(x^2-2*x+1,index = 1)^2+RootOf(x^2-2*x+1,index = 1)*RootOf(x^2-2*x+1,index = 1)+c;

simplify( (34) );

Taking advantage of the presence of multiple roots:

1/(alpha-RootOf(_Z^3-11*_Z^2+35*_Z-25));

simplify( (36) );

Less processing time when no simplification is available:

simplify(RootOf(-RootOf(_Z^4+_Z+1,index= 4)+_Z^3,index = 1));

More transformations are considered:

2^(-sqrt(2)/4-1)*(sqrt(2)+2)^(sqrt(2)/4)*(2-sqrt(2))^(sqrt(2)/4)/Pi;

simplify((39));

More identities are taken into account.

(-alpha+2*y(x)^2*alpha+2)*WhittakerM(1/4*(alpha-2)/alpha,-1/4,y(x)^2)+(-1+alpha)*WhittakerM(1/4*(-2+5*alpha)/alpha,-1/4,y(x)^2)-WhittakerM(-1/4*(3*alpha+2)/alpha,-1/4,y(x)^2);

simplify((41));

BesselJ(1+1/v,x)-2/v*BesselJ(1/v,x)/x+BesselJ(-1+1/v,x);

simplify((43));

These improvements have also had a positive effect in other parts of the Maple library. For example, this Abel type differential equation and implicit exact solution are now testable due to improvements in the simplification of Bessel functions.

ode := diff(y(x),x) = 2*delta^3*y(x)*d/(-y(x)*d*delta^3+x*(x*d*delta^3-4));

sol := _C1 = -(x*BesselI(2/d/delta^3,y(x)^(1/2))+y(x)^(1/2)*BesselI((2+d*delta^3)/d/delta^3,y(x)^(1/2)))/(x*BesselK(2/d/delta^3,y(x)^(1/2))-y(x)^(1/2)*BesselK((2+d*delta^3)/d/delta^3,y(x)^(1/2)));

odetest(sol, ode);

Products of Integrals and Sums can now be combined using combine.

Examples

Int(f(a,x),x)*Sum(g(a,x),_k2 = 0 .. n-_k1);

combine((48));

The five Heun functions are solutions to the five canonical forms of the Heun family of second order linear ordinary differential equations. The General Heun Equation

diff(y(x),x,x) + ((alpha+beta+1-delta-gamma)/(x-a)+delta/(x-1)+gamma/x)*diff(y(x),x) + ((alpha*beta*a-q)/(x-a)/a/(a-1)+(-alpha*beta+q)/(x-1)/(a-1)-q/x/a)*y(x) = 0;

has four regular singular points. The other Heun equations are obtained from the general equation using confluence processes.

None of the solutions to these five equations can be expressed in terms of other mathematical functions.

Due to the rich structure of their singularities, Heun equations appear in the representation of a large number of problems, from finance to general relativity and quantum physics. The generality of these functions is also illustrated by the fact that most other mathematical functions are particular cases of Heun functions, including the Spheroidal wave function, the Mathieu, Lame and hypergeometric pFq functions, and with them all of Legendre, Kummer, Bessel etc. functions admitting hypergeometric representation in the 2F1, 1F1, and 0F1 classes.

Examples

The Heun functions are defined as the solutions of the Heun equations for given initial conditions. The equations and conditions can be seen using the FunctionAdvisor.

FunctionAdvisor(definition, HeunG);

The 2F1 and 1F1 hypergeometric functions are special cases of HeunG (the Heun General) and HeunC (the Heun Confluent) functions.

FunctionAdvisor(specialize, HeunG, hypergeom);

FunctionAdvisor(specialize, HeunC, hypergeom);

Some identities and special values:

FunctionAdvisor(identities,HeunC);

FunctionAdvisor(special_values,HeunG);

Series and asymptotic series expansions for the HeunT (Triconfluent Heun) and HeunD (Doubleconfluent Heun) functions:

FunctionAdvisor(series, HeunT);

FunctionAdvisor(asympt, HeunD);

* Partial match of "asympt" against topic "asymptotic_expansion".

For more details, see the Heun help page.

The spherical harmonics SphericalY(lambda,mu,theta,phi) are the angular part of the solution to Laplace's equation in spherical coordinates (r,theta,phi). These functions are frequently used to represent solutions in problems with spherical symmetry, and are particularly relevant in Quantum Mechanics, where they are eigenfunctions of observable operators associated with angular momentum. The SphericalY harmonics are related to Legendre functions as follows.

FunctionAdvisor(definition, SphericalY);

The differentiation rule with respect to the two angular variables is known in closed form.

Diff(SphericalY(lambda,mu,theta,phi),theta): (58) = value((58));

Diff(SphericalY(lambda,mu,theta,phi),phi): (59) = value((59));

The series expansion with respect to phi:

series( SphericalY(lambda,mu,theta,phi), phi, 3 );    # up to order 3

The Wrightomega function is a single-valued (but discontinuous on two rays in the complex plane) variant of the LambertW function. It is defined as follows.

FunctionAdvisor(definition, Wrightomega);

Because the Wrightomega function is single-valued, its branching behavior is simpler than that of the LambertW function and the relationship  can be used as an analytic continuation of LambertW in the (otherwise discrete) branch index.

The Wrightomega function sometimes has another advantage over the LambertW function. For large ,

Wrightomega(x) = asympt( Wrightomega(x), x, 3 );

and when Wrightomega appears in applications, the equivalent formulation in terms of LambertW, namely  can overflow on computation of , before being "undone" by LambertW. In other words, for some applications, such as the fringing fields of a capacitor, numerical evaluation of Wrightomega is easier.

The Maple 10 Dirac command allows for a compact representation, usual in formulations in Physics, of an n-dimensional Dirac delta function, defined in terms of the product of 1-dimensional Dirac functions.

Dirac([x, y, z, t]) = expand( Dirac([x, y, z, t]) );

Derivatives of the n-dimensional Dirac function are denoted by the two-argument Dirac function as in the 1-dimensional case (see Dirac). The Maple library has been updated accordingly, so it is now possible to integrate, expand, compute integral transforms and other operations using the n-dimensional form.

Example

Int(Int(Int(Int( Dirac([x, y, z, t])*f(x,y,z,t), x=-infinity..infinity), y=-infinity..infinity), z=-infinity..infinity), t=-infinity..infinity);

value((65));

Example

FunctionAdvisor(identities, HeunG);

The Psi function now takes into account assumptions made on the function parameters.

Psi(n,x) assuming n::posint, x=1;

Psi(n,x) assuming n=1, x=1/4;

The new Equate command is used to turn pairs of datasets into a list of equations, matching up the elements of the datasets pairwise. The inputs can be two lists, a list and a Vector, two Matrices, or in fact any two objects of the same structure. For example, a 2x3 Matrix can be paired with .

The ImportMatrix and ImportVector commands now have the option of skipping lines at the beginning of source data.

Example

ImportMatrix("myData.dat", source=delimited, delimiter=",", skiplines=2):

Error, (in ImportMatrix) file or directory does not exist: myData.dat

The iratrecon command has been extended to implement maximal quotient rational reconstruction.

The solve command now accepts lists of equations and variables. This removes the need to convert lists to sets for use with solve. Also when the variables are given in the list, solve will return the answer as list of lists of the equations, which left hand sides will be sorted according to initial order of variables' list.

The Groebner package has been enhanced and the PolynomialIdeals and RegularChains packages added.

The QDifferenceEquations and SumTools packages have been enhanced.

For more information, see Enhanced Packages in Maple 10.