Addition, Subtraction, Multiplication, and Division

The symbols +, -, *, and /  are used for addition, subtraction, multiplication, and division, respectively.  Don't try any of these on your graphing calculator!

>	575754575849849885 + 748949854985944749598984;

>	87575750 - 4897475988744894574949;

>	6868868686 * 18234987271740;

>	996868686127325465986865000000000000 / 5000;

>

Each command has to end with a semi-colon  (or colon , if you don't wish to see the result).

>

Powers

Either ^  or **  can be used to raise a number to a power.

>	55757 ^ 22;

>

109 ** 5;

>

Exponentials are handled with the exp  command.

>

exp( 2 );

>

Euler's constant, , is obtained as

>

exp( 1 );

>

The Maple name for  is infinity .

>

infinity;

>

Palettes

Maple has three palettes  containing shortcuts to entering commands via the keyboard.  The Expression  palette can be used to compute powers, roots, elementary transcendental functions, limits, derivatives, and other basic calculus-based quantities. To open this palette, pull down the View  menu, choose Palettes  and then select Expression Palette . Drag the palette to a position where it does not interfere with the current worksheet. (You may also need to resize the Maple and/or worksheet window.)

To use the palette to enter a quantity like , position the cursor in an empty input region,

>

sqrt(%?);

click on the symbol  in the palette.  This produces sqrt( )   with the argument ( %? ) selected.  Type 390625  and then execute the group.  Your final input and output should appear as

>	sqrt(390625);

>

When a palette generates a template that involves more than one argument, the Tab  key can be used to move from one argument to the next. For example, to compute , use the  a / b button on the palette, enter 757555, press Tab , enter 5, then press Return  to obtain

>	((757555)/5);

>

Exact vs. Approximate Calculations

Maple is designed to provide exact answers to mathematical computations.

>	sqrt( 27 );

>

While the exact simplification in the previous example is useful, there are times when an exact answer is not helpful.  For example, the following rational number is returned unchanged because it is already in reduced form.

>

5899 / 7;

>

There are several ways to instruct Maple to produce an approximate value for this number.  Maple will display an answer as a floating point number if at least one number in the calculation is a floating point number (i.e., contains a decimal point).

>	5899. / 7;

>

The evalf  command can also be used to force Maple to eval uate using f loating point arithmetic

>	evalf( 5899 / 7 );

>

By default, Maple performs all floating point computations using 10 significant digits. The following command performs the same calculation except that only 5 significant digits are used in the calculations. (See also the online help for Digits .)

>	evalf[5]( 5899 / 7 );

>

Using Previous Results

The ditto operator   %  always represents the result of the last command executed by Maple.

>	625 / 125;

At this point, the most recent result computed is 5.  This can be squared with the command

>

% ^ 2;

It is permissible to include more than one command in a single input region.  For example,

>	sqrt( 23.1 ); 2 - 9;

In this case, the most recent result is -7.  The next most recent result can recalled with %% .

>	%%` ^ 2 + %;

>

Warning, incomplete quoted name;  use ` to end the name

The ditto operators should be used sparingly.  You should get in the habit of assigning results to explicit names.

>

Assignments

The Maple command for assigning a value to a name is the two-character sequence `` :=  ''.  The single character `` =  '' is used to form equations or to test for equality of two objects.  Names generally consist of a letter followed by one or more letters, numbers, and underscores.

The commands to assign x  the value 2 and y  the value 3 are

>

x := 2;

>

y := 3;

>

The name prod  will be assigned the product of x  and y  

>	prod := x * y;

>

From now on, the name prod  will be replaced with this value.  Thus,

>

prod;

>

and, if the value of x  is changed, the value of prod  is not affected

>	x := 9; prod;

>

The unassign  command removes assignments to the listed names; note that the single quotes are required to prevent Maple from evaluating these names to their assigned values. (To erase all  assignments, it is easier to use restart; .)

>	unassign( 'x', 'y', 'prod' );

>	x, y, prod;

>

Note that a different behavior is obtained if we define prod  as before, but before assigning values to x  and y ,

>	prod := x * y;

>

When values are assigned to x  and y , these values are used to compute the current value of prod .

>	x := 10; y :=  9; prod;

>

And, if one or both of x  and y  are changed, the value of prod  changes as well.

>	x := 3; prod;

>

The difference in these two examples is whether the names used in the definition of prod  have values at the time the assignment is made .

Suppressing Output

The last few examples have had more than one command in each input region.  In this example, multiple names receive values in a single assignment. In this case the result of this assignment is suppressed because the assignment command is terminated with a colon.

>	x, y := 90, 30: x; y; prod;

>

Built-In Commands and Constants

Maple commands consist of a string of letters (and numbers) followed by one or more arguments enclosed in round brackets (parentheses).  The evalf  and unassign  commands have already been encountered in this worksheet.  Here are a few more examples.

If  and  are integers, $    ..  returns the list of all integers from  to  inclusive.

>	nums := $ 1 .. 10;

>

If  represents a expression sequence of numbers, then min(     )  will return the smallest number in .

>	min( nums );

>

To find the smallest number in a set or list, the surrounding brackets must be eliminated to obtain an expression sequence.

>	L := [ 2, 3, 6 ];

>

min( L );

Error, (in simpl/min) arguments must be of type algebraic

>	min( L[] );

>

The following plot  command will plot the function   on the domain [    ,   ].

>	plot( cos(x) - x, x = -Pi .. 2*Pi );

>

In Maple, the equation  is represented exactly as we would write it by hand. Note the use of     =  to form an equation, not the assignment operator   :=  .  The following fsolve  command locates a solution to  near .

>	fsolve( cos(x) - x = 0, x = 0 .. 2 );

>

As mentioned previously, some Maple names are predefined to standard constants.  For example, Pi  is .  Recall that Euler's constant, , is obtained with exp(1) .

>	evalf( Pi ); evalf( exp(1) );

>	evalf( Pi^exp(1) ) < evalf( exp(Pi) );

The command for the square root of a number  is sqrt(x) .

>	sqrt( 4 );

>

Note that Maple has no trouble handling the square root of a negative number;   I  is the imaginary unit, i.e., .

>	sqrt( -4 );

>

Each of these quantities could also have been assembled using the expresssion palette.

Command Options

Many Maple commands, particularly the plotting commands, accept optional arguments for customizing the output.  For example, the option linestyle=3   plots the command using a dashed line.

>	plot( sin(x) + cos(2*x), x = 0 .. 4*Pi, linestyle = 3 );

>

In the next plot  command, two functions,  and    , are plotted simultaneously with the first function appearing as a dashed line and the second as a solid line. (Although it is not apparent in a hardcopy of this worksheet, Maple displays the first plot in red and the second in green.  The color=  option can be used to control the colors used in a plot.)

>	plot( [x^2, x^2*sin(x)^2], x = -5*Pi .. 5*Pi, linestyle = [ 1, 3 ] );

For a complete listing of the optional arguments for the plot  command, see the online help for plot,options .

>

Online Help

The Maple command for accessing information in the online help database is help(     ); , or the abbreviated form ? . The help information appears in a separate window within Maple.  While the help document appears to be very similar to a Maple worksheet, it is not possible to execute any commands that appear in a help document.  Commands in the Examples section of a help worksheet can be copied individually or in their entirety and pasted in worksheet. To return to an active worksheet, either close the help window or select the desired window in the list of windows under the Window  menu.

>	help( fsolve );

>	?plot,color

>

The Help  menu can also be used to browse the online help database. This is particularly powerful when you do not know the command name.  The New User's Tour  is particularly useful for new users.

>

Packages

In addition to the standard Maple functions available to you at the beginning of every Maple session, there are an ever-growing number of additional functions contained in packages  that must be loaded into the Maple session prior to their use.  The with  command is used to load a package.  Two of the more common packages for use in a Calculus course are the plots  and Student[Calculus1]  packages.

>	with( plots );

Warning, the name changecoords has been redefined

>	with( Student[Calculus1] );

>

The output of a successful with  command is the list of commands that have been added to Maple's repertoire. If this list is unwanted, use a colon to terminate the command.

One of the commands that is now defined is implicitplot .

>	implicitplot( x^2 + y^4 = y^2 - x,               x = -1.3 .. 0.3, y = -1.2 .. 1.2,               scaling=constrained );

The scaling=constrained  option instructs Maple to use the same scaling for each axis in the plot.

>

Creating Functions

Users can create their own Maple commands, including Maple implementations of mathematical functions. For example, the function  can be defined using

>	f := x -> x^2 * sin(x)^2;

>

The variable  is a dummy variable; it is replaced by whatever object appears as the first argument to f .

>

f( y );

>	f( fred );

>	f( Pi/2 );

>

Notice how Maple automatically simplifies the value of the function when possible.

To plot the function you can use either of the following commands

>	plot( f(x), x = -5*Pi .. 5*Pi );

>	plot( f, -5*Pi .. 5*Pi );

The plots are identical, except for the label on the horizontal axis.

>

The unapply  command provides a second way to define a Maple function.

>	g := unapply( abs(x^2-4), x );

>	plot( g, -3 .. 3 );

Notice that the output of the unapply  command uses the same arrow notation as was used to define f  above.  The main difference between the arrow operator and unapply  is that the argument to unapply  is evaluated before  the function is created.  In contrast, the right-hand side of the arrow operator is not evaluated .

>

Definitions

Two of the most important data structures in Maple are the list and set. A list  is an ordered expression sequence contained in square brackets, [     ] , and a set  is an unordered expression sequence contained in braces, {     } . (An expression sequence  is a comma-separated collection of numbers, names, equations, or other Maple objects.)

>	S := { 1, 3, 111 };

>	L := [ $ 6 .. 10 ];

>

Notice that the elements of a list or set can be any valid Maple object, including another list or set.

>	SS := { L, S };

>	LL := [ L, S ];

>

Look carefully at the previous results. Even though the only difference in the definition of LL  and SS  is the type of brackets, the order of the elements in SS  might appear in the opposite of the order in which they appeared in the definition. Recalling that the elements of a set are not ordered, this is not surprising. (It should also not be surprising to know that the order in which Maple displays the elements of a set can change from one session to another.)

Creating Lists and Sets

Except for the surrounding brackets, lists and sets are created in exactly the same ways. We have already seen how to create lists and sets from explicit collections of numbers and with the repetition command ( $  ). The seq  and map  command provide two additional methods for creating lists and sets.

The seq  command generates an expression sequence consisting of terms formed from the first argument for each value of the second argument. For example, the squares of the first ten positive integers is

>	pts := [ seq( i^2, i = 1 .. 10 ) ];

>

This list could also be created using $  as

>	[ i^2 $ i = 1 .. 10 ];

>

To plot a list of values  against their index in the set, use the listplot  command from the plots  package. The style=point  optional argument instructs Maple to display discrete points (not connected), symbol=cross  sets the plot symbol (the default is a diamond), and symbolsize=20  sests the size of the symbols (in points; the default is 10).

>	listplot( pts, style=point, symbol=cross, symbolsize=20);

>

A list of 101 points  on the polar curve  is constructed and displayed next.  The list is not displayed as it is quite lengthy.  Because the list elements include both the - and -coordinates, the plot  command can be used.

>	r := t -> sin(2*t):

>	rose4 := [ seq( [r(t*Pi/50)*cos(t*Pi/50), r(t*Pi/50)*sin(t*Pi/50)],                 t = 0..100 ) ]:

>	plot( rose4 );

>

The same plot could also have been created directly with any of the following variations of the plot  command.

>	listplot( rose4 ):

>	plot( [ r(t) * cos(t), r(t) * sin(t), t = 0 .. 2*Pi ] ):

>	plot( r(t), t = 0 .. 2*Pi, coords=polar ):

>

The last two commands show to create the graph of a parametric curve (C: ,  for  in ) and how to plot a polar function by specifying only the radius function and the range for the polar angle.

>

Extracting Elements of a List or Set

Much more than plotting can be done with a list or set. The third element of the list pts  can be accessed as

>

pts[3];

>

Notice that it does not make sense to talk about the third element of a set. While Maple will not object to this, you should not expect to receive the same result every time the command is executed. The select  and remove  commands are designed to extract elements of a set that meet certain criteria. For example, the subset of S  containing all elements that are in the open interval ( -10, 10 ) can be found as follows. (The evalb  command returns either  or  (or ) indicating the Boolean value of its argument.)

>

S;

>	select( x -> evalb( abs( x - 10 ) < 20 ), S );

>

The number of elements in a list or set can be determined with the nops  command.

>	nops( rose4 );

>

Recall that each element of rose4  is an ordered pair -- actually, a two-element list.

>	rose4[ 10 ];

>

A floating-point approximation to this point is

>	evalf( % );

>

The -coordinate of the tenth element of the list is

>	rose4[ 10, 2 ];

>

Negative indices can be used to reference elements relative to the end of the list. The last point in rose4  is

>	rose4[ -1 ] = rose4[ nops(rose4) ];

>

The first ten elements of rose for can be specified using rose4[ 1 .. 10 ] . The floating point approximations to the -coordinates of each of these points can be obtained with

>	seq( evalf(p[1]), p = rose4[ 1 .. 10 ] );

>

Sets can also be manipulated using the standard set operators: union , intersect , and minus .  Each of these commands can be used both as an infix operator, following standard mathematical notation, or as a prefix operator, which looks more program-like.

>	word := { "to", "too", "two" }; num := { "one", "two", "three", "four" };

>	word union num;

>	`union`(word, num);

>	word intersect num;

>	num minus word;

The quotes on the command in the prefix form of the commands are required (to delay evaluation). The prefix forms of union  and intersect  can accept any number of sets.

>

Extracting Solutions to an Equation

When Maple finds the solution to an equation or system of equations, the output will be displayed as an expression sequence. You will often want to convert this to a list or set by inserting the appropriate brackets around the solve  (or fsolve ) command.

>	sol := [ fsolve( x^2 = 3, {x} ) ];

>

sol[ 1 ];

>

Approximations to the four solutions to the quartic polynomial equation  can be found, as a set, using

>	realsol := { fsolve( x^4 - 3*x^2 + x = 0, x ) };

>

In general, fsolve  returns at most one (real) solution.  For a polynomial, all real valued solutions are returned.  To obtain complex-valued solution, add complex  as an optional argument.

>	complexsol := { fsolve( x^4 - 3*x^2 + x = 4, x, complex ) };

>

Any individual solution can be obtained as above, but the result would depend on the order of the elements in a set -- which is unpredicable.

>	realsol[3];

>

The largest element of a set can be found using

>	max( realsol[] );

>

The absolute value of each solution can be obtained using

>	map( abs, complexsol );

>

To sort the four real roots in increasing order, re-express the solutions as a list and then call the sort  command

>	realsol2 := convert( realsol, list );

>	sort( realsol2 );

>

To sort the solutions by other orderings, e.g., the magnitude of the solutions, a user-defined ordering can be specified as the second argument to the sort  command

>	sort( realsol2, (a,b) -> evalb( abs(a) < abs(b) ) );

>

To conclude this discussion, consider the system of equations that describes the set of all points on the unit circle, , and the line, .

>	eq1 := x^2 + y^2 = 1; eq2 := x + 2*y = 1;

>

The system of equations and variables are each specified as sets that, when fed to the solve  command, show two solutions

>	syssol := [ solve( { eq1, eq2 }, { x, y } ) ];

>

Each solution is a set of equations giving the x - and y -coordinates of a point on both curves. Note that the order of the equations within each solution may not be consistent. These solutions can be converted to ordered pairs using

>	syspts := seq( eval( [x,y], pt ), pt = syssol );

>

The two curves involved in this problem can be plotted with the implicitplot  command from the plots  package. The two solutions can be plotted using plot  with style=point .  The display  command (also from the plots  package) can be used to display the information in both plots in a single plot.  The output from the plot-creating commands in the definition of p1  and p2  is the corresponding ``plot data structure'', not a graphical object. (If you really want to see this, change the colons to semi-colons.)

>	p1 := implicitplot( { eq1, eq2 }, x = -2 .. 2, y = -2 .. 2,                     scaling=constrained ): p2 := plot( [ syspts ], style=point, color=black, symbol=circle,             symbolsize=30 ): display( [ p1, p2 ] );

Note that the implicitplot  command cannot accept a list as its first argument.  This inconsistency with the other plot commands is corrected in Maple 9.

>

Using a Command That Is Not Known by the Maple Kernel

Some commands are defined as part of a package  that is not automatically loaded into the Maple kernel.  If one of these commands is used prior to loading the package, the output will simply echo the input after the arguments have been simplified (if possible). For example,

>

restart;

>	completesquare( x^2 + 2*x + 2 );

>	with( student );

>	completesquare( x^2 + 2*x + 2 );

>

Using Reserved Words and Protected Names

Maple places relatively few restrictions on the names that can be used for objects.  When such a name is used, Maple generates an appropriate error message.

>	union := {1,2,3};

Error, reserved words `union` or `minus` unexpected

>	Pi := 22/7;

Error, attempting to assign to `Pi` which is protected

>

Be forewarned, however, that if a value is assigned to a name that is also a Maple command, then the new assignment overwrites the command definition.  This feature can be used --- by knowledgeable and brave users --- to extend or customize the functionality of some of Maple's built-in commands.

>

Limits

>

restart;

The Maple command to compute  is limit ( f(x), x=a ); .

>	limit( sin(x)/x, x=0 );

>	limit( (1+x)^(1/x), x=0 );

>

To obtain a limit at , use infinity .

>	limit( (1+x/n)^n, n=infinity );

>

Right- or left-hand limits are returned when the (optional) third argument is right  or left , respectively.

>	limit( tan(x), x=Pi/2 );

>	limit( tan(x), x=Pi/2, right );

>	limit( tan(x), x=Pi/2, left );

>

Derivatives and Tangent Lines

>

restart;

Given a function f, the slope of the secant lines through ( ,  ) and ( ,  ) is the difference quotient. As  approaches 0, these quantities become the slope of the tangent line at ( ,  ). The slope of the secant line can be obtained with the Maple command

>	m[secant] := (f(x+h) - f(x) ) / h;

>

In practice, it is often necessary to use the simplify command to force Maple to simplify  the difference quotient. For example,

>	f := x -> x^3 - 3*x^2 - 4;

>	m[secant];

>	simplify( m[secant] );

>	m[tangent] := limit( m[secant], h=0 );

>

The Tangent  command from the Student[Calculus1]  package provides a simple means to display a function and the tangent line at a point.

>	with( Student[Calculus1] );

>	Tangent( f(x), x=1, output=plot );

>

The equation of this tangent line is obtained by changing the third argument to output=line .

>	Tangent( f(x), x=1, output=line );

Applications of Derivatives

Definite, Indefinite, and Improper Integrals

>

restart;

The int  command is used to compute integrals in Maple. The indefinite integral  is obtained with the command

>	int( ln(x), x ) + C;

>

Note that it is necessary to explicitly include the constant of integration, .

If additional information is given, it should be possible to determine a specific value for . For example, Maple can be used to find the function that satisfies the initial value problem

 y'(x) =
   

First, find the antiderivative (don't forget to include the constant of integration)

>	eq1 := y = int( 5*exp(-3*x), x ) + C;

>

To determine the appropriate value of , apply the initial condition

>	eq2 := eval( eq1, { y=-10, x=0 } );

>

and solve for  

>	eq3 := C = solve( eq2, C );

>

The solution to the initial value problem is

>	eval( eq1, eq3 );

>

The Student[Calculus1]  package contains a number of commands for the visualization and estimation of Riemann sums.

>	with( Student[Calculus1] ):

>

To illustrate, consider the problem of approximating the value of . Let

>	f := x^3 + 1;

>

The midpoint approximation to this integral with 6 subdivisions is the area of the rectangles displayed with the ApproximateInt  command

>	ApproximateInt(f, x=1..2, method=midpoint, partition=6, output=plot);

Observe that this plot displays the value of the corresponding Riemann sum (4.73958332) and the value of the definite integral (4.75).  The explicit Riemann sum for this example can be obtained with

>	ApproximateInt(f, x=1..2, method=midpoint, partition=6, output=sum);

The value of this Riemann sum can be obtained as either

>	value( % );

or

>	ApproximateInt( f, x=1..2, method=midpoint, partition=6 );

The floating-point approximation to this value is

>	evalf( % );

>

An animation showing the convergence of a Riemann sum, or other quadrature method, can be obtained as follows:

>	ApproximateInt( f, x=1..2, output=animation,                 method=random, subpartition=all, refinement=random,                 partition=2, iterations=8 );

>

For other Riemann sums, change the method  option to right , left , random , upper , lower , or random .  For the Trapezoidal and Simpson's Rules,  use method=trapezoid  or method=simpson , respectively.

>	ApproximateInt(f, x=1..2, method=trapezoid, partition=4, output=plot);

>

The exact value of the definite integral is

>	int( f, x = 1 .. 2 );

>	evalf( % );

>

Applications of Integrals