Improved Symbolics in Maple V Release 5
Many improvements to the symbolic capabilities of Maple have been made in Release 5. A brief description of these improvements follows.
General
Evaluation (eval, evala)
Simplification (simplify)
Conversions (convert)
New Functions
Changes to Functions
The Integrator
The Differential Equation solvers
Pattern Matcher
The gcd command now can manipulate radicals, radical extensions, and in some cases, can attempt to deal with transcendental expressions. (Care must be exercised if non-rational subexpressions are algebraically dependent, but many common cases will work.)
gcd( sin( x ), cos( x ), 'a', 'b' );
1
a;
sin⁡x
b;
cos⁡x
The gcd command takes advantage of (partially) factored inputs and can thus return some partially factored results.
The commands seq, add, and mul work better with infinities.
Two-dimensional coordinate systems can be added using addcoords.
readlib( addcoords )( cnew, [ t1, t2 ], [ ( t1^2 - 1 ) / t2, ( t2^3 - 1 ) / t1 ] );
plot( sqrt( x ), x = -10 .. 10, coords = cnew );
The coefficients of x^infinity and x^-infinity, in a polynomial, are 0:
coeff(p(x),x,infinity);
0
coeff(p(x),x,-infinity);
The degree and ldegree commands now behave correctly with respect to the zero polynomial.
degree( 0, x );
−∞
ldegree( 0, x );
∞
The dsolve command has been rewritten to use Lie's symmetry methods by default, resulting in a remarkable improvement in its performance and functionality. Also dsolve is now fully integrated with the odeadvisor command (see DEtools,Lie).
ODE[1] := diff(y(x),x)=(y(x)-x*ln(x))^2/(x^2) + ln(x);
ODE1≔ⅆⅆxy⁡x=y⁡x−x⁢ln⁡x2x2+ln⁡x
DEtools[odeadvisor](ODE[1]);
_1st_order,_with_linear_symmetries,_Riccati
DEtools[symgen](ODE[1]); # ODE symmetries
_ξ=x,_η=x+y
dsolve(ODE[1], can);
y⁡x=−x⁢−2⁢5⁢ln⁡x+5⁢tanh⁡ln⁡x+c__1⁢52−5⁢510
A high order example solved using symmetries (see dsolve,Lie)
ODE[2] := diff(y(x),x,x)*diff(y(x),x)*y(x)*x^6 - 2*diff(y(x),x)^3*x^6 + 2*diff(y(x),x)^2*y(x)*x^5+y(x)^5;
ODE2≔ⅆ2ⅆx2y⁡x⁢ⅆⅆxy⁡x⁢y⁡x⁢x6−2⁢ⅆⅆxy⁡x3⁢x6+2⁢ⅆⅆxy⁡x2⁢y⁡x⁢x5+y⁡x5
ans := dsolve(ODE[2], gon2);
ans≔y⁡x=3⁢x22⁢x⁢c__1⁢x+1⁢2⁢c__1⁢x−3⁢c__2⁢x2+2⁢2⁢x⁢c__1⁢x+1
dsolve now uses ODESolStruc to convey reductions of order of high order ODEs.
The evala command has improved performance and functionality.
The functions factors and eliminate are now readlib defined.
The value command understands more functions: DESol, RESol, Hypergeom, Eval, Intat.
Eval( sin(x), x = Pi );
sin⁡xx=π|sin⁡xx=π
value( (14) );
The galois command has been improved. The Galois groups of polynomials of degree up to 8 can now be computed.
Additionally, galois now returns more information about the groups it computes, including the order and sign (indicating whether the group is contained in the alternating group of the same degree). The form of generators has also changed; they are represented as Maple strings written in disjoint cycle notation.
readlib( galois ): with( group ):
p := sum( (-1)^i * x^(2*i) - i, i=0..4);
p≔x8−x6+x4−x2−9
Grec := galois( p );
Grec≔8T44,[2^4]S(4),-,384,(4 8),(1 8)(4 5),(1 2 3 8)(4 5 6 7)
member( permgroup( degree( p, x ), {[]} ), DerivedS( permgroup( degree( p, x ), Grec[5] ) ) ); # is p(x) solvable by radicals?
true
The sum command has been improved. Moenck's algorithm has been replaced with Abramov's algorithm. Performance is better and simpler representations are often achieved.
Handling of the incomplete GAMMA function by expand has been improved.
The performance of lattice has been improved.
The testeq command is faster and more powerful.
The optimizer (for expressions and computation sequences and simple maple procedures), optimize, has been improved. There is also a new option, tryhard{optimize}.
a := 'a': b := 'b': c := 'c':
f := proc(a,b,c) local r,s; r := a * b + a * c; s := c * b + c^2; r - s; end;
f:=proca,b,clocalr,s;r:=b*a+c*a;s:=c*b+c^2;r − send proc
codegen[optimize]( f );
proca,b,clocalt4;t4:=c^2;b*a+c*a − c*b − t4end proc
codegen[optimize]( f, 'tryhard' );
proca,b,clocalresult,t1;t1:=b+c;result:=a*t1 − c*t1end proc
f := 'f':
The directory separator for the machine currently running Maple can be found using kernelopts(dirsep)
To see the effect of optimization, we can use the cost function on the computation sequence from the body of f.
cs := [ r = a * b + a * c, s = c * b + c^2 ];
cs≔r=b⁢a+c⁢a,s=c⁢b+c2
codegen[optimize]( cs );
r=b⁢a+c⁢a,t4=c2,s=c⁢b+t4
codegen[cost]( (23) );
2⁢additions+4⁢multiplications+3⁢assignments
codegen[optimize]( cs, 'tryhard' );
t2=b+c,r=t2⁢a,s=t2⁢c
codegen[cost]( (25) );
additions+3⁢assignments+2⁢multiplications
Evaluation at a point, using the second argument of eval, has been added. Note that this is defined quite generally, and can deal with expressions where subs was incorrect.
eval( sin(t - Pi/2), t = Pi );
eval( x/sin(x), x=0);
Error, numeric exception: division by zero
int(f(x),x=-infinity..infinity);
∫−∞∞f⁡xⅆx
eval( (28), f=(t->exp(-t^2)));
π
Functions with special support for evaluation at a point:
diff, Diff,
int, Int,
limit, Limit,
product, Product,
sum, Sum,
the inttrans functions and piecewise.
eval( int( sin( t ), t = 0 .. x ), x = Pi/2 );
eval( int( f( t ), t = 0 .. x ), t = a );
∫0xf⁡tⅆt
eval( diff( abs(x), x ), x = 0 );
Error, (in `simpl/abs`) abs is not differentiable at 0
eval( diff( abs(x), x ), x = 1 );
In addition, a new command, intat, for "evaluating integrals at a point" has been added.
intat(F(a),a =r) = int(F(r),r);
∫` `rF⁡aⅆa=∫F⁡rⅆr
Intat(diff(F(z),z,z),z=G(x))=intat(diff(F(z),z,z),z=G(x));
∫` `G⁡xⅆ2ⅆz2F⁡zⅆz=D⁡F⁡G⁡x
The internals of evala have been substantially improved. It is now faster and more powerful.
The evala command can now handle more expressions by operating recursively.
Expand( ( 1 + RootOf( x^2 - 2 ) )^1000 );
Expand⁡1+RootOf⁡_Z2−21000
evala( (35) );
21093096734545788527500836634727099588489384390319004814017810623293211815789209911283798336840541227810827362247961462076340236731742628764087168306758128066643738616268857975982438181087665615915626282432004505944399554607844270641892800758687636009968274277222295140088568054131815535180156183128363609909859421735474877635959333893583537947135921530940258496573995974651586025272⁢RootOf⁡_Z2−2+29830143474442298001129795174793040151744428847802742169166276817001664681121782120915351803428453748118551925116779805767489527890968849645306147349089263359830312589220741815894109864844474418807750002082487853475867434347137762094092099359890863256272576723592614162865351044825595779184368879043532947321306433685532982297015411679683242382695050673704586852323753879398408655937
The simplify command has been extended to interpret the following functions.
Ci
LegendreP
LegendreQ
LerchPhi
Whittaker
wronskian
diff( LerchPhi( z, 3, 4 ), z );
LerchPhi⁡z,2,4z−4⁢LerchPhi⁡z,3,4z
simplify( (37) );
4⁢z3+27⁢z2+108⁢polylog⁡2,z−432⁢polylog⁡3,z+324⁢z108⁢z5
convert(..., Sum)
Convert MeijerG functions to sums.
convert(MeijerG([[1,1],[2,2,2]],[[3,3,3,3],[4,4,4,4,4]],z),'Sum',z);
∑_k1=0∞⁡−1_k1⁢Γ⁡4+_k12⁢Γ⁡3+_k13⁢z4+_k1⁢1+_k15Γ⁡2+_k19
convert(..., dawson)
Convert to a Dawson integral. Dawson's integral is defined as
exp( -x^2 ) * Int( exp( t^2 ), t = 0 .. x );
ⅇ−x2⁢∫0xⅇt2ⅆt
convert( erf( x ), 'dawson' );
−2⁢I⁢ⅇ−x2⁢dawson⁡I⁢xπ
convert(..., erfi)
Convert to an expression in terms of the imaginary error function erfi.
convert( dawson( x ), 'erf' );
−I2⁢π⁢erf⁡I⁢xⅇx2
convert( dawson( x ), 'erfi' );
π⁢erfi⁡x2⁢ⅇx2
convert(..., sincos)
Specify only those terms that depend upon a specified variable which are to be converted, using an optional third parameter.
convert(cot(t)*tan(x),'sincos');
cos⁡t⁢sin⁡xsin⁡t⁢cos⁡x
convert(cot(t)*tan(x),'sincos',x);
cot⁡t⁢sin⁡xcos⁡x
convert(..., StandardFunctions)
Convert functions represented in terms of hypergeometric functions and Meijer G functions to a form in terms of standard special and elementary functions.
convert( hypergeom([1,3],[1/2],z), 'StandardFunctions');
−2⁢z2+9⁢z+88⁢1−z3+15⁢z⁢arcsin⁡z8⁢1−z72
convert(..., MeijerG)
Convert special functions to a form using MeijerG functions.
convert(..., Riccati) and convert(..., linearODE)
Convert a linear second order homogeneous ODE into a first order Riccati type ODE and vice-versa; see convert,ODEs.
ODE := diff(y(x),x)-y(x)^2+y(x)*sin(x)-cos(x);
ODE≔ⅆⅆxy⁡x−y⁡x2+y⁡x⁢sin⁡x−cos⁡x
ODE2 := convert(ODE,linearODE);
ODE2≔ⅆ2ⅆx2_a⁡x=−sin⁡x⁢ⅆⅆx_a⁡x−cos⁡x⁢_a⁡x,y⁡x=−ⅆⅆx_a⁡x_a⁡x
The first element in the sequence above is the second order linear ODE and the second element is the transformation of variables used in the process.
The linear ODE can be reconverted into one of Riccati type introducing an arbitrary function _F1
convert(ODE2[1], Riccati);
ⅆⅆx_b⁡x=_F1⁡x⁢_b⁡x2+−sin⁡x⁢_F1⁡x−ⅆⅆx_F1⁡x⁢_b⁡x_F1⁡x+cos⁡x_F1⁡x,_a⁡x=ⅇ−∫_b⁡x⁢_F1⁡xⅆx⁢c__1
Special Functions
Many new special functions have been added in Release 5.
StruveH The Struve H function
dsolve(x^2*diff(y(x),x,x)+x*diff(y(x),x)+(x^2-v^2)*y(x) =(4*(x/2)^(v+1))/(sqrt(Pi)*GAMMA(v+1/2)),y(x));
y⁡x=BesselJ⁡v,x⁢c__2+BesselY⁡v,x⁢c__1+StruveH⁡v,x
StruveL The Struve L function
dsolve(x^2*diff(y(x),x,x)+x*diff(y(x),x)-(x^2+v^2)*y(x)=(4*(x/2)^(v+1))/(sqrt(Pi)*GAMMA(v+1/2)),y(x));
y⁡x=BesselI⁡v,x⁢c__2+BesselK⁡v,x⁢c__1+StruveL⁡v,x
LerchPhi The general Lerch Phi function is defined as the following integral.
( z, a, v ) -> Sum( z^n / ( v + n )^a, n = 0 .. infinity );
z,a,v↦∑n=0∞⁡znv+na
erfi The Imaginary Error Function. This is related to the error function erf by the following relation.
erfi( x ) = -I * erf( I * x );
erfi⁡x=−I⁢erf⁡I⁢x
KummerM - Kummer function M[mu], [nu](z)
KummerU - Kummer function U[mu], [nu](z)
LegendreP - The Legendre functions and associated Legendre functions of the first and second kinds
LegendreQ - The Legendre functions and associated Legendre functions of the first and second kinds
LommelS1 - Lommel function s[mu], [nu](z)
LommelS2 - Lommel function S[mu], [nu](z)
WhittakerM - Whittaker function M[mu], [nu](z)
WhittakerW - Whittaker function W[mu], [nu](z)
The Whittaker functions occur in the solution of the following differential equation.
dsolve( z * diff( y( z ), z, z ) + ( nu - z ) * diff( y( z ), z ) - mu * y( z ) = 0, y( z ) );
y⁡z=c__1⁢KummerM⁡μ,ν,z+c__2⁢KummerU⁡μ,ν,z
AiryAiZeros - Real zeros of the Airy Ai function
BesselJZeros - Real zeros of Bessel J functions
BesselYZeros - Real zeros of Bessel Y functions
map( AiryAi, [ AiryAiZeros( 1 .. 5 ) ] );
BesselJZeros(1/2,3);
3⁢π
Other Functions
intat and Intat for evaluating integrals at a point. In some cases, the solution to ODEs and PDEs returned by dsolve and pdsolve is presented using intat.
ODE := diff(diff(y(x),x),x) = 1/x^2*(diff(y(x),x)^2*x^2-2*y(x)*diff(y(x),x)*x+y(x)^2);
ODE≔ⅆ2ⅆx2y⁡x=ⅆⅆxy⁡x2⁢x2−2⁢y⁡x⁢ⅆⅆxy⁡x⁢x+y⁡x2x2
dsolve(ODE);
y⁡x=ⅇc__1⁢Ei1⁡−ln⁡1x+c__1+c__2⁢x
The new Maple PDE-solver, pdsolve, returns general or particular solutions for PDEs, and accepts hints.
PDE := S(x,y)*diff(S(x,y),y,x) + diff(S(x,y),x)*diff(S(x,y),y) = 1;
PDE≔S⁡x,y⁢∂2∂x∂yS⁡x,y+∂∂xS⁡x,y⁢∂∂yS⁡x,y=1
pdsolve(PDE, HINT=P(x,y)^(1/2));
S⁡x,y=f__2⁡x+f__1⁡y+2⁢y⁢x
odetest and pdetest are for testing implicit or explicit answers for ODEs and PDEs.
ODE := diff(y(x),x)=exp(y(x)/x)*ln(y(x)/x);
ODE≔ⅆⅆxy⁡x=ⅇy⁡xx⁢ln⁡y⁡xx
ans := dsolve(ODE,implicit);
ans≔∫` `y⁡xx1ⅇ_a⁢ln⁡_a−_aⅆ_a−ln⁡x−c__1=0
odetest(ans, ODE);
A new command for conveying reductions of order by dsolve was implemented (see ODESolStruc). A third order ODE reduced to a first order ODE of Riccati type.
ODE := diff(diff(diff(y(x),x),x),x) = (y(x)-x)/diff(diff(y(x),x),x)*(-1+diff(y(x),x))^5;
ODE≔ⅆ3ⅆx3y⁡x=y⁡x−x⁢−1+ⅆⅆxy⁡x5ⅆ2ⅆx2y⁡x
ans := dsolve(ODE);
ans≔y⁡x=_f+∫ⅇ∫_g⁡_fⅆ_f+c__1ⅆ_f+c__2whereⅆⅆ_f_g⁡_f=2⁢_g⁡_f2+_f_g⁡_f,_f=y⁡x−x,_g⁡_f=−ⅆ2ⅆx2y⁡x−1+ⅆⅆxy⁡x2,x=∫ⅇ∫_g⁡_fⅆ_f+c__1ⅆ_f+c__2,y⁡x=_f+∫ⅇ∫_g⁡_fⅆ_f+c__1ⅆ_f+c__2
Reductions of order can also be tested using odetest
The new solvefor function can be used to solve for a specified unknown, or set of unknowns, in an equation. It is mostly meant to be used by the Context Menu functionality of the Graphical User Interface. This function is related to eliminate but the output is easier to use in further interactive exploration.
solvefor[x]( x^2 - y^3 = 1 );
x=y3+1,x=−y3+1
solvefor[y]( x^2 - y^3 = 1 );
y=x2−113,y=−x2−1132−I⁢3⁢x2−1132,y=−x2−1132+I⁢3⁢x2−1132
You can augment a set of equations with initial conditions, using the new initialcondition routine.
de := diff( f( x ), x) = exp( x );
de≔ⅆⅆxf⁡x=ⅇx
initialcondition[ f ]( de );
ⅆⅆxf⁡x=ⅇx,Dn0⁡f⁡0=0
The new command charfcn can be used to represent the characteristic function of sets.
S := { 1, 2, 3, 4 };
S≔1,2,3,4
charfcn[ S ]( 2 );
charfcn[ S ]( 5 );
map( charfcn[ { a, b, c } ], [ c, d ] );
1,0
charfcn[ 0 .. 1 + I ]( 1 - I );
charfcn[ 0 .. 1 + I ]( ( 1 + I ) / 2 );
charfcn[ 0 .. 1000 ]( x );
charfcn0..1000⁡x
evalrC - Evaluate an expression using complex range arithmetic.
f := x -> x^2;
f≔x↦x2
dom := INTERVAL( 0, 0, 1, 1 );
dom≔INTERVAL⁡0,0,1,1
rng := evalrC( f( INTERVAL( 0, 0, 1, 1 ) ) );
rng≔INTERVAL⁡−1,0,1,2
with( plots ): with( plottools ):
dom_plot := rectangle( [op(1,dom),op(2,dom)],[op(3,dom),op(4,dom)], color=pink):
rng_plot := rectangle( [op(1,rng),op(2,rng)],[op(3,rng),op(4,rng)], color=yellow):
display( { dom_plot, rng_plot } ):
intat - Integration at a point
Intat - Inert integration at a point
Intat( f( t ), t = x );
∫` `xf⁡tⅆt
subs( f = sin, (81) );
∫` `xsin⁡tⅆt
value( (82) );
−cos⁡x
The operators `^` and `**` are now active functions.
The C procedure, which compiles Maple expressions to C code, is now in the codegen package.
The C procedure can still be loaded using readlib.
C handles ceil, floor, round, trunc
f := proc( a, b ) local t; t := a^2 + b^2; ceil( t ); end;
f:=proca,blocalt;t:=b^2+a^2;ceil⁡tend proc
codegen[C]( f, 'optimized', 'ansi' );
#include <math.h> int f(double a,double b) { double t1; double t2; { t1 = a*a; t2 = b*b; return(ceil(t1+t2)); } }
The fortran procedure, which compiles Maple into fortran code, is now part of the codegen package.
However, fortran can be accessed without using readlib or with in Release 5.
fortran( f, optimized, mode = generic );
integer function f(a,b)
real a
real b
real t1
real t2
t1 = a**2
t2 = b**2
f = ceil(t1+t2)
return
end
int of DESol
int of surd
lots of improvements on inttrans
the definite integrator has been substantially improved for the cases where the integrand can be converted to a MeijerG function and the usual theorems for integration of such functions apply
elliptic integration - Improved with symbolic parameters
An integral that previous versions of Maple could not evaluate can now be solved in R5 in two different ways.
f := x -> 1/(1+x^3)^(1/3):
r := Int(f(x),x);
r≔∫1x3+113ⅆx
Let's evaluate this integral.
value(r);
x⁢hypergeom⁡13,13,43,−x3
Maple can also compute this integral in algebraic form, and to do that, we'll convert the integral into RootOf notation.
g := convert(r, RootOf);
g≔∫1RootOf⁡_Z3−x3−1,index=1ⅆx
Maple can compute the value of g using the Risch-Trager algorithm. On a Pentium Pro 200, R5 evaluates this integral in half the time it takes R4 to perform it.
value(g);
RootOf⁡_Z2−_Z+1⁢ln⁡RootOf⁡_Z2−_Z+12⁢x3−3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=12⁢x−3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=1⁢x2−4⁢RootOf⁡_Z2−_Z+1⁢x3+3⁢RootOf⁡_Z3−x3−1,index=12⁢x+3⁢RootOf⁡_Z3−x3−1,index=1⁢x2+4⁢x3−RootOf⁡_Z2−_Z+1+23−ln⁡RootOf⁡_Z2−_Z+12⁢x3+3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=12⁢x+3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=1⁢x2+2⁢RootOf⁡_Z2−_Z+1⁢x3+x3+RootOf⁡_Z2−_Z+1+1⁢RootOf⁡_Z2−_Z+13+ln⁡RootOf⁡_Z2−_Z+12⁢x3+3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=12⁢x+3⁢RootOf⁡_Z2−_Z+1⁢RootOf⁡_Z3−x3−1,index=1⁢x2+2⁢RootOf⁡_Z2−_Z+1⁢x3+x3+RootOf⁡_Z2−_Z+1+13
convert((88), radical);
12+I⁢32⁢ln⁡12+I⁢322⁢x3−3⁢12+I⁢32⁢x3+123⁢x−3⁢12+I⁢32⁢x3+113⁢x2−4⁢12+I⁢32⁢x3+3⁢x3+123⁢x+3⁢x3+113⁢x2+4⁢x3+32−I⁢323−ln⁡12+I⁢322⁢x3+3⁢12+I⁢32⁢x3+123⁢x+3⁢12+I⁢32⁢x3+113⁢x2+2⁢12+I⁢32⁢x3+x3+32+I⁢32⁢12+I⁢323+ln⁡12+I⁢322⁢x3+3⁢12+I⁢32⁢x3+123⁢x+3⁢12+I⁢32⁢x3+113⁢x2+2⁢12+I⁢32⁢x3+x3+32+I⁢323
And we verify that the solution is indeed correct.
simplify(diff((89),x)-f(x));
New Hermite reduction-type algorithms have been implemented for some classes of elementary functions where the solution is in terms of polylogarithms.
int(ln(x+1)^2/x, x);
ln⁡x+12⁢ln⁡−x+2⁢ln⁡x+1⁢polylog⁡2,x+1−2⁢polylog⁡3,x+1
int(x^3/(exp(x)-a)^2, x);
x3a⁢−ⅇx+a+x44⁢a2−x3⁢ln⁡1−ⅇxaa2−3⁢x2⁢polylog⁡2,ⅇxaa2+6⁢x⁢polylog⁡3,ⅇxaa2−6⁢polylog⁡4,ⅇxaa2−x3a2+3⁢x2⁢ln⁡1−ⅇxaa2+6⁢x⁢polylog⁡2,ⅇxaa2−6⁢polylog⁡3,ⅇxaa2
The following examples can now be evaluated in R5 using newly implemented algorithms of Meijer G Function representations.
int(z^n*BesselJ(nu,z),z);
z⁢n+ν−1⁢BesselJ⁡ν,z⁢LommelS1⁡n−1,ν−1,z−z⁢BesselJ⁡ν−1,z⁢LommelS1⁡n,ν,z
int(sin(b*x)/(x^2+z^2)^rho, x=0..infinity);
∫0∞sin⁡b⁢xx2+z2ρⅆx
int(cos(alpha*x^2+2*b*x), x=0..infinity);
limx→∞⁡π⁢2⁢cos⁡b2α⁢FresnelC⁡2⁢α⁢x+bπ⁢α+sin⁡b2α⁢FresnelS⁡2⁢α⁢x+bπ⁢α−cos⁡b2α⁢FresnelC⁡b⁢2π⁢α−sin⁡b2α⁢FresnelS⁡b⁢2π⁢α2⁢α
int(cos(b*x)*arctan(a/x^2), x=0..infinity);
∫0∞cos⁡b⁢x⁢arctan⁡ax2ⅆx
int(cos(b*sqrt(x))*BesselJ(0,c*x)/sqrt(x), x=0..infinity);
∫0∞cos⁡b⁢x⁢BesselJ⁡0,c⁢xxⅆx
int(BesselJ(1,b*x)*BesselJ(1,c*x)/x^2, x=0..infinity);
∫0∞BesselJ⁡1,b⁢x⁢BesselJ⁡1,c⁢xx2ⅆx
int(x*BesselJ(nu/4, b*x^2)^2*BesselJ(nu, c*x), x=0..infinity);
∫0∞x⁢BesselJ⁡ν4,b⁢x22⁢BesselJ⁡ν,c⁢xⅆx
int(exp(I*p*x)*HankelH1(0,c*x),x=0..infinity);
∫0∞ⅇI⁢x8−x6+x4−x2−9⁢x⁢HankelH1⁡0,c⁢xⅆx
int(x^(nu+1)*sin(c*x^2/(2*a))*BesselK(nu,c*x), x=0..infinity);
∫0∞xν+1⁢sin⁡c⁢x22⁢a⁢BesselK⁡ν,c⁢xⅆx
int(sin(b*x^2)*BesselK(nu,c*x), x=0..infinity);
∫0∞sin⁡b⁢x2⁢BesselK⁡ν,c⁢xⅆx
The differential equation solver dsolve has been substantially rewritten. It is now much more powerful, and uses several new techniques for finding closed form solutions.
The most noticable improvements are in the areas of nonlinear ODEs and ODEs with special function solutions.
The partial differential equation solve pdesolve is now obsolete, and has been replaced by the much more powerful pdsolve.
There is now a wealth of tools available to manipulate, explore and solve differential equations and related objects in the packages PDEtools and DEtools.
applyrule - applying rules
compiletable - table lookup
patmatch - pattern matching
tablelook - table lookup
define - define characteristics of an operator name
definemore - define characteristics of an operator name
Several example worksheets are available: examples/patmatch examples/define examples/applyrl.
Download Help Document