Advanced Math Improvements in Maple 2024
Maple 2024 includes many improvements to the math engine.

fsolve for Univariate Polynomials• The fsolve command now uses RootFinding:-Isolate for computing roots of univariate
polynomials of degree greater than two.
• By default no method is specified. The Isolate methods ABND, RS, RC, HR, and PW are
optionally accepted by fsolve and passed to Isolate.
• The PW method is new. For more about that method and the improved underlying
RootFinding:-Isolate command, see the Faster Univariate Complex Solver section of
the Performance Improvements in Maple 2024 help page.
• Supplying the option NAG to fsolve will force use of the modified Laguerre method
followed by iterated root-polishing, which was the prior default.

Multivariate Complex Solver• The RootFinding:-Isolate command can now find complex solutions for multivariate
polynomial systems.

> unassign('a','b','c','d','e'):> cyclic5 := [a+b+c+d+e, a*b+b*c+c*d+d*e+e*a, a*b*c+b*c*d+c*d*e+d*e*a+
e*a*b,
a*b*c*d+b*c*d*e+c*d*e*a+d*e*a*b+e*a*b*c, a*b*c*d*e-1];
cyclic5 d a C b C c C d C e, a b C e a C b c C c d C d e, a b c C e a b C d e a C b c d C c d e, a b c d
C e a b c C d e a b C c d e a C b c d e, a b c d e L 1> map(print, RootFinding:-Isolate(cyclic5, [a,b,c,d,e])):a = L2.618033989, b = L0.3819660113, c = 1.000000000, d = 1.000000000, e = 1.000000000
a = L2.618033989, b = 1.000000000, c = 1.000000000, d = 1.000000000, e = L0.3819660112
a = L0.3819660112, b = L2.618033989, c = 1.000000000, d = 1.000000000, e = 1.000000000
a = L0.3819660112, b = 1.000000000, c = 1.000000000, d = 1.000000000, e = L2.618033989
a = 1.000000000, b = L2.618033989, c = L0.3819660113, d = 1.000000000, e = 1.000000000
a = 1.000000000, b = L0.3819660112, c = L2.618033989, d = 1.000000000, e = 1.000000000
a = 1.000000000, b = 1.000000000, c = L2.618033989, d = L0.3819660113, e = 1.000000000
a = 1.000000000, b = 1.000000000, c = L0.3819660113, d = L2.618033989, e = 1.000000000
a = 1.000000000, b = 1.000000000, c = 1.000000000, d = L2.618033989, e = L0.3819660113
a = 1.000000000, b = 1.000000000, c = 1.000000000, d = L0.3819660113, e = L2.618033989

> map(print, RootFinding:-Isolate(cyclic5, [a,b,c,d,e], 'complex')):a = L2.618033989, b = L0.3819660112, c = 1., d = 1., e = 1.
a = L2.618033989, b = 1., c = 1., d = 1., e = L0.3819660112
a = L0.8090169944 L 2.489898285 I, b = L0.1180339887 L 0.3632712640 I, c = 0.3090169944
C 0.9510565163 I, d = 0.3090169944 C 0.9510565163 I, e = 0.3090169944 C 0.9510565163 I
a = L0.8090169944 L 2.489898285 I, b = 0.3090169944 C 0.9510565163 I, c = 0.3090169944
C 0.9510565163 I, d = 0.3090169944 C 0.9510565163 I, e = L0.1180339887 L 0.3632712640 I
a = L0.8090169944 L 0.5877852523 I, b = L0.8090169944 L 0.5877852523 I, c = L0.8090169944
L 0.5877852523 I, d = 0.3090169944 C 0.2245139883 I, e = 2.118033989 C 1.538841769 I
a = L0.8090169944 L 0.5877852523 I, b = L0.8090169944 L 0.5877852523 I, c = L0.8090169944
L 0.5877852523 I, d = 2.118033989 C 1.538841769 I, e = 0.3090169944 C 0.2245139883 I
a = L0.8090169944 L 0.5877852523 I, b = L0.8090169944 L 0.5877852523 I, c = 0.3090169944
C 0.2245139883 I, d = 2.118033989 C 1.538841769 I, e = L0.8090169944 L 0.5877852523 I
a = L0.8090169944 L 0.5877852523 I, b = L0.8090169944 L 0.5877852523 I, c = 2.118033989
C 1.538841769 I, d = 0.3090169944 C 0.2245139883 I, e = L0.8090169944 L 0.5877852523 I
a = L0.8090169944 L 0.5877852523 I, b = L0.8090169944 C 0.5877852523 I, c = 0.3090169944
C 0.9510565163 I, d = 1., e = 0.3090169944 L 0.9510565163 I
a = L0.8090169944 L 0.5877852523 I, b = 0.3090169944 L 0.9510565163 I, c = 1., d = 0.3090169944
C 0.9510565163 I, e = L0.8090169944 C 0.5877852523 I
a = L0.8090169944 L 0.5877852523 I, b = 0.3090169944 C 0.2245139883 I, c = 2.118033989
C 1.538841769 I, d = L0.8090169944 L 0.5877852523 I, e = L0.8090169944 L 0.5877852523 I
a = L0.8090169944 L 0.5877852523 I, b = 0.3090169944 C 0.9510565163 I, c = 0.3090169944
L 0.9510565163 I, d = L0.8090169944 C 0.5877852523 I, e = 1.
a = L0.8090169944 L 0.5877852523 I, b = 1., c = L0.8090169944 C 0.5877852523 I, d = 0.3090169944
L 0.9510565163 I, e = 0.3090169944 C 0.9510565163 I
a = L0.8090169944 L 0.5877852523 I, b = 2.118033989 C 1.538841769 I, c = 0.3090169944
C 0.2245139883 I, d = L0.8090169944 L 0.5877852523 I, e = L0.8090169944 L 0.5877852523 I
a = L0.8090169944 C 0.5877852523 I, b = L0.8090169944 L 0.5877852523 I, c = 0.3090169944
L 0.9510565163 I, d = 1., e = 0.3090169944 C 0.9510565163 I
a = L0.8090169944 C 0.5877852523 I, b = L0.8090169944 C 0.5877852523 I, c = L0.8090169944
C 0.5877852523 I, d = 0.3090169944 L 0.2245139883 I, e = 2.118033989 L 1.538841769 I
a = L0.8090169944 C 0.5877852523 I, b = L0.8090169944 C 0.5877852523 I, c = L0.8090169944
C 0.5877852523 I, d = 2.118033989 L 1.538841769 I, e = 0.3090169944 L 0.2245139883 I
a = L0.8090169944 C 0.5877852523 I, b = L0.8090169944 C 0.5877852523 I, c = 0.3090169944
L 0.2245139883 I, d = 2.118033989 L 1.538841769 I, e = L0.8090169944 C 0.5877852523 I
a = L0.8090169944 C 0.5877852523 I, b = L0.8090169944 C 0.5877852523 I, c = 2.118033989

