Symbolics - Maple Help
For the best experience, we recommend viewing online help using Google Chrome or Microsoft Edge.

Online Help

All Products    Maple    MapleSim


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

Integration

• 

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

int1x,x=a..2

(1)

r := int(1/x, x=a..2, 'AllSolutions');

rundefineda<0a=0lna+ln20<a

(2)

r assuming a > 0;

lna+ln2

(3)

r assuming a < 0;

undefined

(4)

int(abs(sin(x)), x=0..2*Pi*m) assuming m::integer;

intabssinx&comma;x&equals;0..2&pi;m

(5)

int(abs(sin(x)), x=0..2*Pi*m, 'AllSolutions') assuming m::integer;

4m

(6)

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

int1x&comma;x&equals;a..b

(7)

int(1/x, x=a..b) assuming a < b;

undefined0<ba<0lna+lnbotherwise

(8)

Differential Equations (DEs)

  

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.

FunctionAdvisor Command

  

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&comma;analytic_extension&comma;asymptotic_expansion&comma;branch_cuts&comma;branch_points&comma;calling_sequence&comma;class_members&comma;classify_function&comma;definition&comma;describe&comma;differentiation_rule&comma;function_classes&comma;identities&comma;integral_form&comma;known_functions&comma;periodicity&comma;plot&comma;relate&comma;required_assumptions&comma;series&comma;singularities&comma;special_values&comma;specialize&comma;sum_form&comma;symmetries&comma;synonyms&comma;table

(9)
  

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&comma;AiryBi&comma;BesselI&comma;BesselJ&comma;BesselK&comma;BesselY&comma;HankelH1&comma;HankelH2&comma;KelvinBei&comma;KelvinBer&comma;KelvinHei&comma;KelvinHer&comma;KelvinKei&comma;KelvinKer

(10)

FunctionAdvisor(describe, BesselK);

BesselK=Modified Bessel function of the second kind

(11)
  

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

BesselKa&comma;Iz=πBesselYa&comma;z2Ia+BesselJa&comma;zlnzlnIzIa&comma;a::integer&comma;BesselKa&comma;Iz=πzaBesselYa&comma;z2Iza+πBesselJa&comma;zIzaza+zacosaπIzacscaπ2&comma;a::¬integer&comma;BesselKa&comma;z=−1aBesselKa&comma;z+BesselIa&comma;zlnzlnz&comma;a::integer&comma;BesselKa&comma;z=zaBesselKa&comma;zza+πzazazazaBesselIa&comma;zcscaπ2&comma;a::¬integer&comma;BesselKa&comma;bczqp=bcpzpqaBesselKa&comma;bcpzpqbczqpaπcscaπBesselIa&comma;bcpzpqbczqpabcpzpqabcpzpqabczqpa2&comma;a::¬integer2p::integer&comma;BesselKa&comma;bczqp=czqpcpzpqaBesselKa&comma;bcpzpq−1aBesselIa&comma;bcpzpqlnbczqplnbcpzpq&comma;a::integer2p::integer&comma;BesselKa&comma;z=2a1BesselKa1&comma;zz+BesselKa2&comma;z&comma;BesselKa&comma;z=2a+1BesselKa+1&comma;zz+BesselKa+2&comma;z

(12)

FunctionAdvisor( special_values, sec );

secπ6=233&comma;secπ4=2&comma;secπ3=2&comma;sec=undefined&comma;secI=0&comma;secπn=−1&comma;n::odd&comma;secπn=1&comma;n::even&comma;secπn2=+I&comma;n::odd

(13)

FunctionAdvisor( sum_form, tan );

tanz=_k1=1bernoulli2_k1−1_k1z2_k114_k116_k1Γ2_k1+1&comma;z<π2

(14)

FunctionAdvisor( integral_form, Beta );

&Beta;x&comma;y&equals;Int_k1x11_k1y1&comma;_k1&equals;0..1&comma;And0<&real;x&comma;0<&real;y

(15)

FunctionAdvisor( relate, sin, WhittakerM );

sinz=I2WhittakerM0&comma;12&comma;2Iz

(16)

FunctionAdvisor( specialize, HermiteH, KummerU );

HermiteHa&comma;z=2aKummerUa2&comma;12&comma;z2&comma;0<zz=00<z

