Commands

Command  Description  Example

restart

clear all Maple definitions

                                          restart:
with

load a Maple package  with( DEtools ); with( plots ):

help (also ?) display Maple on-line help

                                          ?DEplot
limit

calculate a limit  limit( sin(a*x)/x, x=0 );
diff

compute the derivative of an expression diff( a*x*exp(b*x^2)*cos(c*y), x )

int

definite or indefinite integration int( sqrt(x), x=0..Pi );

Limit

inert (unevaluated) form of limit              Limit( sin(a*x)/x, x=0 );
Diff

inert (unevaluated) form of diff               Diff( a*x*exp(b*x^2)*cos(c*y), x );
Int

inert (unevaluated) form of int                Int( sqrt(x), x=0..Pi );
value

evaluate an inert expression (typically used with Limit, Diff, or Int)

                                          G := Int( exp(-x^2), x );
                                          value( G );
plot

create a 2-dimensional plot of functions plot( u^3, u=0..1, title="cubic" );

                                          plot( [sin(x), cos(x)], x=0..Pi );
plot3d

create a 3-dimensional plot of functions  plot3d(sin(x)*cos(y),x=0..4*Pi,y=0..Pi);
display

display plot structures (in plots package)

                                          with( plots ):
                                          F:=plot( exp(x), x=0..3, style=line );
                                          G:=plot( 1/x, x=0..3, style=point );
                                          display( [F,G], title="2 curves" );
solve

solve equations or inequalities solve( x^4 - 5*x^2 + 6*x = 2, { x } );

fsolve

solve using floating-point arithmetic fsolve( t/10 + t*exp(-2*t) = 1, t );

dsolve

solve ordinary differential equations; see ?dsolve for a list of available options

                                          dsolve( diff(y(x),x)-y(x)=1, y(x) );
odeplot

create 2D and 3D plots from solutions obtained

by dsolve (with type=numeric);

see ?odeplot for more options (in plots package)

                                          with( plots ):
                                          S:=diff(x(t),t)=-y(t),diff(y(t),t)=x(t):
                                          IC:=x(0)=1,y(0)=1:
                                          P:=dsolve({S,IC}, {x(t),y(t)}, numeric):
                                          odeplot(P, [[t,x(t)],[t,y(t)]], 0..Pi);
                                          odeplot(P, [x(t),y(t)], 0..Pi);
DEplot

create plot associated with an ODE or system of ODEs; see ?DEplot for more information (in DEtools package)

                                          ODE := diff( y(x),x ) = 2*x*y(x);
                                          DEplot( ODE, [y(x)], x=-2..2,
                                                  y=-1..1, arrows=SMALL );
D

differential operator (often used when specifying derivative initial conditions for dsolve)

                                          ODE :=  diff(y(x),x$2) +y(x) = 1;
                                          IC := y(0)=1, D(y)(0)=1;
                                          dsolve( { ODE, IC }, y(x) );
subs

substitute values into an expression subs( x=r^(1/3), 3*x*ln(x^3) );

simplify

apply simplification rules to an expression simplify( exp( a+ln(b*exp(c)) ) );

factor

factor a polynomial  factor( (x^3-y^3)/(x^4-y^4) );
convert

convert an expression to a different form convert( x^3/(x^2-1), parfrac, x );

collect

collect coefficients of like powers collect( (x+1)^3*(x+2)^2, x );

rhs

right-hand side of an equation

                                          rhs( y = a*x^2 + b );
lhs

left-hand side of an equation

                                          lhs( y = a*x^2 + b );
numer

extract the numerator of an expression

                                          numer( (x+1)^3/(x+2)^2 );
denom

extract the denominator of an expression

                                          denom( (x+1)^3/(x+2)^2 );
evalf

evaluate using floating-point arithmetic evalf( exp( Pi^2 ) );

evalc

evaluate a complex-valued expression (returns a value in the form a+I*b)

                                          evalc( exp( alpha+I*omega ) );
evalb

evaluate a Boolean expression (returns true or false)

                                          evalb( evalf( exp(Pi) > Pi^exp(1) ) );
assign

perform assignments (often used after solve or dsolve)

                                          S:=solve( {x+y=1, 2*x+y=3}, {x,y} );
                                          assign( S ); x; y;
seq

create a sequence

                                          seq( [0,i], i=-3..3 );
for . . . while . . .
do . . . od

repetition statement; see do for syntax tot := 0;

                                          for i from 11 by 2 while i < 100 do
                                            tot := tot + i^2
                                          od;
assume

inform Maple of additional properties of objects

                                          assume( t>0 );
about

check assumptions on Maple objects

                                          about( t );