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

Online Help

All Products    Maple    MapleSim


Advanced Mathematics

Maple 2022 includes a very large number of improvements that strengthen the math engine, expanding Maple's abilities to handle new areas of mathematics and solve harder problems, faster.  In addition to the mathematical improvements described in more detail elsewhere, Maple 2022 enhances support for many areas of mathematics, and improves fundamental routines that are used regularly both by users and by other Maple commands.

 

 

Improvements to Core Mathematics Routines

Introduction of Ball Arithmetic

Formal Power Series

Graph Theory

Linear Recurrence Relations

Polyhedral Sets

Real Root Finding

Intersection Multiplicities

Improvements to Core Mathematics Routines

Integration

For Maple 2022, we put a large focus on improving integration by correcting known weaknesses, and, as a result, Maple can solve more integration problems than ever.  The following are some examples.

 

int is now smarter about changes of variables that can avoid integrating term by term:

int(x*(x^2+1)^99,x);

x2+1100200

(1.1.1)

Significant improvements to elliptic integration led to these new results:

VectorCalculus:-ArcLength(z-> <sqrt(-z+2), sqrt(z-1), z>, 1 .. 2);

2EllipticE22

(1.1.2)

int(sqrt((-5*x^2 + 81)/(-9*x^2 + 81)), x = 0 .. 3);

3EllipticE53

(1.1.3)

int((1 - I*sqrt(1 - z^3))^4, z=-1..1);

64I25512I3142EllipticFI2+32&comma;32I255547+4I3342EllipticFI2+32&comma;32I255+1223I3EllipticF23I336&comma;32I255+4I233I3EllipticF23I336&comma;32I25543342EllipticFI2+32&comma;32I255123142EllipticFI2+32&comma;32I255

(1.1.4)

int((z^3 - I*sqrt(1 - z^4))^4, z=-1..1);

4291445045

(1.1.5)

int(1/(sqrt(z-1)*sqrt(z-2)*sqrt(3-z)),z=0..1);

2EllipticK22+2EllipticF233&comma;22

(1.1.6)

This integral gives a new result:

int( sin(Pi*(x^2+y^2)), y = 0 .. (-x^2+1)^(1/2) ) assuming x>0, x<1;

cosπx2FresnelSx2+12+sinπx2FresnelCx2+1222

(1.1.7)

Previously this gave an error:

int(1-abs(x)-abs(x-y)+abs(-1+abs(x)+abs(x-y)),x) assuming -1<x,x<1;

xx22x0x220<x12x2+yxxy12x2yx+y2y<x+x2+yxxx12+y2x2yx+x+12y2y+12x0yx+x+12y2y+12xyx2+yx+x12y2+12yx12+y2x2yxx+112+y2<xy<1x2x000<x1+y=0x2+yxxx01+yx0<xotherwiseotherwise0<yx2+yxxx12+y2x2yx+x+12y2y+12xyyx+x12y2+12yx0x2+yx+x12y2+12yx12+y2x2yxx+112+y2<xy<10x0x20<x1y=01+yxx0x2yxx0<xotherwiseotherwiseotherwise

(1.1.8)

This was previously unevaluated:

int(1-abs(x)-abs(x-y)+abs(1-abs(x)-abs(x-y)),[x = -1 .. 1, y = -1 .. 1]);

43

(1.1.9)

This integral gives a new result:

int(z^(1/5)/(z^2+1),z = -infinity .. infinity, method=FTOC);

π2555+2I5525510I2102510+25

(1.1.10)

This was previously unevaluated:

int(((z-1)/(z+1)^(1/2))^(2*x+1), z=0..1);

−12x2x+12232+xhypergeom12x&comma;12x&comma;32x&comma;12Γx+12+4Γ32xΓ2x+2x2Γ32xΓ2x+2Γx+121+2x

(1.1.11)

This was previously unevaluated:

int(Sum((-1)^x*((99/100*Pi*z-99/100*Pi)/(99/100*Pi*z+1/100*Pi)^(1/2))^(2*x+1)/(2*x+1)!,x = 0 .. infinity), z=0..1);

πx=0−13xπx22x+252x+1hypergeom12x&comma;12x&comma;32x&comma;1100Γx+12+200Γ32xΓ2x+2x100Γ32xΓ2x+22x+1!Γx+121+2x99

(1.1.12)

This was previously unevaluated:

int(int(f(y), y=a..b), y=a..b);

baabfy&DifferentialD;y

(1.1.13)

This was previously unevaluated:

int(((1/t)^(1 - 2*n)  - 1) / (t - 1), t=0..x);

2π1x2nx2nn+21x2nLerchPhi1x&comma;1&comma;2nnsin2πn+1x2nsin2πn+2nlnxsin2πn+2nlnx1xsin2πn2sin2πnn

(1.1.14)

This was previously unevaluated:

int(exp(t^3),t=0..x);

x3232π33Γ13&comma;x3Γ239x2Γ23

(1.1.15)

This was previously unevaluated:

int(cos(x)^(1/3)*sin(x)^2,x=-Pi/2..Pi/2);

9Γ23Γ567π

(1.1.16)

This integral gives a new result:

int(arctan(z)*(z-1)^(1/3), z=0..1);

63I−1+I233+2−1+I23_R=RootOf_Z6+2_Z3+2lnI32_R+1_R22−1+I23_R=RootOf_Z6+2_Z3+2ln_R_R23−1+I234IπI3+12I312−1+I23

(1.1.17)

Better handling of Dirac in int led to this improved result:

int(1/exp(I*q*a), q = -infinity .. infinity);

2πDiraca

(1.1.18)

This new result is due to improved discontinuity handling in the presence of Heaviside:

int(Heaviside(-y^2+B)/(-y^2+B)^(1/2), y=-infinity .. infinity) assuming B>0;

π

(1.1.19)

This new result is due to an improvement in simplification of logarithms:

int(cos(x)^3*sin(x)^n,x);