(17)
  

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=arccotz=π2Iln1Izln1+Iz2&comma;with no restrictions on z

classify_function=arctrig&comma;elementary

symmetries=arccotz=πarccotz&comma;arccotz&conjugate0;=arccotz&conjugate0;&comma;notzComplexRangeI&comma;−IorzComplexRangeI&comma;I

periodicity=arccotz&comma;No periodicity

singularities=arccotz&comma;z=+I

branch_points=arccotz&comma;z−I&comma;I

branch_cuts=arccotz&comma;zComplexRangeI&comma;−IzComplexRangeI&comma;I

special_values=arccot−1=3π4&comma;arccot33=2π3&comma;arccot3=5π6&comma;arccot0=π2&comma;arccot3=π6&comma;arccot33=π3&comma;arccot1=π4&comma;arccot=0&comma;arccot=π

identities=cotarccotz=z&comma;cotarccotz+arccoty=zy1z+y

sum_form=arccotz=_k1=0zIz_k1+−Iz_k12_k1+2+π2&comma;Andabsz<1

series=seriesarccotz&comma;z&comma;4=π2z+13z3+Oz5

asymptotic_expansion=asymptarccotz&comma;z&comma;4=1z13z3+O1z5

integral_form&equals;arccotz&equals;Int12I_k1&comma;_k1&equals;1&plus;Iz..1Iz&plus;12&pi;&comma;with no restrictions on z

differentiation_rule&equals;Diffarccotz&comma;z&equals;1z2&plus;1&comma;Diffarccotz&comma;z&dollar;n&equals;piecewisen&equals;0&comma;arccotz&comma;2n1MeijerG0&comma;0&comma;12&comma;&comma;0&comma;12n12&comma;12n&comma;z2z1n

DE=fz=arccotz&comma;&DifferentialD;&DifferentialD;zfz=1z2+1

(18)

Conversion Routines for Mathematical Functions

  

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.

  

Examples

  

New function conversions:

harmonic(z,n);

harmonicz&comma;n

(19)

(19) = convert((19), Psi) assuming n::posint;

harmonicz&comma;n=−1nΨn1&comma;1Ψn1&comma;z+1n1!

(20)

(19) = convert((19), Zeta);

harmonicz&comma;n=ζnζ0&comma;n&comma;z+1

(21)

(19) = convert((19), LerchPhi);

harmonicz&comma;n=ζnLerchPhi1&comma;n&comma;z+1

(22)

convert(InverseJacobiAM(z,k), EllipticF) assuming And(-1/2*Pi < Re(z),Re(z) < 1/2*Pi);

EllipticFsinz&comma;k

(23)

InverseJacobiSC(z,k) = convert(InverseJacobiSC(z,k), InverseJacobiSN);

InverseJacobiSCz&comma;k=−IInverseJacobiSNIz&comma;k2+1

(24)
  

Sum and integral representations for the trigonometric functions:

trigonometric_functions := FunctionAdvisor( trig )(z);

The 6 functions in the "trig" class are:

trigonometric_functionscosz&comma;cotz&comma;cscz&comma;secz&comma;sinz&comma;tanz

(25)

map(f -> f = convert(f,Sum), trigonometric_functions) assuming abs(z) < Pi/2;

cosz=_k1=0−1_k1z2_k12_k1!&comma;cotz=_k1=0−1_k122_k1bernoulli2_k1z2_k112_k1!&comma;cscz=_k1=0222_k111bernoulli2_k1z2_k11−1_k12_k1!&comma;secz=_k1=0−1_k1euler2_k1z2_k12_k1!&comma;sinz=_k1=0−1_k1z2_k1+12_k1+1!&comma;tanz=_k1=1bernoulli2_k1−1_k1z2_k114_k116_k1Γ2_k1+1

(26)

map(f -> f = convert(f,Int), [sin, cos](z) );

sinz&equals;zIntexp2I_t1z&comma;_t1&equals;0..1expIz&comma;cosz&equals;12I2z&plus;&pi;IntexpI_t12z&plus;&pi;&comma;_t1&equals;0..1expIz

(27)

tan(z) = convert(tan(z), Int) assuming z in RealRange(Open(0), Open(Pi/2));

