Several new system level procedures have been added.

The new function nprintf is like sprintf, but it returns a name instead of a string.

a := 5;

$a≔5$

nprintf( "The value of \"a\" is %d\n", a );

$\mathrm{The\; value\; of\; "a"\; is\; 5}$

sprintf( "The value of \"a\" is %d\n", a );

$''The\; value\; of\; "a"\; is\; 5''$

Use the procedure timelimit to limit the amount of CPU time spent on a computation.

f := proc(n::posint)
        local   i;
        for i from 1 to n do
                2^i;
        od;
end;

$f:=\mathbf{proc}\left(n::\mathrm{posint}\right)\mathbf{local}i\;\mathbf{for}i\mathbf{to}n\mathbf{do}2\^i\mathbf{end\; do}\mathbf{end\; proc}$

timelimit( 3, f( 10^6 ) );

Operating system environment variables (on platforms that have them) can be retrieved using the new procedure getenv.

getenv( "PATH" );

The current directory of the Maple process can be queried, or set (on platforms that support this), using the procedure currentdir.

currentdir( "/" ): # old working directory is returned

currentdir(); # print cwd

$''/''$

A new format %A has been added to printf.  It is essentially the same as the %a format except that backquotes are not put around names even though they might need it to be valid maple input.

The new type constructors And, Or, and Not allow you to construct new types from existing types by means of boolean combinations, or to test directly for boolean combinations of type.

type( Pi, 'And( constant, numeric )' );

$\mathrm{false}$

type( Pi, 'And( constant, Not( numeric ) )' );

$\mathrm{true}$

type( 3.14, 'And( constant, numeric )' );

$\mathrm{true}$

`type/stringythingy` := 'Or( string, name )';

$\mathrm{type/stringythingy}≔\mathrm{string}\vee \mathrm{name}$

type( `foo`, 'stringythingy' );

$\mathrm{true}$

type( "bar", 'stringythingy' );

$\mathrm{true}$

type( 27, 'stringythingy' );

$\mathrm{false}$

Use the new type arctrigh to test for an expression that is a call to an inverse hyperbolic function.

type( sin( x ), 'arctrigh' );

$\mathrm{false}$

type( arcsin( x ), 'arctrigh' );

$\mathrm{false}$

type( sinh( x ), 'arctrigh' );

$\mathrm{false}$

type( arcsinh( x ), 'arctrigh' );

$\mathrm{true}$

An optional additional argument allows you to check that the expression is an inverse hyperbolic function of some name.

type( arctanh( 2 * sin( x / y ) ), 'arctrigh( x )' );

$\mathrm{true}$

type( arctanh( 2 * sin( x / y ) ), 'arctrigh( t )' );

$\mathrm{false}$

An object is of type atomic if it is a string, fraction, integer, float, indexed or symbol. You can test for objects of type atomic as in the following examples.

type( 2, 'atomic' );

$\mathrm{true}$

type( a[i], 'atomic' );

$\mathrm{true}$

type( "a string", 'atomic' );

$\mathrm{true}$

type( ( x + y ) * z, 'atomic' );

$\mathrm{false}$

type( 2/3, 'atomic' );

$\mathrm{true}$

If evalf returns a number of the form a + b * I, with a and b floating point numbers, or if evalf returns infinity or -infinity, then the solution is of type complex constant, called complexcons.

type( -infinity, 'complexcons' );

$\mathrm{true}$

type( arcsinh( 1 + I ), 'And( complexcons, arctrigh )' );

$\mathrm{true}$

Arrays of hardware floating point numbers (hfarrays) are new in Maple V Release 5. They are of type hfarray.

a := hfarray( 0..2 );

$a≔\mathrm{Array}\left(0..2\,\left\{0=Float\left(\mathrm{undefined}\right)\,1=Float\left(\mathrm{undefined}\right)\,2=Float\left(\mathrm{undefined}\right)\right\}\,\mathrm{datatype}={\mathrm{float}}_8\,\mathrm{storage}=\mathrm{rectangular}\,\mathrm{order}=\mathrm{C\_order}\right)$

type( a, 'hfarray' );

$\mathrm{true}$

type( a, 'array' );

$\mathrm{false}$

Objects that are of type integer, fraction, float, or string are said to be of type literal. Type literal is now a valid Maple type.

type( "a short string", 'literal' );

$\mathrm{true}$

type( 1/5, 'literal' );

$\mathrm{true}$

type( M[2,3], 'literal' );

$\mathrm{false}$

An integer that is not positive, nonposint, is a new Maple type introduced in this release.

type( 2, 'nonposint' );

$\mathrm{false}$

type( 0, 'nonposint' );

$\mathrm{true}$

type( -1, 'nonposint' );

$\mathrm{true}$

type( -2/3, 'nonposint' );

$\mathrm{false}$

type( -infinity, 'nonposint' );

$\mathrm{false}$

type( infinity, 'nonposint' );

$\mathrm{false}$

procedure -- check for a procedure

range -- check for a range

A new type constructor, Range, allows you to construct a "type" that determines whether an object lies in a specified numeric range.

type( 2, 'Range( 1, 3 )' );

$\mathrm{true}$

type( 5, 'Range( 1, 3 )' );

$\mathrm{false}$

