The Maple debugger provides a full set of debugging facilities including watchpoints, breakpoints, and single-step, trace-back (immediately) after an error condition.

f:=proc(x) g(x+1) end: g:=proc(x) 1/x end: f(-1);

Error, (in g) numeric exception: division by zero

tracelast;

 f called with arguments: -1
 #(f,1): g(x+1)

 g called with arguments: 0
 #(g,1): 1/x

Error, (in g) numeric exception: division by zero

An extensive I/O library with a complete suite of functions including

A new function writedata() serves as a complement to readdata. The function readdata() can take a file descriptor.

The routine setattribute allows users to assign an attribute to an expression. Attributes can be queried using attributes.

setattribute(Rose, pink); attributes(Rose);

$\mathrm{Rose}$

$\mathrm{pink}$

L:=setattribute( [ Rose, Candy], pink ); attributes(L);

$L≔\left[\mathrm{Rose}\,\mathrm{Candy}\right]$

$\mathrm{pink}$

A new type matching facility, typematch, simplifies Maple coding.

typematch( x^3,  c::(a::name ^ b::integer) );

$\mathrm{true}$

printf(`a=%a, b=%a, c=%a \n`,a, b, c );

a=x, b=3, c=x^3

a := 'a': b := 'b': c := 'c':

A name as the third argument gets a replacement list (instead of doing the assignments).

typematch( x^3, c::(a::name ^ b::integer), 's'); s;

$\mathrm{true}$

$\left[a=x\,b=3\,c=x^3\right]$

evaln: evaluate the argument to a name.

f:=proc(x::evaln) print(x) end:  y:=3; f(y), f( y[y] );

$y≔3$

$y$

$y_3$

uneval: do not evaluate the argument.

g:=proc(x::uneval) print(x) end: g(y), g(y[y]), g(diff(x^25,x));

$y$

$y_y$

$\frac{\ⅆ}{\ⅆx}\left(x^{25}\right)$

Compare this behavior with the normal evaluation:

h:=proc(x) print(x) end: h(y), h(y[y]), h(diff(x^25,x));

$3$

$3_3$

$25x^{24}$

y:='y':

New types:

type[linear], type[quadratic], type[cubic], type[quartic].

type(x^4+y, quartic(x));

$\mathrm{true}$

There is a new substitution facility algsubs  which is more general than the present subs command.

algsubs( x+y=5, x+y+z );

$5+z$

Complete Fortran and C subroutines from Maple procedures. For C, the ansi form can be requested.

readlib(C):

Error, could not find `C` in the library

a :=proc(x) local y; y:=x+5; y:=sin(y)+3 end:

C(a);

$C\left(a\right)$

fortran(a);

$\mathrm{fortran}\left(a\right)$

See fortran[procedure] and C[procedure].

The function ASSERT is used to guarantee pre- and post-conditions while a Maple procedure is executing.

$\mathrm{kernelopts}\left(\mathrm{ASSERT}=\mathrm{true}\right)$

$\mathrm{false}$

$\mathrm{ASSERT}\left(2+2=5\,\mathrm{`wrong\; addition`}\right)$

Error, assertion failed, wrong addition

$\mathrm{kernelopts}\left(\mathrm{ASSERT}=\mathrm{false}\right)$

$\mathrm{true}$

$\mathrm{ASSERT}\left(2+2=5\,\mathrm{`wrong\; addition`}\right)$

The add function is used to add up an explicit sequence of values. The mul function computes a product of an explicit sequence of values. Although one can use the for-loop statement to obtain the same effect, add/mul are generally more efficient than the for-loop versions because the for-loop versions construct many intermediate sums and products.

L := [seq(i, i=1..5)]:

mul( x-i, i=L );

$\left(x-1\right)\left(x-2\right)\left(x-3\right)\left(x-4\right)\left(x-5\right)$

add( a[i]*x^i, i=0..5 );

$a_5{x}^5+a_4{x}^4+a_3{x}^3+a_2{x}^2+a_{1}x+a_0$

map2 is a map() function that expands on the second argument.

map2(op,1, [ x^3, y=z] );

$\left[x\,y\right]$

The routine dismantle displays internal representation of data structures.

readlib(dismantle)( [ 1, x+3, y^x ] );

LIST(2)
   EXPSEQ(4)
      INTPOS(2): 1
      SUM(5)
         NAME(4): x
         INTPOS(2): 1
         INTPOS(2): 3
         INTPOS(2): 1
      POWER(3)
         NAME(4): y
         NAME(4): x

Various routines to support the recording and analysis of runtime information are provided: profile, showprofile, exprofile, unprofile, excallgraph.

readlib(profile):

fib:=proc(n) option remember; if n<2 then n else fib(n-1)+fib(n-2) fi;end:

profile(fib);

fib(5);

$5$

showprofile(fib);

function           depth    calls     time    time%         bytes   bytes%
---------------------------------------------------------------------------
fib                    5        9    0.000     0.00          6224   100.00
---------------------------------------------------------------------------
total:                 5        9    0.000     0.00          6224   100.00

maplemint generates semantic information for a procedure and also checks for sections of code which can never be executed.

readlib(maplemint):

a:=proc()
   local b; global c;
   if (b=5) then
   b:=6;
   RETURN(true);
   lprint(`test`);
   fi;