tanz&equals;2Int_k12z&pi;1_k121&comma;_k1&equals;0..&infin;&pi;

(28)

trigonometric_functions := FunctionAdvisor( trig )(z);

The 6 functions in the "trig" class are:

trigonometric_functionscosz&comma;cotz&comma;cscz&comma;secz&comma;sinz&comma;tanz

(29)

map(f -> f = convert(f,Sum), trigonometric_functions) assuming abs(z) < Pi/2;

cosz=_k1=0−1_k1z2_k12_k1!&comma;cotz=_k1=0−1_k122_k1bernoulli2_k1z2_k112_k1!&comma;cscz=_k1=0222_k111bernoulli2_k1z2_k11−1_k12_k1!&comma;secz=_k1=0−1_k1euler2_k1z2_k12_k1!&comma;sinz=_k1=0−1_k1z2_k1+12_k1+1!&comma;tanz=_k1=1bernoulli2_k1−1_k1z2_k114_k116_k1Γ2_k1+1

(30)

map(f -> f = convert(f,Int), [sin, cos](z) );

sinz&equals;zIntexp2I_t1z&comma;_t1&equals;0..1expIz&comma;cosz&equals;12I2z&plus;&pi;IntexpI_t12z&plus;&pi;&comma;_t1&equals;0..1expIz

(31)

tan(z) = convert(tan(z), Int) assuming z in RealRange(Open(0), Open(Pi/2));

tanz&equals;2Int_k12z&pi;1_k121&comma;_k1&equals;0..&infin;&pi;

(32)

Special Functions

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&phi;&comma;k&equals;Int11k2sin_&theta;12&comma;_&theta;1&equals;0..&phi;&comma;with no restrictions on &phi;&comma;k

(33)

FunctionAdvisor(special_values, InverseJacobiAM);

InverseJacobiAMφ&comma;k=InverseJacobiAMφ&comma;k&comma;InverseJacobiAMφ&comma;k=InverseJacobiAMφ&comma;k&comma;InverseJacobiAM0&comma;k=0&comma;InverseJacobiAMφ&comma;0=φ&comma;InverseJacobiAMnπ2&comma;k=nEllipticKk&comma;n::integer&comma;InverseJacobiAMφ&comma;k=lnsecφ+tanφ&comma;φ<π2k−1&comma;1&comma;InverseJacobiAMφ&comma;k=0&comma;k&comma;&comma;InverseJacobiAMI&comma;k=EllipticKkEllipticK1kk&comma;k20&comma;1

(34)

InverseJacobiCN(z,k) assuming z = -1;

2EllipticKk

(35)

InverseJacobiSN(z,k) assuming z = infinity, k^2 > 1;

EllipticKkEllipticK1k2k

(36)

JacobiDN( InverseJacobiDN(z,k), k );

z

(37)

Mathieu Functions

  

In Maple 9, the family of Mathieu functions is available. These functions are the solutions of Mathieu's equation:

y''+a2qcos2xy=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) );

Einz=zn1Γ1n&comma;z

(38)
  

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;

Ein&comma;z&equals;Intexpz_k1_k1n&comma;_k1&equals;1..&infin;

(39)
  

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;

Eiz&equals;Intexp_k1_k1&comma;_k1&equals;&infin;..z&comma;CauchyPrincipalValue

(40)
  

This classical definition is extended to the entire complex plane using:

FunctionAdvisor( analytic_extension, Ei(z) );

Eiz=γln1z2+lnz2+zhypergeom1&comma;1&comma;2&comma;2&comma;z

(41)

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 harmonicz is:

FunctionAdvisor( definition, harmonic(z) );

harmonicz=Ψz+1+γ&comma;with no restrictions on z

(42)
  

and the generalized harmonic function is defined by:

FunctionAdvisor( definition, harmonic(z,n) );

harmonicz&comma;n=ζnζ0&comma;n&comma;z+1&comma;with no restrictions on z&comma;n

(43)
  

where:

harmonic(z,n) assuming n = 1;

harmonicz

(44)

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;

2n2n2!

(45)

doublefactorial(n) assuming n > 0, n::odd;

n!2n212n212!

(46)

GaussAGM Command

GaussAGM(a,b) assuming a = 0;

0

(47)

GaussAGM(a,b) assuming a = b;

a

(48)

