Advanced Math - New Features in Maple 2019 - Maplesoft

What's New in Maple 2019

Pricing & Purchase
Upgrade to Maple 2019
Back to What's New Overview

Advanced Math

Maple 2019 includes numerous cutting-edge updates in a variety of branches of mathematics.



Differential Equations 

The new command FindODE, in the DEtools package, tries to find a linear ordinary differential equation with polynomial coefficients for the given expression. 

> DEtools[FindODE](cos(sqrt(x)), y(x))
 

Typesetting:-mprintslash([`+`(y(x), `*`(2, `*`(diff(y(x), x))), `*`(4, `*`(x, `*`(diff(y(x), `$`(x, 2))))))], [`+`(y(x), `*`(2, `*`(diff(y(x), x))), `*`(4, `*`(x, `*`(diff(diff(y(x), x), x)))))])
 

> DEtools[FindODE](`+`(BesselI(0, x), `*`(x, `*`(BesselI(2, x)))), y(x))
 

Typesetting:-mprintslash([`+`(`*`(`+`(`-`(`*`(`^`(x, 4))), `-`(`*`(2, `*`(`^`(x, 3)))), `-`(`*`(4, `*`(`^`(x, 2)))), `-`(`*`(3, `*`(x)))), `*`(y(x))), `*`(`+`(`-`(`*`(`^`(x, 3))), x, 4), `*`(diff(y(x)...
 

 

int 

Description 

  • There have been various improvements made to the int command for Maple 2019.
 

int Examples 

  • New results from int:
 

> int(abs(sin(`*`(`^`(x, 2)))), x = 0 .. Pi)
 

`+`(`-`(`*`(`/`(1, 2), `*`(FresnelS(`*`(`^`(2, `/`(1, 2)), `*`(`^`(Pi, `/`(1, 2))))), `*`(`^`(2, `/`(1, 2)), `*`(`^`(Pi, `/`(1, 2))))))), `*`(FresnelS(`*`(`^`(2, `/`(1, 2)))), `*`(`^`(2, `/`(1, 2)), `...
 

> int(exp(`*`(I, `*`(sin(x)))), x = 0 .. Pi)
 

`+`(`*`(Pi, `*`(BesselJ(0, 1))), `*`(I, `*`(Pi, `*`(StruveH(0, 1)))))
 

> int(`*`(`^`(sec(u), 2), `*`(exp(`+`(`-`(sec(u)))))), u = 0 .. `+`(`*`(`/`(1, 2), `*`(Pi))))
 

BesselK(1, 1)
 

> int(signum(arccos(`/`(1, `*`(z)))), z = 0 .. 1)
 

I
 

> `assuming`([int(abs(`+`(cos(`*`(`+`(p, `-`(1)), `*`(x))), `-`(cos(`*`(`+`(p, 1), `*`(x)))))), x = 0 .. Pi)], [`>`(p, 1)])
 

`+`(`-`(`/`(`*`(2, `*`(`+`(`*`(sin(`*`(Pi, `*`(p))), `*`(signum(sin(`*`(Pi, `*`(p)))), `*`(cos(`/`(`*`(Pi), `*`(p)))))), `-`(`*`(sin(`*`(Pi, `*`(p))), `*`(signum(sin(`*`(Pi, `*`(p))))))), `-`(`*`(sin(...
 

> int(`*`(`^`(`+`(csc(x), `-`(1)), nu), `*`(cos(x))), x = 0 .. `+`(`*`(`/`(1, 2), `*`(Pi))))
 

`/`(`*`(Pi, `*`(nu)), `*`(sin(`*`(nu, `*`(Pi)))))
 

> int(`+`(`*`(`^`(x, 2)), `-`(`/`(1, 2)), `/`(`*`(`*`(`/`(1, 2), `*`(I)), `*`(ln(`+`(`-`(exp(`*`(`*`(2, `*`(I)), `*`(Pi, `*`(`^`(x, 2)))))))))), `*`(Pi))), x = 0 .. 2)
 

`+`(5, `-`(`*`(`^`(2, `/`(1, 2)))), `-`(`*`(`^`(3, `/`(1, 2)))))
 

  • Improved answers for definite integrals when the AllSolutions option is given:
 

> int(round(t), t = 0 .. x, AllSolutions)
 

Typesetting:-mprintslash([`+`(`*`(`/`(1, 2), `*`(PIECEWISE([`+`(`-`(`*`(`^`(ceil(`+`(x, `-`(`/`(1, 2)))), 2))), `*`(x, `*`(PIECEWISE([`+`(`*`(2, `*`(x)), `-`(1)), (`+`(x, `/`(1, 2)))::integer], [`+`(`...
 

> int(`/`(1, `*`(`+`(2, cos(t)))), t = 0 .. x, AllSolutions)
 

Typesetting:-mprintslash([`+`(`*`(`/`(1, 3), `*`(PIECEWISE([`+`(`*`(2, `*`(Pi, `*`(ceil(`+`(`-`(`/`(`*`(`/`(1, 2), `*`(`+`(Pi, `-`(x)))), `*`(Pi)))))))), PIECEWISE([Pi, (`+`(`-`(`/`(`*`(`/`(1, 2), `*`...
 

> int(`/`(1, `*`(ln(t))), t = 0 .. x, AllSolutions, CauchyPrincipalValue)
 

Typesetting:-mprintslash([PIECEWISE([`+`(`-`(`*`(`+`(I), `*`(Pi))), Ei(`+`(ln(`+`(`-`(x))), `*`(I, `*`(Pi))))), `<`(x, 0)], [0, x = 0], [Ei(ln(x)), `<`(x, 1)], [`+`(`-`(infinity)), x = 1], [Ei(ln(x)),...
 

 

Integral Transforms 

Description 

  • The inttrans package in Maple 2019 has had several transforms, specifically laplace, invlaplace, fourier and invfourier, extended to handle a larger class of problems, and in some cases already handled classes of problems faster. This has been accomplished via an integration by differentiation approach described in the following:
    - A. Kempf, D.M. Jackson and A.H. Morales, "New Dirac delta function based methods with applications to perturbative expansions in quantum field theory", J. Phys. A:47, 2014
    - D. Jia, E. Tang, and A. Kempf, "Integration by differentiation: new proofs, methods and examples", J. Phys. A:50, 2017
 

  • One can view this approach, in simplest possible terms, as a product rule.
 

Fourier Examples 

  • Here are a few examples which failed to transform in prior versions of Maple, but now transform quite rapidly:
 

> ex1 := `/`(`*`(exp(`+`(`-`(`*`(`/`(1, 2), `*`(t))))), `*`(sin(t))), `*`(`+`(1, exp(`+`(`-`(t)))), `*`(t)))
 

Typesetting:-mprintslash([ex1 := `/`(`*`(exp(`+`(`-`(`*`(`/`(1, 2), `*`(t))))), `*`(sin(t))), `*`(`+`(1, exp(`+`(`-`(t)))), `*`(t)))], [`/`(`*`(exp(`+`(`-`(`*`(`/`(1, 2), `*`(t))))), `*`(sin(t))), `*`...
 

> inttrans[fourier](ex1, t, s)
 

`+`(`-`(`*`(`+`(`*`(`/`(1, 2), `*`(I))), `*`(ln(`/`(`*`(`+`(csc(`+`(`*`(I, `*`(Pi, `*`(s))), `*`(`+`(`-`(`/`(1, 2)), `-`(I)), `*`(Pi)))), cot(`+`(`*`(I, `*`(Pi, `*`(s))), `*`(`+`(`-`(`/`(1, 2)), `-`(I...
 

> ex2 := `*`(exp(`+`(`*`(`/`(1, 2), `*`(t)))), `*`(ln(`+`(1, exp(`+`(`-`(t))))), `*`(cos(t))))
 

Typesetting:-mprintslash([ex2 := `*`(exp(`+`(`*`(`/`(1, 2), `*`(t)))), `*`(ln(`+`(1, exp(`+`(`-`(t))))), `*`(cos(t))))], [`*`(exp(`+`(`*`(`/`(1, 2), `*`(t)))), `*`(ln(`+`(1, exp(`+`(`-`(t))))), `*`(co...
 

> inttrans[fourier](ex2, t, s)
 

`*`(Pi, `*`(`+`(`/`(`*`(csc(`*`(Pi, `*`(`+`(`-`(`/`(1, 2)), `*`(I, `*`(`+`(s, `-`(1))))))))), `*`(`+`(`*`(`*`(2, `*`(I)), `*`(s)), `+`(`-`(1), `-`(`*`(2, `*`(I))))))), `/`(`*`(csc(`*`(Pi, `*`(`+`(`-`(...
 

> ex3 := `*`(`+`(`*`(exp(`+`(`-`(t))), `*`(Heaviside(t))), `*`(exp(t), `*`(Heaviside(`+`(`-`(t)))))), `*`(`/`(`+`(`*`(2, `*`(t)), `*`(2, `*`(I))))))
 

Typesetting:-mprintslash([ex3 := `/`(`*`(`+`(`*`(exp(`+`(`-`(t))), `*`(Heaviside(t))), `*`(exp(t), `*`(Heaviside(`+`(`-`(t))))))), `*`(`+`(`*`(2, `*`(t)), `*`(2, `*`(I)))))], [`/`(`*`(`+`(`*`(exp(`+`(...
 

> inttrans[fourier](ex3, t, s)
 

`+`(`*`(`/`(1, 2), `*`(exp(`+`(`-`(s))), `*`(`+`(`-`(`*`(Ei(1, `+`(`-`(I), `-`(s))), `*`(exp(`+`(`-`(I)))))), `*`(Ei(1, `+`(I, `-`(s))), `*`(exp(I))))))))
 

> ex4 := `/`(`*`(csch(t), `*`(sin(t))), `*`(t))
 

Typesetting:-mprintslash([ex4 := `/`(`*`(csch(t), `*`(sin(t))), `*`(t))], [`/`(`*`(csch(t), `*`(sin(t))), `*`(t))])
 

> inttrans[fourier](ex4, t, s)
 

`+`(`-`(`*`(`+`(I), `*`(`+`(`-`(`*`(2, `*`(Pi))), ln(`/`(`*`(`+`(exp(`*`(Pi, `*`(`+`(s, 1)))), 1)), `*`(`+`(exp(`*`(Pi, `*`(`+`(s, `-`(1))))), 1)))))))))
 

 

 

Multivariate Limits 

The limit command in Maple 2019 has been enhanced for the case of limits of quotients of multivariate functions. See Multivariate Limits for details. 

 

Real Roots of Polynomials 

A new algorithm for univariate polynomials has been added to the RootFinding:-Isolate command. It is particularly efficient for ill-conditioned problems and high accuracy solutions, and it provides certified real root isolation for polynomials with irrational coefficients. See Real Root Finding for details. 

 

Residue 

The residue command has a new optional argument that allows the user to specify the maximal order of the underlying series computations.  

 

simplify 

Description 

  • The simplify command in Maple 2019 has undergone several improvements, especially with regard to expressions containing piecewise functions.
 

simplify Examples 

  • Simplification of expressions containing piecewise functions has been improved.
 

Equal, equivalent, or implied piecewise branches are now combined by simplify; 

> simplify(piecewise(x = 1, 5, x = 2, 5, 6))
 

Typesetting:-mprintslash([PIECEWISE([5, Or(x = 1, x = 2)], [6, otherwise])], [piecewise(Or(x = 1, x = 2), 5, 6)])
 

> simplify(piecewise(`+`(`*`(`/`(1, 2), `*`(Pi))) = T, 0, (`+`(`/`(`*`(`/`(1, 2), `*`(`+`(`*`(2, `*`(T)), `-`(Pi)))), `*`(Pi))))::integer, cos(T), 1))
 

Typesetting:-mprintslash([PIECEWISE([cos(T), (`+`(`-`(`/`(`*`(`/`(1, 2), `*`(`+`(`-`(`*`(2, `*`(T))), Pi))), `*`(Pi)))))::integer], [1, otherwise])], [piecewise((`+`(`-`(`/`(`*`(`/`(1, 2), `*`(`+`(`-`...
 

> simplify(piecewise(`+`(`*`(`^`(a, 2)), `*`(`^`(b, 2))) = 0, 0, sqrt(`/`(`*`(`+`(`*`(`^`(a, 2)), `*`(`^`(b, 2)))), `*`(`^`(a, 2))))))
 

`*`(`^`(`/`(`*`(`+`(`*`(`^`(a, 2)), `*`(`^`(b, 2)))), `*`(`^`(a, 2))), `/`(1, 2)))
 

> `assuming`([simplify(piecewise(`<`(m, 2), floor(`+`(`*`(`/`(1, 2), `*`(m)))), 0))], [m::posint])
 

0
 

Piecewise conditions involving floor, ceil, round, frac, trunc can now be simplified: 

> simplify(piecewise(`>`(round(x), `/`(1, 2)), f(x), g(x)))
 

Typesetting:-mprintslash([PIECEWISE([g(x), `<`(x, `/`(1, 2))], [f(x), `<=`(`/`(1, 2), x)])], [piecewise(`<`(x, `/`(1, 2)), g(x), `<=`(`/`(1, 2), x), f(x))])
 

Branch conditions other than equations, inequations, and inequalities are now taken into account while simplifying branch values: 

> simplify(piecewise(x::integer, floor(x), `*`(`^`(x, 2))))
 

Typesetting:-mprintslash([PIECEWISE([x, x::integer], [`*`(`^`(x, 2)), otherwise])], [piecewise(x::integer, x, `*`(`^`(x, 2)))])
 

> simplify(piecewise(x::posint, `*`(`^`(`*`(`^`(x, 3)), `/`(1, 3))), x))
 

x
 

Branch conditions are now simplified more effectively using basic boolean logic: 

> simplify(piecewise(Or(a = 1, And(a = 1, b::integer)), 0, 1))
 

Typesetting:-mprintslash([PIECEWISE([0, a = 1], [1, otherwise])], [piecewise(a = 1, 0, 1)])
 

> simplify(piecewise(Or(`*`(`^`(x, 2)) = `*`(`^`(y, 2)), `<`(`*`(`^`(x, 2)), `*`(`^`(y, 2)))), f(x), g(x)))
 

Typesetting:-mprintslash([PIECEWISE([f(x), `<=`(`*`(`^`(x, 2)), `*`(`^`(y, 2)))], [g(x), otherwise])], [piecewise(`<=`(`*`(`^`(x, 2)), `*`(`^`(y, 2))), f(x), g(x))])
 

simplify now reorders piecewise conditions when appropriate: 

> simplify(`+`(piecewise(a = b, 4, `<>`(a, b), 5), `-`(piecewise(`<>`(a, b), 5, a = b, 4))))
 

0
 

Piecewise conditions are now better normalized; 

> simplify(`+`(piecewise(`<>`(x, `+`(`*`(`/`(1, 2), `*`(t)))), f(x), 0), `-`(piecewise(`<>`(`+`(`*`(2, `*`(x)), `-`(t)), 0), f(x), 0))))
 

0
 

Common terms and factors are now pulled out of piecewise branch values where possible: 

> simplify(`+`(piecewise(`<`(`+`(z, `-`(y)), `/`(1, 2)), y, `+`(y, 1)), `-`(piecewise(`<`(`+`(z, `-`(y)), `/`(1, 2)), `+`(`*`(2, `*`(y))), `+`(`*`(2, `*`(y)), 1)))))
 

`+`(`-`(y))
 

> simplify(piecewise(x = 0, `+`(`-`(`*`(4, `*`(Pi, `*`(_C8[_Z1, _Z2], `*`(`^`(BesselJ(_Z1, `*`(BesselJZeros(_Z1, _Z2), `*`(r))), 2), `*`(r))))))), `+`(`-`(`*`(2, `*`(Pi, `*`(_C8[_Z1, _Z2], `*`(`^`(Besse...
 

Typesetting:-mprintslash([`*`(PIECEWISE([-4, _Z1 = 0], [-2, otherwise]), `*`(Pi, `*`(_C8[_Z1, _Z2], `*`(`^`(BesselJ(_Z1, `*`(BesselJZeros(_Z1, _Z2), `*`(r))), 2), `*`(r)))))], [`*`(piecewise(_Z1 = 0, ...
 

  • Nonpiecewise-related improvements made to simplify:
 

Improved simplification of Gamma: 

> `assuming`([simplify(`/`(1, `*`(GAMMA(`+`(1, `-`(n))), `*`(GAMMA(n)))))], [n::integer])
 

0
 

Trig functions are now expanded if it helps with simplification: 

> simplify(`+`(sec(z), `*`(I, `*`(`+`(`*`(I, `*`(tan(`+`(`*`(`/`(1, 4), `*`(Pi)), `*`(`/`(1, 2), `*`(z)))))), `-`(`*`(`+`(I), `*`(tan(z)))))))))
 

0
 

Simplification of expressions containing arctan has been improved: 

> simplify(`+`(sin(`+`(`*`(`/`(1, 3), `*`(arctan(`+`(`*`(`/`(1, 9), `*`(sqrt(111))))))), `*`(`/`(1, 6), `*`(Pi)))), `-`(cos(`+`(`*`(`/`(1, 6), `*`(arctan(`+`(`*`(`/`(3, 5), `*`(sqrt(111))))))), `*`(`/`(...
 

0
 

Expressions containing csgn can now be more effectively simplified: 

> simplify(`+`(`-`(`*`(sqrt(`*`(`^`(y, 2))), `*`(csgn(y)))), y), csgn)
 

0
 

Conversion between powers, exponentials, trig functions, and radicals to achieve simplification has been improved: 

> simplify(`+`(cos(x), `-`(`*`(`/`(1, 2), `*`(exp(`*`(I, `*`(x))))))))
 

`+`(`*`(`/`(1, 2), `*`(exp(`+`(`-`(`*`(`+`(I), `*`(x))))))))
 

> simplify(`+`(sinh(x), `-`(cosh(x)), exp(`+`(`-`(x)))))
 

0
 

> simplify(`+`(`*`(`+`(`-`(`*`(3, `*`(sin(x)))), `*`(9, `*`(I))), `*`(exp(`+`(`-`(`*`(`+`(`*`(`/`(1, 3), `*`(I))), `*`(sin(x)))))))), `*`(`+`(`-`(`*`(9, `*`(I))), `-`(`*`(3, `*`(sin(x))))), `*`(exp(`*`(...
 

0
 

> simplify(`+`(`-`(`*`(`^`(`+`(z, 1), `+`(`*`(`/`(1, 2), `*`(b)), `/`(1, 2))), `*`(exp(`*`(I, `*`(`+`(b, 1), `*`(Pi)))), `*`(`+`(`^`(z, `+`(`-`(a), `-`(b), `-`(1))), `-`(`^`(z, `+`(`-`(a), `-`(b), 1))))...
 

0
 

Symbolic powers of integers are now combined more effectively: 

> simplify(`*`(`^`(-1, `+`(`*`(2, `*`(k)))), `*`(`+`(`*`(`^`(4, k), `*`(`^`(25, k))), `-`(`^`(100, k))))))
 

0
 

simplify now rewrites expressions using a common integer base: 

> simplify(`*`(`^`(-1, _k2), `*`(`^`(4, _k2), `*`(`^`(2, `+`(`-`(nu))), `*`(`^`(16, `+`(`-`(_k2))))))))
 

`*`(`^`(2, `+`(`-`(`*`(2, `*`(_k2))), `-`(nu))), `*`(`^`(-1, _k2)))
 

Radicals are now typically combined by simplify: 

> simplify(`*`(sqrt(3), `*`(sqrt(2))))
 

`*`(`^`(6, `/`(1, 2)))
 

If appropriate conditions are satisfied, certain simplifications of floor, ceil, and round are applied: 

 

> `assuming`([simplify(`+`(floor(`+`(z, `/`(1, 2))), floor(z)))], [z::real])
 

floor(`+`(`*`(2, `*`(z))))
 

> `assuming`([simplify(`+`(round(z), `-`(floor(`+`(`*`(2, `*`(z)))))))], [(`+`(z, `-`(`/`(1, 2))))::(And(real, Not(negint)))])
 

`+`(`-`(floor(z)))
 

EllipticE(`^`(-1, n), x)now simplifies: 

> `assuming`([simplify(EllipticE(`^`(-1, n), x))], [n::integer])
 

`*`(`^`(-1, n), `*`(EllipticE(x)))
 

 

solve  

Description 

  • The solve command in Maple 2019 has undergone several improvements.
 

solve Examples 

Maple2019 solves equations with inequalities more carefully: 

> solve(`<=`(sqrt(x), 0))
 

0
 

> solve(`<=`(`+`(`-`(`/`(1, `*`(sqrt(x))))), 2))
 

RealRange(Open(0), infinity)
 

> [solve(`<=`(sqrt(x), `+`(`-`(`*`(`^`(y, 2))))), {x, y})]; 1
 

[{x = 0, y = 0}]
 

> solve({`<`(`/`(`*`(x, `*`(sqrt(`+`(x, 5)))), `*`(sqrt(`+`(x, 6)))), 0)}, {x}); 1
 

{`<`(x, -6)}, {`<`(-5, x), `<`(x, 0)}
 

 

Other Improvements 

Description 

  • There are other commands which have improved.
 

Other examples 

minimize can now solve this example: 

> minimize(`/`(`*`(`+`(`*`(`^`(x, 4)), `*`(`^`(y, 4)), `*`(`^`(z, 4)))), `*`(`+`(`*`(`^`(x, 2)), `*`(`^`(y, 2)), `*`(`^`(z, 2))))), x = -1 .. 1, y = -1 .. 1, z = -1 .. 1); 1
 

0
 

expand now takes into account more assumptions: 

> `assuming`([expand(`+`(`*`(`^`(`/`(`*`(c), `*`(`+`(c, `-`(1)))), m), `*`(`^`(`/`(`*`(`+`(c, `-`(1))), `*`(c)), m), `*`(`^`(c, m)))), `-`(`*`(`^`(`/`(`*`(`+`(c, `-`(1))), `*`(c)), m), `*`(`^`(c, m)))),...
 

0
 

floor and ceil now make better use of assumptions: 

> `assuming`([floor(w)], [`>=`(w, 0), `<`(w, `/`(1, 2))])
 

0
 

rationalize works better on certain examples of nested radicals: 

> rationalize(`/`(1, `*`(`^`(`/`(`*`(y), `*`(`^`(x, `/`(3, 2)))), `/`(7, 3))))); 1
 

`/`(`*`(`^`(`/`(`*`(y), `*`(`^`(x, `/`(3, 2)))), `/`(2, 3)), `*`(`^`(x, `/`(9, 2)))), `*`(`^`(y, 3)))
 

Expressions with nested calls to Re and Im now evaluate better: 

> Re(`+`(`*`(`^`(Re(x), 2)), Im(`*`(`^`(x, 2))))); 1
 

`+`(`*`(`^`(Re(x), 2)), Im(`*`(`^`(x, 2))))
 



Back to What's New Overview
Prêt(e) pour l'étape suivante ?
Discutez aujourd'hui avec nos spécialistes produits pour évaluation gratuite de Maple.

*Ce programme d'évaluation n'est proposé actuellement ni aux étudiants ni aux particuliers.


Achetez:

 

Licences mono-utilisateurs

Licences multi-utilisateurs

Effectuez la mise à jour vers Maple 2026