Enhancements to Symbolic Capabilities in Maple 9
Maple 9 includes a number of enhancements to its symbolic capabilities, including updates to the special functions, differential and algebraic equation solvers, and integration.
Integration
Differential Equations (DEs)
FunctionAdvisor Command
Conversion Routines for Mathematical Functions
Special Functions
Series of Mathematical Functions
assuming Facility
Simplification
Solving Algebraic and Recurrence Equations
Miscellaneous
The new AllSolutions option is available for int. This option causes the int command to work harder when attempting to calculate a definite integral and return the entire set of solutions. For more information, see int.
int(1/x, x=a..2);
Warning, unable to determine if 0 is between a and 2; try to use assumptions or use the AllSolutions option
int⁡1x,x=a..2
r := int(1/x, x=a..2, 'AllSolutions');
r≔undefineda<0∞a=0−ln⁡a+ln⁡20<a
r assuming a > 0;
−ln⁡a+ln⁡2
r assuming a < 0;
undefined
int(abs(sin(x)), x=0..2*Pi*m) assuming m::integer;
int⁡abs⁡sin⁡x,x=0..2⁢π⁢m
int(abs(sin(x)), x=0..2*Pi*m, 'AllSolutions') assuming m::integer;
4⁢m
int(1/x, x=a..b);
Warning, unable to determine if 0 is between a and b; try to use assumptions or use the AllSolutions option
int⁡1x,x=a..b
int(1/x, x=a..b) assuming a < b;
undefined0<b∧a<0−ln⁡a+ln⁡botherwise
Differential equation solving capabilities (for exact and numeric solutions) are greatly enhanced by new algorithms and an interactive interface for solving ODEs. To learn about the DE updates, including those related to the dsolve and pdsolve commands, see Updates to Differential Equation Solvers.
In addition to using mathematical functions computationally, you also need general information about their properties in Maple, for example, definitions, identities, integral forms, and series expansions. You can access this information directly from the Maple 9 prompt, using the new FunctionAdvisor command (and the related MathematicalFunctions package).
The main purpose of this command is to return information about the Maple mathematical language in a form that you can read and directly use in mathematical computations.
The FunctionAdvisor command provides information on the whole set of mathematical functions implemented in the Maple system and also on the following function classes.
trig,
trigh,
arctrig,
arctrigh,
elementary,
GAMMA_related,
Psi_related,
Kelvin,
Airy,
Hankel,
Bessel_related,
`0F1`,
Ei_related,
erf_related,
Kummer,
Whittaker,
Cylinder,
`1F1`,
orthogonal_polynomials,
Elliptic_related,
Legendre,
Chebyshev,
`2F1`,
Lommel,
Struve_related,
hypergeometric,
Jacobi_related,
Elliptic_doubly_periodic,
Weierstrass_related,
Zeta_related,
Other
For each mathematical function or function class, when applicable, the FunctionAdvisor command provides information on the following topics.
analytic_extension
asymptotic_expansion
branch_cuts
branch_points
calling_sequence
class_members
classify_function
DE
definition
describe
differentiation_rule
display
function_classes
identities
integral_form
known_functions
plot
relate
series
singularities
special_values
specialize
sum_form
synonyms
table
topics
Examples
When called without arguments, FunctionAdvisor returns information on how to use the command.
FunctionAdvisor();
The usage is as follows: > FunctionAdvisor( topic, function, ... ); where 'topic' indicates the subject on which advice is required, 'function' is the name of a Maple function, and '...' represents possible additional input depending on the 'topic' chosen. To list the possible topics: > FunctionAdvisor( topics ); A short form usage, > FunctionAdvisor( function ); with just the name of the function is also available and displays a summary of information about the function.
FunctionAdvisor(topics);
The topics on which information is available are:
DE,analytic_extension,asymptotic_expansion,branch_cuts,branch_points,calling_sequence,class_members,classify_function,definition,describe,differentiation_rule,function_classes,identities,integral_form,known_functions,periodicity,plot,relate,required_assumptions,series,singularities,special_values,specialize,sum_form,symmetries,synonyms,table
FunctionAdvisor can return basic information, for example, the names for the Bessel functions in the Maple system,
FunctionAdvisor(bess);
* Partial match of "bess" against topic "Bessel_related". The 14 functions in the "Bessel_related" class are:
AiryAi,AiryBi,BesselI,BesselJ,BesselK,BesselY,HankelH1,HankelH2,KelvinBei,KelvinBer,KelvinHei,KelvinHer,KelvinKei,KelvinKer
FunctionAdvisor(describe, BesselK);
BesselK=Modified Bessel function of the second kind
as well as the complicated relationships between mathematical functions and their identities, which are computed using a knowledge database and related algorithms.
FunctionAdvisor( identities, BesselK ); # see also ?convert,to_special_function
BesselK⁡a,I⁢z=−π⁢BesselY⁡a,z2⁢Ia+BesselJ⁡a,z⁢ln⁡z−ln⁡I⁢zIa,a::integer,BesselK⁡a,I⁢z=−π⁢za⁢BesselY⁡a,z2⁢I⁢za+π⁢BesselJ⁡a,z⁢−I⁢zaza+za⁢cos⁡a⁢πI⁢za⁢csc⁡a⁢π2,a::¬integer,BesselK⁡a,−z=−1a⁢BesselK⁡a,z+BesselI⁡a,z⁢ln⁡z−ln⁡−z,a::integer,BesselK⁡a,−z=za⁢BesselK⁡a,z−za+π⁢za−za−−zaza⁢BesselI⁡a,z⁢csc⁡a⁢π2,a::¬integer,BesselK⁡a,b⁢c⁢zqp=b⁢cp⁢zp⁢qa⁢BesselK⁡a,b⁢cp⁢zp⁢qb⁢c⁢zqpa−π⁢csc⁡a⁢π⁢BesselI⁡a,b⁢cp⁢zp⁢q⁢b⁢c⁢zqpab⁢cp⁢zp⁢qa−b⁢cp⁢zp⁢qab⁢c⁢zqpa2,a::¬integer∧2⁢p::integer,BesselK⁡a,b⁢c⁢zqp=c⁢zqpcp⁢zp⁢qa⁢BesselK⁡a,b⁢cp⁢zp⁢q−−1a⁢BesselI⁡a,b⁢cp⁢zp⁢q⁢ln⁡b⁢c⁢zqp−ln⁡b⁢cp⁢zp⁢q,a::integer∧2⁢p::integer,BesselK⁡a,z=2⁢a−1⁢BesselK⁡a−1,zz+BesselK⁡a−2,z,BesselK⁡a,z=−2⁢a+1⁢BesselK⁡a+1,zz+BesselK⁡a+2,z
FunctionAdvisor( special_values, sec );
sec⁡π6=2⁢33,sec⁡π4=2,sec⁡π3=2,sec⁡∞=undefined,sec⁡∞⁢I=0,sec⁡π⁢n=−1,n::odd,sec⁡π⁢n=1,n::even,sec⁡π⁢n2=∞+∞⁢I,n::odd
FunctionAdvisor( sum_form, tan );
tan⁡z=∑_k1=1∞⁡bernoulli⁡2⁢_k1⁢−1_k1⁢z2⁢_k1−1⁢4_k1−16_k1Γ⁡2⁢_k1+1,z<π2
FunctionAdvisor( integral_form, Beta );
Β⁡x,y=Int⁡_k1x−1⁢1−_k1y−1,_k1=0..1,And⁡0<ℜ⁡x,0<ℜ⁡y
FunctionAdvisor( relate, sin, WhittakerM );
sin⁡z=−I2⁢WhittakerM⁡0,12,2⁢I⁢z
FunctionAdvisor( specialize, HermiteH, KummerU );
HermiteH⁡a,z=2a⁢KummerU⁡−a2,12,z2,0<ℜ⁡z∨ℜ⁡z=0∧0<ℑ⁡z
A table with a summary of information about the inverse cotangent function:
arccot_info := FunctionAdvisor(table, arccot, quiet): # raw table of information
FunctionAdvisor(display, arccot_info); # ordered display
describe=arccot=inverse cotangent function
definition=arccot⁡z=π2−I⁢ln⁡1−I⁢z−ln⁡1+I⁢z2,with no restrictions on ⁡z
classify_function=arctrig,elementary
symmetries=arccot⁡−z=π−arccot⁡z,arccot⁡z&conjugate0;=arccot⁡z&conjugate0;,notz∈ComplexRange⁡−∞⁢I,−Iorz∈ComplexRange⁡I,∞⁢I
periodicity=arccot⁡z,No periodicity
singularities=arccot⁡z,z=∞+∞⁢I
branch_points=arccot⁡z,z∈−I,I
branch_cuts=arccot⁡z,z∈ComplexRange⁡−∞⁢I,−I∨z∈ComplexRange⁡I,∞⁢I
special_values=arccot⁡−1=3⁢π4,arccot⁡−33=2⁢π3,arccot⁡−3=5⁢π6,arccot⁡0=π2,arccot⁡3=π6,arccot⁡33=π3,arccot⁡1=π4,arccot⁡∞=0,arccot⁡−∞=π
identities=cot⁡arccot⁡z=z,cot⁡arccot⁡z+arccot⁡y=z⁢y−1z+y
sum_form=arccot⁡z=∑_k1=0∞⁡−z⁢I⁢z_k1+−I⁢z_k12⁢_k1+2+π2,And⁡abs⁡z<1
series=series⁡arccot⁡z,z,4=π2−z+13⁢z3+O⁡z5
asymptotic_expansion=asympt⁡arccot⁡z,z,4=1z−13⁢z3+O⁡1z5
integral_form=arccot⁡z=Int⁡−12⁢I_k1,_k1=1+I⁢z..1−I⁢z+12⁢π,with no restrictions on ⁡z
differentiation_rule=Diff⁡arccot⁡z,z=−1z2+1,Diff⁡arccot⁡z,z$n=piecewise⁡n=0,arccot⁡z,−2n−1⁢MeijerG⁡0,0,12,,0,12⁢n−12,12⁢n,z2⁢z1−n
DE=f⁡z=arccot⁡z,ⅆⅆzf⁡z=−1z2+1
This network of conversions between mathematical functions was introduced in Maple 8. In Maple 9, the number of possible connections paths is almost tripled leading to many more relationships. Also, fourteen new conversions are available in the library, including conversions to EllipticF, InverseJacobiAM, InverseJacobiSN, JacobiAM, JacobiCN, JacobiDN, JacobiSN, Li, LommelS1, LommelS2, Psi, Si, Ssi, and Zeta. Two additional new conversion routines, to integral form and to sum form are also available, so that it is possible to obtain a sum or integral representation for most mathematical functions.
New function conversions:
harmonic(z,n);
harmonic⁡z,n
(19) = convert((19), Psi) assuming n::posint;
harmonic⁡z,n=−1n⁢Ψ⁡n−1,1−Ψ⁡n−1,z+1n−1!
(19) = convert((19), Zeta);
harmonic⁡z,n=ζ⁡n−ζ⁡0,n,z+1
(19) = convert((19), LerchPhi);
harmonic⁡z,n=ζ⁡n−LerchPhi⁡1,n,z+1
convert(InverseJacobiAM(z,k), EllipticF) assuming And(-1/2*Pi < Re(z),Re(z) < 1/2*Pi);
EllipticF⁡sin⁡z,k
InverseJacobiSC(z,k) = convert(InverseJacobiSC(z,k), InverseJacobiSN);
InverseJacobiSC⁡z,k=−I⁢InverseJacobiSN⁡I⁢z,−k2+1
Sum and integral representations for the trigonometric functions:
trigonometric_functions := FunctionAdvisor( trig )(z);
The 6 functions in the "trig" class are:
trigonometric_functions≔cos⁡z,cot⁡z,csc⁡z,sec⁡z,sin⁡z,tan⁡z
map(f -> f = convert(f,Sum), trigonometric_functions) assuming abs(z) < Pi/2;
cos⁡z=∑_k1=0∞⁡−1_k1⁢z2⁢_k12⁢_k1!,cot⁡z=∑_k1=0∞⁡−1_k1⁢22⁢_k1⁢bernoulli⁡2⁢_k1⁢z2⁢_k1−12⁢_k1!,csc⁡z=∑_k1=0∞⁡−2⁢22⁢_k1−1−1⁢bernoulli⁡2⁢_k1⁢z2⁢_k1−1⁢−1_k12⁢_k1!,sec⁡z=∑_k1=0∞⁡−1_k1⁢euler⁡2⁢_k1⁢z2⁢_k12⁢_k1!,sin⁡z=∑_k1=0∞⁡−1_k1⁢z2⁢_k1+12⁢_k1+1!,tan⁡z=∑_k1=1∞⁡bernoulli⁡2⁢_k1⁢−1_k1⁢z2⁢_k1−1⁢4_k1−16_k1Γ⁡2⁢_k1+1
map(f -> f = convert(f,Int), [sin, cos](z) );
sin⁡z=z⁢Int⁡exp⁡2⁢I⁢_t1⁢z,_t1=0..1⁢exp⁡−I⁢z,cos⁡z=−12⁢I⁢2⁢z+π⁢Int⁡exp⁡I⁢_t1⁢2⁢z+π,_t1=0..1⁢exp⁡−I⁢z
tan(z) = convert(tan(z), Int) assuming z in RealRange(Open(0), Open(Pi/2));
tan⁡z=2⁢Int⁡_k12⁢zπ−1_k12−1,_k1=0..∞π
Family of Inverse Jacobi Functions
In Maple 9, the family of twelve inverse Jacobi functions is available. These functions are represented by the InverseJacobiPQ commands where P and Q are any two of {C, D, N, S}. The InverseJacobiAM function represents the normal trigonometric form of the Elliptic integral of the first kind (see 8.111 in Gradshteyn and Ryzhik. Table of Integrals Series and Products. 5th ed. Academic Press).
Example
FunctionAdvisor(definition, InverseJacobiAM);
InverseJacobiAM⁡φ,k=Int⁡11−k2⁢sin⁡_θ12,_θ1=0..φ,with no restrictions on ⁡φ,k
FunctionAdvisor(special_values, InverseJacobiAM);
InverseJacobiAM⁡−φ,k=−InverseJacobiAM⁡φ,k,InverseJacobiAM⁡φ,−k=InverseJacobiAM⁡φ,k,InverseJacobiAM⁡0,k=0,InverseJacobiAM⁡φ,0=φ,InverseJacobiAM⁡n⁢π2,k=n⁢EllipticK⁡k,n::integer,InverseJacobiAM⁡φ,k=ln⁡sec⁡φ+tan⁡φ,ℜ⁡φ<π2∧k∈−1,1,InverseJacobiAM⁡φ,k=0,k∈∞,−∞,InverseJacobiAM⁡∞⁢I,k=EllipticK⁡k−EllipticK⁡1kk,k2∈0,1
InverseJacobiCN(z,k) assuming z = -1;
2⁢EllipticK⁡k
InverseJacobiSN(z,k) assuming z = infinity, k^2 > 1;
EllipticK⁡k−EllipticK⁡1k2k
JacobiDN( InverseJacobiDN(z,k), k );
z
Mathieu Functions
In Maple 9, the family of Mathieu functions is available. These functions are the solutions of Mathieu's equation:
y''+a−2⁢q⁢cos2⁢x⁢y=0
and their related support functions. Included are the 2*Pi-periodic solutions (MathieuCE and MathieuSE), the general even and odd solutions (MathieuC and MathieuS), the Floquet solution (MathieuFloquet), and the first derivatives of all of these (higher derivatives can be represented in terms of the functions and their first derivatives using the differential equation).
Maple also implements the characteristic value functions (MathieuA and MathieuB) and the characteristic exponent function (MathieuExponent).
For more information, see Mathieu.
Analytic Extension for the Exponential Integral Function
In Maple 9, the exponential integral function accepts non-real arguments and a non-integer first argument in the two-argument calling sequence. The analytic extension in Maple is:
FunctionAdvisor( analytic_extension, Ei(n,z) );
Ein⁡z=zn−1⁢Γ⁡1−n,z
which extends the classical definition (valid only for n non-negative integer and 0<ℜ⁡z):
Ei(n, z) = convert(Ei(n, z), Int) assuming n::nonnegint, Re(z) > 0;
Ei⁡n,z=Int⁡exp⁡−z⁢_k1⁢_k1−n,_k1=1..∞
The classical definition for the one-argument exponential integral is a Cauchy Principal Value integral, defined for real arguments x.
Ei(z) = convert(Ei(z), Int) assuming z::real;
Ei⁡z=Int⁡exp⁡_k1_k1,_k1=−∞..z,CauchyPrincipalValue
This classical definition is extended to the entire complex plane using:
FunctionAdvisor( analytic_extension, Ei(z) );
Ei⁡z=γ−ln⁡1z2+ln⁡z2+z⁢hypergeom⁡1,1,2,2,z
The Generalized harmonic Function
The harmonic function, representing the harmonic numbers, is generalized to accept two arguments, but still accepts the one-argument calling sequence. The definition of harmonic⁡z is:
FunctionAdvisor( definition, harmonic(z) );
harmonic⁡z=Ψ⁡z+1+γ,with no restrictions on ⁡z
and the generalized harmonic function is defined by:
FunctionAdvisor( definition, harmonic(z,n) );
harmonic⁡z,n=ζ⁡n−ζ⁡0,n,z+1,with no restrictions on ⁡z,n
where:
harmonic(z,n) assuming n = 1;
harmonic⁡z
Computing under Assumptions on the Command Parameters
In Maple 9, more commands take assumptions into account (see assuming), including: doublefactorial, EllipticModulus, EllipticNome, GaussAGM, harmonic, pochhammer, LerchPhi, Zeta, the two Lommel commands, and the twenty-six Jacobi and InverseJacobi commands.
doublefactorial Command
doublefactorial(n) assuming n > 0, n::even;
2n2⁢n2!
doublefactorial(n) assuming n > 0, n::odd;
n!2n2−12⁢n2−12!
GaussAGM Command
GaussAGM(a,b) assuming a = 0;
0
GaussAGM(a,b) assuming a = b;
a
EllipticNome and EllipticModulus Commands
EllipticNome(k) assuming k = 1;
1
EllipticNome(k) assuming k^2 = 1/2;
ⅇ−π
EllipticModulus(q) assuming q = exp(-Pi);
22
LerchPhi Command
LerchPhi(z,a,v) assuming z=1;
z⁢ζ⁡0,a,v
LerchPhi(z,a,v) assuming v=1;
v⁢polylog⁡a,zz
Lommel Commands
LommelS2(mu,nu,z) assuming mu = nu + 1;
zν
LommelS1(mu,nu,z) assuming mu = nu;
Γ⁡12+ν⁢π⁢2ν−1⁢StruveH⁡ν,z
LommelS1(mu,nu,z) assuming mu = 0;
π⁢tan⁡ν⁢π2⁢AngerJ⁡ν,z−WeberE⁡ν,z2
Jacobi Commands
JacobiZeta(z,k) assuming (2*z/Pi)::integer;
JacobiZeta⁡z,k
JacobiAM(z,k) assuming k = 1;
2⁢arctan⁡ⅇz−π2
JacobiCN(z,k) assuming k = 0;
cos⁡z
JacobiSN(z,k) assuming k = 0;
sin⁡z
InverseJacobi Commands
InverseJacobiCN(z,k) assuming k=1;
arcsech⁡z
InverseJacobiSN(z,k) assuming z=1;
EllipticK⁡k
InverseJacobiAM(z,k) assuming z = n/2*Pi, n::integer;
2⁢z⁢EllipticK⁡kπ
pochhammer Command
pochhammer(a,b) assuming a=-1, b=-2;
−1b⁢Γ⁡1−aΓ⁡1−a−b
pochhammer(a,b) assuming b::complex(numeric), csgn(b)=-1;
1pochhammer⁡a+b,−b
Zeta Command
Zeta(n,z,q) assuming q=1;
ζ⁡n,z
Zeta(n,z,q) assuming n = 0, z::integer, z > 1;
−1z⁢Ψ⁡z−1,qz−1!
Zeta(n,z,q) assuming n = 0, z::integer, z < 1;
−bernoulli⁡1−z,q1−z
The Maple 9 series command can compute series for various new functions: EllipticNome, GaussAGM, ChebyshevT, ChebyshevU, and the four JacobiTheta functions.
series( EllipticNome(k), k );
116⁢k2+132⁢k4+O⁡k6
series( JacobiTheta1(z,q), q );
2⁢q14⁢sin⁡z−2⁢q94⁢sin⁡3⁢z+O⁡q254
series( JacobiTheta4(z,q), q );
1−2⁢cos⁡2⁢z⁢q+2⁢cos⁡4⁢z⁢q4+O⁡q9
series( ChebyshevT(5,z), z );
5⁢z−20⁢z3+16⁢z5
series( ChebyshevT(a,z), z, 4 );
cos⁡a⁢π2+sin⁡a⁢π2⁢a⁢z−12⁢cos⁡a⁢π2⁢a2⁢z2−sin⁡a⁢π2⁢−16⁢a+16⁢a3⁢z3+O⁡z4
series( ChebyshevU(a,z), z, 3 );
cos⁡a⁢π2−sin⁡a⁢π2⁢−a−1⁢z+cos⁡a⁢π22−−a−12⁢cos⁡a⁢π22⁢z2+O⁡z3
series( GaussAGM(x,y), x, 3 );
π⁢y2⁢2⁢ln⁡2−ln⁡xy−18⁢π⁢−1+2⁢ln⁡2−ln⁡xyy⁢2⁢ln⁡2−ln⁡xy2⁢x2+O⁡x3
In Maple 9, the series command can compute series expansions in various new situations for some functions, including LegendreP, LegendreQ, MeijerG, GegenbauerC, JacobiP, erf, and the four Bessel functions.
series( LegendreP(-1/2,1/4,-(z+1)/(z-1)), z, 4 );
1Γ⁡34⁢z18−z783⁢Γ⁡34−5⁢z15842⁢Γ⁡34−31⁢z238462⁢Γ⁡34+O⁡z318
series( LegendreQ(-1/2,1/4,-(z+1)/(z-1)), z, 2 );
18+I8⁢π⁢234⁢Γ⁡58⁢434csc⁡3⁢π8⁢Γ⁡78⁢z18−2+2⁢I⁢214⁢Γ⁡342⁢Γ⁡78⁢z18π⁢Γ⁡58⁢csc⁡π8−124+I24⁢π⁢234⁢Γ⁡58⁢434⁢z78csc⁡3⁢π8⁢Γ⁡78+25+2⁢I5⁢214⁢Γ⁡342⁢Γ⁡78⁢z98π⁢Γ⁡58⁢csc⁡π8+O⁡z158
series( MeijerG([[], []],[[-1/4], [1/4]],1/4*z^2), z );
414π⁢z−414⁢z322⁢π+414⁢z7224⁢π+O⁡z112
series( MeijerG([[1/2, 1/2], []],[[0], [-1/2]],-z^2), z);
2⁢π+13⁢π⁢z2+320⁢π⁢z4+O⁡z6
series( GegenbauerC(a,b,z), z, 2);
GegenbauerC⁡a,b,0+GegenbauerC⁡a−1,b,0⁢a+2⁢GegenbauerC⁡a−1,b,0⁢b−GegenbauerC⁡a−1,b,0⁢z+O⁡z2
series( BesselK(a,z+1), z, 2 );
BesselK⁡a,1+a⁢BesselK⁡a,1−BesselK⁡a+1,1⁢z+O⁡z2
series( polylog(a,z), z );
z+12a⁢z2+13a⁢z3+14a⁢z4+15a⁢z5+O⁡z6
This expansion for polylog is valid only for z<1. You can verify this using the new FunctionAdvisor command.
FunctionAdvisor( sum_form, polylog );
polylog⁡a,z=∑_k1=1∞⁡z_k1_k1a,z<1,polylog⁡a,z=z2+∑_k1=−∞∞⁡Γ⁡1−a,2⁢I⁢_k1⁢π−ln⁡z⁢2⁢I⁢_k1⁢π−ln⁡z−1+a,a::posint,polylog⁡a,z=z2+∑_k1=−∞∞⁡∑_k2=0∞⁡−2⁢I⁢_k1⁢π+ln⁡z_k22⁢I⁢_k1⁢π−ln⁡z−1+a⁢Γ⁡_k2+1⁢−_k2−1+a+Γ⁡1−a⁢2⁢I⁢_k1⁢π−ln⁡z−1+a,a::¬posint
Using the new MathematicalFunctions[Series] command, you can compute abstract series representations (not of type/series; see also series) for various functions by factoring out abstract powers and returning possible restrictions on the validity of the series expansion when applicable.
with(MathematicalFunctions, Series);
Series
Series(polylog(a,z), z);
z+12a⁢z2+13a⁢z3+14a⁢z4+15a⁢z5+O⁡z6,And⁡abs⁡z<1
Series(GAMMA(a,z), z, 3);
za⁢Γ⁡a−1a+1a+1⁢z−14+2⁢a⁢z2+O⁡z3,And⁡a::Not⁡nonposint
Series(BesselJ(a,z), z);
za⁢12a⁢Γ⁡a+1−14⁢12a⁢Γ⁡2+a⁢z2+132⁢12a⁢Γ⁡3+a⁢z4+O⁡z6,And⁡a::Not⁡negint
Series( LommelS1(a,b,z), z, 4 );
za⁢1a−b+1⁢a+b+1⁢z−1a−b+1⁢a−b+3⁢a+b+1⁢a+b+3⁢z3+O⁡z5,a+b::¬negint∧odd∧a−b::¬negint∧odd
In Maple 9, the assuming command accepts the optional additionally argument.
The expr assuming x1::prop1, x2::prop2, ... command evaluates the expression expr under the assumption(s) prop1, prop2, ... on the name(s) x1, x2, ..., respectively. By default, previously existing assumptions on x1, x2, ..., if any, are ignored when computing the result. To override this behavior, specify the 'additionally' argument to the right of assuming in the command.
assume(x < 1);
about(x); # display what is known about about x
Originally x, renamed x~: is assumed to be: RealRange(-infinity,Open(1))
By default, the existing assumption x<1 is ignored when computing using assuming.
is(1-x^2, positive) assuming x > -1;
false
Using additionally, the existing assumption on x is taken into account when computing leading to:
is(1-x^2, positive) assuming additionally, x > -1;
true
Independent of whether you specify the additionally argument, any previously existing assumptions on the variables are preserved.
about(x); # same assumption as returned previously
x := 'x': # remove assumptions on 'x'
Trigonometric Functions
In Maple 9, the simplification of trigonometric functions is enhanced with new algorithms for trigonometric polynomials, and includes the following new behavior.
simplify( sin(x)^2 ); # 1 - cos(x)^2 in Maple 8
sin⁡x2
simplify( cos(x)^2 ); # works as in Maple 8
cos⁡x2
simplify( 1 - cos(x)^2 ); # 1 - cos(x)^2 in Maple 8
simplify( 1 - sin(x)^2 ); # works as in Maple 8
Powers and Radicals
The simplify command returns better results for expressions containing radicals.
((-(x-1)/x)^(1/2)*x*((x+1)/x)^(1/2)*a-b*(1-x^2)^(1/2))/(1-x^2)^(1/2);
−−1+xx⁢x⁢x+1x⁢a−b⁢−x2+1−x2+1
simplify((95),power) assuming x > 1;
a−b
In Maple 9, the simplify command can better simplify more functions.
simplify(Ssi(z)+1/2*Pi - Si(z));
simplify(GegenbauerC(2,a,z)) assuming a=1;
4⁢z2−1
simplify(GegenbauerC(n,a,z)) assuming z=-1, n::nonnegint;
−1n⁢Γ⁡2⁢a+nΓ⁡2⁢a⁢Γ⁡n+1
Chebyshev functions:
simplify(ChebyshevT(a,z)) assuming z = 0;
cos⁡a⁢π2
simplify(ChebyshevT(a,z)) assuming z = 1;
simplify(ChebyshevU(a,z)) assuming z = 1;
a+1
simplify(ChebyshevU(a,z)) assuming a = -1/2;
22⁢z+1
With the new functions in the InverseJacobiPQ family, new related simplification routines map the problem - when possible - into a simpler one in terms of InverseJacobiAM.
simplify(InverseJacobiDS(sec(1/2)*(1-k^2)^(1/2),k) - EllipticK(k));
InverseJacobiAM⁡12,k
simplify(InverseJacobiCS(csch(1/2),k));
−I⁢InverseJacobiAM⁡I2,−k2+1
Simplification of RootOf
There is a new routine for simplifying expressions that contain RootOf expressions in a non-polynomial manner.
zero := Phi(y(x),(y(x)+RootOf(Phi(y(x),(y(x)+x*_Z)/_Z))*x)/RootOf(Phi(y(x),(y(x)+x*_Z)/_Z)));
zero≔Φ⁡y⁡x,y⁡x+RootOf⁡Φ⁡y⁡x,y⁡x+x⁢_Z_Z⁢xRootOf⁡Φ⁡y⁡x,y⁡x+x⁢_Z_Z
simplify(zero); # new output
Equate zero to a variable ZERO and remove one RootOf from this expression (see also DEtools/remove_RootOf).
normal( DEtools[remove_RootOf]( zero = ZERO ) );
Φ⁡y⁡x,RootOf⁡−Φ⁡y⁡x,_Z+ZERO=0
simplify((108)); # new output
ZERO=0
sin(RootOf(sin(_Z)+_Z-_Z^3))+RootOf(sin(_Z)+_Z-_Z^3)-RootOf(sin(_Z)+_Z-_Z^3)^3;
sin⁡RootOf⁡−sin⁡_Z−_Z+_Z3+RootOf⁡−sin⁡_Z−_Z+_Z3−RootOf⁡−sin⁡_Z−_Z+_Z33
simplify((110),RootOf); # new output
Simplification of Constant Expressions and of the Size of Expressions
More elaborate simplification of constant expressions (see the new simplification of constant expressions help page):
ee := -1/2*I*exp(I)*Ei(1,I) - 1/2*Ei(1,I)*sin(1) + 1/2*I*Ei(1,I)*cos(1) - 1/2*Ei(1,-I)*sin(1) - 1/2*I*Ei(1,-I)*cos(1) + 1/2*I*exp(-I)*Ei(1,-I);
ee≔−I⁢ⅇI⁢Ei1⁡I2−Ei1⁡I⁢sin⁡12+I⁢Ei1⁡I⁢cos⁡12−Ei1⁡−I⁢sin⁡12−I⁢Ei1⁡−I⁢cos⁡12+I⁢ⅇ−I⁢Ei1⁡−I2
simplify((112)); # using simplify(ee, constant) produces the same result faster
Regarding the size of an expression, see the new simplification of an expression size help page.
e2 := -3*sin(x)^(1/2)*cos(x)^2*sin(x)^m + 3*sin(x)^(1/2)*cos(x)^2*cos(x)^n + 4*sin(x)^(1/2)*cos(x)^4*sin(x)^m - 4*sin(x)^(1/2)*cos(x)^4*cos(x)^n;
e2≔−3⁢sin⁡x⁢cos⁡x2⁢sin⁡xm+3⁢sin⁡x⁢cos⁡x2⁢cos⁡xn+4⁢sin⁡x⁢cos⁡x4⁢sin⁡xm−4⁢sin⁡x⁢cos⁡x4⁢cos⁡xn
simplify((114), size); # requires the extra argument 'size' to be specified
−4⁢cos⁡xn−sin⁡xm⁢sin⁡x⁢cos⁡x2−34⁢cos⁡x2
Simplification of Dummy Variables
In Maple 9, expressions that contain subexpressions similar up to the dummy variable name, for example, as integration or summation variables in definite integrals or sums, can be simplified.
Int(f(x), x=a..b) - Int(f(y), y=a..b);
Int⁡f⁡x,x=a..b−Int⁡f⁡y,y=a..b
simplify((116));
Limit(f(x), x=a) - Limit(f(y), y=a);
limx→a⁡f⁡x−limy→a⁡f⁡y
simplify((118));
When dummy variables are present in Intat constructions, such as in differential equation solutions, simplify attempts to make the dummy variable names the same, when possible, leading to expressions with better manipulation properties. For example,
e1 := (-x*Intat(exp(-Int(f(_b),_b))*g(_b),_b = y(x))+exp(-Intat(f(_a),_a = y(x))))/x;
−x⁢Intat⁡exp⁡−Int⁡f⁡_b,_b⁢g⁡_b,_b=y⁡x+exp⁡−Intat⁡f⁡_a,_a=y⁡xx
The previous expression contains the dummy variables _a and _b; simplify makes the names the same.
e2 := simplify(e1);
−x⁢Intat⁡exp⁡−Int⁡f⁡_a,_a⁢g⁡_a,_a=y⁡x+exp⁡−Intat⁡f⁡_a,_a=y⁡xx
The mathematical manipulation properties of e2 are better. For example, compare the success of factor with e1 and e2.
factor(diff(e1,x)); # does not factor because the dummy variables are different
−exp⁡−Intat⁡f⁡_b,_b=y⁡x⁢diff⁡y⁡x,x⁢g⁡y⁡x⁢x2+diff⁡y⁡x,x⁢f⁡y⁡x⁢exp⁡−Intat⁡f⁡_a,_a=y⁡x⁢x+exp⁡−Intat⁡f⁡_a,_a=y⁡xx2
factor(diff(e2,x)); # factors
−exp⁡−Intat⁡f⁡_a,_a=y⁡x⁢diff⁡y⁡x,x⁢g⁡y⁡x⁢x2+diff⁡y⁡x,x⁢f⁡y⁡x⁢x+1x2
The solve command is extended to find parametric solutions of equations. If the variables for which to solve are functions of a free variable, solve returns parametric solutions in terms of that variable.
solve( u^2+v^2-1, {u(s)=-1,v(s)=0} );
u=s2−1s2+1,v=2⁢ss2+1
solve( x^x - y^y, {x(t),y(t)});
x=ⅇt⁢ln⁡1tt−1,y=t⁢ⅇt⁢ln⁡1tt−1
In Maple 9, rsolve can search for series solutions of systems of recurrence equations using the LinearFunctionalSystems package. If the 'series' option is specified, rsolve finds formal series solution by using the LinearFunctionalSystems[SeriesSolution] command.
sys := {y(x)*x^2+3*y(x)*x+2*y(x)-2*z(x)*x^2-4*z(x)*x+z(x+1)*x^2+z(x+1)*x = 0, y(x+5)-z(x) = 0};
sys≔y⁡x+5−z⁡x=0,y⁡x⁢x2+3⁢y⁡x⁢x+2⁢y⁡x−2⁢z⁡x⁢x2−4⁢z⁡x⁢x+z⁡x+1⁢x2+z⁡x+1⁢x=0
vars := {y(x), z(x)};
vars≔y⁡x,z⁡x
Order := 2: sol := rsolve(sys,vars,'series');
sol≔y⁡x=11171256901⁢_c564+202134809⁢_c416−1160265804390⁢_c10−2101241187045⁢_c94−91956626685⁢_c8−20248267725⁢_c74+6211703225⁢_c68+_c3+x⁢84884655807⁢_c5320+695475963⁢_c480−3716103506346⁢_c10−5262694938963⁢_c94−164157505659⁢_c8−4935798315⁢_c74+16465573215⁢_c68+O⁡x2,z⁡x=_c1+_c2−1586137831⁢_c48+56102335540020⁢_c10+41273311696155⁢_c92+2753324557830⁢_c8+100460135475⁢_c72−127908744775⁢_c64−147985008059⁢_c532+3⁢_c3+x⁢−4720528435⁢_c68−28346072083⁢_c5320−325292447⁢_c480+1024685474274⁢_c10+1528239898647⁢_c94+52115239071⁢_c8+4509246735⁢_c74+O⁡x2
Converting between Boolean Functions and Boolean Operators
A new convert(expr, boolean_function) facility converts, in a given expression, all boolean statements constructed using the operators and, or, not, xor, implies to equivalent boolean function constructions using the functions And, Or, Not. This conversion facility is of use, among others things, for:
- Avoiding the automatic simplification of boolean operators
- Allowing the read of the boolean statement with the order of execution and precedence of the operations made explicit with parentheses
Boolean statements constructed with operators are simplified automatically.
z <> 0 and (b-2*a-2 = 0 or b-2*a = 0);
The equivalent boolean function statement is not automatically simplified. In this example, right single quotes around the boolean operator statement are required when performing the conversion.
convert( 'z <> 0 and (b-2*a-2 = 0 or b-2*a = 0)', boolean_function );
z≠0∧b−2⁢a−2=0∨b−2⁢a=0
This function representation permits further manipulations of the boolean statement without automatic simplification to false.
When using the boolean operators and, or, xor, implies, the precedence of the operations is not always obvious, for example:
a and b or c and d or e;
aandborcanddore
The order of execution and the precedence becomes explicit when converting to boolean functions.
convert((131), boolean_function);
a∧b∨c∧d∨e
a xor b implies c and d;
axorb⇒candd
convert((133), boolean_function);
¬a∧¬b∨¬a∧b∨c∧d
Converting Complex Ranges to Real Ranges or Relations
In connection with the new functionality provided by the FunctionAdvisor command, two new related routines, to convert from Complex Ranges to Real Ranges and from Real or Complex Ranges to relations, are available.
z::ComplexRange(-1-I,1+I);
z::ComplexRange⁡−1−I,1+I
convert( (135), RealRange );
ℜ⁡z::−1,1,ℑ⁡z::−1,1
convert( (135), relation );
−1≤ℜ⁡z∧ℜ⁡z≤1∧−1≤ℑ⁡z∧ℑ⁡z≤1
FunctionAdvisor( branch_cuts, arccot );
arccot⁡z,z∈ComplexRange⁡−∞⁢I,−I∨z∈ComplexRange⁡I,∞⁢I
convert( (138), relation );
arccot⁡z,ℜ⁡z=0∧−∞≤ℑ⁡z∧ℑ⁡z≤−1∨ℜ⁡z=0∧1≤ℑ⁡z∧ℑ⁡z≤∞
define
Two new procedures redefine and undefine (see undefine) are available. These are used to change the definition of a name defined using the define and definemore commands.
define( F, F( 0 ) = 1, F( x::nonunit(algebraic) + y::nonunit(algebraic) ) = F( x ) + F( y ) );
F( 2 * a + b );
F⁡2⁢a+F⁡b
redefine( F, [ F( 0 ) = 1, F( x::nonunit(algebraic) + y::nonunit(algebraic) ) = F( x ) + F( y ), F( a::nonunit(numeric) * b::nonunit(algebraic) ) = a * F( b ) ] );
2⁢F⁡a+F⁡b
undefine( F );
F⁡2⁢a+b
See Also
assuming
convert/boolean_function
convert/Int
convert/Sum
DEtools/remove_RootOf
Exponential Integral
factor
FunctionAdvisor
harmonic
Index of New Maple 9 Features
int
Intat
InverseJacobi
LinearFunctionalSystems
MathematicalFunctions[Series]
Mathieu
redefine
RootOf
rsolve
simplify
simplify/constant
simplify/size
solve
undefine
Updates to Differential Equation Solvers
Download Help Document