L 1.538841769 I, d = 0.3090169944 L 0.2245139883 I, e = L0.8090169944 C 0.5877852523 I
a = L0.8090169944 C 0.5877852523 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944
C 0.9510565163 I, d = L0.8090169944 L 0.5877852523 I, e = 1.
a = L0.8090169944 C 0.5877852523 I, b = 0.3090169944 L 0.2245139883 I, c = 2.118033989
L 1.538841769 I, d = L0.8090169944 C 0.5877852523 I, e = L0.8090169944 C 0.5877852523 I
a = L0.8090169944 C 0.5877852523 I, b = 0.3090169944 C 0.9510565163 I, c = 1., d = 0.3090169944
L 0.9510565163 I, e = L0.8090169944 L 0.5877852523 I
a = L0.8090169944 C 0.5877852523 I, b = 1., c = L0.8090169944 L 0.5877852523 I, d = 0.3090169944
C 0.9510565163 I, e = 0.3090169944 L 0.9510565163 I
a = L0.8090169944 C 0.5877852523 I, b = 2.118033989 L 1.538841769 I, c = 0.3090169944
L 0.2245139883 I, d = L0.8090169944 C 0.5877852523 I, e = L0.8090169944 C 0.5877852523 I
a = L0.8090169944 C 2.489898285 I, b = L0.1180339887 C 0.3632712640 I, c = 0.3090169944
L 0.9510565163 I, d = 0.3090169944 L 0.9510565163 I, e = 0.3090169944 L 0.9510565163 I
a = L0.8090169944 C 2.489898285 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944
L 0.9510565163 I, d = 0.3090169944 L 0.9510565163 I, e = L0.1180339887 C 0.3632712640 I
a = L0.3819660113, b = L2.618033989, c = 1., d = 1., e = 1.
a = L0.3819660112, b = 1., c = 1., d = 1., e = L2.618033989
a = L0.1180339887 L 0.3632712640 I, b = L0.8090169944 L 2.489898285 I, c = 0.3090169944
C 0.9510565163 I, d = 0.3090169944 C 0.9510565163 I, e = 0.3090169944 C 0.9510565163 I
a = L0.1180339887 L 0.3632712640 I, b = 0.3090169944 C 0.9510565163 I, c = 0.3090169944
C 0.9510565163 I, d = 0.3090169944 C 0.9510565163 I, e = L0.8090169944 L 2.489898285 I
a = L0.1180339887 C 0.3632712640 I, b = L0.8090169944 C 2.489898285 I, c = 0.3090169944
L 0.9510565163 I, d = 0.3090169944 L 0.9510565163 I, e = 0.3090169944 L 0.9510565163 I
a = L0.1180339887 C 0.3632712640 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944
L 0.9510565163 I, d = 0.3090169944 L 0.9510565163 I, e = L0.8090169944 C 2.489898285 I
a = 0.3090169944 L 0.9510565163 I, b = L0.8090169944 L 0.5877852523 I, c = L0.8090169944
C 0.5877852523 I, d = 0.3090169944 C 0.9510565163 I, e = 1.
a = 0.3090169944 L 0.9510565163 I, b = L0.8090169944 C 0.5877852523 I, c = 1., d = L0.8090169944
L 0.5877852523 I, e = 0.3090169944 C 0.9510565163 I
a = 0.3090169944 L 0.9510565163 I, b = L0.8090169944 C 2.489898285 I, c = L0.1180339887
C 0.3632712640 I, d = 0.3090169944 L 0.9510565163 I, e = 0.3090169944 L 0.9510565163 I
a = 0.3090169944 L 0.9510565163 I, b = L0.1180339887 C 0.3632712640 I, c = L0.8090169944
C 2.489898285 I, d = 0.3090169944 L 0.9510565163 I, e = 0.3090169944 L 0.9510565163 I
a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = L0.8090169944
C 2.489898285 I, d = L0.1180339888 C 0.3632712640 I, e = 0.3090169944 L 0.9510565163 I
a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = L0.1180339888
C 0.3632712640 I, d = L0.8090169944 C 2.489898285 I, e = 0.3090169944 L 0.9510565163 I
a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944

a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944
L 0.9510565163 I, d = L0.8090169944 C 2.489898285 I, e = L0.1180339887 C 0.3632712640 I
a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = 0.3090169944
L 0.9510565163 I, d = L0.1180339887 C 0.3632712640 I, e = L0.8090169944 C 2.489898285 I
a = 0.3090169944 L 0.9510565163 I, b = 0.3090169944 C 0.9510565163 I, c = L0.8090169944
L 0.5877852523 I, d = 1., e = L0.8090169944 C 0.5877852523 I
a = 0.3090169944 L 0.9510565163 I, b = 1., c = 0.3090169944 C 0.9510565163 I, d = L0.8090169944
C 0.5877852523 I, e = L0.8090169944 L 0.5877852523 I
a = 0.3090169944 L 0.2245139883 I, b = L0.8090169944 C 0.5877852523 I, c = L0.8090169944
C 0.5877852523 I, d = L0.8090169944 C 0.5877852523 I, e = 2.118033989 L 1.538841769 I
a = 0.3090169944 L 0.2245139883 I, b = 2.118033989 L 1.538841769 I, c = L0.8090169944
C 0.5877852523 I, d = L0.8090169944 C 0.5877852523 I, e = L0.8090169944 C 0.5877852523 I
a = 0.3090169944 C 0.2245139883 I, b = L0.8090169944 L 0.5877852523 I, c = L0.8090169944
L 0.5877852523 I, d = L0.8090169944 L 0.5877852523 I, e = 2.118033989 C 1.538841769 I
a = 0.3090169944 C 0.2245139883 I, b = 2.118033989 C 1.538841769 I, c = L0.8090169944
L 0.5877852523 I, d = L0.8090169944 L 0.5877852523 I, e = L0.8090169944 L 0.5877852523 I
a = 0.3090169944 C 0.9510565163 I, b = L0.8090169944 L 2.489898285 I, c = L0.1180339887
L 0.3632712640 I, d = 0.3090169944 C 0.9510565163 I, e = 0.3090169944 C 0.9510565163 I
a = 0.3090169944 C 0.9510565163 I, b = L0.8090169944 L 0.5877852523 I, c = 1., d = L0.8090169944
C 0.5877852523 I, e = 0.3090169944 L 0.9510565163 I
a = 0.3090169944 C 0.9510565163 I, b = L0.8090169944 C 0.5877852523 I, c = L0.8090169944
L 0.5877852523 I, d = 0.3090169944 L 0.9510565163 I, e = 1.
a = 0.3090169944 C 0.9510565163 I, b = L0.1180339887 L 0.3632712640 I, c = L0.8090169944
L 2.489898285 I, d = 0.3090169944 C 0.9510565163 I, e = 0.3090169944 C 0.9510565163 I
a = 0.3090169944 C 0.9510565163 I, b = 0.3090169944 L 0.9510565163 I, c = L0.8090169944
C 0.5877852523 I, d = 1., e = L0.8090169944 L 0.5877852523 I
a = 0.3090169944 C 0.9510565163 I, b = 0.3090169944 C 0.9510565163 I, c = L0.8090169944
L 2.489898285 I, d = L0.1180339888 L 0.3632712640 I, e = 0.3090169944 C 0.9510565163 I
a = 0.3090169944 C 0.9510565163 I, b = 0.3090169944 C 0.9510565163 I, c = L0.1180339888
L 0.3632712640 I, d = L0.8090169944 L 2.489898285 I, e = 0.3090169944 C 0.9510565163 I
a = 0.3090169944 C 0.9510565163 I, b = 0.3090169944 C 0.9510565163 I, c = 0.3090169944
C 0.9510565163 I, d = L0.8090169944 L 2.489898285 I, e = L0.1180339887 L 0.3632712640 I
a = 0.3090169944 C 0.9510565163 I, b = 0.3090169944 C 0.9510565163 I, c = 0.3090169944
C 0.9510565163 I, d = L0.1180339887 L 0.3632712640 I, e = L0.8090169944 L 2.489898285 I
a = 0.3090169944 C 0.9510565163 I, b = 1., c = 0.3090169944 L 0.9510565163 I, d = L0.8090169944
L 0.5877852523 I, e = L0.8090169944 C 0.5877852523 I
a = 1., b = L2.618033989, c = L0.3819660112, d = 1., e = 1.
a = 1., b = L0.8090169944 L 0.5877852523 I, c = 0.3090169944 C 0.9510565163 I, d = 0.3090169944