EllipticNome and EllipticModulus Commands

EllipticNome(k) assuming k = 1;

1

(49)

EllipticNome(k) assuming k^2 = 1/2;

&ExponentialE;π

(50)

EllipticModulus(q) assuming q = exp(-Pi);

22

(51)

LerchPhi Command

LerchPhi(z,a,v) assuming z=1;

zζ0&comma;a&comma;v

(52)

LerchPhi(z,a,v) assuming v=1;

vpolyloga&comma;zz

(53)

Lommel Commands

LommelS2(mu,nu,z) assuming mu = nu + 1;

zν

(54)

LommelS1(mu,nu,z) assuming mu = nu;

Γ12+νπ2ν1StruveHν&comma;z

(55)

LommelS1(mu,nu,z) assuming mu = 0;

πtanνπ2AngerJν&comma;zWeberEν&comma;z2

(56)

Jacobi Commands

JacobiZeta(z,k) assuming (2*z/Pi)::integer;

JacobiZetaz&comma;k

(57)

JacobiAM(z,k) assuming k = 1;

2arctan&ExponentialE;zπ2

(58)

JacobiCN(z,k) assuming k = 0;

cosz

(59)

JacobiSN(z,k) assuming k = 0;

sinz

(60)

InverseJacobi Commands

InverseJacobiCN(z,k) assuming k=1;

arcsechz

(61)

InverseJacobiSN(z,k) assuming z=1;

EllipticKk

(62)

InverseJacobiAM(z,k) assuming z = n/2*Pi, n::integer;

2zEllipticKkπ

(63)

pochhammer Command

pochhammer(a,b) assuming a=-1, b=-2;

−1bΓ1aΓ1ab

(64)

pochhammer(a,b) assuming b::complex(numeric), csgn(b)=-1;

1pochhammera+b&comma;b

(65)

Zeta Command

Zeta(n,z,q) assuming q=1;

ζn&comma;z

(66)

Zeta(n,z,q) assuming n = 0, z::integer, z > 1;

−1zΨz1&comma;qz1!

(67)

Zeta(n,z,q) assuming n = 0, z::integer, z < 1;

bernoulli1z&comma;q1z

(68)

Series of Mathematical Functions

  

The Maple 9 series command can compute series for various new functions: EllipticNome, GaussAGM, ChebyshevT, ChebyshevU, and the four JacobiTheta functions.

  

Examples

series( EllipticNome(k), k );

116k2+132k4+Ok6

(69)

series( JacobiTheta1(z,q), q );

2q14sinz2q94sin3z+Oq254

(70)

series( JacobiTheta4(z,q), q );

12cos2zq+2cos4zq4+Oq9

(71)

series( ChebyshevT(5,z), z );

5z20z3+16z5

(72)

series( ChebyshevT(a,z), z, 4 );

cosaπ2+sinaπ2az12cosaπ2a2z2sinaπ216a+16a3z3+Oz4

(73)

series( ChebyshevU(a,z), z, 3 );

cosaπ2sinaπ2a1z+cosaπ22a12cosaπ22z2+Oz3

(74)

series( GaussAGM(x,y), x, 3 );

πy22ln2lnxy18π1+2ln2lnxyy2ln2lnxy2x2+Ox3

(75)
  

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.

  

Examples

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

1Γ34z18z783Γ345z15842Γ3431z238462Γ34+Oz318

(76)

series( LegendreQ(-1/2,1/4,-(z+1)/(z-1)), z, 2 );

18+I8π234Γ58434csc3π8Γ78z182+2I214Γ342Γ78z18πΓ58cscπ8124+I24π234Γ58434z78csc3π8Γ78+25+2I5214Γ342Γ78z98πΓ58cscπ8+Oz158

(77)

series( MeijerG([[], []],[[-1/4], [1/4]],1/4*z^2), z );

414πz414z322π+414z7224π+Oz112

(78)

series( MeijerG([[1/2, 1/2], []],[[0], [-1/2]],-z^2), z);

2π+13πz2+320πz4+Oz6

(79)

series( GegenbauerC(a,b,z), z, 2);

GegenbauerCa&comma;b&comma;0+GegenbauerCa1&comma;b&comma;0a+2GegenbauerCa1&comma;b&comma;0bGegenbauerCa1&comma;b&comma;0z+Oz2