I&ExponentialE;Ixn&ExponentialE;2Ix1n12n&ExponentialE;I2πncsgnI&ExponentialE;2Ix1csgnI&ExponentialE;−Ixcsgnsinx+πncsgnI&ExponentialE;2Ix1csgnsinx2+πncsgnI&ExponentialE;−Ixcsgnsinx2+πncsgnsinx3πncsgnsinxcsgnIsinx2πncsgnIsinx3+πncsgnsinxcsgnIsinx+πncsgnIsinx2πn6x8n+3+I12n&ExponentialE;2Ix1n&ExponentialE;Ixnn+9&ExponentialE;I2πncsgnI&ExponentialE;2Ix1csgnI&ExponentialE;−Ixcsgnsinx+πncsgnI&ExponentialE;2Ix1csgnsinx2+πncsgnI&ExponentialE;−Ixcsgnsinx2+πncsgnsinx3πncsgnsinxcsgnIsinx2πncsgnIsinx3+πncsgnsinxcsgnIsinx+πncsgnIsinx2πn2x8n+31+nI12n&ExponentialE;2Ix1n&ExponentialE;Ixn&ExponentialE;I2πncsgnI&ExponentialE;2Ix1csgnI&ExponentialE;−Ixcsgnsinx+πncsgnI&ExponentialE;2Ix1csgnsinx2+πncsgnI&ExponentialE;−Ixcsgnsinx2+πncsgnsinx3πncsgnsinxcsgnIsinx2πncsgnIsinx3+πncsgnsinxcsgnIsinx+πncsgnIsinx2πn+6x8n+3I12n&ExponentialE;2Ix1n&ExponentialE;Ixnn+9&ExponentialE;I2πncsgnI&ExponentialE;2Ix1csgnI&ExponentialE;−Ixcsgnsinx+πncsgnI&ExponentialE;2Ix1csgnsinx2+πncsgnI&ExponentialE;−Ixcsgnsinx2+πncsgnsinx3πncsgnsinxcsgnIsinx2πncsgnIsinx3+πncsgnsinxcsgnIsinx+πncsgnIsinx2πn+2x8n+31+n

(1.1.20)

There is a new result from inttrans:-fourier:

inttrans:-fourier(x^n*ln(x),x,s) assuming n::posint;

In&pi;I&pi;Diracn&comma;s2Sumbinomialn&comma;_k1diffHeavisides&comma;s&dollar;_k1pochhammern&plus;_k1&comma;n_k1s1n&plus;_k1&comma;_k1&equals;0..n

(1.1.21)

Some improvements to IntegrationTools:-Change led to these new results:

IntegrationTools:-Change(Int((-3*x^2+x+2*Pi)*x, x=0..1), u = -3*x^2+x+2*Pi);

16Int24&pi;12u&plus;1112u&plus;24&pi;u112u&plus;24&pi;&comma;u&equals;2&pi;..112&plus;2&pi;&plus;16Int24&pi;12u&plus;1&plus;112u&plus;24&pi;u112u&plus;24&pi;&comma;u&equals;2&plus;2&pi;..112&plus;2&pi;

(1.1.22)

Differential Equations

Improved solvers for partial differential equations enable Maple 2022 to solve problems it couldn't solve before. For example, pdsolve can now handle this problem:

pde[N3] := diff(u(r, theta, t), t, t) = (diff(u(r, theta, t), r)+r*(diff(u(r, theta, t), r, r))+(diff(u(r, theta, t), theta, theta))/r)/(4*r);
iv[N3] := u(1, theta, t) = 0, (D[2](u))(r, 0, t) = 0, (D[2](u))(r, Pi, t) = 0, u(r, theta, 0) = r^2*cos(2*theta), (D[3](u))(r, theta, 0) = 0;
pdsolve([pde[N3], iv[N3]], u(r, theta, t), HINT = boundedseries(r = [0])) assuming r >= 0, r <= 1, theta >= 0, theta <= Pi;

pdeN32t2ur&comma;θ&comma;t=rur&comma;θ&comma;t+r2r2ur&comma;θ&comma;t+2θ2ur&comma;θ&comma;tr4r

ivN3u1&comma;θ&comma;t=0,D2ur&comma;0&comma;t=0,D2ur&comma;π&comma;t=0,ur&comma;θ&comma;0=r2cos2θ,D3ur&comma;θ&comma;0=0

ur&comma;&theta;&comma;t&equals;casesplit/ansSum_C90&comma;nBesselJ0&comma;&lambda;nrcos12&lambda;nt&plus;2BesselJZeros2&comma;n2BesselJ1&comma;BesselJZeros2&comma;n8BesselJZeros2&comma;nBesselJ0&comma;BesselJZeros2&comma;n&plus;16BesselJ1&comma;BesselJZeros2&comma;nBesselJ2&comma;BesselJZeros2&comma;nrcos2&theta;cos12&lambda;ntBesselJ1&comma;BesselJZeros2&comma;n2BesselJZeros2&comma;n3&comma;n&equals;1..&infin;&comma;And&lambda;n&equals;BesselJZeros0&comma;n&comma;0&lambda;n

(1.2.1)

The FindODE command in the DEtools package has been improved. It has a few new options, and it is more efficient on many examples. The following examples took more than twice as long in earlier versions of Maple:

with(DEtools):

DE := CodeTools:-Usage(FindODE(arctan(z)^2+sin(z)^4+log(1+z)^5, y(z), 12)):

memory used=86.33MiB, alloc change=32.00MiB, cpu time=870.00ms, real time=835.00ms, gc time=150.50ms

PDEtools:-difforder(DE,z);

11

(1.2.2)

DE := CodeTools:-Usage(FindODE((3*z+5*z^7+11*z^13)*log(1+z^3+z^7)+arctanh(z)*cos(z)^5, y(z), 15)):

memory used=1.01GiB, alloc change=50.23MiB, cpu time=8.86s, real time=8.23s, gc time=1.20s

PDEtools:-difforder(DE,z);

14

(1.2.3)

Integral Equations

The intsolve command now has an option to specify if an approximate solution using collocation is to be determined numerically or symbolically. For example:

ie := f(x) + int( f(y) * piecewise( x < y, x * ( 5 - y ), y * ( 5 - x ) ), y = 0 .. 5 ) - x = 0;