a = 1., b = L0.8090169944 L 0.5877852523 I, c = 0.3090169944 C 0.9510565163 I, d = 0.3090169944
L 0.9510565163 I, e = L0.8090169944 C 0.5877852523 I
a = 1., b = L0.8090169944 C 0.5877852523 I, c = 0.3090169944 L 0.9510565163 I, d = 0.3090169944
C 0.9510565163 I, e = L0.8090169944 L 0.5877852523 I
a = 1., b = L0.3819660112, c = L2.618033989, d = 1., e = 1.
a = 1., b = 0.3090169944 L 0.9510565163 I, c = L0.8090169944 L 0.5877852523 I, d = L0.8090169944
C 0.5877852523 I, e = 0.3090169944 C 0.9510565163 I
a = 1., b = 0.3090169944 C 0.9510565163 I, c = L0.8090169944 C 0.5877852523 I, d = L0.8090169944
L 0.5877852523 I, e = 0.3090169944 L 0.9510565163 I
a = 1., b = 1., c = L2.618033989, d = L0.3819660112, e = 1.
a = 1., b = 1., c = L0.3819660112, d = L2.618033989, e = 1.
a = 1., b = 1., c = 1., d = L2.618033989, e = L0.3819660113
a = 1., b = 1., c = 1., d = L0.3819660113, e = L2.618033989
a = 2.118033989 L 1.538841769 I, b = L0.8090169944 C 0.5877852523 I, c = L0.8090169944
C 0.5877852523 I, d = L0.8090169944 C 0.5877852523 I, e = 0.3090169944 L 0.2245139883 I
a = 2.118033989 L 1.538841769 I, b = 0.3090169944 L 0.2245139883 I, c = L0.8090169944
C 0.5877852523 I, d = L0.8090169944 C 0.5877852523 I, e = L0.8090169944 C 0.5877852523 I
a = 2.118033989 C 1.538841769 I, b = L0.8090169944 L 0.5877852523 I, c = L0.8090169944
L 0.5877852523 I, d = L0.8090169944 L 0.5877852523 I, e = 0.3090169944 C 0.2245139883 I
a = 2.118033989 C 1.538841769 I, b = 0.3090169944 C 0.2245139883 I, c = L0.8090169944
L 0.5877852523 I, d = L0.8090169944 L 0.5877852523 I, e = L0.8090169944 L 0.5877852523 I

Better Handling of Parameters in Solve Solutions• By default, solve gives a representative solution for the following problems:> solve( cos(x)*sin(x)=0, x );p
,02
> solve( cos(x)=1/2, x );p
3
• The allsolutions option can be used to get a more complete solution, using _Z torepresent any integer.

> solve( cos(x)=1/2, x, 'allsolutions' );11
p C 2 p _Z1~, L p C 2 p _Z1~
3
3
• If preferred, the new command SolveTools:-DisplaySolutions can be used to format thesolution in a more readable way using standard notation.

> sol1 := solve(x*sin(x)^2 = -x, [x], allsolutions);
sol1 dx = 0 , x = 2 p _Z2~ C I ln 1 C

L I ln 1 C

2, x = I ln 1 C

2, x = LI ln 1 C

2 C p C 2 p _Z2~ , x = 2 p _Z3~

2 C p C 2 p _Z3~

> SolveTools:-DisplaySolutions( sol1 );x=0
x = 2 p n1 C I ln 1 C
x = LI ln 1 C

2 C p C 2 p n1

x = 2 p n2 L I ln 1 C
x = I ln 1 C

22

n1 2 Zn2 2 Z

2 C p C 2 p n2

• When called with the option allsolutions=true in Maple 2023 and earlier, solve may
return a solution in terms of parameters starting with _B, _NN, and _Z. In Maple 2024,
solutions will no longer include the _B variables but instead solve will expand those
automatically into multiple solutions.
• The _NN and _Z parameters typically stand for all natural numbers or integers,
respectively, so cannot be expanded, but the new command SolveTools:DisplaySolutions can be used to format them in an easier to read format.

Pattern Matching for Definite Summation• Maple 2024 includes a new pattern matching method for definite summation problems,
accessible through the sum command. This method uses a database of known definite
summation problems with their closed forms. By matching a given definite sum to all
entries of the database, Maple can now return closed forms for several definite sums
which earlier versions were unable to compute.
• The sum command now recognizes power series expansions of some nonhypergeometric functions.

> sum(z^k*(-k)^(k-1)/k!, k=1..infinity) assuming abs(z) < exp(-1);
LambertW z> sum(bernoulli(2*n)*(-4)^n*(1-4^n)*x^(2*n-1)/(2*n)!, n=1..infinity)
assuming abs(x) < Pi/2;
tan x> sum(Stirling2(n,k)*z^k, k=0..n) assuming n::nonnegint;
BellB n, z
• The database also contains some definite sums involving the floor function.