(80)

series( BesselK(a,z+1), z, 2 );

BesselKa&comma;1+aBesselKa&comma;1BesselKa+1&comma;1z+Oz2

(81)

series( polylog(a,z), z );

z+12az2+13az3+14az4+15az5+Oz6

(82)
  

This expansion for polylog is valid only for z<1. You can verify this using the new FunctionAdvisor command.

FunctionAdvisor( sum_form, polylog );

polyloga&comma;z=_k1=1z_k1_k1a&comma;z<1,polyloga&comma;z=z2+_k1=Γ1a&comma;2I_k1πlnz2I_k1πlnz1+a&comma;a::posint,polyloga&comma;z=z2+_k1=_k2=02I_k1π+lnz_k22I_k1πlnz1+aΓ_k2+1_k21+a+Γ1a2I_k1πlnz1+a&comma;a::¬posint

(83)
  

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.

  

Example

with(MathematicalFunctions, Series);

Series

(84)

Series(polylog(a,z), z);

z+12az2+13az3+14az4+15az5+Oz6,Andabsz<1

(85)

Series(GAMMA(a,z), z, 3);

zaΓa1a+1a+1z14+2az2+Oz3,Anda::Notnonposint

(86)

Series(BesselJ(a,z), z);

za12aΓa+11412aΓ2+az2+13212aΓ3+az4+Oz6,Anda::Notnegint

(87)

Series( LommelS1(a,b,z), z, 4 );

za1ab+1a+b+1z1ab+1ab+3a+b+1a+b+3z3+Oz5,a+b::¬negintoddab::¬negintodd

(88)

assuming Facility

  

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.

  

Examples

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

(89)
  

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

(90)
  

Independent of whether you specify the additionally argument, any previously existing assumptions on the variables are preserved.

about(x);          # same assumption as returned previously

Originally x, renamed x~:
  is assumed to be: RealRange(-infinity,Open(1))

x := 'x':          # remove assumptions on 'x'

Simplification

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

sinx2

(91)

simplify( cos(x)^2 );        # works as in Maple 8

cosx2

(92)

simplify( 1 - cos(x)^2 );    # 1 - cos(x)^2 in Maple 8

sinx2

(93)

simplify( 1 - sin(x)^2 );    # works as in Maple 8

cosx2

(94)

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+xxxx+1xabx2+1x2+1

(95)

simplify((95),power) assuming x > 1;

ab

(96)

Special Functions

  

In Maple 9, the simplify command can better simplify more functions.

simplify(Ssi(z)+1/2*Pi - Si(z));

0

(97)

simplify(GegenbauerC(2,a,z)) assuming a=1;

4z21

(98)

simplify(GegenbauerC(n,a,z)) assuming z=-1, n::nonnegint;

−1nΓ2a+nΓ2aΓn+1

(99)
  

Chebyshev functions:

simplify(ChebyshevT(a,z)) assuming z = 0;

cosaπ2

(100)

simplify(ChebyshevT(a,z)) assuming z = 1;

1

(101)

simplify(ChebyshevU(a,z)) assuming z = 1;

a+1

(102)

simplify(ChebyshevU(a,z)) assuming a = -1/2;

22z+1

(103)
  

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

InverseJacobiAM12&comma;k

(104)

simplify(InverseJacobiCS(csch(1/2),k));

−IInverseJacobiAMI2&comma;k2+1

(105)

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Φyx&comma;yx+RootOfΦyx&comma;yx+x_Z_ZxRootOfΦyx&comma;yx+x_Z_Z

(106)

simplify(zero);  # new output

0

(107)
  

Equate zero to a variable ZERO and remove one RootOf from this expression (see also DEtools/remove_RootOf).

normal( DEtools[remove_RootOf]( zero = ZERO ) );

Φyx&comma;RootOfΦyx&comma;_Z+ZERO=0

(108)

simplify((108));     # new output

ZERO=0

(109)

sin(RootOf(sin(_Z)+_Z-_Z^3))+RootOf(sin(_Z)+_Z-_Z^3)-RootOf(sin(_Z)+_Z-_Z^3)^3;

sinRootOfsin_Z_Z+_Z3+RootOfsin_Z_Z+_Z3RootOfsin_Z_Z+_Z33

