The type function can be used to code a routine that does
different things depending on the type of the input.
For example, the DIFF routine below differentiates expressions
which are polynomials in the given variable .
DIFF := proc(a:algebraic,x:name) local u,v;
if type(a,numeric) then 0
elif type(a,name) then if a = x then 1 else 0 fi
elif type(a,`+`) then map( DIFF, a, x )
elif type(a,`*`) then u := op(1,a); v := a/u; DIFF(u,x)*v + DIFF(v,x)*u
elif type(a,anything^integer) then
u := op(1,a); v := op(2,a); v*DIFF(u,x)*u^(v-1)
else ERROR(`don't know how to differentiate`,a)
fi
end;
Types are used in the DIFF procedure for two different purposes. The first usage is for type checking. The inputs must be an algebraic expression or a formula, and a name for the differentiation variable. The second usage is to examine the type of the input - is it a sum or product - and decide what differentiation rule is to be used. The DIFF example shows the use of the map function, a very useful function, which we will now explain. It has the following syntax
map( ,
,
, ...,
)
The meaning is to apply the function to the operands of the expression
passing the additional arguments
, ...,
to
.
In our DIFF procedure, there is one additional argument x.
Often, there are no additional arguments.
Formally, this is equivalent to computing the sequence
seq( f( op(1,a), x1, ..., xn ), i=1..nops(a) );
and then creating from this sequence a value of the same type as the type of .
Here are some examples
=-1.00.5plus##1`##1=12=^^M=12 > p := x^3+2*x+1; 3 p := x + 2 x + 1
> map( F, p ); 3 F(x ) + F(2 x) + F(1)
> map( x -> x^2, p ); 6 2 x + 4 x + 1
> map( degree, p, x ); 4
plusplus -100 plus The DIFF function also shows the use of a structured type. The types anything, name, `+` and `*` are simple types. The type anything^integer is a structured type. It means that the value must be a power, and the base can be anything, i.e. any type, but the exponent must be an integer. It is equivalent to writing
if type(a,`^`) and type(op(2,a),integer) then
Structured types allow you to replace long type tests with concise tests. Let us illustrate another common case. Many routines take a set or list of names or equations as arguments. For example, the solve command allows one to solve a set of equations for a set of unknowns. For example
=-1.00.5plus##1`##1=12=^^M=12 > solve( x+y=2, x-y=3, x,y );
y = -1/2, x = 5/2
plusplus -100 plus A set of zero or more equations can be tested with the type: set(equation), and as set of zero or more unknowns with the type set(name). But the solve command also allows a set of algebraic formulae which are implicitly equated to zero, i.e. the example above could have been input this way
=-1.00.5plus##1`##1=12=^^M=12 > solve( x+y-2, x-y-3, x,y );
y = -1/2, x = 5/2
plusplus -100 plus Hence the type should of the first argument should be either a set of equations, or a set of algebraic expressions, i.e. the type {set(algebraic),set(equation)}. Notice that this is not the same as set({algebraic,equation}). Why?
Further information about the various different types can be obtained from the on-line help system under ?type .