> sum(binomial(n,k)*binomial(n-k,n-2*k)/4^k, k=0..floor(n/2)) assuming
n::nonnegint;
2Ln

2n
n

• Option formal can be used instead of assumptions.

> sum(z^k*(-k)^(k-1)/k!, k=1..infinity);N

zk Lk k L1
k!
k= 1

>

> sum(z^k*(-k)^(k-1)/k!, k=1..infinity, 'formal');LambertW z

Improvements to the Collocation Method for Solving Integral
Equations• The intsolve command now supports special nodes, custom nodes, and custom basis
functions for the collocation method. For example, consider the following integral
equation:> a := 0;
ad0> b := 2 * Pi;b d 2p> ie := sin(x) - 3 * f(x) - 2 * int( y * f(y), y = a .. b );2p

ie d sin x L 3 f x L 2y f y dy0

• We can find the exact solution, and use it to compare with two collocation
approximations:> p := rhs( intsolve( ie, f(x) ) );
pd

4p
sin x
C
2
3
3 4p C3• For our first approximation, we use Chebyshev nodes and polynomial degree of 10:> q := rhs( intsolve( ie, f(x), 'method' = 'collocation', 'nodes' ='chebyshev', 'order' = 10 ) );2

q d 0.0986117180199666 C 0.333260721136436 x C 0.000459774186936986 x
34

5

L 0.0566851981501486 x C 0.00141350936988733 x C 0.00175692703461348 x
67

8

C 0.000451378463967157 x L 0.000189985444324564 x C 0.0000202277956674285 x
L 7.15411949464578 # 10

L7 9

x C 1.39733837106331 # 10