A number that is algebraic and is expressed as a Maple radical or using RootOf notation is of type radalgnum.

map( type, [ 2/7, evalf( Pi ), RootOf( x^2 + 1 ), RootOf( z^2 - x, z ) ], 'radalgnum' );

$\left[\mathrm{true}\,\mathrm{false}\,\mathrm{true}\,\mathrm{false}\right]$

You can test whether an expression is a radical algebraic function of its indeterminates, or of a specified set of indeterminates, using a type test against the type radalgfun.

The hyperbolic functions have been ascribed the Maple type trigh. The hyperbolic functions are sinh, cosh, tanh, sech, csch and coth.

type( sin( x ), 'trigh' );

$\mathrm{false}$

type( tanh( x ), 'trigh' );

$\mathrm{true}$

type( arcsech( coth( x ) ), 'trigh' );

$\mathrm{false}$

Use the new Maple type symbol to test whether an object is a symbol. A symbol is a name that is not of type indexed

There are several new types associated with the new Ore_algebra and Groebner packages: OreAlgebra, ClosedIdeal, CommAlgebra, ShortTermOrder, SkewParamAlgebra, SkewAlgebra, SkewPolynomial, TermOrder. Please see the corresponding help pages, and Ore Algebra example worksheets for further information.

Parser generated warnings now have line numbers.

Tracing of builtin functions is now fully implemented.

The tracelast command now gives line numbers (in a format that you can cut and paste to the stopat command).

The tracelast command will tell you where a computation was interrupted by the user.

New options for stoperror:

stoperror(interrupted); ,

stoperror("time expired"); ,

stoperror("assertion failed"); ,

stoperror(all); ,

stoperror("invalid argument"); .

Setting interface(warnlevel = 4) warns about lexically scoped variables.

The debugger has a where function that shows the call stack of a stopped procedure.

There is a new WARNING function that users can use to issue warnings in their own procedures.

f := proc(x::integer)
        if x < 0 then
                WARNING( sprintf( "negative argument passed to %s", procname ) );
        fi;
        2*x;
end:

f(1);

$2$

f(0);

$0$

f(-2);

Warning, negative argument passed to f

$\mathrm{-4}$

The new kernelopts(dagtag) option maps between internal data structure IDs and their names.

kernelopts( dagtag = PROC );

$32$

kernelopts( dagtag = 1 );

$\mathrm{INTNEG}$

seq( kernelopts( dagtag = i ), i = 1..46 );

$\mathrm{INTNEG},\mathrm{INTPOS},\mathrm{RATIONAL},\mathrm{FLOAT},\mathrm{STRING},\mathrm{NAME},\mathrm{TABLEREF},\mathrm{DCOLON},\mathrm{CATENATE},\mathrm{POWER},\mathrm{PROD},\mathrm{SERIES},\mathrm{SUM},\mathrm{FUNCTION},\mathrm{UNEVAL},\mathrm{EQUATION},\mathrm{INEQUAT},\mathrm{LESSEQ},\mathrm{LESSTHAN},\mathrm{AND},\mathrm{NOT},\mathrm{OR},\mathrm{EXPSEQ},\mathrm{LIST},\mathrm{LOCAL},\mathrm{PARAM},\mathrm{LEXICAL},\mathrm{PROC},\mathrm{RANGE},\mathrm{SET},\mathrm{TABLE},\mathrm{HFARRAY},\mathrm{ASSIGN},\mathrm{FOR},\mathrm{IF},\mathrm{READ},\mathrm{SAVE},\mathrm{STATSEQ},\mathrm{STOP},\mathrm{HASH},\mathrm{HASHTAB},\mathrm{GARBAGE},\mathrm{FOREIGN},\mathrm{CONTROL},\mathrm{PROMPT},\mathrm{DEBUG}$

A detailed account of the storage being used by objects of different types can be obtained using kernelopts(memusage).

The directory separator, as a string, used on the particular platform that Maple is running on, can be queried using kernelopts(dirsep).

The limits on cpu time, data and stack sizes that can be set through the command line can now be queried using kernelopts(cpulimit), kernelopts(datalimit), and kernelopts(stacklimit) respectively.

The new interface(errorcursor) controls how errors are indicated in the TTY version of Maple

The new interface(autoassign) variable controls whether the context-sensitive menus automatically generate an assignment for the results of a menu operation, and what variable name it uses if this feature is used.

Command completion has been reenabled (see editing, and the lib/cmds file).

Maple quits on reaching end of file. Use the -F option to recover the old behavior, which allows you to continue interactively after the end of the input file has been reached.

Input files can now be specified as command line arguments of the maple command. It is no longer necessary to write maple < file, using shell redirection. (See the man page.)

The help system in the TTY version now returns near-matches if an exact match was not found.

?evalfh

An alternate initialization file may be specified on the command line, using the new -i option.

For example, if you use the Korn shell, you can use the alias alias maplev5="maplev5 -i $HOME/.maplev5.init" to ensure that your new version of Maple uses the correct initialization file.

Karatsuba's algorithm is used for multiplying large integers.

Use of hardware floating point arrays (hfarrays) improves performance dramatically in some areas (such as plotting).

Profiling of the kernel has been done, and significant performance improvements were implemented as a result of finding some bottlenecks.