iefx+05fyx5yx<yy5xotherwise&DifferentialD;yx=0

(1.3.1)

intsolve( ie, f(x), 'method' = 'collocation', 'order' = 5, 'numeric' = 'true' );

fx=0.0249169435217379x50.235304198570564x4+0.791580191676118x31.08998977144344x2+0.500379185550479x+8.41923579640045×10−15

(1.3.2)

intsolve( ie, f(x), 'method' = 'collocation', 'order' = 5, 'numeric' = 'false' );

fx=15602x5174375741062x4+293305370531x3403875370531x2+185406370531x

(1.3.3)

Simplification

Simplification has been improved in a number of areas.

The arctrig functions now perform some new automatic simplification by pulling out signs:

arccos(csgn(z)*z),arccot(csgn(z)*z),arcsec(csgn(z)*z);

π2csgnzarcsinz,π2csgnzarctanz,π2csgnzarccscz

(1.4.1)

The following inverse trigonometric identities are now recognized by simplify:
arctanz&plus;arccotz &equals; arccosz&plus;arcsinz &equals; arcsecz&plus;arccscz &equals; π2

SA := () -> simplify(args, 'arctrig'):

SA(arcsin(z) + arccos(z)),
SA(arcsec(z) + arccsc(z));

π2,π2

(1.4.2)

 

simplify and combine now recognize the following identities:

SA(arccot(1)+arccot(2)+arccot(3));
combine(arccot(1)+arccot(2)+arccot(3));

π2

π2

(1.4.3)

simplify now recognizes when two simplifications can be combined:

SA(arctan(cos(2)/sin(2)));

π22

(1.4.4)

When no cancellation is available, simplify converts to arctan, arcsin, or arccsc by default:

SA(arccos(x) + Pi/2),
SA(arcsec(x) + Pi/2);

πarcsinx,πarccscx

(1.4.5)

When one form is more compact, it uses that form instead of the default:
SA(Pi/2 - arctan(z)),
SA(Pi/2 - arcsin(z)),
SA(Pi/2 - arccos(z)),
SA(Pi/2 - arcsec(z)),
SA(Pi/2 - arccsc(z));

arccotz,arccosz,arcsinz,arccscz,arcsecz

(1.4.6)

 

Trigonometric simplification now makes use of formulae such as the following where applicable:
 1cos2 x12  2 sinx212

simplify(-1+1/2*sin(1/4*Pi+1)*(2+2*sin(2))^(1/2)-1/2*cos(1/4*Pi+1)*(2-2*sin(2))^(1/2));

0

(1.4.7)

Improved simplification of nested integrals:

simplify(Int(((x-1)*(-Heaviside(y)*Heaviside(x)*Heaviside(y-x)+Heaviside(y)*Heaviside(x))+x*Heaviside(y)*Heaviside(x)*Heaviside(y-x))*((x-1)*(-Heaviside(y)*Heaviside(x)*Heaviside(y-x)+Heaviside(y)*Heaviside(x))+(x-1)*(-Heaviside(y+x)*Heaviside(y)*Heaviside(x)+Heaviside(y+x)*Heaviside(x))), x = -1 .. 1, y = -1 .. 1));

IntHeavisideyHeavisidexx12Heavisideyx1&comma;x&equals;1..1&comma;y&equals;1..1

(1.4.8)

An improvement in combine regarding linear functions:

combine(Sum(Sum(a[u]*a[v], u = 1 .. n), v = 1 .. n) + Sum(Sum(a[u]*b[v], u = 1 .. n), v = 1 .. n) + Sum(Sum(a[u]*b[v], v = 1 .. n), u = 1 .. n));

v=1nu=1nauav+2aubv

(1.4.9)

Simplification of intat and Intat has been improved:

simplify(intat(f(x),x=y)+Intat(-f(x),x=y));

0

(1.4.10)

Repeated application of simplify with this input previously failed to converge. Now it does:

simplify(Intat(exp(Intat(g(_a),_a=_b)), _b=t)+Intat(h(_a),_a=t));

IntatexpIntatg_a&comma;_a&equals;_b&comma;_b&equals;t&plus;Intath_a&comma;_a&equals;t

(1.4.11)

Simplification of logarithms is now more careful not to expand unnecessarily. This led to the following new result:

simplify(ln(csgn(I*(x^(3/2)+1)))) assuming x, real;

lncsgnI+Ix32

(1.4.12)

There is a new formula in use when combining logarithms:
lna  lnb  lnab when argaargbπ2&comma;π2

ans := combine(ln(1-exp(-t)) - ln(1-exp(t))) assuming t > 0;

ansln1+&ExponentialE;t1+&ExponentialE;t

(1.4.13)

That led to an improved result from simplify as well:

simplify(ans) assuming t > 0;

tIπ

(1.4.14)

Improvement in simplification of radicals led to this new result from solve:

solve(1-1/(1+203808*exp(-342569/506*t)*(1/131537))^(131537/203808)=44983/56599, t);

506ln74448626635659972271131537116165926613153727500110184448131537203808342569

(1.4.15)

A weakness in simplification of piecewise functions regarding constant functions has been eliminated:

simplify(piecewise(Or(And(f(0)<0, f(0)<=0), f(0)>=0), 1, 0));

1

(1.4.16)

simplify is now more careful when simplifying indexed piecewise functions:

p1 := piecewise[undefined](t >= 200 and t <= 300, 1, t > 300 and t <= 400, 2):
p2 := simplify(p1, piecewise);
eval([p1,p2], t=100);

p2undefinedt<2001t3002t400undefined400<t

undefined&comma;undefined

(1.4.17)

There has been an improvement in simplify when simplifying constants:

