Maple has three major programming abilities. First off, it can export expressions for use in Fortran and C programs. It can also export expressions that can be used with the LaTeX and troff editors. Next, it can allow the user to read/write data, output, and worksheets. Lastly, it has a powerful internal programming language that can be used to create user specific functions, libraries and procedures.
Let us go ahead and define a fairly complicated expression:
> sample:=( Pi +
> ((x+9)/(sin(x) +y)) *
> ((3*cos(x+y)) / (sqrt(x+y) + y^(x-1))) -
> ((x+y)/Pi)^2);
2
(x + 9)cos(x + y) (x + y)
sample := Pi + 3------------------------------------ ---------
1/2 (x - 1) 2
(sin(x) + y) ((x + y) + y ) Pi
We can invoke both the Fortran and
C libraries with the
readlib command:
> readlib (fortran); proc(x) ... end > readlib(C); proc() ... end
And now we can produce code to calculate sample in both Fortran and C:
> fortran([a=sample],optimized);
t6 = x+y
t10 = y**(x-1)
t15 = t6**2
t16 = Pi**2
a = 0.3141593E1+3*(x+9)/(sin(x)+y)*cos(t6)/(sqrt(t6)+t10)-t15/t16
> C([a=sample], optimized);
t6 = x+y;
t8 = sqrt(t6);
t10 = pow(y,x-1.0);
t15 = t6*t6;
t16 = Pi*Pi;
a = 0.3141592653589793E1+3.0*(x+9.0)/(sin(x)+y)*cos(t6)/(t8+t10)-t15/t16;
We can export the expression as a LaTeX
expression and save it as the file
latex.out:
> latex(sample, 'latex.out');
\pi +{\frac {\left (3\,x+27\right
)\cos(x+y)}{\left (\sin(x)+y\right )
\left (\sqrt {x+y}+{y}^{x-1}\right )}}-{\frac
{\left (x+y\right )^{2}}
{{\pi }^{2}}}
And we can produce the expression for use with troff:
> eqn(sample);
2
(x + 9) cos(x +y) (x + y)
eqn(Pi + 3------------------------------------ ---------)
1/2 (x - 1) 2
(sin(x) + y) ((x + y) + y ) Pi
So far, you have notices that all of the
examples require you to type data and
expressions directly into Maple. It would be
nice if Maple could read and write data files.
Well, it can. Take a simple unformatted file
called datafile:
% cat datafile 18 74 56 75 9 8 45 23 90 28 28 9 84 37 58 49
Maple can read this data just fine:
> readlib(readdata);
proc(fname) ... end
> readdata(datafile, integer, 4);
[[18, 74, 56, 75], [9, 8, 45, 23], [90,28, 28, 9], [84, 37, 58, 49]]
Now we can place this data into a matrix, A, and transpose it:
> A := convert(",matrix);
[ 18 74 56 75 ]
[ ]
[ 9 8 45 23 ]
A := [ ]
[ 90 28 28 9 ]
[ ]
[ 84 37 58 49 ]
> At := linalg[transpose](A);
[ 18 9 90 84 ]
[ ]
[ 74 8 28 37 ]
At := [ ]
[ 56 45 28 58 ]
[ ]
[ 75 23 9 49 ]
We can now export this data as ASCII text:
> for i from 1 to 4 do > printf(`%d %d %d %d \n`, At[i,1], At[i,2], At[i,3], At[i,4] ); > od; 18 9 90 84 74 8 28 37 56 45 28 58 75 23 9 49
Maple also has the ability to save and restore
the entire session for later use. Maple files
are binary with a .m
extension. The save,
read, writeto, and
appendto commands are used.
We can go ahead and start using Maple and establish our worksheet.
> a:=Pi/2;
a := 1/2 Pi
> b:=9/5;
b := 9/5
> c:=a/b;
c := 5/18 Pi
When we are ready, just go ahead and save the worksheet. Note: The filename needs to be in the back-quote, not the apostrophe. The backquote is usually located below the tilde (~) on the keyboard.
save `maple_session.m`;
We can now quit Maple assured that the session is ready to start back up. Later, we can read the file:
read `maple_session.m`;
And everything is back to the way it was:
> evalf(c);
.8726646262
The writeto and
appendto commands are formatted the
same as the save and
read commands.
Writeto directs all Maple output
to a file instead of a terminal. If the file
already exists, Maple will overwrite that
file, essentially deleting all prior contents.
Appendto is similar to
writeto except that Maple will
now keep all previous file information and
append all new output to the end of the
desired file.
Maple has its own internal programming language. It is not the intent of this page to fully cover this language but rather to let you, the user, know that it is available. For more information on programming within Maple please see the references.
MapleÕs main method of custom programming is in the form of the procedure. A procedure is a series of commands and expression. Let us define a simple procedure that takes the square of a number and divides it by 2:
> sample := proc(x) (x^2)/2 end; sample := proc(x) 1/2*x^2 end
sample is now defined as a procedure. We can now use it anywhere we want:
> a:=sample;
a := sample
> b:=(sample/2);
b := 1/2 sample
> a(9);
81/2
> b(5);
25/4
Maple allows very complex programs, libraries, and protocols to be edited and utilized. Loops, If/Thens, etc are all ready to be added.
L O S A L A M O S N A T I O N A L L A B O R A T O R Y
Operated by the University of California for the U.S. Department of Energy