(110)

simplify((110),RootOf); # new output

0

(111)

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

eeI&ExponentialE;IEi1I2Ei1Isin12+IEi1Icos12Ei1−Isin12IEi1−Icos12+I&ExponentialE;−IEi1−I2

(112)

simplify((112));  # using simplify(ee, constant) produces the same result faster

0

(113)
  

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;

e23sinxcosx2sinxm+3sinxcosx2cosxn+4sinxcosx4sinxm4sinxcosx4cosxn

(114)

simplify((114), size); # requires the extra argument 'size' to be specified

4cosxnsinxmsinxcosx234cosx2

(115)

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

Intfx&comma;x&equals;a..bIntfy&comma;y&equals;a..b

(116)

simplify((116));

0

(117)

Limit(f(x), x=a) - Limit(f(y), y=a);

limxafxlimyafy

(118)

simplify((118));

0

(119)
  

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;

xIntatexpIntf_b&comma;_bg_b&comma;_b&equals;yx&plus;expIntatf_a&comma;_a&equals;yxx

(120)
  

The previous expression contains the dummy variables _a and _b; simplify makes the names the same.

e2 := simplify(e1);

xIntatexpIntf_a&comma;_ag_a&comma;_a&equals;yx&plus;expIntatf_a&comma;_a&equals;yxx

(121)
  

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

expIntatf_b&comma;_b&equals;yxdiffyx&comma;xgyxx2&plus;diffyx&comma;xfyxexpIntatf_a&comma;_a&equals;yxx&plus;expIntatf_a&comma;_a&equals;yxx2

(122)

factor(diff(e2,x));   # factors

expIntatf_a&comma;_a&equals;yxdiffyx&comma;xgyxx2&plus;diffyx&comma;xfyxx&plus;1x2

(123)

Solving Algebraic and Recurrence Equations

• 

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=s21s2+1&comma;v=2ss2+1

(124)

solve( x^x - y^y, {x(t),y(t)});

x=&ExponentialE;tln1tt1&comma;y=t&ExponentialE;tln1tt1

(125)
• 

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

sysyx+5zx=0&comma;yxx2+3yxx+2yx2zxx24zxx+zx+1x2+zx+1x=0

(126)

vars := {y(x), z(x)};

varsyx&comma;zx

(127)

Order := 2: sol := rsolve(sys,vars,'series');

solyx=11171256901_c564+202134809_c4161160265804390_c102101241187045_c9491956626685_c820248267725_c74+6211703225_c68+_c3+x84884655807_c5320+695475963_c4803716103506346_c105262694938963_c94164157505659_c84935798315_c74+16465573215_c68+Ox2&comma;zx=_c1+_c21586137831_c48+56102335540020_c10+41273311696155_c92+2753324557830_c8+100460135475_c72127908744775_c64147985008059_c532+3_c3+x4720528435_c6828346072083_c5320325292447_c480+1024685474274_c10+1528239898647_c94+52115239071_c8+4509246735_c74+Ox2

(128)

Miscellaneous

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

  

Examples

  

Boolean statements constructed with operators are simplified automatically.

z <> 0 and (b-2*a-2 = 0 or b-2*a = 0);

false

(129)
  

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

z0b2a2=0b2a=0

(130)
  

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

(131)
  

The order of execution and the precedence becomes explicit when converting to boolean functions.

convert((131), boolean_function);

abcde

(132)

a xor b implies c and d;

axorbcandd

(133)

convert((133), boolean_function);

¬a¬b¬abcd

(134)

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−1I&comma;1+I

(135)

convert( (135), RealRange );

z::−1&comma;1,z::−1&comma;1

(136)

convert( (135), relation );

−1zz1−1zz1

(137)

FunctionAdvisor( branch_cuts, arccot );

arccotz&comma;zComplexRangeI&comma;−IzComplexRangeI&comma;I

(138)

convert( (138), relation );

arccotz&comma;z=0zz−1z=01zz

(139)

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

F2a+Fb

(140)

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 ) ] );

F( 2 * a + b );

2Fa+Fb

(141)

undefine( F );

F( 2 * a + b );

F2a+b

(142)

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

series

simplify

simplify/constant

simplify/size

solve

undefine

Updates to Differential Equation Solvers