simplify((9*(20/(36+18*2^(1/2))^2+13/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*x*2^(1/2)+9*(20/(
36+18*2^(1/2))^2+13/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*x+9*(20/(36+18*2^(1/2))^2+
13/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*y-252*(20/(36+18*2^(1/2))^2+13/(36+18*2^(1/
2))^2*2^(1/2))^(1/2)*z/(20+13*2^(1/2))-162*(20/(36+18*2^(1/2))^2+13/(36+18*2^(1
/2))^2*2^(1/2))^(1/2)*z/(20+13*2^(1/2))*2^(1/2)-31/9*(12*2^(1/2)+17)/(20/(36+18
*2^(1/2))^2+13/(36+18*2^(1/2))^2*2^(1/2))^(1/2)/(23*2^(1/2)+33)/(8+2^(1/2)))^2-
3844*(12*2^(1/2)+17)^2*(2+2^(1/2))^2/(20+13*2^(1/2))/(23*2^(1/2)+33)^2/(8+2^(1/
2))^2+(9*(8/(36+18*2^(1/2))^2+1/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*x-9*(8/(36+18*
2^(1/2))^2+1/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*y*2^(1/2)-9*(8/(36+18*2^(1/2))^2+
1/(36+18*2^(1/2))^2*2^(1/2))^(1/2)*y+144*(8/(36+18*2^(1/2))^2+1/(36+18*2^(1/2))
^2*2^(1/2))^(1/2)*z/(8+2^(1/2))+126*(8/(36+18*2^(1/2))^2+1/(36+18*2^(1/2))^2*2^
(1/2))^(1/2)*z/(8+2^(1/2))*2^(1/2)+31/9*(1+2^(1/2))/(23*2^(1/2)+33)/(8/(36+18*2
^(1/2))^2+1/(36+18*2^(1/2))^2*2^(1/2))^(1/2)/(8+2^(1/2)))^2-3844*(1+2^(1/2))^2*
(2+2^(1/2))^2/(23*2^(1/2)+33)^2/(8+2^(1/2))^3-590*(3+2*2^(1/2))/(20+13*2^(1/2))
/(8+2^(1/2))*(z-41/1180*(20+13*2^(1/2))*(10+7*2^(1/2))/(3+2*2^(1/2))/(23*2^(1/2
)+33))^2+1681/2360*(20+13*2^(1/2))*(10+7*2^(1/2))^2/(3+2*2^(1/2))/(8+2^(1/2))/(
23*2^(1/2)+33)^2-2);

5x2+3y4z8x+2y2+6z4y5z2+7z2

(1.4.18)

Mathematical Logic

Maple 2022 includes improvements to the the use of assume and is:

These all returned FAIL previously:

is(x^2+x+1, odd) assuming x::integer;

true

(1.5.1)

is(sec(x),real) assuming x::real, (x/Pi-1/2)::Non(integer);

true

(1.5.2)

is(csc(x),real) assuming x::real, (x/Pi)::Non(integer);

true

(1.5.3)

Smarter handling of inequalities led to this new result from coulditbe:

coulditbe(And(r^2=0,r*s<>0));

false

(1.5.4)

Some improvements in is relating to indexed variables resulted in this new result from signum:

signum(r) assuming r>low[r],low[r]>0;

1

(1.5.5)

is and coulditbe can now handle more complicated RootOf functions:

map(is, [`=`, `<`, `>`](RootOf (exp(_Z) - exp (1/5), 0.21), 100000));

false&comma;true&comma;false

(1.5.6)

This led to the following new result from solve:

solve({(sqrt(1+1/x)-ln(sqrt(1+x)+sqrt(x)))/sqrt(x)>1,x>0},{x});

0<x&comma;x<&ExponentialE;2RootOf&ExponentialE;_Z4+2&ExponentialE;_Z3_Z2&ExponentialE;_Z32&ExponentialE;_Z22_Z&ExponentialE;_Z2&ExponentialE;_Z+1&comma;0.7505612007124&ExponentialE;RootOf&ExponentialE;_Z4+2&ExponentialE;_Z3_Z2&ExponentialE;_Z32&ExponentialE;_Z22_Z&ExponentialE;_Z2&ExponentialE;_Z+1&comma;0.75056120072

(1.5.7)

And also an improved result from Student:-Calculus1:-InflectionPoints:

Student:-Calculus1:-InflectionPoints((1+sin(x))^cos(x), x = 0 .. 2*Pi);

Warning, some inflection points are returned as numeric approximations

0&comma;1.374838238&comma;3.780861806&comma;3π2&comma;2π

(1.5.8)

This new result from expand is due to an improvement in is:

expand(exp((sin(x + arctan(x*sqrt(2)/sqrt(-2*x^2 + 1)))^2)/4)) assuming x > 0;

&ExponentialE;sinx21+2x22x2+114&ExponentialE;sinxcosxx221+2x22x2+12x2+1&ExponentialE;cosx2x22x2+11+2x22x2+1

(1.5.9)

There is now more consistent error handling in assume:

assume(Not(true), n=0);
assume(false, n=0);
assume(n=0, false);

Error, (in assume) contradictory assumptions

Error, (in assume) contradictory assumptions

Error, (in assume) contradictory assumptions

Miscellaneous

This new result from minimize was due to improvement in min and max:

alias(alpha=RootOf(2*_Z^2-2*RootOf(2*_Z^3-1,index = 1)-2*_Z+1,1.237360513)):
minimize((x^2+y^2)^2+1/(x^2+y^2)+(x^2-2*x+1+y^2)^2+1/(x^2-2*x+1+y^2));
alias(alpha=alpha):

8α624α5+36α432α3+18α26α+922α22α+1

(1.6.1)

An improvement in allvalues led to a new result:

{allvalues(RootOf(product(f(r, _Z), r=RootOf(_Z^2-1))))};

RootOff−1&comma;_Z&comma;RootOff1&comma;_Z

(1.6.2)

Improved handling of dummy variables by depends:

depends(sum(f[x], x=0..infinity), f[x]);
depends(Product(f(x,a),x = 6 .. 5),a);
depends(Product(f(x,a),x = 5 .. 5),a);

false

false

true

(1.6.3)

Introduction of Ball Arithmetic

Maple 2022 includes new facilities for ball arithmetic in the form of RealBox and ComplexBox objects that provide an interface to the arblib package.

• 

The RealBox and ComplexBox objects represent boxes on the real line and in the complex plane, respectively.

• 

A RealBox object is defined by a center and radius. Thus, it represents a closed and bounded interval on the line, unless it is the entire real line.

• 

A ComplexBox object is defined as a pair of RealBox objects representing its real and imaginary parts. This represents either a closed and bounded box in the complex plane, the entire plane, or a doubly infinite strip in the direction of either the real or imaginary axis.

• 

Unlike the extant facilities in Maple for interval arithmetic, there is no need for you to use a special evaluator like evalr, since the arithmetic and function evaluations are built in to the real and complex box objects.

• 

The accuracy of box calculations is controlled by a precision option that is available for most operations, including the creation of real and complex boxes. This also affects the conversion of numeric quantities (centers and radii) in the construction of box objects.

Radius( RealBox( 2/3 ) );

5.820766113350852282417152×10−11

(2.1)

Note that the radius for an inexactly representable quantity is smaller with greater precision, as directed by the precision=80 option.

Radius( RealBox( 2/3, 'precision' = 80 ) );

8.2718061697×10−25

(2.2)

Radius( RealBox( 3/2 ) );

0.

(2.3)

Arithmetic operations on RealBox objects are built-in. You can operate with RealBox objects in many respects as though they were numeric quantities.

p := randpoly( x );

p7x5+22x455x394x2+87x56

(2.4)

eval( p, x = RealBox( Zeta( 3 ) ) );

RealBox: -154.41±1.71822&ExponentialE;-07

(2.5)

b := RealBox( 0.42, 1e-5 );

bRealBox: 0.42±1.00000&ExponentialE;-05

(2.6)

Many mathematical functions are defined for RealBox objects.

sin( b );

RealBox: 0.40776±9.13188&ExponentialE;-06

(2.7)

Chi( b^2 );

RealBox: -1.15±4.83663&ExponentialE;-05

(2.8)

For more information see, for example, RealBox/Circular, RealBox/Hyperbolic and RealBox/Special.

A ComplexBox object can be constructed from a complex numeric input.

b := ComplexBox( 2.3 + 7.77*I, 'precision' = 50 );

bComplexBox: [2.3 +/- 3.55271e-15]+[7.77 +/- 7.10543e-15]I

(2.9)

The result is an object with two RealBox components representing the real and imaginary parts.

Re( b );

RealBox: 2.3±3.55271&ExponentialE;-15

(2.10)

Im( b );

RealBox: 7.77±7.10543&ExponentialE;-15

(2.11)

As with RealBox objects, ComplexBox objects can be manipulated using ordinary arithmetic operations.

eval( p, x = b );

ComplexBox: [-176235 +/- 0.000143251]+[-102440 +/- 7.15837e-05]I

(2.12)

1/b^10 - I;

ComplexBox: [7.90907e-10 +/- 1.20159e-19]+[-1 +/- 1.16415e-10]I

(2.13)

Apart from cases where the output of an operation is necessarily real, the result of a function applied to a ComplexBox is again a ComplexBox object.

Li( b );

ComplexBox: [3.76298 +/- 7.32189e-09]+[4.33322 +/- 6.45855e-09]I

(2.14)

exp( b );

ComplexBox: [0.836664 +/- 2.13816e-10]+[9.93903 +/- 2.44814e-09]I

(2.15)

Note that the magnitude of b is evaluated as a RealBox object.

abs( b );

RealBox: 8.10326±9.76226&ExponentialE;-10

(2.16)

For more information see, for example, ComplexBox/Circular, ComplexBox/Hyperbolic and ComplexBox/Elementary.

Certain specific constants, such as π, can be computed to high accuracy by using the precision option for the RealBox or ComplexBox constructor.

RealBox( Pi );

RealBox3.1415926537010818719863891601562500&comma;1.16415322086873060553523210-10

(2.17)

RealBox( Pi, 'precision' = 100000 );

RealBox: 3.14159±2.00495&ExponentialE;-3010

(2.18)

Formal Power Series

The convert(...,FormalPowerSeries) command has been completely rewritten for Maple 2022. It is now able to find both closed form solutions and recurrence relations for many more examples than in previous versions.

Graph Theory

Several new commands were added to the GraphTheory package.

• 

IsChordal tests if a graph is chordal.

• 

IsComparabilityGraph tests if a graph is a comparability graph.

• 

IsIntervalGraph tests if a graph is an interval graph.

• 

IsOriented tests if a directed graph is oriented, i.e. if it contains no pair of symmetric arcs.

• 

IsPerfectGraph tests if a graph is a perfect graph.

• 

IsSimplicial tests if a graph vertex is simplicial, i.e. if its neighborhood forms a clique.

• 

RichClubCoefficients computes the rich club coefficients for a graph. These are intended to measure the extent to which well-connected vertices also connect to each other.

• 

Traverse returns either a vertex list corresponding to a breadth-first or depth-first traversal of the graph, or an Iterator which can perform such a traversal interactively.

Additionally, within the SpecialGraphs subpackage, two related new commands were added.

• 

CompleteKaryArborescence computes the compute k-ary arborescence to a given depth. An arborescence is a directed analog of a tree with arcs leading away from the source.

• 

CompleteKaryAntiArborescence computes the compute k-ary anti-arborescence to a given depth. An anti-arborescence is a directed analog of a tree with arcs leading towards the sink.

Linear Recurrence Relations

A new command, mhypergeomsols, was added to the LREtools package, which can find m-fold (also called m-interlacing) solutions of linear recurrence equations with polynomial coefficients for arbitrary positive integers m.

with(LREtools);

AnalyticityConditions&comma;GCRD&comma;GeneralizedExponents&comma;GuessRecurrence&comma;HypergeometricTerm&comma;IsDesingularizable&comma;LCLM&comma;MinimalRecurrence&comma;MultiplyOperators&comma;OperatorToRecurrence&comma;REcontent&comma;REcreate&comma;REplot&comma;REprimpart&comma;REreduceorder&comma;REtoDE&comma;REtodelta&comma;REtoproc&comma;RecurrenceToOperator&comma;RightDivision&comma;RightFactors&comma;SumDecompose&comma;ValuesAtPoint&comma;autodispersion&comma;constcoeffsol&comma;dAlembertiansols&comma;δ&comma;dispersion&comma;divconq&comma;firstlin&comma;hypergeomsols&comma;mhypergeomsols&comma;polysols&comma;ratpolysols&comma;riccati&comma;shift

(5.1)

RE := (n+1)*(n+2)*(n+3)*(n+4)*a(n+4) + 10*(n+1)*(n+2)*a(n+2) + 9*a(n) = 0;

REn+1n+2n+3n+4an+4+10n+1n+2an+2+9an=0

(5.2)

hypergeomsols(RE, a(n), {}, output=basis);

InΓn+1&comma;−InΓn+1&comma;3InΓn+1&comma;3InΓn+1

(5.3)

msols := mhypergeomsols(RE, a(n), complex);

msols1&comma;RootOf_Z2+1nn!&comma;RootOf_Z2+9nn!&comma;2&comma;−9n2n!&comma;−1n2n!

(5.4)

msols1 is equivalent to the solutions returned by hypergeomsols, while msols2 gives all 2-fold hypergeometric solutions, which cannot be found by hypergeomsols.

allvalues(msols[1,2,1]), allvalues(msols[1,2,2]);

Inn!,−Inn!,3Inn!,3Inn!

(5.5)

sol1 := unapply(eval(op([2,2,1],msols),n=n/2),n);

sol1n−9n2n!

(5.6)

normal(expand(eval(RE,a=sol1)));

0=0

(5.7)

sol2 := unapply(eval(op([2,2,2],msols),n=n/2),n);

sol2n−1n2n!

(5.8)

normal(expand(eval(RE,a=sol2)));

0=0

(5.9)

Polyhedral Sets

A new command, IntegerHull, was added to the PolyhedralSets package. It computes the integer hulls of 2-D (bounded or unbound) and 3-D (bounded) polyhedral sets.

The integer hull of a convex polyhedral set is the smallest polyhedral set that contains all the integer points in the input set.

restart&semi; withPolyhedralSets&colon;

ineqs2 x&plus;5 y64&comma;7 x&plus;5 y20 &comma;3 x6 y7&colon;

poly2dPolyhedralSetineqs&comma;x&comma;y&semi;

PolyhedralSets:-PolyhedralSet20757yx&comma;x2y73&comma;x52y&plus;32&comma;x&comma;y

(6.1)

The input to the command is a PolyhedralSet object. By default, the command returns the integer hull in the form [vertices, rays].

 IntegerHullpoly2d&semi;

12&comma;8&comma;−8&comma;16&comma;−7&comma;14&comma;−5&comma;11&comma;0&comma;4&comma;1&comma;3&comma;3&comma;3&comma;11&comma;7&comma;

(6.2)

The command also has the option to return the integer hull in the PolyhedralSet object format.

intpoly2dIntegerHullpoly2d&comma;output&equals;polyhedralset&semi; 

PolyhedralSets:-PolyhedralSet3y&comma;y&plus;4x&comma;20757yx&comma;23y&plus;73x&comma;12yx&comma;x2y3&comma;xy&plus;4&comma;x52y&plus;32&comma;x&comma;y

(6.3)

In this example, the white triangle is the input polyhedral set, and the red polygon is the output integer hull.

Plotintpoly2d&comma;poly2d&comma;faceoptions&equals;transparency&equals;0&comma;0.13&comma;color&equals;red&comma;white&semi; 

The input 2-D polyhedral set can be unbounded.

inset  PolyhedralSet7&sol;5&comma;0&comma;13&sol;4&comma;0&comma;5&sol;3&comma;1&comma;5&sol;2&comma;1&comma;0&comma;1&comma; x&comma;y&semi; 

PolyhedralSets:-PolyhedralSety0&comma;53x&comma;415y75x&comma;x134&comma;x&comma;y

(6.4)

vert IntegerHullinset&semi; 

vert−1&comma;0&comma;3&comma;0&comma;0&comma;−1

(6.5)

intpoly  PolyhedralSetopvert&comma;x&comma;y&semi; 

PolyhedralSets:-PolyhedralSety0&comma;1x&comma;x3&comma;x&comma;y

(6.6)

Plotintpoly&comma;inset&comma;faceoptions&equals;transparency&equals;0&comma;0.13&comma;color&equals;red&comma;white&semi; 

The following is a bounded 3-D example.

varsx1&comma;x2&comma;x3&colon; 

vertices  2&comma; 52&comma; 3&comma; 1&comma; 5&sol;2&comma; 3&comma; 32&comma; 4&comma; 5&sol;2&comma; 5&comma; 5&sol;2&comma; 4&colon; 

 poly  PolyhedralSetvertices&comma;&comma; vars&semi; 

PolyhedralSets:-PolyhedralSet791827391x267x3x1&comma;1910&plus;35x2&plus;45x3x1&comma;x14314&plus;35x267x3&comma;x1279764138x2&plus;1338x3&comma;x1&comma;x2&comma;x3

(6.7)

intpolyIntegerHullpoly&comma;output&equals;polyhedralset&semi; 

PolyhedralSets:-PolyhedralSetx32&comma;2x2&comma;x23&comma;x212x3&plus;3&comma;x2x31x1&comma;34x378x214x1&comma;45x245x315x1&comma;x32x1&comma;12x2&plus;12x332x1&comma;x3&plus;12x22x1&comma;35x2&plus;45x395x1&comma;x134x234x3&plus;134&comma;x135x245x3&plus;3&comma;x112x2x3&plus;3&comma;x112x3&plus;3&comma;x1x2&plus;x3&plus;5&comma;x11413x2&plus;413x3&plus;4613&comma;x154x2&plus;x3&plus;194&comma;x12x2&plus;6&comma;x1&comma;x2&comma;x3

(6.8)

In this example, the white transparent tetrahedron is the input polyhedral set, and the red polyhedron is the output integer hull.

 Plotintpoly&comma;poly&comma;faceoptions&equals;transparency&equals;0&comma;0.5&comma;color&equals;red&comma;white&semi;

The following shows a more complex example, with a higher number of vertices in the output.

 vertices  154&comma;172&comma;5&comma;4&comma; 8&comma; 6&comma; 1&comma; 10&sol;3&comma; 14&comma; 6&sol;2&comma; 8&comma; 10&sol;3&comma; 14&sol;2&comma; 22&sol;3&comma; 4&colon; 

poly  PolyhedralSetvertices&comma; &comma; vars&semi; 

PolyhedralSets:-PolyhedralSet15812498x211072498x3&plus;7321249x1&comma;9031724x27833448x3&plus;7471724x1&comma;3334x2&plus;34x328134x1&comma;x121430x2239430x3&plus;1493215&comma;x133898x2160449x3&plus;2624449&comma;x16392x2&plus;34x3&plus;22946&comma;x1&comma;x2&comma;x3

(6.9)

vertIntegerHullpoly&semi; 

vert−2&comma;3&comma;4&comma;−2&comma;4&comma;3&comma;−2&comma;6&comma;−2&comma;−2&comma;8&comma;−2&comma;−1&comma;−2&comma;11&comma;−1&comma;−2&comma;12&comma;−1&comma;4&comma;−2&comma;−1&comma;5&comma;−3&comma;0&comma;−4&comma;12&comma;0&comma;−1&comma;12&comma;0&comma;0&comma;2&comma;0&comma;0&comma;11&comma;0&comma;1&comma;0&comma;2&comma;−6&comma;7&comma;2&comma;0&comma;−3&comma;2&comma;1&comma;−3&comma;3&comma;−7&comma;5&comma;3&comma;−1&comma;7&comma;4&comma;−8&comma;4&comma;4&comma;−6&comma;1&comma;4&comma;−1&comma;5&comma;4&comma;8&comma;6&comma;5&comma;1&comma;1&comma;6&comma;−7&comma;−2&comma;6&comma;−6&comma;−3&comma;6&comma;−5&comma;−3&comma;6&comma;−5&comma;−1&comma;6&comma;−3&comma;−1&comma;

(6.10)

intpoly  PolyhedralSetopvert&comma;vars&semi; 

PolyhedralSets:-PolyhedralSet3x3&comma;x312&comma;x24x1&comma;23x323x2x1&comma;49x323x2&plus;49x1&comma;511x3711x2&plus;711x1&comma;819x31219x2&plus;1219x1&comma;513x3813x2&plus;813x1&comma;35x335x2&plus;15x1&comma;16x3712x213x1&comma;311x3611x2&plus;611x1&comma;417x3917x2&plus;817x1&comma;522x32344x2&plus;511x1&comma;731x31631x2&plus;1431x1&comma;12x312x2x1&comma;14x312x2&plus;12x1&comma;12x22x1&comma;15x275x1&comma;x34x1&comma;2x1&comma;13x3&plus;13x2133x1&comma;23x3&plus;56x2223x1&comma;34x3&plus;3132x2334x1&comma;x3&plus;x211x1&comma;43x3&plus;43x2443x1&comma;x1413x3&plus;213x2&plus;8413&comma;x1611x3&plus;111x2&plus;7611&comma;x112x3&plus;114x2&plus;467&comma;x112x3&plus;118x2&plus;599&comma;x1719x3&plus;119x2&plus;11219&comma;x147x3&plus;121x2&plus;14821&comma;x1925x3&plus;125x2&plus;14625&comma;x16&comma;x127x3&plus;407&comma;x123x3&plus;8&comma;x112x312x2&plus;5&comma;x134x323x2&plus;5912&comma;x134x31928x2&plus;6914&comma;x154x334x2&plus;132&comma;x1&comma;x2&comma;x3

(6.11)

Plotintpoly&comma;poly&comma;faceoptions&equals;transparency&equals;0&comma;0.5&comma;color&equals;red&comma;white&semi; 

The following tables are benchmarks of the new algorithm.

Integer hulls of triangles (2-D)

Volume

27.95

111.79

11179.32

Time(s)

0.172

0.244

0.159

Number of vertices in the output

4

8

10

Integer hulls of hexagons (2-D)

Volume

58.21

5820.95

23283.82

Time(s)

0.303

0.275

0.304

Number of vertices in the output

8

20

25

Integer hulls of tetrahedrons (3-D)

Volume

447.48

6991.89

55935.2

Time(s)

0.977

1.223

1.378

Number of vertices in the output

27

33

39

 

Real Root Finding

Two new commands were added to the RootFinding package.

• 

RefineRoot refines an isolating box for a real root of a polynomial system to arbitrary precision.

• 

EvaluateAtRoot evaluates a number of polynomials or constraints at such an isolating box, to arbitrary precision, or to ensure signs or truth values, respectively.

 

These two commands offer new ways of working with real roots for real polynomials at specified precisions.

withRootFinding&colon;

RefineRoot allows for refinement of a real root:

px3x2&colon;

rtop1&comma;2&comma; Isolatep&comma;digits=15&comma;output=interval

rt449032033445746112207295147905179352825856&comma;224516016722873056117147573952589676412928

(7.1)

evalfrt&comma;20

1.5213797068045675696&comma;1.5213797068045675697

(7.2)

refinedRefineRootrt&comma;p&comma;x&comma;digits=40

refined21204938244789929644880041254127300206513111393796574908163946345982392040522594123776&comma;1060246912239496482244002062706365010325669696898287454081973172991196020261297061888

(7.3)

evalfrefined&comma;45

1.52137970680456756960408083225443851442837514&comma;1.52137970680456756960408083225443851442839451

(7.4)

RefineRoot is compatible with syntaxes previously and widely used within RootFinding, as well as real algebraic numbers represented by RootOfs:

RefineRootRootOf_Z22RootOf_Z39&comma;2..3&comma;1..2

RootOf_Z22RootOf_Z39&comma;49114590637698329387692361183241434822606848..196458362550793317550779444732965739290427392&comma;96319696147222114250994722366482869645213696..192639392294444228501999444732965739290427392

(7.5)

EvaluateAtRoot allows for evaluation of polynomials or relations on such at a real root. In particular, in taking in specific information about the real root, the routine provides robust evaluation of polynomial expressions in lieu of other evaluation methods involving evalf or similar.

EvaluateAtRoot offers a wide range of overloads to support various use cases amongst evaluation of constraints or polynomials.

In the case of relations, the main available output is a truth value:

constraintsx23<0&comma;x22&gt;0&comma; x&plus;4&gt;0&colon;

sysx22&colon;varsx&colon;box1..2&colon;

EvaluateAtRootconstraints&comma;box&comma;sys&comma;vars&comma; &apos;digits&apos;&equals;30

true&comma;false&comma;FAIL

(7.6)

If the constraints are given as polynomials, the main available output is a list of signs:

polysmaplhsrhs&comma;constraints

polysx23&comma;x2+2&comma;4x

(7.7)

RootFinding:-EvaluateAtRootpolys&comma;box&comma;sys&comma;vars

−1&comma;0&comma;−1

(7.8)

A multivariate example:

sysx2+y+z1&comma;y2+x+z1&comma;z2+x+y1&colon;

varsx&comma;y&comma;z&colon;

boxIsolatesys&comma;vars&comma;output=interval&comma;digits=20

boxx=729651277404161901210817302231454903657293676544&comma;29186051096166476048432531208925819614629174706176&comma;y=29186051096166476048432631208925819614629174706176&comma;29186051096166476048432551208925819614629174706176&comma;z=1459302554808323802421631604462909807314587353088&comma;29186051096166476048432571208925819614629174706176&comma;x=1&comma;1&comma;y=0&comma;0&comma;z=0&comma;0&comma;x=0&comma;0&comma;y=1&comma;1&comma;z=0&comma;0&comma;x=40060277630991140434472479671406556917033397649408&comma;20030138815495570217236334835703278458516698824704&comma;y=10015069407747785108618132417851639229258349412352&comma;20030138815495570217236334835703278458516698824704&comma;z=10015069407747785108618132417851639229258349412352&comma;20030138815495570217236294835703278458516698824704&comma;x=0&comma;0&comma;y=0&comma;0&comma;z=1&comma;1

(7.9)

evalfbox1&comma;25

x=−2.414213562373095048801696&comma;−2.414213562373095048801684&comma;y=−2.414213562373095048801692&comma;−2.414213562373095048801685&comma;z=−2.414213562373095048801691&comma;−2.414213562373095048801687

(7.10)

constraints17 x4y75x3yz+80x2z244y3z+71yz382y30&comma;                                62 x2z3+97xy3z73yz456xyz2+87xy<0&comma;                                23 x y3z+87xz4+72x2z2+37xyz2+74xy2+6y20&colon; 

EvaluateAtRootmaplhsrhs&comma;constraints&comma;box1&comma;sys

−1&comma;1&comma;−1

(7.11)

EvaluateAtRootconstraints&comma;box1&comma;sys

true&comma;false&comma;FAIL

(7.12)

values&comma; refinedboxEvaluateAtRootmaplhsrhs&comma;constraints&comma;box1&comma;sys&comma;accuracy=40&comma; &apos;output&equals;intervals&comma;refinement&apos;&colon;

values

4506467062523519726920791998043029943085529802413393365375409332725729550921208179070754913983135744&comma;4506467062523519726920791998043029943085529802413333365375409332725729550921208179070754913983135744&comma;50310293669599533354711502532907160552684536180816812923003274661805836407369665432566039311865085952&comma;50310293669599533354711502532907160552684536180821492923003274661805836407369665432566039311865085952&comma;1865078863459351682758176993701453346185745101771859730750818665451459101842416358141509827966271488&comma;37301577269187033655163539874029066923714902035435591461501637330902918203684832716283019655932542976

(7.13)

evalfvalues&comma;45

−12333.7995590714406028729662150027030187209087&comma;−12333.7995590714406028729662150027030187209087&comma;1721.18499167334940947621998942265763945608181&comma;1721.18499167334940947621998942265763945608181&comma;−2552.27748751002411421432998413398645918412272&comma;−2552.27748751002411421432998413398645918412272

(7.14)

refinedbox

x=144522324962293773579732328477904570046878791221456015986310706507378352962293074805895248510699696029696&comma;144522324962293773579732328477904570046878791221455515986310706507378352962293074805895248510699696029696&comma;y=36130581240573443394933082119476142511719697805363951496577676626844588240573268701473812127674924007424&comma;144522324962293773579732328477904570046878791221455715986310706507378352962293074805895248510699696029696&comma;z=144522324962293773579732328477904570046878791221455795986310706507378352962293074805895248510699696029696&comma;144522324962293773579732328477904570046878791221455735986310706507378352962293074805895248510699696029696

(7.15)

evalfrefinedbox&comma;45

x=−2.41421356237309504880168872420969807856967188&comma;−2.41421356237309504880168872420969807856967188&comma;y=−2.41421356237309504880168872420969807856967188&comma;−2.41421356237309504880168872420969807856967188&comma;z=−2.41421356237309504880168872420969807856967188&comma;−2.41421356237309504880168872420969807856967188

(7.16)

 

Intersection Multiplicities

A new algorithm has been implemented in the IntersectionMultiplicity command in the RegularChains package. It can handle cases that the previous version was unable to solve, and it is much faster in many cases.

Summary

• 

With Maple 2022 comes a redesigned, more powerful version of the IntersectionMultiplicity command in the AlgebraicGeometryTools subpackage of the RegularChains package.

• 

The new command exceeds the previous version in both computational power and sheer performance. Using a newly designed algorithm, the new version of the IntersectionMultiplicity command can compute far more examples than previously possible. Moreover, the new version can compute these examples in a matter of seconds, far faster than the previous counterpart.

• 

The new algorithm incorporated into the IntersectionMultiplicity command no longer requires at least one polynomial to be non-singular at the point of interest. Hence, the intersection multiplicity command can now handle cases where all inputs are singular at the point of study.

• 

If the intersection multiplicity is required only at a single point, this can now be done directly, without having to encode the point as a regular chain.