L15 10x> plot( abs( p - q ), x = a .. b, 'color' = 'blue', 'adaptive' ='false', 'numpoints' = 1000, 'size' = [0.4,0.4], 'title' = "Error of
Collocation Solution Using Chebyshev Nodes" );Error of Collocation Solution Using Chebyshev Nodes
2. # 10-6

1.8 # 10 - 6
1.6 # 10 - 6
1.4 # 10 - 6
1.2 # 10 - 6
1. # 10 - 6
8. # 10 - 7
6. # 10 - 7
4. # 10 - 7
2. # 10 - 7

p
4

p
2

3p
4

p

5p
4

3p
2

7p
4

2p

x

• For our second approximation, we specify a custom basis, which gives the exact solution
here:> r := rhs( intsolve( ie, f(x), 'method' = 'collocation', 'basis' =[1,x,sin(x),cos(x)], 'numeric' = 'false' ) );
rd

4p
sin x
C
2
3
3 4p C3

> is( p = r );true
> a, b, q, r := 'a, b, q, r':

Improvements to is, coulditbe, argument, and signum• Maple 2024 includes improvements to assumption handling, leading to better resultsfrom the is, coulditbe, argument, and signum commands.
• is and coulditbe are now careful when dealing with inequalities with nonreal operands:> is(I*((x-1)^20+1)+I<0);
false• A subalgorithm used by is and coulditbe which assumed that variables were real has
been corrected, leading to these improved answers:> conditions := [w^2 = abs(w)^2, w = conjugate(w), cos(z)/abs(cos(z))= abs(cos(z))/cos(z)]:> map(is, conditions);
false, false, false> map(is, conditions) assuming real;
true, true, true
• Some improvements in normalization of properties (see assume) have been fixed,
leading to the following improvements for top-level calls.
This call to coulditbe now returns immediately:> coulditbe(y^4*(y^8+6*y^4+1)^2*(y-1)^6*(y+1)^6*(y^2+1)^6, 0) assuming
y::real;true
This square root previously simplified only by replacing z/x by a new variable. Now that's
not necessary:> sqrt(sin(z/x)^2) assuming 0<z/x, z/x<Pi/2;
sin

z
x

These results no longer return FAIL:> coulditbe(y^2*(y^4+1)/(y^2+1)=0) assuming y::real;true> is(1/x=0) assuming x=0;
false

> coulditbe(-N^(1/2)/Pi,integer) assuming (N^(1/2)/Pi)::Not(integer);false• coulditbe is better at dealing with the conjunction of multiple conditions which dependon the same subexpression:> coulditbe(And(k::integer,k <= 20,0 <= k));true
• Maple 2023 included some new improved functionality for recognizing difference ofsquares patterns in is and coulditbe:> is(0 <= sqrt(p^3 + q^2) + q) assuming (0 < p, q::real);
trueThis feature has been improved again for Maple 2024. For example, this problem:> is((a*u+b)^(1/2)/b^(1/2)-1>0) assuming a>0,b>0,u>0;
true
is now solved by recognizing that it can be transformed into is((a*u+b)/b-1 > 0), i.e. is(a*u/b > 0).
• Maple 2023 included some improvements in coulditbe/is when there are assumptions
involving Re or Im:> is(b, real) assuming 0 < Re(b);false> is(r + i*I, real) assuming r < 0, i::real;false• These improvements have been extended for Maple 2024:> coulditbe(x<0) assuming Im(x)>0;
false> coulditbe(x<0) assuming Re(x)>0;
false> piecewise(a<0,0,a<=0,1,Im(a)<>0,2) assuming Im(a)<>0;2• This answer used to be true which was incorrect:> coulditbe((a+I*b+1)/2, integer) assuming abs(a)<1, a::real,
b::real;FAIL• There are also some improved results from is when there are multiple related inequality
assumptions:> is(exp(I*y)^2, real) assuming 0<y, y<t, 0<t;false• An improvement in AndProp led to this new result in coulditbe:> coulditbe(a+I*b, imaginary) assuming b::real, a>0;false
• In Maple 2023, some improvements were made to handle nested signum:> signum(a - signum(a)) assuming (1 < a^2);
signum a• For Maple 2024, argument and signum now recognize determining assumptions such as
the following:> (argument, signum)(x) assuming x/(I+1) > 0;
p
,
4

2
I 2
C
2
2

Manipulating Trigonometric Expressions• Before Maple 2023, simplify in general converted trig functions to sincos form. Now it
uses any of the 6 trig functions (sin, cos, tan, sec, csc, cot) and the corresponding
hyperbolic trig functions (sinh, cosh, etc.) to express the simplified answer. As a result,many examples can be returned in a more compact form:> simplify((sin(x)+cos(x))/sin(x));
1 C cot x
Along the same lines, 1/tan and 1/cot simplify to cot and tan respectively as of Maple
2024:> map(simplify,[1/tan(x),1/cot(x)]);cot x , tan x• Trig simplification now includes combining trig functions by default:> simplify((sin(8) - 2*sin(4))/(1 + cos(8) - 2*cos(4)));tan 4> simplify(2*c[1]*tan(sqrt(3)*x/4)/(1 + tan(sqrt(3)*x/4)^2) + c[2]*(1- tan(sqrt(3)*x/4)^2)/(1 + tan(sqrt(3)*x/4)^2));c2 cos

3 x
2

3 x
2

C c1 sin• Conversion of tan(x/2) to sincos now just uses tan=sin/cos, which is consistent with what
happens with arbitrary arguments:> convert~([tan(x/2), tan(f(x)/2), tan(x)], sincos);
x
2
x
cos
2
sin

•

f x
2
,
f x
cos
2
sin

,

sin x
cos x

• simplify more consistently uses the inverse trig identities arccos + arcsin = arccsc +arcsec = Pi/2 to convert expressions to a more compact form if possible:> simplify([Pi/2 - arcsin(sin(x)), Pi/2 - arccos(cos(x)), Pi/2 arccsc(csc(x)), Pi/2 - arcsec(sec(x))]);
arccos sin x , arcsin cos x , arcsec csc x , arccsc sec x• Combining with respect to trig no longer expands unnecessarily. This result is now morecompact:> combine(-7+(4*cos(1/7*Pi)^3+I*cos(1/14*Pi)-3*cos(1/7*Pi))*(-7^(5/7)*
O*(I*cos(5/14*Pi)+cos(1/7*Pi)))^(1/2), trig);
L7 C cos

3p
7

C I cosp14

L75 7 O I cos

5p
14

C cos

p
7

• simplify now converts this expression to a simpler one involving radicals:> simplify(-1/7-(-1/7*I*7^(5/7)*exp(2/7*I*Pi)*sin(1/7*Pi)-1/7*cos(1/7*
Pi)*7^(5/7)*exp(2/7*I*Pi))^(7/2));
L

1
L1 2 7 L L1 3 7L77• simplify in Maple 2023 included an improved ability to remove terms in trig arguments
which are integer multiples of Pi/2:> simplify(sin(Pi*(x + z))) assuming z::integer;
sin p x

L1 z

• This feature has been improved for Maple 2024. For example this previously simplified
only without the assumption:> simplify(cos((x+1)*Pi/2)) assuming x::integer;
Lsin

px
2

• In previous versions of Maple, to get the following simplified answer, simplify had to becalled twice:> simplify((-2*F+2*_y1*sin(y)*cos(y))/(-1+cos(2*y)), trig);
F csc y 2 L _y1 cot y• Due to improved trig simplifications this integral is now solved:> int(sqrt((1-cos(t))^2+sin(t)^2)*(t-sin(t)),t=0..Pi);
16
3
and this answer is smaller:

> int(1/sqrt(cos(x)-cos(x0)), x=0..x0) assuming x0>0,x0<Pi;
2 InverseJacobiAM
sin

x0
x0
, csc
2
2

x0
2

Similarly this result from dsolve is more compact:> dsolve(diff(y(t), t, t)-sin(t)*(diff(y(t), t))-y(t));
y t = c1 HeunC 2, L

1
1
15 cos t
1, L , L1,
,
C
2
2
8
2
2

C c2 cost
2

HeunC 2,1
1
15
, L , L1,
,
2
2
8

cos t
1
C
2
2
• After various improvements in Maple 2023 and Maple 2024, the length of this result
from simplify has decreased by more than 10 times:> simplify(-8/Pi^2/cosh(3/2*Pi)*(1/2*exp(1/2*Pi*x-3/2*Pi)-1/2*exp(-1/2*Pi*x+3/2*Pi))+8/9/Pi^2/cosh(9/2*Pi)*(1/2*exp(3/2*Pi*x-9/2*Pi)-1/2*exp(-3/2*Pi*x+9/2*Pi))-8/25/Pi^2/cosh(15/2*Pi)*(1/2*exp(5/2*Pi*
x-15/2*Pi)-1/2*exp(-5/2*Pi*x+15/2*Pi))+8/49/Pi^2/cosh(21/2*Pi)*(1/2*
exp(7/2*Pi*x-21/2*Pi)-1/2*exp(-7/2*Pi*x+21/2*Pi))-8/81/Pi^2/cosh(27/2*Pi)*(1/2*exp(9/2*Pi*x-27/2*Pi)-1/2*exp(-9/2*Pi*x+27/2*Pi)),trig, size=false);
3 p L3 Cx

1
2

p L3 Cx

p 3 Lx

2

2

Le

4

Ce

3p
sech
2

p

L

C

e

L

9

5 p L3 Cx

5 p 3 Lx

7 p L3 Cx

2

2

2

e

C

25

e

25

9 p L3 Cx

C L

e

C

e

49

e

2

9

sech

9p
2

sech

21 p
2

C

7 p 3 Lx

L

e

2

49

9 p 3 Lx

2

81

15 p
sech
2

3 p 3 Lx

2

C

e

2

81

sech

27 p
2

Sum, products, integrals, limits: simplification and evaluation• For Maple 2023, there were a number of improvements in evaluating integrals usingtransformations involving the integration variable:> eval(Int(f(x, a), a), a = x);x

f x, _a d_a> eval(Intat(f(x, y), x = g(x)), y=x);g xf _a, x d_ag xf _a, x d_a• Also as of Maple 2023, simplify began to follow the semantics of sum in applying limit
instead of eval when simplifying a Sum at a singular point:> tmp := Sum(sin(k)/k, k = 0 .. 0):> (simplify = value)(tmp);
1=1
and improved its ability to pull out provably non-zero factors from potentially infinite sums,
integrals, limits, products, etc.:> simplify(Sum(-sin(n*Pi*x)*(exp(Pi) - exp(-Pi))*(-1 + (-1)^n)/n, n =2 .. infinity));NL>

sin n p x

n=2

L1 C L1 n
n

p

Lp

e Le

> simplify(Int(2*Pi*n*f(x), x = 0 .. infinity));Nf x n dx2p0

• In Maple 2024, evaluation of a sum or product involving t^k at t=0 now correctly
recognizes that the k=0 term should actually be 1:> eval(sum(t^k*f(k), k=0..infinity), t=0);
f 0> eval(Product(f(t^k), k=0..infinity), t=0);
0

N

k= 0

k= 1

?f 1 ?f 0• Also, simplify now recognizes when sums or products can absorb extra terms or factors
to simplify the whole expression:> simplify(f(n)+Sum(f(k), k=1..n-1)) assuming integer;
n

>f k
k= 1

> simplify(f(n)*Product(f(k), k=1..n-1)) assuming integer;
n

?f k
k= 1

simplify
Argument processing, options and core algorithm improvements• As of Maple 2023, simplify included the following improvements to its option
processing and core algorithms:
It raises an exception when there is an unexpected argument passed to it:> simplify(sin(x + Pi/4), foo);
Error, (in `simplify/do`) unexpected argument: foo
The symbolic option is now effective even when given not as the last argument:> simplify(sqrt(x^2), symbolic, sqrt);
xWhen multiple particular simplification procedures are requested via extra arguments
to simplify, they will each be retried as many times as needed to obtain the full
simplification. For example, the extra arguments exp and RootOf can now be given ineither order to achieve the full simplification:> e := RootOf(_Z^2 - exp(2*RootOf(_Z^2+1,index=1)*x) - 1):> simplify( diff(e-subs(RootOf(_Z^2+1,index=1) = I, e), x), RootOf,
exp);
0
It uses expand more extensively to simplify functions:> simplify(polar(sqrt(13), arctan(3/2)) + polar(sqrt(65), -arctan(7/4)));
6L4I
It avoids normalizing pure rational polynomials when there is no advantage in doingso:> simplify((x + 1)^5/a + 1);
xC1 5
C1
a
... or when the benefits are outweighed by the drawbacks. In this case, the input
expression, although non-polynomial, is nevertheless considered simpler than the 307term polynomial which results from dividing through by the denominator:> simplify((x^307 - 1)/(x - 1));x307 L 1
xL1
The latter can of course still be obtained via normal or factor:

> type(normal((x^307 - 1)/(x - 1)), polynom);true• As of Maple 2024, simplify cancels factors whose ratio is the imaginary unit:> simplify((I*x+1)/(x-I) );I

Elliptic functions
Maple now has improved simplification and normalization for various Elliptic functions.
• Symmetries in EllipticPi are now used to automatically factor out or remove minus
signs from its arguments:> EllipticPi(1, nu, -k), EllipticPi(nu, -k), EllipticPi(-z, nu, -k);
EllipticPi n, k , EllipticPi n, k , LEllipticPi z, n, k
• A symmetry in EllipticF is now used to simplify its arguments:> simplify(EllipticF(z*k, 1/k));EllipticF z, k k> simplify([EllipticPi((-1)^n, nu, k), EllipticF((-1)^n, k)])assuming n::integer;
L1 n EllipticPi n, k , L1 n EllipticK k> simplify(EllipticPi((z^2)^(1/2),nu,k), EllipticPi);
z2 EllipticPi z, n, kz
> tmp := [EllipticE, EllipticK](k*I/sqrt(1-k^2)):> simplify(tmp);kEllipticE

k2 L 1, EllipticKkk2 L 1> simplify(tmp) assuming k^2 < 1;
EllipticE k
2, EllipticK k

Lk2 C 1

Lk C 1> simplify((-2*k^2 + 2)*EllipticE(k*I/sqrt(-k^2 + 1)) - EllipticK(k*I/sqrt(-k^2 + 1)) + (-2*EllipticE(k) + EllipticK(k))*sqrt(-k^2+ 1)) assuming 0<k, k<1;
0
• Limits of Elliptic functions at certain infinite values are now more accurate. This
example previously returned a complex infinity:

> evalf(Limit(BesselI(0,z)+EllipticPi(1/2,1/z),z = -infinity));
Float Nbinomial, Beta, GAMMA• Simplification of binomial was introduced in Maple 2023 and has been improved for
Maple 2024:> simplify(4^n*binomial(n - 1/2, n) - binomial(2*n, n));0
• Conversion and simplification of Beta has been introduced for Maple 2024:> convert(Beta(a,1-a),elementary);p
sin p a> simplify(-1/2*Beta(1/6,1/2)+1/3*Pi^2*2^(2/3)/GAMMA(2/3)^3*3^(1/2));
0• This integral now returns (unevaluated) quickly due to improved simplification of
GAMMA:> int((1/2)^(2061+2*z)/z/(1+2*z)*GAMMA(3/2+z)^2/GAMMA(z)^2, z);
2061 C2 z

1
2

G

2
3
Cz
2

z 1C2z G z

2dz

piecewise• In Maple 2023, simplify became better at recognizing when function calls can befactored out of piecewise functions:> simplify(piecewise(x < 0, f(y), f(z)));
f

y

x!0

z

0%x

• In Maple 2024, simplify and combine are both now better at recognizing when twopiecewise branch values can be merged into one:> {simplify, combine}(piecewise(x <= 0,2*ln(1-x),0 < x,ln((x-1)^2))) assuming x,real;ln x L 1 2
and when multiple piecewise functions can be merged into one:> {simplify, combine}(piecewise(a<0, f1(a), a>0, f2(a), Or(a=0, Im(a)<>0), f3(a)) + piecewise(a<0, g1(a), a>0, g2(a), Or(a=0, Im(a)<>0), g3(a)));>

f1 a C g1 a

a!0

f2 a C g2 a

0!a

f3 a C g3 a

a = 0nI a s 0

As a result the following integral can now be solved in terms of limits:> int(piecewise(t <= 1,-(cos(alpha*t)-1)/alpha,1 < t,(cos(alpha*t)*cos(alpha)+sin(alpha*t)*sin(alpha)-cos(alpha*t))/alpha)*sin(alpha*x),alpha=0..infinity);lim Si a x L
a N
limN

a

Si a t L x
2

L

Si a t C x
2

Si a t C x
2

LC

Si a t L x
2

Si a Lx C t L 1
2

C

t!1
Si a x C t L 1
2

logarithm and dilogarithm• Simplification and numeric evaluation of expressions containing ln with large integer
components is now handled more carefully:> tmp := simplify(-127/6*ln(2)-1/2*ln(3)+7/6*ln(233512967+14798283*
249^(1/2))+ln(11014713425-698029101*249^(1/2)));
tmp d L127 ln 2ln 3
7 ln 233512967 C 14798283
L
C
6
2
6

L 698029101

249

C ln 11014713425

249> evalf[20](tmp);
L1.8847449302970215778• Simplification of dilog is now more careful to avoid simplifications which are branchdependent. For example, this call to simplify now correctly returns the input
unchanged:> simplify(dilog(s + 2) + dilog(1/(s + 2))) assuming s < -2;
dilog s C 2 C dilog

1
sC 2

power and radical• In Maple 2023, there were some improvements in the simplification of radicals which
led to the following improved results:

1%t

•

> simplify(sqrt(x^2), sqrt) assuming x::real;x> simplify(-1/(x*(-y + sqrt(-2/x))*(y + sqrt(-2/x))));
1
y xC2
2

> simplify((A + B*sqrt(x))^a*a^2*B^2/(4*x*(A + B*sqrt(x))^2) - (A +B*sqrt(x))^a*a*B/(4*x^(3/2)*(A + B*sqrt(x))) - (A + B*sqrt(x))^a*a*B^2/(4*x*(A + B*sqrt(x))^2) + a*B*(A + B*sqrt(x))^(a - 1)/(4*x^(3/2)) - pochhammer(a - 1, 2)*B^2*(A + B*sqrt(x))^(a - 2)/(4*x));0> simplify(-B*(A^2*sqrt(x) + 2*A*B*x + B^2*x^(3/2))*(a - 1)*(A + B*
sqrt(x))^(a - 2) + (2*A*B*sqrt(x) + B^2*x + A^2)*(A + B*sqrt(x))^(a - 1) - (-B*(a - 2)*sqrt(x) + A)*(A + B*sqrt(x))^a);0• For Maple 2024, simplify(.., power) no longer expands unnecessarily. For thisexample the new result is now more compact:> simplify( (Pi^k*2^(2*k+2)*5^(2*k+1)/(-1+2*k)*hypergeom([-2*k-1, k+1/2],[3/2-k],1/100)/GAMMA(2*k+2)+25*Pi^(k+1)*(2*k+1)*(3+2*k)/GAMMA(k+5/2)^2*sec(Pi*k))*(-1)^(3*k), power);k

20 p 4k 25k hypergeom

L2 k L 1, Lk C

1
,
2

3
1
Lk ,
2
100

L1 C 2 k G 2 k C 2

k C1

C

25 p

2kC1

3 C 2 k sec p k
5 2
G kC
2

L1 3 k• Also, simplify no longer pulls polynomial factors out of a radical without good reason:> simplify(I/(cos(x)-1)^(3/2), radical) assuming 0 < x,x < 1/2*Pi;
L

1
Lcos x C 1 3 2

min/max• As of Maple 2023, simplify included better normalization for min and max:

> simplify(Vector([min(x + y, x + z), max(3*x, 3*y), max(-x, -y), min(x, -y) + max(y, -x), min(x, -y) - max(y, -x), min(x, -x) - max(x, x), min(x, -x) + max(x, -x)]));min y, z C x
3 max x, y
Lmin x, y
0
2 min x, Ly
2 min x, Lx0«> (simplify(max(z*x, z*y)) assuming (z < 0));z min x, y
• For Maple 2024, min and max are now better at recognizing whether inputs are real. For
example, this is a real number in disguise:> alias(r= -1/2*(-cos(RootOf(sin(_Z)^2*_Z^2+sin(_Z)^2+6*_Z*sin(_Z)+8,-0.-1.931327404*I))-3)*csc(RootOf(sin(_Z)^2*_Z^2+sin(_Z)^2+6*_Z*sin(_Z)+8,3.761757270))*sin(1/2*(-cos(RootOf(sin(_Z)^2*_Z^2+sin(_Z)^2+6*_Z*sin(_Z)+8,-0.-1.931327404*I))-3)*csc(RootOf(sin(_Z)^2*_Z^2+
sin(_Z)^2+6*_Z*sin(_Z)+8,3.761757270)))^2-1/2*(-cos(RootOf(sin(_Z)^2*_Z^2+sin(_Z)^2+6*_Z*sin(_Z)+8,-0.-1.931327404*I))-3)*csc(RootOf(sin(_Z)^2*_Z^2+sin(_Z)^2+6*_Z*sin(_Z)+8,3.761757270))):> evalf(r);L7.786927399 C 0. I
> Im(r);0
min no longer complains that the number is not real:> min(2,r);min 2, r> alias(:-r=:-r):

IntegrationTools:-Change• In Maple 2023, IntegrationTools:-Change became better at restricting the change ofvariables to the subinterval where it is valid. For example, in this case thetransformation is not valid on x=Pi/4..Pi/2 so it is only applied to the subinterval x=0..
Pi/4:

> IntegrationTools:-Change(Int(sin(x)/(1 + sin(x)*cos(x))^(1/2), x = 0.. 1/2*Pi), x = arcsin(y)/2);
1

arcsin ysin
22

Ly C 1
0

4C2y

p
2

sin x

dy C
p
4

1 C sin x cos xdx• After some more improvements for Maple 2024, this change of variables can now be
done:> tmp := convert(-EllipticF(u*2^(1/2)*(1/(cos(y0)+1))^(1/2),cos(1/2*y0))*2^(1/2)/(1/(cos(y0)+1))^(1/2)/(2*cos(y0)+2), Int);> IntegrationTools:-Change(tmp, _alpha1=a*T, a);• Also, this request to change variables now returns the given integral unchanged
because the change of variables requested does not involve the existing integration
variable:> IntegrationTools:-Change(Int(cos(t),z), {x = r*cos(t)}, [r]);cos t dz
• Finally, these calls to IntegrationTools:-Change now give more useful error messages:> IntegrationTools:-Change(Int(f(x),x=a..b), x=-x);
Error, (in IntegrationTools:-Change) transformation equations must
depend on at least two variables, the old integration variable and thenew one> IntegrationTools:-Change(Int(f(k*z+v*t,v*z+k*t),z = 0 .. 1),{t = (k*y-x*v)/(-v^2+k^2), z = (-v*y+k*x)/(-v^2+k^2)},[x, y]);Error, (in IntegrationTools:-Change) only 1 transformation equation(s){z = (k*x-v*y)/(k^2-v^2)} was applicable to the integral(s) in the
input; the number of new integration variables specified, [x, y], shouldbe the same
> tmp := Int(Int(f(x^2)*g(y),x = a .. b),y = c .. d);dbf x2 g y dx dy

tmp d
c

a

> IntegrationTools:-Change(tmp, {x = u^2+U, y = v^2+V});
Error, (in IntegrationTools:-Change) ambiguous change of variables;
please specify (using the third argument) which 2 of {U, V, u, v} are
the new variables

Verification
Verification of two expressions up to sign differences has undergone some significant
improvements recently.
• As of Maple 2023, verify,sign now recurses into non-algebraic expressions:> verify([x/(1-x)], [-x/(x-1)], sign);
true
Signs can now be factored out of both even and odd powers as part of the equivalence:> verify((1-x)^2/(1-y)^3, -(x-1)^2/(y-1)^3, sign);
true
Also two new options oddfuncs = ... and evenfuncs = ... were added, allowing use of odd
or even function symmetries in the equivalence:

> verify(-Int(sin(1 - x), x), Int(sin(x - 1), x), 'sign'(oddfuncs ={Int, sin}));true• For Maple 2024, verification of relations (equations, inequations, and inequalities) withrespect to sign is now possible:> verify(a = b, -a = -b, 'sign');true> verify(a <> b, -a <> -b, 'sign');true> verify(a < b, -b < -a, 'sign');true> verify(a <= b, -b <= -a, 'sign');true> verify(a < b, -a < -b, 'sign');false> verify(a <= b, -a <= -b, 'sign');false

Miscellaneous Improvements in Advanced Math
• The results of converting between mathematical functions are now better simplified:> convert(-I-1/z*Im(z)+I*abs(1,z)/signum(z),signum);
I
2

1L

1
signum z 2• There was an improvement in int by expressing exponentials in the integrand as integer
powers of a common base exponential:
For this answer the length has decreased by more than 10x:

> int(arctanh(exp(2*x))*(exp(10*x)-3*exp(6*x)-exp(-2*x)+3*exp(2*x))/(exp(4*x)-1)^2, x);arctanh

ex
2

2

ex

2

C

ex

arctanh2 ex

22ln ex C 1
L ln e C
2
x

C

ln

ex

2

2

C1

C

ln ex L 1
2

For this answer, the length has decreased by 7.5 times:> dsolve(-diff(y(x), x)^2/y(x)^2 + diff(y(x), x, x)/y(x) + 2*coth(2*x)*diff(y(x), x)/y(x) = 2);c arctanh e2 x
1

y x =
•

e

e2 x C 1
ex c2

ex C 1

ex L 1• A problem in dsolve was fixed, leading to this now correct (and much more compact)
answer:> ode := x^4*diff(y(x),x$2)+(a*sin(lambda/x)+b)*y(x)=0:> ans := dsolve(ode);
ans d y x = c1 x MathieuC
arccos sin

4b

2a

l

l

2 ,L

2 , arccos

sin

pxC2l
4x

C c2 x MathieuS

4b

2a

l

l

2 ,L

2 ,

pxC2l
4x

> odetest(ans, ode);0• FunctionAdvisor is now more careful when generating identities:> FunctionAdvisor(arccoth, identities, quiet);coth arccoth z= z, I coth arccoth Ly C arccoth z C I p =yzL 1
IzL Iy• lcm and gcd now treat single-argument input consistently with that of multiple
argument inputs and just leave it alone rather than potentially returning an error:> lcm(sin(2*x));sin 2 x> gcd(1+I+z);
1C IC z• A case where factor was not idempotent has been fixed:> alias(c=-(-x^2*y^n + 2*g(x)*y^n + 5*x*y^n - 4*y^n + 2*y)*(g(x)*x*y^n+ x^2*y^n - 10*x*y^n + y*x + 24*y^n)/(y^n*(x - 3)*(x + 4)^2*(g(x)*y^n + x*y^n - 2*y^n + y))):> alias(d=-(-g(x)*x^3*(y^n)^2 - x^4*(y^n)^2 + 2*g(x)^2*x*(y^n)^2 + 7*g(x)*x^2*(y^n)^2 + 15*x^3*(y^n)^2 - y*x^3*y^n - 24*g(x)*x*(y^n)^2 78*x^2*(y^n)^2 + 4*y*g(x)*x*y^n + 7*y*x^2*y^n + 48*g(x)*(y^n)^2 +160*x*(y^n)^2 - 24*y*x*y^n + 2*x*y^2 - 96*(y^n)^2 + 48*y*y^n)/(y^n*(x - 3)*(x + 4)^2*(g(x)*y^n + x*y^n - 2*y^n + y))):> factor(d^(5/4)-c^(5/4));0> alias(:-c=:-c, :-d=:-d):• A formula relating InverseJacobiSD to InverseJacobiCN has been corrected:> tmp := InverseJacobiSD(z, k):> tmp = convert(tmp, InverseJacobiCN);
InverseJacobiSD z, k = LInverseJacobiCN

Lk2 C 1 z, k C EllipticK k

InverseJacobiSD z, k = LInverseJacobiCN

Lk2 C 1 z, k C EllipticK k• This call to product no longer gives an unexpected error:> product( q*sinh(Pi*(q^2+1)^(1/2))/sinh(Pi*q)/(q^2+1)^(1/2), q=2..
infinity);N?

q sinh p

q = 2 sinhpq

q2 C 1
q2 C 1• Numeric evaluation of certain trig expressions is now more careful:> evalf(cot(-1/8-10^10*I));
L4.259906707 # 10L8685889639 C I> evalf(Psi(-1/8-10^10*I));23.02585093 L 1.570796327 I• The relative difference between the absolute values of the radical and non-radical partof a large power of the golden ratio is very small, making it difficult to distinguishnumerically whether the expanded power is positive or negative:> phi := (sqrt(5) - 1)/2:> phi_381 := expand(phi^381);
phi_381 d
L21050428445219715212283513071197708058110642480418964396226164263063778766736638
C 9414037791801298231433263155603126899071963535550379906525232657258068886564353
5> evalf([op(phi_381)]);L2.105042845 # 1079, 2.105042844 # 1079
As such, some extra care is now taken by abs to determine that this expression ispositive:> abs(phi_381);
L21050428445219715212283513071197708058110642480418964396226164263063778766736638
C 9414037791801298231433263155603126899071963535550379906525232657258068886564353
5> phi := 'phi':phi_381 := 'phi_381':• Some improvements to the inttrans code led to these new results:> inttrans:-fourier(sqrt(-t^2 + 1)*(Heaviside(t + 1) - Heaviside(t 1)), t, w);
p BesselJ 1, w
w
This result is new as of Maple 2023:

> inttrans:-laplace( 1 / ( 1 + I * mu * x )-Int( f(y) / ( 1 + I * x *y ), y = 0 .. infinity ), x, s );
N

I
2

f y e
2

LI s
y

Ei1

LI s
y

y

dy

0
LI s

e
C

m

L2 Ei1LI sm

L 2 lnLI
LI s
C 2 ln s C ln
mmm

L ln I m• expand was not being called recursively on some examples involving integrals. Now it
is:> expand(Int(f(x)*(b*x+c),x));bf x x dx C c

f x dx• evalc no longer assumes that two-argument GAMMA must be real if it has realarguments:> evalc(Im(GAMMA(2/3, -1/3)));
2
1
,L
3
3

I G

• Expansion of Bessel and Hankel functions has been made much more efficient. This
example now runs over 250 times faster than it did in Maple2023:> time(expand(BesselJ(750,x)));
0.075
As well, expansion of BesselK in particular now takes advantage of the symmetry
BesselK(-v,x)=BesselK(v,x) to achieve a new expanded normal form in terms of BesselK(v__i, k) with v_i between 0 and 1:> expand(BesselK(4/3, x));2 BesselK
3x

1
,x
3

C BesselK2,x3> expand(2/3*BesselK(1/3, x)/x+BesselK(2/3, x)-BesselK(4/3, x));0
• collect no longer gets confused by the letter O (which is used to express series results):> collect(O, O, F);
F 1 O