Using the same mechanism for calling C and Fortran programs, Maple can now call static functions in a JavaTM class. Declare the function and argument types in define_external the same way you would when calling C or Fortran procedures, plus add the keyword JAVA, CLASSPATH=, and CLASS= to fully specify your function.  Maple returns a procedure that automatically converts data into Java types and calls the Java function making it seem like the Java function was a built-in Maple procedure.

Maple repositories can now be uniquely named, and many can be saved in the same directory. Access to repositories is still controlled by the variable, libname, which can now specify either a directory, or an individual .lib file, or a mixture of both. The built-in march command lets you control the order of repositories in a directory by setting a priority attribute on the repositories. Libraries can also be marked as ``read-only''.

Two new procedures, isdir, and listdir, help users manage files in directories, by providing the ability to list the contents of a directory. When iterating through the contents of a directory, isdir() helps to distinguish between subdirectories and regular files.

The new kernel option pathsep, helps write code that makes use of explicit path names in a platform independent way. The kernel option datadir provides a standard location for system and user data.

kernelopts(opaquemodules=false) makes it easier to debug code that uses modules. The effect of this command is to make local members of a module accessible outside the module. Normally only exported module members are accessible outside the module in order to provide encapsulation and data hiding. During code development and debugging however, it is often convenient to be able to inspect local members as well.

The new Maple include file userinfo.mi is provided in this release. It defines the macros `UI_INFO', `UI_TRACE' and `UI_DEBUG'. These macro names define the standard information levels used in the library for userinfo messages.

Two new built-in procedures andmap and ormap have been implemented. They allow you to determine, respectively, whether a predicate holds for each, or for some member or operand of an expression.

andmap( isprime, { seq( i, i = 2 .. 19 ) } );

andmap( type, { seq( i, i = 2 .. 19 ) }, 'integer' );

ormap( isprime, { seq( i, i = 2 .. 19 ) } );

ormap( type, { seq( 2*i, i = 2 .. 19 ) }, 'odd' );

The member procedure now accepts functions as a second argument as well as sets, lists, and modules.

member(3, F(2, 3), 'p');

p;

The new membertype function behaves in a manner similar to the member function, except that the first argument is a type and it checks whether or not an object of the given type exists in the second argument.  If a match is found and a third argument is given, that argument must be a name, and the name is assigned the position of the first occurrence of an object of the given type in the second argument.

membertype(integer, F(a, b, 1/2, 3), 'p');

p;

membertype(fraction, [a, b, 1/2, 3], 'p');

p;

membertype(string, {a, b, 1/2, 3}, 'p');

The maptype function is similar to the map command, but takes an additional first argument that specifies a type. The expression  is equivalent to  when  is true, and is equal to  otherwise.

map( f, b*c );

maptype( `+`, f, b*c );

map( f, a + b*c );

maptype( `+`, f, a + b*c );

The new evalindets procedure is similar to subsindets, but uses the two-argument form of eval (evaluation at a point) in place of subs.

Maple's type system is now ``module-aware''. The old method of introducing new types by assigning a type definition to a name of the form `type/foo` (which defines the type `foo') is deprecated in favor of the new method that uses the new TypeTools package. See TypeTools and updates/Maple8/packages for more information about the TypeTools package.

To define a new type `foo' in Maple, use the procedure TypeTools:-AddType. It takes the name of the type as its first argument, and a type definition as the second argument. The type definition may be a structured type or a procedure that implements a predicate (returning either true or false).

The name of a type need not be global.

with( TypeTools );

AddType( 'oddprime', 'And( odd, prime )' );

type( 2, 'oddprime' );

type( 3, 'oddprime' );

type( 4, 'oddprime' );

m := module()
    export    oddprime, evenprime;
    local    deftypes;
    option package, load = deftypes;
    deftypes := proc()
        use TypeTools in
            AddType( evenprime, 2 );
            AddType( oddprime, proc( expr )
                    print("local oddprime");
                    expr <> 2 and type( expr, 'prime' )
                end )
        end use
    end proc;
    deftypes();
end module;

with( m );

GetTypes();

type( 2, 'oddprime' );

type( 3, 'oddprime' );

type( 3, ':-oddprime' );

type( 4, 'oddprime' );

andmap( type, [ 2, 3, 5, 7 ], 'oddprime' );

ormap( type, [ 2, 3, 5, 7 ], 'evenprime' );

andmap( type, [ 3, 5, 7 ], 'oddprime' );

As the examples above show, it is possible to shadow a global type name with a local type name using the new mechanism.

The older method of defining new types by means of symbol concatenation is still supported in this release.

A new type which determines whether or not the object can be assigned to using either the assignment operator or the assign function.

type(f(x), 'assignable');

type(f[x], 'assignable');

protect(f):

type(f[x], 'assignable');

unprotect(f):

type((f+g)[3], 'assignable');

The conversion convert,float now accepts an option that specifies the setting of digits at which the conversion is to take place.

convert(Pi, 'float');

convert(Pi, 'float', 3);

The new conversion convert,compose composes any number of conversions on the expression, applying them in order.

convert(sin(1), 'compose', 'list', 'float'(3));

convert([1, 2, exp(2)], 'compose', 'list', 'float'(4));

The new conversion convert/iupac converts from and to the atomic number of a chemical element of the Periodic Table, and its temporary IUPAC name or symbol.

convert(114, iupac);

convert(114, iupac, symbol);

See updates/Maple8/efficiency and convert/fullparfrac for information on efficiency improvements made in these conversions.

A major overhaul of the network of conversions among the elementary and basic special functions has been undertaken for this release. See updates,Maple8,symbolic for more information.

The routine ListTools,Enumerate converts the operands of a list into a list of pairs of the form , one for each expression  in the input list. The first entry pos of each pair is the position of expr in the list, while the second entry is the expression expr itself.

L := [a, b, c, d, e, f]:

ListTools[Enumerate](L);

ListTools[Enumerate](L, 0);

See updates/Maple8/packages