end:

maplemint(a);

Procedure a()
  These names were used as global names but were not declared:  test
  These global variables were declared, but never used:  c
  These local variables were used before they were assigned a value:  b
  There is unreachable code following a RETURN or return statement at
      statement 4: lprint(test)

hasfun tests an expression for a specified function:

e := sin(x)+exp(y)+1;

$e≔\sin \left(x\right)+{\&ExponentialE;}^y+1$

hasfun(e,exp);

$\mathrm{true}$

hasfun(e,{sin,cos},x);

$\mathrm{true}$

hasoption selects an option from a list or set of options:

Options := [title=sin(w*x), numpoints=99, style=POINT];

$\mathrm{Options}≔\left[\mathrm{title}=\sin \left(wx\right)\&comma;\mathrm{numpoints}=99\&comma;\mathrm{style}=\mathrm{POINT}\right]$

hasoption( Options, style, 's', 'Options' );

$\mathrm{true}$

s; Options;

$\mathrm{POINT}$

$\left[\mathrm{title}=\sin \left(wx\right)\&comma;\mathrm{numpoints}=99\right]$

applyop applies a function to specified operand(s) of an expression:

e := (z+1)*ln(z*(z^2-2));

$e≔\left(z+1\right)\ln \left(z\left(z^2-2\right)\right)$

applyop(expand,2,e);

$\left(z+1\right)\ln \left(z\left(z^2-2\right)\right)$

applyop(expand,[2,1],e);

$\left(z+1\right)\ln \left(z^3-2z\right)$

depends checks for mathematical dependence:

restart;

depends(sin(x)+cos(z),{x,y});

$\mathrm{true}$

depends(int(f(x),x=a..b),x);

$\mathrm{false}$

remove:

The command remove does the opposite of select. It removes items from a list, set, sum, product, or function according to a boolean value.

integers := [$10..20]:

select(isprime, integers);

$\left[11\&comma;13\&comma;17\&comma;19\right]$

remove(isprime, integers);

$\left[10\&comma;12\&comma;14\&comma;15\&comma;16\&comma;18\&comma;20\right]$

ispoly is a predicate function for testing and picking apart polynomials:

ispoly( 3*x^2-11*x+5, quadratic,x, 't0','t1','t2'); t0,t1,t2;

$\mathrm{true}$

$5,\mathrm{-11},3$

coeff:

coeff(a,x,i); where a is a polynomial in x works without the need of using collect.

coeff( (1+x+x^2)^100000, x, 5 );

$83341666458332500020000$

Remember tables of functions can be printed together with the functions:

interface(verboseproc=3):

fib:=proc(n::nonnegint) option remember;
   if n=1 or n=0 then 1 else fib(n-1)+fib(n-2) fi end:

fib(5);

$8$

print(fib);

$\mathbf{proc}\left(n::\mathrm{nonnegint}\right)\mathbf{option}\mathrm{remember}\&semi;\mathbf{if}n\&equals;1\mathbf{or}n\&equals;0\mathbf{then}1\mathbf{else}\mathrm{fib}\left(n-1\right)\&plus;\mathrm{fib}\left(n-2\right)\mathbf{end\; if}\mathbf{end\; proc}\text{\#(0) = 1}\text{\#(1) = 1}\text{\#(2) = 2}\text{\#(3) = 3}\text{\#(4) = 5}\text{\#(5) = 8}$

:: (new) binding operator, which binds variables to the matched components in type tests, and in parameter declaration.

The <> operator is now user definable; <|> and <||> are now removed.

<> gets transformed upon entry to a call to the anglebracket() function.

restart;

anglebracket:=proc() f([ args ]) end: <x,y,z,t>;

$\left[\begin{array}{c}x\\ y\\ z\\ t\end{array}\right]$

Selection operation l[i..j] where l is a list (set) now returns a list (set).

l := [1,3,5,7,9];

$l≔\left[1\&comma;3\&comma;5\&comma;7\&comma;9\right]$

l[1..3];

$\left[1\&comma;3\&comma;5\right]$

Negative selectors can now be used. The -1th element is the last, the -2th the second last, and so on:

l[-2];

$7$

Extraction of operands from an expression (op):  if the first argument to op is a list, the elements of the list refer to a sub-operand of the input at the increasing levels of nesting:

w := f(g(a,b),h(c,d));

$w≔f\left(g\left(a\&comma;b\right)\&comma;h\left(c\&comma;d\right)\right)$

op([2,1],w) = op(1, op(2, w) );

$c=c$

op([-1,-1],w);

$d$

Similarly for subsop:

p := f(x,g(x,y,z),x);

$p≔f\left(x\&comma;g\left(x\&comma;y\&comma;z\right)\&comma;x\right)$

subsop( [2,3]=w, p );

$f\left(x\&comma;g\left(x\&comma;y\&comma;f\left(g\left(a\&comma;b\right)\&comma;h\left(c\&comma;d\right)\right)\right)\&comma;x\right)$

subsop( [2,0]=h, [2,3]=w, 3=a, p );

$f\left(x\&comma;h\left(x\&comma;y\&comma;f\left(g\left(a\&comma;b\right)\&comma;h\left(c\&comma;d\right)\right)\right)\&comma;a\right)$