QQ登录

只需要一步,快速开始

 注册地址  找回密码
查看: 16984|回复: 7
打印 上一主题 下一主题

maple基础

[复制链接]
字体大小: 正常 放大

1

主题

5

听众

4

积分

升级  80%

该用户从未签到

自我介绍
爱学习
跳转到指定楼层
1#
发表于 2012-6-12 16:53 |只看该作者 |正序浏览
|招呼Ta 关注Ta

# r# j+ }: W$ o# Y' b) o6 ?! D第一章  Maple基础+ k) W4 @" S5 y7 H6 _# q# T

, g$ g( B; u" p4 w8 C0 k1 初识计算机代数系统Maple, m! \; j0 ?- S+ B7 }8 d
1.1 Maple简说, l( \0 t" O2 F6 R1 h
1980年9月, 加拿大Waterloo大学的符号计算机研究小组成立, 开始了符号计算在计算机上实现的研究项目, 数学软件Maple是这个项目的产品. 目前, 这仍是一个正在研究的项目. & C/ Z  U# ]/ |, j& r4 R
Maple的第一个商业版本是1985年出版的. 随后几经更新, 到1992年, Windows系统下的Maple 2面世后, Maple被广泛地使用, 得到越来越多的用户. 特别是1994年, Maple 3出版后, 兴起了Maple热. 1996年初, Maple 4问世, 1998年初, Maple 5正式发行. 目前广泛流行的是Maple 7以及2002年5月面市的Maple 8.
3 k9 H4 r' P/ l0 r3 CMaple是一个具有强大符号运算能力、数值计算能力、图形处理能力的交互式计算机代数系统(Computer Algebra System). 它可以借助键盘和显示器代替原来的笔和纸进行各种科学计算、数学推理、猜想的证明以及智能化文字处理.
- Y- ?. s% [+ m- E* CMaple这个超强数学工具不仅适合数学家、物理学家、工程师, 还适合化学家、生物学家和社会学家, 总之, 它适合于所有需要科学计算的人. 1 D" n! x# t. L4 F7 u+ [3 I
1.2 Maple结构; {: c$ f  ~' V
Maple软件主要由三个部分组成: 用户界面(Iris)、代数运算器(Kernel)、外部函数库(External library). 用户界面和代数运算器是用C语言写成的, 只占整个软件的一小部分, 当系统启动时, 即被装入, 主要负责输入命令和算式的初步处理、显示结果、函数图象的显示等. 代数运算器负责输入的编译、基本的代数运算(如有理数运算、初等代数运算等)以及内存的管理. Maple的大部分数学函数和过程是用Maple自身的语言写成的, 存于外部函数库中. 当一个函数被调用时, 在多数情况下, Maple会自动将该函数的过程调入内存, 一些不常用的函数才需要用户自己调入, 如线性代数包、统计包等, 这使得Maple在资源的利用上具有很大的优势, 只有最有用的东西才留驻内存, 这保证了Maple可以在较小内存的计算机上正常运行. 用户可以查看Maple的非内存函数的源程序, 也可以将自己编的函数、过程加到Maple的程序库中, 或建立自己的函数库.
& D: G8 ^* H) V" F4 g: @1.3 Maple输入输出方式; l) B$ G1 R2 Y, @6 v
为了满足不同用户的需要, Maple可以更换输入输出格式: 从菜单“Options | Input Display和Out Display下可以选择所需的输入输出格式. 9 a7 n; c* V" Q% }# ?3 Z
Maple 7有2种输入方式: Maple语言(Maple Notation)和标准数学记法(Standard Math Notation). Maple语言是一种结构良好、方便实用的内建高级语言, 它的语法和Pascal或C有一定程度的相似, 但有很大差别. 它支持多种数据操作命令, 如函数、序列、集合、列表、数组、表, 还包含许多数据操作命令, 如类型检验、选择、组合等. 标准数学记法就是我们常用的数学语言. 7 k6 F  C' n3 @, y
启动Maple, 会出现新建文档中的“[>”提示符, 这是Maple中可执行块的标志, 在“>”后即可输入命令, 结束用“;”(显示输出结果)或者“:”(不显示输出结果). 但是, 值得注意的是, 并不是说Maple的每一行只能执行一句命令, 而是在一个完整的可执行块中健入回车之后, Maple会执行当前执行块中所有命令(可以是若干条命令或者是一段程序). 如果要输入的命令很长, 不能在一行输完, 可以换行输入, 此时换行命令用“shift+Enter”组合键, 而在最后一行加入结束标志“;”或“:”, 也可在非末行尾加符号“\”完成. # E% L/ T$ n" b, q4 _. |+ H8 K
Maple 7有4种输出方式: Maple语言、格式化文本(Character Notation)、固定格式记法(Typeset Notation)、标准数学记法(Standard Math Notation). 通常采用标准数学记法. 0 ^1 P) V3 q# \; i
Maple会认识一些输入的变量名称, 如希腊字母等. 为了使用方便, 现将希腊字母表罗列如下,输入时只需录入相应的英文,要输入大写希腊字母, 只需把英文首字母大写:   
2 \; {7 w: y0 P/ y
7 L# b6 I2 {/ `( j
( n/ g) }2 R1 g* ^& Q 6 X% `' c+ _* r" }& g2 }# @9 H
) C: t" k, U$ B, p7 ]% J+ z' w

9 Y5 p& J2 W. Q
. Y* K/ D( G. t' |7 h9 K
; |7 ~4 k4 {6 X; u9 m. m ( i4 K" k' N6 P9 }

3 }+ T0 U0 ^1 A3 f( W; _5 ^
( Y' ^# m- q. I% l3 `" B- F # \5 H  ^' w9 [+ d8 T1 j
, ~. s, @) S+ _

/ I. z  S" L, U) h" f4 k* a* dalpha        beta        gamma        delta        epsilon        zeta        eta        theta        iota        kappa        lambda        mu* l$ b+ q) S) l! p7 ]+ \1 V- n
7 b3 h6 H" R# P. r9 r
1 h. ]6 w" p$ `8 F

. r; p9 }9 m# M 1 ~: u" W; z8 |- y" F

$ |) ^% @0 i2 w. Q
8 U* u4 O* Q) U) F6 L. O  T* [
: _( g  ]: K  h% M % c9 g% ~; v- M& S0 w* r

9 {2 u$ x# Q) i: w7 K% x' n0 v4 f* k # E, \* {3 s9 X6 y

5 p; L# w, w: l& b 5 V- ?& i4 ?7 [8 z$ `
) P+ v! X( l& L
nu        xi        omicron        pi        rho        sigma        tau        upsilon        phi        chi        psi        omega$ p/ b* b! A0 Q9 p2 _& A
有时候为了美观或特殊需要,可以采用Maple中的函数或程序设计方式控制其输出方式,如下例:
5 q/ x# f6 g7 h> for i to 10 do
/ ?6 w& ?$ t5 @- {printf("i=%+2d and i^(1/2)=%+6.3f", i, eval(sqrt(i)));
0 W7 i- h4 B  Z, e- Kod;
8 t. D$ L3 B/ \7 ii=+1 and i^(1/2)=+1.000i=+2 and i^(1/2)=+1.414i=+3 and i^(1/2)=+1.732i=+4 and i^(1/2)=+2.000i=+5 and i^(1/2)=+2.236i=+6 and i^(1/2)=+2.449i=+7 and i^(1/2)=+2.646i=+8 and i^(1/2)=+2.828i=+9 and i^(1/2)=+3.000i=+10 and i^(1/2)=+3.162
$ Q- X+ T  o  G, G3 R+2d的含义是带符号的十进位整数,域宽为2. 显然,这种输出方式不是我们想要的,为了得到更美观的输出效果,在语句中加入换行控制符“\n”即可:% G7 V3 G, h6 h5 j7 ]0 v
> for i to 10 do - E' V) e" G- S/ W) g
printf("i=%+2d and i^(1/2)=%+6.3f\n", i, eval(sqrt(i)));! W9 {" B4 p0 u$ J4 W/ c; m
od;
* q1 c( M. R$ S- H6 Ui=+1 and i^(1/2)=+1.000
# T+ @! C9 ^% k+ g  E* Q1 w) {0 i# H2 L$ c/ si=+2 and i^(1/2)=+1.414
0 I0 ^4 w6 Y4 y* H4 Ai=+3 and i^(1/2)=+1.7327 g+ M5 m- W; M/ q" m9 J
i=+4 and i^(1/2)=+2.000. i  X+ \* K: ~3 M" {6 [# ^
i=+5 and i^(1/2)=+2.236
+ j, j: A* X+ u9 o! B1 ai=+6 and i^(1/2)=+2.4494 c& W: c+ K) x
i=+7 and i^(1/2)=+2.6460 C1 s/ b: i8 V# T
i=+8 and i^(1/2)=+2.828
: q- O: i+ `* J. T7 ki=+9 and i^(1/2)=+3.000
1 ^  Y, ^  `2 }1 A8 B% di=+10 and i^(1/2)=+3.162$ ?, g# a; g4 k/ k6 W1 V. g2 w9 b% k
再看下例:将输入的两个数字用特殊形式打印:
, |1 B7 ]  K. g3 [> niceP:=proc(x,y)5 ~( p/ T9 g( e7 i( X4 Z
printf("value of x=%6.4f, value of y=%6.4f",x,y);- M, B3 N/ c6 ?2 ]
end proc;$ b" ?8 W9 q# R4 B0 C0 u4 k

; d; M7 t9 @" y> niceP(2.4,2002.204);. ^9 |# r% d( y2 W" B$ o
value of x=2.4000, value of y=2002.2040
# L' _) G( D6 Q7 ?/ c5 }+ ]0 n7 {1.4 Maple联机帮助
% v0 Y4 |/ a" ^7 H学会寻求联机帮助是掌握一个软件的钥匙. Maple有一个非常好的联机帮助系统, 它包含了90%以上命令的使用说明. 要了解Maple的功能可用菜单帮助“Help”, 它给出Maple内容的浏览表, 这是一种树结构的目录表, 跟有…的词条说明其后还有子目录, 点击这样的词条后子目录就会出现(也可以用Tab键和up, down选定). 可以从底栏中看到函数命令全称, 例如, 我们选graphics…, 出现该条的子目录, 从中选2D…, 再选plot就可得到作函数图象的命令plot的完整帮助信息. 一般帮助信息都有实例, 我们可以将实例中的命令部分拷贝到作业面进行计算、演示, 由此可了解该命令的作用. : m! v1 H. e/ A+ z1 }6 \
在使用过程中, 如果对一个命令把握不准, 可用键盘命令对某个命令进行查询. 例如, 在命令区输入命令“?plot”(或help(plot);), 然后回车将给出plot命令的帮助信息, 或者将鼠标放在选定的要查询的命令的任何位置再点击菜单中的“Help”即可.   C2 M4 d) K, R: k- y$ a5 l
2  Maple的基本运算- y, i' Z, X5 }0 @4 N+ X+ y
2.1 数值计算问题9 y! P: {" Y. x# _9 P
算术是数学中最古老、最基础和最初等的一个分支, 它研究数的性质及其运算, 主要包括自然数、分数、小数的性质以及他们的加、减、乘、除四则运算. 在应用Maple做算术运算时, 只需将Maple当作一个“计算器”使用, 所不同的是命令结束时需加“;”或“:”.
' l  L) I9 R, Z在Maple中, 主要的算术运算符有“+”(加)、“–”(减)、“*”(乘)、“/”(除)以及“^”(乘方或幂,或记为**), 算术运算符与数字或字母一起组成任意表达式, 但其中“+”、“*”是最基本的运算, 其余运算均可归诸于求和或乘积形式. 算述表达式运算的次序为: 从左到右, 圆括号最先, 幂运算优先, 其次是乘除,最后是加减. 值得注意的是, “^”的表达式只能有两个操作数, 换言之,  是错误的, 而“+”或“*”的任意表达式可以有两个或者两个以上的操作数. ' f( n/ r3 N" G2 }
Maple有能力精确计算任意位的整数、有理数或者实数、复数的四则运算, 以及模算术、硬件浮点数和任意精度的浮点数甚至于矩阵的计算等等. 总之, Maple可以进行任意数值计算.
; X! I$ e3 y5 `- A2 R# H3 C但是, 任何软件或程序毕竟只是人们进行科学研究的一种必要的辅助, 即便它有很多优点, 但也有它的局限性, 为了客观地认识数学软件、认识Maple, 下面通过两个简单例子予以说明.
( @3 |$ p( c* f3 F4 r4 k第一个简单的数值计算实例想说明Maple数值计算的答案的正确性:   : B" t) g( B3 @4 \
> 3!!!;# s& R8 z: W- `9 p% ?
2601218943565795100204903227081043611191521875016945785727541837850835631156947382240678577958130457082619920575892247259536641565162052015873791984587740832529105244690388811884123764341191951045505346658616243271940197113909845536727278537099345629855586719369774070003700430783758997420676784016967207846280629229032107161669867260548988445514257193985499448939594496064045132362140265986193073249369770477606067680670176491669403034819961881455625195592566918830825514942947596537274845624628824234526597789737740896466553992435928786212515967483220976029505696699927284670563747137533019248313587076125412683415860129447566011455420749589952563543068288634631084965650682771552996256790845235702552186222358130016700834523443236821935793184701956510729781804354173890560727428048583995919729021726612291298420516067579036232337699453964191475175567557695392233803056825308599977441675784352815913461340394604901269542028838347101363733824484506660093348484440711931292537694657354337375724772230181534032647177531984537341478674327048457983786618703257405938924215709695994630557521063203263493209220738320923356309923267504401701760572026010829288042335606643089888710297380797578013056049576342838683057190662205291174822510536697756603029574043387983471518552602805333866357139101046336419769097397432285994219837046979109956303389604675889865795711176566670039156748153115943980043625399399731203066490601325311304719028898491856203766669164468791125249193754425845895000311561682974304641142538074897281723375955380661719801404677935614793635266265683339509760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000% I1 y% d9 B/ S8 i) f
上述运算结果在IBM PC机(1G, 128M)上计算只需要0.01秒, 得到如此复杂的结果(1747位), 一个自然的问题是: 答案正确吗?
9 q( K' ~) \5 T  ^8 e为了回答这个问题, 我们借助于数值分析方法, 由Stiring公式. J' \  g% G& ]+ B% c+ u
: ~& b7 X- c2 G/ ]8 m
可得:  , 前三位数字与Maple输出结果相同, 且两者结果均为1747位. 另外, 在720!的计算中, 5的因子的个数为:   
& w! N/ ]+ ^! m( g* Q* Y
% Q8 R8 v3 A* i" J* |) _. c这些5与足够多的2相乘将得到178个0, 而Maple的输出结果中最后178位数为零. 由此, 可以相信Maple结果的正确性.
2 s/ |# O9 ^4 U; R# [# D+ g另一个例子则想说明Maple计算的局限性:   & I# I2 I7 N$ h$ |$ ]- F& R
  2 ?  g) O. L3 Q) O
Maple在处理问题时, 为了避免失根, 从不求算术式的近似值, 分数则化简为既约分数. 因此, 在Maple中很容易得到:   
& ^2 m: x  c0 y3 \# h6 a9 a4 S
3 ?  `- w1 N+ |6 V: g显然这是错误的. 这一点可以从代数的角度予以分析. & S7 ]  k( H' y! j' \& q
不妨设 , 则 , 即 , 显然 有3个结果, -2是其实数结果.
* {* J  Q! }9 I" W, T. _另一方面, 设 , 则 , 即:! I7 V* t* v* t3 f
  V/ }% a& Z/ m5 E- Q! O
显然 有6个结果, -2、2是其实数结果.
1 W( Y, o7 r' k( s6 L+ N+ I) K( z这个简单的例子说明了Maple在数值计算方面绝对不是万能的, 其计算结果也不是完全正确的, 但是, 通过更多的实验可以发现: Maple只可能丢失部分结果, 而不会增加或很少给出完全错误的结果(如上例中Maple的浮点数结果皆为 ). 这一点提醒我们, 在利用Maple或其他任何数学软件或应用程序进行科学计算时, 必须运用相关数学基础知识校验结果的正确性.
; C1 K7 ?( c* \" g$ C尽管Maple存在缺陷(实际上, 任何一个数学软件或程序都存在缺陷), 但无数的事实说明Maple仍然不失为一个具有强大科学计算功能的计算机代数系统. 事实上, Maple同其他数学软件或程序一样只是科学计算的一个辅助工具, 数学基础才是数学科学中最重要的. / w0 r) ^1 u1 P% p5 W, k. }- H" Y
2.1.1 有理数运算, x) A3 ^; N5 t: o
作为一个符号代数系统, Maple可以绝对避免算术运算的舍入误差. 与计算器不同, Maple从来不自作主张把算术式近似成浮点数, 而只是把两个有公因数的整数的商作化简处理. 如果要求出两个整数运算的近似值时, 只需在任意一个整数后加“.”(或“.0”), 或者利用“evalf”命令把表达式转换成浮点形式, 默认浮点数位是10 (即: Digits:=10, 据此可任意改变浮点数位, 如Digits:=20).
+ g) S- `4 E) `& A6 Y> 12!+(7*8^2)-12345/125;
+ K2 k0 [0 \* B* `& X; ~: W. u
  v. M' h$ t0 {4 @7 ^+ d  x> 123456789/987654321;& O+ g* j  P% x) s, }' t

# G/ w  B8 C# A! Y$ a+ q: D> evalf(%);. b% S" n0 t, a; u* v( [1 Y, G
" z7 d/ c5 _; l) m6 n6 a: n* z
> 10!; 100*100+1000+10+1; (100+100)*100-9;
/ v$ ?7 I- b. X4 S4 \1 Y% T+ @
( q6 Z0 e4 V1 L% n2 w- V
* e2 b8 p5 m0 b5 D4 Y8 d
6 ]+ \/ E. M# S* J2 ~> big_number:=3^(3^3);
- n# x/ g. ~, i: F) e) w9 t 7 a3 R4 k! V5 y* X' I, q' i
> length(%);
# w" O- n! S8 e, d) L 4 z! M/ U$ a" {  D; V6 l
上述实验中使用了一个变量“big_number”并用“:=”对其赋值, 与Pascal语言一样为一个变量赋值用的是“:=”. 而另一个函数“length”作用在整数上时是整数的十进制位数即数字的长度. “%”是一个非常有用的简写形式, 表示最后一次执行结果, 在本例中是上一行输出结果. 再看下面数值计算例子:   
' ?$ h' t& h2 U( I5 T& }    1)整数的余(irem)/商(iquo)
4 C/ H1 E" o; S. w6 e命令格式:   
7 a% W4 r( n7 d, P2 n6 qirem(m,n);        #求m除以n的余数% ~/ }7 w! S& [& g. {8 U& n# c4 C' q# T
irem(m,n,'q');    #求m除以n的余数, 并将商赋给q
: ~, E2 E2 z; P3 siquo(m,n);        #求m除以n的商数* I5 m% G. [6 a" Y
iquo(m,n,'r');    #求m除以n的商数, 并将余数赋给r+ N* R! U$ S$ }. D1 j
其中, m, n是整数或整数函数, 也可以是代数值, 此时, irem保留为未求值.
5 f, q0 i# }0 n% X/ m> irem(2002,101,'q'); # 求2002除以101的余数, 将商赋给q/ I1 T5 P9 P& I3 A$ M
  a  R# O  q0 W. }& M, y/ i
> q; #显示q
6 @/ F, E9 ?: \1 i# i/ m 4 C) V' _: j; x: Y
> iquo(2002,101,'r'); # 求2002除以101的商, 将余数赋给r
/ j+ G4 h  o$ g  I  l
8 b' V- o$ ]7 |( T* V> r; #显示r
+ E" i) ~* k: p4 h
. u' @( z; Y5 G* |' E> irem(x,3);- w  R, i+ t* Z) w% K/ F

3 G5 l% O$ v7 b* `( n( c* ~2)素数判别(isprime)9 R  V6 Y# [% e( m4 x. C
素数判别一直是初等数论的一个难点, 也是整数分解问题的基础. Maple提供的isprime命令可以判定一个整数n是否为素数. 命令格式: isprime(n); - P% X, j# R( k. J# J7 A
    如果判定n可分解, 则返回false, 如果返回true, 则n“很可能”是素数. 2 p3 I. p* r3 F; y9 C
> isprime(2^(2^4)+1);" A# W- ]; Z, A% @4 R0 E0 w

& _" ~% Q4 S  w. U> isprime(2^(2^5)+1);
8 v+ l$ f; x5 ]2 I9 ]$ B) A& U 8 i1 K' Q& s( f
上述两个例子是一个有趣的数论难题。形如 的数称为Fermat数, 其中的素数称为Fermat素数, 显然, F0=3、F1=5、F2=17、F3=257、F4=65537都是素数. Fermat曾经猜想所有的Fn都是素数, 但是Euler在1732年证明了F5=641•6700417不是素数. 目前, 这仍是一个未解决的问题, 人们不知道还有没有Fermat素数, 更不知道这样的素数是否有无穷多.
; o0 O: _, N' i2 r6 k0 g7 t7 @& V8 S3) 确定第i个素数(ithprime)8 f: i7 ^+ f" Z9 ]2 e) u
若记第1个素数为2,判断第i个素数的命令格式: ithprime(i);    3 v5 N6 ^/ r- ?$ I! h  C# |
> ithprime(2002);
1 b2 S* f" [, V3 |$ F5 e, W 4 _; a% ?' R7 t$ V; L0 D% t" v
> ithprime(10000);
4 p7 S3 k8 G7 \, U7 V4 T- G1 b6 t
0 X# i2 o  i4 ^# r1 q3 D' Y4) 确定下一个较大(nextprime)/较小(prevprime)素数0 e4 k) p! {6 [+ z' A) g
当n为整数时,判断比n稍大或稍小的素数的命令格式为:   
( `6 o- c3 Z  C. \- H0 Qnextprime(n);  
% T7 F3 p4 U! U  p2 w! f% p" A/ _prevprime(n);
" n' Q0 M* P0 _1 z* m6 Q: ~> nextprime(2002);
* D) ~3 J9 U" i: I- h 1 C. R/ c$ K( K
> prevprime(2002);
7 T/ G" ?6 N' ^) t3 Z
: \7 V- i+ v& _, S1 u5) 一组数的最大值(max)/最小值(min)' I: ?% }. g4 k$ A+ ~
命令格式: max(x1,x2,…,xn);   #求x1,x2,…,xn中的最大值/ r6 u4 B1 G1 Z; F
             min(x1,x2,…,xn);   #求x1,x2,…,xn中的最小值
% Z  M5 V# _0 n% I6 v> max(1/5,ln(3),9/17,-infinity);
1 n2 ^7 x* g2 W2 u3 @7 a3 x* b# [0 {0 O 9 y+ G- G* S0 B- ^
> min(x+1,x+2,y);. K, Q' a1 u) [% b

8 @. E- W/ \" `  V- z( ]; X: r. U6)模运算(mod/modp/mods)
' \) K& L! ^. G) `7 Y! z命令格式:  e mod m;    # 表达式e对m的整数的模运算- f. I8 Q; P; F* @1 G
modp(e,m);  # e对正数m的模运算  ~, I" x+ U: v! ^0 z
mods(e,m);  # e对m负对称数(即 -m)的模运算" a! @0 ]) n- h
`mod`(e,m);  # 表达式e对m的整数的模运算, 与e mod m等价
+ Y3 F) F1 V) F) n# s值得注意的是, 要计算i^n mod m(其中i是一整数), 使用这种“明显的”语法是不必要的, 因为在计算模m之前, 指数要先在整数(可能导致一个非常大的整数)上计算. 更适合的是使用惰性运算符“&^”即: i &^n mod m, 此时, 指数运算将由mod运算符智能地处理. 另一方面, mod运算符的左面优先比其他运算符低, 而右面优先高于+和-, 但低于*和/.
6 ~; F6 Q2 i$ T7 `& |, v, i+ a4 H> 2002 mod 101;
% f7 |4 S6 k4 _/ ] $ Y* o( W% ^8 ?/ M
> modp(2002,101);
& o% h2 [& a- c3 }  o$ h
' C4 h# `: D9 ^! Y" j1 }5 l> mods(49,100);' f' C6 \+ t0 F/ b( {

/ e* b5 C! |9 F3 A. q1 s- U5 h> mods(51,100);
# c! P/ U0 Y7 b# q  S+ i
. M. I; d/ j2 E$ V> 2^101 mod 2002;  # 同 2 &^101 mod 2002;
; j( m% M; T$ ~% N+ A7 {. U/ f8 @ 1 R- s  C7 y1 R  G# B
7)随机数生成器(rand)
. E" l& R8 U4 z- b命令格式:   4 _" P- `* U3 h( H) C
rand( );    #随机返回一个12位数字的非负整数
. k( X: q+ e4 t, J( prand(a..b);  #调用rand(a..b)返回一个程序, 它在调用时生成一个在范围[a, b]内的随机数* M; e; A! ^% Y7 Q. X# H/ K5 h# |
> rand();+ F  t! B1 L, m; ~  V7 e0 N
$ K( L8 x" g4 {! E
> myproc:=rand(1..2002):
3 }* z# d' G# N5 U0 M6 E' ~> myproc();
- u( i  x( z6 C8 @; r1 g 0 ?. Y- X1 H6 X! @# K' ~  d  M
> myproc();( Y" d' n4 g6 C: c' {0 ]9 P6 f
+ a# g% b8 k, ~8 Y! w) P7 y- @
    注意, rand(n)是rand(0..n-1)的简写形式.
/ }, A; I& g5 t9 x( b0 R2.1.2 复数运算
! h* y$ o1 ^: B# J7 v6 n. E" Z7 S' d. s复数是Maple中的基本数据类型. 虚数单位i在Maple中用I表示. 在运算中, 数值类型转化成复数类型是自动的, 所有的算术运算符对复数类型均适用. 另外还可以用Re( )、Im( )、conjugate( )和argument( )等函数分别计算实数的实部、虚部、共轭复数和幅角主值等运算. 试作如下实验:   
6 e, E# F/ L( d, ^/ _" T> complex_number:=(1+2*I)*(3+4*I);) l1 `3 _' |" z* C5 s

6 Z4 L" Q3 d6 V8 i' l5 k  q4 U/ N> Re(%);Im(%%);conjugate(%%%);argument(complex_number);
- |6 t+ j" O) v2 A
( K6 P/ t3 q6 g9 s$ n( z/ E( |
- }7 s# R: {" T% j) t. u
  [( O8 ?& `( m( M' X - f3 h& ?- [9 i  n1 s. T5 R
值得注意的是上行命令中均以“;”结束, 因此不能将命令中的2个%或3个%(最多只能用3个%)改为1个%, 因为%表示上一次输出结果, 若上行命令改为“,”结束, 则均可用1个%.   G8 S* e( E, v7 x2 }0 b
为了在符号表达式中进行复数运算, 可以用函数evalc( ), 函数evalc把表达式中所有的符号变量都当成实数, 也就是认为所有的复变量都写成 的形式, 其中a、b都是实变量. 另外还有一些实用命令, 分述如下:   
& X; F) w, L7 H+ g2 G. N0 P; p: M1) 绝对值函数
1 Y6 g9 Y5 L: X" j命令格式: abs(expr);  
! B& d( L/ Z5 |" C: P9 A9 P当expr为实数时,返回其绝对值,当expr为复数时,返回复数的模.
" n3 g1 ?3 y/ ?1 @# Q+ O& s> abs(-2002);    #常数的绝对值
+ f$ Q3 v# s( j& U, o ' P* J  g- R  U5 S4 l6 m& J
> abs(1+2*I);   #复数的模  V* c. P/ V  t

2 G  \3 ^5 F. c3 I" A3 w> abs(sqrt(3)*I*u^2*v);  #复数表达式的绝对值
. |6 Z) V% O3 [" d
  w0 [' H. ]$ n> abs(2*x-5);   #函数表达式的绝对值/ f" s5 ~3 n- O: h# ]) a

3 y# X- W$ r- |) P1 m3 u- e2)复数的幅角函数
! G( U0 C( {2 ~命令格式:   argument(x);  #返回复数x的幅角的主值
  X& o" n2 Q9 ]: b7 u> argument(6+11*I);% K% w1 B& z" U0 d
; U* v& V$ Q" z; {7 Y/ z7 }/ p% Z
> argument(exp(4*Pi/3*I));
( `! p. q" a6 y  Y1 i6 Z: u5 ?# e
7 G7 Z/ M) K9 I- u$ z; b3)共轭复数
, D& B' J2 i9 U* H) g" g0 f" E命令格式:   conjugate(x);  #返回x的共轭复数
- z) b8 @- a2 z4 y, F" O4 t> conjugate(6+8*I);
2 ]0 e# B  D. {' u7 A6 e' e
) C% t: @; n0 a, v$ i> conjugate(exp(4*Pi/3*I));
2 C& F5 s7 x; g+ K2 G
8 l/ S; Y- |) [; |; B8 K% i6 b2.1.3 数的进制转换4 n* m; p8 L+ N# v/ q5 l4 k
数的进制是数值运算中的一个重要问题. 而在Maple中数的进制转换非常容易, 使用convert命令即可.
$ s& O. k# M$ e9 Z: @  ^- `) Z- R命令格式:   convert(expr, form, arg3, ...);   
$ L) |( |) M, s其中, expr为任意表达式, form为一名称, arg3, ... 可选项. + h& z' |  r* S. Z6 ~
下面对其中常用数的转换予以概述. 而convert的其它功能将在后叙章节详述. # M& F3 n5 ^% t! O- t
    1)基数之间的转换
5 ~( G# t$ I- v. \2 i" j命令格式:   
6 B/ `$ H' i# {convert(n, base, beta);      #将基数为10的数n转换为基数为beta的数7 ~& C# ]' g8 n4 p  O
    convert(n, base, alpha, beta);#将基数为alpha的数字n转换为基数为beta的数
* Y4 O7 ~- h, q. d7 c, c  }& ^; _> convert(2003,base,7); #将10进制数2002转换为7进制数, 结果为: (5561)7! [5 u0 E4 a; o* ?( U
& _& H5 K! c7 c5 P' u
> convert([1,6,5,5],base,7,10); #将7进制数5561转换为10进制数
- F4 R" g7 l9 |  P( @ ; Y( P) j6 X& {2 r8 \$ @9 A7 Z
> convert(2002,base,60);       #将十进制数2002转换为60进制数, 得33(分钟)22(秒)
; H0 P: x' I: u6 c
( M. B, i! e, E8 W" G) P    2)转换为二进制形式! O5 t0 d( C( U8 H7 [
命令格式: convert(n, binary);
2 y* q5 \+ l: _其功能是将十进制数n转换为2进制数. 值得注意的是, 数可以是正的, 也可以是负的, 或者是整数, 或者是浮点数, 是浮点数时情况较为复杂.
+ @5 M5 |# Y& N" f> convert(2002,binary);   
9 b! @3 w' X& @8 {4 j: v 7 e6 z" M0 ~0 j" Q: B
> convert(-1999,binary); 2 d/ i9 ?# a. u6 x0 K

. b' ~7 E$ u2 s" J2 x" _7 m> convert(1999.7,binary);
. v3 [6 J9 Y! @: e* X  X
* ]  y, N, l: J0 J3)转换为十进制形式
3 t* @2 w* K0 X& @6 T: u其它数值转换为十进制的命令格式为:   
0 [5 h) U5 r) ~& v5 @* r6 K0 Mconvert(n, decimal, binary);   #将一个2进制数n转换为10进制数
- ^9 `; [' D9 w2 ~/ u    convert(n, decimal, octal);    #将一个8进制数n转换为10进制数
% L  F; T- C/ Y; r' p    convert(string, decimal, hex);  #将一个16进制字符串string转换为10进制数
' n( C* G! N# S( z8 u4 n5 i! ^& q# W7 z> convert(11111010010, decimal, binary);    " F$ b; ^! w3 g% j

6 d7 U$ }! i- x7 x3 D$ T! D> convert(-1234, decimal, octal);           
; x4 \) D% H- y+ G2 a
3 ?0 u2 y& X# [! F3 ?( S> convert("2A.C", decimal, hex);          ! V* b) r/ K. h9 [0 y

2 A$ s! {# z0 }" ?4 O: ?2 @" j4) 转换为16进制数
; ?2 C" c' m1 U" L  B将自然数n转换为16进制数的命令格式为: convert(n, hex);   
+ i* b& c& Q& R9 ]8 H) {7 B6 W' @> convert(2002,hex);  convert(1999,hex);
7 i2 l8 d! ]1 R- I/ d
- {1 T4 H: ]+ m6 H/ x
/ K" @0 X  J( S9 q% a* F6 o5)转换为浮点数
5 w; H; ~4 C# X& W' ?5 o! B3 @命令格式: convert(expr, float);
7 i0 b' J6 P6 P注意, convert/float命令将任意表达式转换为精度为全局变量Digits的浮点数, 且仅是对evalf的调用.
& o4 w9 z2 n/ g$ \6 m/ _% }7 R> convert(1999/2002,float);# L7 A/ I+ a# H
- v% U8 o! D% t+ o% r
> convert(Pi,float);$ w" f- c; `* ~& S* \7 ?+ z

% S! f+ F, q0 D" l; u  P' L2.2 初等数学
& ]' G# s! J2 P+ s4 S6 G    初等数学是数学的基础之一, 也是数学中最有魅力的一部分内容. 通过下面的内容我们可以领略Maple对初等数学的驾驭能力, 也可以通过这些实验对Maple产生一些感性认识. ! n7 |4 v9 ^% P8 [3 A" G
2.2.1 常用函数" c2 V& @# ^, I! a* b  E# V6 H8 ?
作为一个数学工具, 基本的数学函数是必不可少的, Maple中的数学函数很多, 现例举一二如下:   
& r9 e2 [* V/ h8 g& k指数函数: exp
: S; s  l9 H8 `2 f: J. ?一般对数: log[a]5 W- G5 w9 v6 M# \
自然函数: ln
( Z1 {* x# H6 R2 p7 V( |常用对数: log10( c+ J% A/ ~& @2 n* o
平方根: sqrt
% E& _/ k6 d- _/ _. R绝对值: abs8 J9 E  l% K, f$ v* ~
三角函数: sin、cos、tan、sec、csc、cot1 J. O7 d5 C4 z  R" f* `# P
反三角函数: arcsin、arccos、arctan、arcsec、arccsc、arccot
) T; m' f0 `! n" J双曲函数: sinh、cosh、tanh、sech、csch、coth4 p; r% A+ M9 p* d" B% J
反双曲函数: arcsinh、arccosh、arctanh、arcsech、arccsch、arccoth
0 s, _* O: }' D9 {8 X3 m8 n" ?贝赛尔函数: BesselI、BesselJ、BesselK、BesselY# y) a; r& Q1 B' _7 [
Gamma函数: GAMMA
' L& ^4 @1 H5 [1 R. w  g3 H( f误差函数: erf. K# i% c! @+ ^! u/ ?& B' B
函数是数学研究与应用的基础之一, 现通过一些实验说明Maple中的函数的用法及功能. # F1 g6 ^' ~9 }+ L+ w$ T! B& V
1) 确定乘积和不确定乘积9 a' i. V; L$ w% \  |- `5 o/ o6 U
命令格式: product(f,k);  
, I5 j* l4 F: _product(f,k=m..n);  + A( B; i8 e8 G6 T* V% i
product(f,k=alpha);
5 I/ t( [! R+ @. P. c7 @8 eproduct(f,k=expr);
, O8 @2 l/ J, n3 S2 Y7 Y3 z8 ?) v其中, f—任意表达式, k—乘积指数名称, m,n—整数或任意表达式, alpha—代数数RootOf,     expr—包含k的任意表达式. , D: H0 L$ U* {/ ]
> product(k^2,k=1..10);   #计算 关于1..10的连乘# S8 }( f1 C  e) f6 H( A' ]4 \
& C- V4 Z0 F/ }0 J- R
> product(k^2,k);         #计算 的不确定乘积
* ?; |; t" m5 z% w! J $ `3 u" D. O2 P+ z7 b
> product(a[k],k=0..5);    #计算ai(i=0..5)的连乘
; Q' A( B9 E6 m1 T
5 h- ~$ q/ O+ _. t> product(a[k],k=0..n);    #计算ai(i=0..n)的连乘8 I) J8 L, R: C. d7 I9 c

. n7 D+ P/ N& V4 A. A/ M2 o/ S: X7 z> Product(n+k,k=0..m)=product(n+k,k=0..m);   #计算(n+k)的连乘, 并写出其惰性表达式1 x1 c6 P) u& t7 V" j0 X' f) m

: e! E& l& |4 u( u5 \8 S2 {> product(k,k=RootOf(x^3-2));     #计算 的三个根的乘积; Y! c2 t+ {0 w! k3 H$ T& W; J

- |' H; ^) `) C1 a* q# t    product命令计算符号乘积, 常常用来计算一个公式的确实或不确实的乘积. 如果这个公式不能求值计算, Maple返回 函数. 典型的例子是:   
" T+ d9 O* A" }, g6 \; ]" V> product(x+k,k=0..n-1);
3 }; f0 a" d+ f3 e1 T# ^$ T 0 @8 w2 x! E$ x  B1 j
如果求一个有限序列值的乘积而不是计算一个公式, 则用mul命令. 如:   4 j1 [/ z, [( J6 b
> mul(x+k,k=0..3);
% U" J5 f5 ?$ M2 q2 w
& g% Z) |8 d. `3 W) }2)指数函数* N1 \9 `! q  q3 }( ?" Y
计算指数函数exp关于x的表达式的命令格式为: exp(x);   O- ]; ^( q3 C  ~
> exp(1);  w6 t' a3 j5 D1 g0 q$ P
. t, B. c6 |1 k/ ^9 A, ~1 y
> evalf(%);' j. A( x* E$ c
) p7 M; B: W- t9 t! ^0 D- [
> exp(1.29+2*I);
5 ~3 x6 Q" H% O, e# [; l+ ]7 L2 y5 Y 1 O$ K/ H* d2 g1 h$ {5 i
> evalc(exp(x+I*y));
; X8 h6 y3 R: Z/ Z- g5 G- L. D - a4 x) K; J+ a
3)确定求和与不确定求和sum
- n9 c, B( O3 r" p; j命令格式: sum(f,k);  
  w9 d5 M4 j0 P8 ksum(f,k=m..n);  
" Q! ?! K% o) Z# ^! h* Xsum(f,k=alpha);
. o1 T* R$ E" s- @1 U0 Qsum(f,k=expr);
+ O) c, d; A# o' j其中, f—任意表达式, k—乘积指数名称, m,n—整数或任意表达式, alpha—代数数RootOf,     expr—不含k的表达式. 2 ^! m( h2 ~4 A/ A  y: l
> Sum(k^2,k=1..n)=sum(k^2,k=1..n);
9 j! c/ Y6 E, u2 m* J / x6 O" B: O1 d" l7 y
> Sum(k^3,k=1..n)=sum(k^3,k=1..n);
9 ?$ x# T  l% H* j- H% C8 V' d
# ^5 i0 @8 i* [> Sum(k^4,k=1..n)=sum(k^4,k=1..n);' ?7 b& m4 k9 [+ q( Q$ y! a+ K6 L

" R! J% ?' T& u/ w4 a> Sum(1/k!,k=0..infinity)=sum(1/k!,k=0..infinity);
) o7 t  o+ i8 c- s% ]* x 2 d( P$ P+ ?& _+ c) D$ _9 I
> sum(a[k]*x[k],k=0..n);
0 v; A- L: ?5 \  C7 n8 e 6 k! i( Y9 m1 b6 m* d3 V/ d. T
> Sum(k/(k+1),k)=sum(k/(k+1),k);
  J6 I% l& W( x5 g( W' W 4 S: A; E2 b1 F$ ?4 x
> sum(k/(k+1),k=RootOf(x^2-3));5 H. h  C# g2 p
) }3 Q2 P- ?3 t
sum函数可计算一个公式的确定和与不确定和, 如果Maple无法计算封闭形式, 则返回未求值的结果. 值得注意的是, 在sum命令中将f和k用单引号括起来, 可避免过早求值. 这一点在某些情况下是必需的.
3 M4 N' J. _4 W> Sum('k','k'=0..n)=sum('k','k'=0..n);! g6 {! {  G7 B1 H& z& Y

' ?( K  S- }1 {# u如果计算一个有限序列的值, 而不是计算一个公式, 可用add命令. 如:   
# I  q. H6 L3 u7 R- G- e, a6 `> add(k,k=1..100);8 L  W. A& z4 B: V8 T. B
: N  I) ?% c& E; s' Z, A) [* ^% c
尽管sum命令常常用于计算显式求和, 但在程序设计中计算一个显式和应该使用add命令.
# g, E3 r9 H) |8 [另外, sum知道各种求和方法, 并会对各类发散的求和给出正确的结果, 如果要将求和限制为收敛求和, 就必须检查显式的收敛性.
# {3 J' B) A8 h3)三角函数/双曲函数; z) Q$ X1 j7 x; I4 o
命令格式:   sin(x);   cos(x);   tan(x);   cot(x);   sec(x);   csc(x);. X3 }0 u- R/ [, L0 m
          sinh(x);  cosh(x);  tanh(x);  coth(x);  sech(x);  csch(x);
4 f- d+ c1 {$ k  s( n其中, x为任意表达式.
, E. a) w3 w$ A& s! W$ k' `4 F# k9 k值得注意的是三角函数/双曲函数的参数以弧度为单位. Maple提供了利用常见三角函数/双曲函数恒等式进行化简和展开的程序, 也有将其转化为其它函数的命令convert.
# e( L4 ]- Z  J" j. Q9 G3 U> Sin(Pi)=sin(Pi);
' ?8 @4 _: W# D! a
( S3 A+ U; R- q# V! u& i4 f4 A> coth(1.9+2.1*I);. l5 ^7 x  p' x/ r! Q

' ]: E  r' [: ^> expand(sin(x+y));     #展开表达式
3 t9 V  m: B& }7 ~& \2 b
0 C! S! W! H9 O/ _/ X7 J9 v7 l> combine(%);        #合并表达式
: L+ G. }9 V4 d' T" z 4 O$ [0 O+ C3 @' l) \1 Q
> convert(sin(7*Pi/60),'radical');3 l% ~' n6 N$ c( P7 M+ _
. j. C; T0 z0 L. j1 g6 O2 x9 `/ {
> evalf(%);, z2 y: C; P" o9 w

7 A4 ^) m$ Y8 S% |; O; e, ~4 ^# F7 e但有趣的是, combine只对sin, cos有效, 对tan, cot竟无能为力.; M, ^5 B* t7 z% c8 @6 q1 m
4)反三角函数/反双曲函数
7 Z. _4 e3 \: J5 \2 Q命令格式: arcsin(x);   arccos(x);   arctan(x);   arccot(x);   arcsec(x);   arccsc(x);
- s: s; w* f( \     arcsinh(x);  arccosh(x);  arctanh(x);  arccoth(x);  arcsech(x);  arccsch(x);   
8 [5 D% V- L+ A0 Uarctan(y,x);
- i2 `( c$ w" h4 ^, M. f* y其中, x, y为表达式. 反三角函数/反双曲函数的参数必须按弧度计算. ! K( m( w  }, m- k& {3 R
算子记法可用于对于反三角函数和反双曲函数. 例如, sin@@(-1)求值为arcsin.
  ~4 i2 h0 E: ~> arcsinh(1);: H+ p  `( q( B/ |4 e; R. e
$ p- N- {3 D, Q1 b
> cos(arcsin(x));: |" X- ~+ k1 s7 h( q

/ u0 T, x% h. I; y- e1 [( s' f> arcsin(1.9+2.1*I);& |  p( t! j/ j/ _! @8 r
- k7 ?  C* ^7 O5 ?, c0 Q7 f
5)对数函数
( f, b$ [- Z4 o& i0 O% L命令格式: ln(x);           #自然对数
" C. ]0 g, I" D# A& D7 {  Glog[a](x);        #一般对数4 S% U( H/ ?% T. N$ W. K9 O  V
log10(x);        #常用对数
8 E1 q* B, {! Q* y* r4 X# V一般地, 在ln(x)中要求x>0. 但对于复数型表达式x, 有:   0 X" z& ~) H, v, p+ W- K3 H. O
  (其中,  )
( c4 R5 Y' l. c: }/ m> ln(2002.0);! |3 c! z9 P5 k! n3 Y3 p

: Q6 X- D+ {$ T5 R/ l" T> ln(3+4*I);7 c( y3 ]7 ?, w6 V3 e5 a2 M& O
( u: ]/ t, v1 s. F4 o9 f- q9 I
> evalc(%);    # 求出上式的实部、虚部0 n* N& `# L- _7 ]5 {+ \( v
/ p0 b0 @% S+ j5 x9 r4 H$ X
> log10(1000000);
! n" s' F0 d+ w3 U5 m( T
% @8 ~, s7 \4 M( L1 a> simplify(%);   #化简上式+ Q9 Z, ~& j7 g9 ]. V' D
$ i$ Q( E: O; U; M) A
2.2.2 函数的定义3 P5 E/ k% r. H& u0 v, L
Maple是一个计算机代数系统, 带未知或者已知字母变量的表达式是它的基本数据形式. 一个简单的问题是, 既然表达式中可以包含未知变量, 那么它是不是函数呢?试看下面一个例子:   
$ Q1 d  x4 Y  D7 W& T> f(x):=a*x^2+b*x+c;1 {' l  Q: w  M# J  S

9 {' D8 I% K0 |# u' _可以看出, Maple接受了这样的赋值语句, 但f(x)是不是一个函数呢?要回答这个问题,一个简单的方法是求函数值:   5 g0 K, t8 w0 `. A  k3 H9 D, p  w
> f(x),f(0),f(1/a);
" [# n# t1 @+ b4 ]6 n * t* ~4 r: E+ @
由上述结果可以看出, 用赋值方法定义的f(x)是一个表达式而不是一个函数, 因为f(x)不能把所定义的“自变量”或者“参数”转换成别的变量或表达式. 但从赋值“过程”可以看出, f(x)虽然也算是一个“函数”, 但却是一个没有具体定义的函数:   
/ }. |6 p% [  m8 r> print(f);
+ y- n5 f) N* Z 3 g) Y# G6 L1 l3 c$ _
事实上, 我们所做的赋值运算, 只不过是在函数f的记忆表(remember table)中加入了f(x)在x上的值, 当我们把自变量换作0或1/a时, f(x)的记忆表中没有对应的表项, 所以输出结果就是抽象的表达式. 3 G/ ^- q& s3 t" s
在Maple中, 要真正完成一个函数的定义, 需要用算子(也称箭头操作符):   
5 V! u# {1 L" Z3 M1 g2 v3 c> f:=x->a*x^2+b*x+c;4 m3 }1 A) n0 n0 q$ T
$ p0 [! P  A/ B- E% k
> f(x),f(0),f(1/a);
# W+ U& s! H$ I2 d
# G6 U, [: w  q- }$ d多变量的函数也可以用同样的方法予以定义, 只不过要把所有的自变量定成一个序列, 并用一个括号“()”将它们括起来(这个括号是必须的, 因为括号运算优先于分隔符“,”).
2 z& p. q9 Y  P2 T- l; t> f:=(x,y)->x^2+y^2;
$ ?5 s7 I* t$ _+ x9 R5 ?- X5 _
, l+ i" N  q% c) u5 h% C> f(1,2);( @" A- U- d6 n/ Q9 C
/ W6 T6 p+ y4 `( S7 G$ `# s% J
> f:=(x,y)->a*x*y*exp(x^2+y^2);
+ U: l( W; t7 ^$ c6 X9 z # [# q4 j* [, e9 k8 {: H1 w
综上所述, 箭头操作符定义函数的方式一般为:   + ^: t& w- P, l, N5 |% o
一元函数: 参数->函数表达式
; Y5 T$ O7 b4 g  K多多函数: (参数序列)->函数表达式
9 a' \1 p$ F& @: ^- K无参数函数也许不好理解, 但可以用来定义常函数:   
) x( w# b2 x  L3 B- O: h2 N> E:=()->exp(1);1 g2 \6 C: u1 f, m0 S+ J9 A

: ]" C' l0 F3 O0 @> E();7 D- V# S, m! V8 M2 |; u
* Z% t4 _& y: `  e  |, L3 o' l
> E(x);
1 T3 K( F6 Z3 ]) U# L, z, J ( t8 M# K# }5 `5 X; H' r
另一个定义函数的命令是unapply,其作用是从一个表达式建立一个算子或函数.
- c% f; `/ M4 |' ^+ N; w+ K( T1 d定义一个表达式为expr的关于x的函数f的命令格式为:  f:=unapply(expr, x);         
6 x7 J6 y# f7 u% K+ ]* A7 J定义一个表达式为expr的关于x,y,…的多元函数f的命令格式为:  f:=unapply(expr, x, y, …);     - x" y6 S6 j% e: N
> f:=unapply(x^4+x^3+x^2+x+1,x);
) N) u# c. p$ L' R  M9 z $ g+ t  L: G; x
> f(4);
9 H  L! D$ \! {: Z# c' `  t 7 B- q, w( z. G" o* R
> f:=unapply(x*y/(x^2+y^2),x,y);
) x9 t0 y. f, _6 h7 s0 o; L7 n
. l" l5 B6 r1 l  e5 e> f(1,1);
! ^2 a1 b8 l' U  s6 w
: S' ?9 A: L. }借助函数piecewise可以生成简单分段函数:
2 e( t1 C5 H' C5 t' S( v> abs(x)=piecewise(x>0,x,x=0,0,x<0,-x);
6 A" m  J1 S/ y) d" n  N( t
. ]: T# B2 j  I/ o" P5 V清除函数的定义用命令unassign. ' c) p( U0 @2 x' D! F
> unassign(f);
  K- H  V" d- y1 E& |$ ]> f(1,1);
1 h/ ]! T- @1 |6 k& z$ [* m 5 Z( ^+ S' `  H% [& p2 S( R/ i2 m
除此之外, 还可以通过程序设计方式定义函数(参见第6章). * W$ A6 s( M% h( q
定义了一个函数后, 就可以使用op或nops指令查看有关函数中操作数的信息. nops(expr)返回操作数的个数, 函数op的主要功能是获取表达式的操作数,其命令格式为:+ d" ^6 K: }, K$ L& Q
op(expr);         
* |. p: ~1 W$ {& m' n! ~" vop(i, expr);         
; Q" b- n" ?3 U- u4 ~" Top(i .. j, expr);      
9 F  c$ ^: e' I5 M. g: rnops(expr);
# ]: K$ |; z/ z9 G如果函数op中的参数i是正整数,则op取出expr里第i个操作数, 如果i是负整数, 则其结果为op(nops(expr)+i+1, expr); 而i=0的情形较为复杂, 当expr为函数时, op(0, expr)返回函数名, 当expr为级数时, 返回级数的展开点(x-x0), 其它数据类型, op(0, expr)返回expr的类型.
! V+ K2 Q6 T0 v  U5 \2 d命令op(i .. j, expr); 执行的结果是expr的第i到第j个操作数, i..j中含负整数时的情形同上.0 w2 R7 O. J6 t. C
命令op(expr); 等价于op(1..nops(expr), expr);
9 `5 F" K) n# E7 b% a$ _1 ?特别地, 当op函数中i为列表[a1, a2, ..., an], 则op([a1, a2, ..., an], expr); 等价于op(an, op(..., op(a2, op(a1, e))...)); / i8 G& r; R9 J
而当expr为一般表达式时,nops(expr)命令返回的是表达式的项数, 当expr是级数时返回级数每一项的系数和指数的总和.
+ T  X7 M+ T' u  ?3 e> expr:=6+cos(x)+sin(x)*cos(x)^2;
$ N. J, P8 T" U! L& h8 J6 s8 I
8 F+ V' B" \6 {$ A+ l3 r> op(expr);2 _4 K! J0 m5 W3 b* i9 }3 P* J

- A3 W+ l* \6 L+ P. |5 ^$ B> nops(expr);- P' i4 R! p0 o; {
8 y3 R- A7 a- ~% h1 }7 U
> p:=x^2*y+3*x^3*z+2;
4 u9 Q( I5 h# i7 V 7 _" Q+ v" C7 L4 K- D" ]
> op(1,p);
6 p2 F" Y2 L% F9 k2 p$ x8 O! r7 p
$ L6 j$ H' K% D" z> op(1..nops(p),p);
: i3 _# K  G" D2 H: F8 o& R $ U/ W+ U  P: e5 R: a1 q
> op(op(2,p));2 Z6 s6 N$ {% K/ ?
6 }# E; Y4 R" U, l0 j1 Z
> u:=[1,4,9];: C* f: S1 ~; c2 q& U0 D3 q

3 v3 Y4 m2 {# S% ^0 |5 p> op(0,u);7 B( j: E# r- `# Q! j1 a
$ D! j* N3 s2 @% }/ r
> s:=series(sin(x),x=1,3);7 o( q9 _, A  y4 ^9 q) U
) A( S3 M3 G: N2 c  }) L3 f: a
> op(0,s);
% g, C6 g+ I. Y& W1 p1 b           h- n# C8 l1 Y+ ~, _; ^
> nops(s);1 A3 F# _+ `# i! e
$ a$ L& q& E+ A
下面一个有趣的例子说明了Maple在处理算术运算时的“个性”:
  b' I( I' o+ u/ q3 w> op(x*y*z);* F, i2 ?: k+ A; G7 z- e/ B

: C. `4 f  D* B> op(x*y*z+1);- a4 I: S! G; _, p% W" Y5 V: V4 e/ ]
& J% h0 ]  f6 Z  N3 }% U3 Y  N9 R
2.2.3 Maple中的常量与变量名
3 V' N! G! _7 e: x为了解决数学问题, 一些常用的数学常数是必要的. Maple系统中已经存储了一些数学常数在表达式序列constants中:   
% f# @2 ~/ E6 K8 I/ f0 P5 X+ [8 }> constants;
, }  c" V5 J& V, n3 E9 v8 q
! [$ C6 {1 x' E* A为了方便使用, 现将上述常数的具体含义列示如下:   : P/ u0 j# m- o( O
常    数        名 称        近似值$ }, j! c9 ^' O
圆周率 + ]) k  ^3 S9 ~
Pi        3.14159265355 P5 m9 V+ p6 X0 Y2 I
Catalan常数 . ]& F! W2 z+ b8 t7 t% ^" S
Catalan        0.9159655942  J- f' s3 d; H" J4 V1 w% R8 A
Euler-Mascheroni常数 6 j; w5 Y+ G/ X9 b# h' e+ [  K
gamma        0.5772156649
) [0 o. X8 [4 Y& e9 P( M 7 k  h# q  t$ Z4 \% C
infinity        % `: ?& K" @% F. o+ Q' S* d( u3 C$ n
0 k7 s; k  M7 r
需要注意的是, 自然对数的底数e未作为一个常数出现, 但这个常数是存在的, 可以通过exp(1)来获取.
/ e  H7 k4 c5 B7 @  s; M/ W& Q在Maple中, 最简单的变量名是字符串, 变量名是由字母、数码或下划线组成的序列, 其中第一个字符必须是字母或是下划线. 名字的长度限制是499个字符. 在定义变量名时常用连接符“.”将两个字符串连接成一个名. 主要有三种形式: “名.自然数”、“名.字符串”、“名.表达式”. 5 {" p: _# T- _6 C/ Z1 ^3 d! }
值得注意的是, 在Maple中是区分字母大小写的. 在使用变量、常量和函数时应记住这一点. 数学常量 用Pi表示, 而pi则仅为符号 无任何意义. 如g, G, new_term, New_Team, x13a, x13A都是不同的变量名.
$ B" R6 F/ _7 y在Maple中有一些保留字不可以被用作变量名:   & {- S, K; d: p& v' e, j
by      do      done     elif     else     end        fi        for      
7 X2 G7 n7 E- c7 y0 jfrom    if       in       local     od     option    options     proc         " Y" E" d7 w" i# p
quit    read     save     stop     then     to        while      D$ Z0 T+ C9 ^5 Y, c" |  ~" {
Maple中的内部函数如sin, cos, exp, sqrt, ……等也不可以作变量名.
" M( H  \1 l) b8 Z0 p另外一个值得注意的是在Maple中三种类型引号的不同作用:   
2 z& Y; x4 A+ }8 x, a( i`  `:   界定一个包含特殊字符的符号, 是为了输入特殊字符串用的;    ' _4 y0 \5 N# i8 V$ {, N
'  ':   界定一个暂时不求值的表达式;    9 V4 {5 ^- h$ E2 i
"  ":   界定一个字符串, 它不能被赋值. * o& w1 ]. W- y6 t  c; }; S6 |
2.2.4 函数类型转换           
/ y: c3 J  i+ W8 u( A函数类型转换是数学应用中一个重要问题, 譬如, 将三角函数转换成指数函数, 双曲函数转换成指数函数, 等等. 在Maple中, 实现函数类型转换的命令是convert. 命令格式:  ( N) B& o* G7 J" C! z
    convert(expr, form);        #把数学式expr转换成form的形式
8 i2 d. Y5 V3 a# mconvert(expr, form, x);      #指定变量x, 此时form只适于exp、sin、cos6 M" N3 M- P0 K) G0 B
convert指令所提供的三角函数、指数与函数的转换共有exp等7种:   
1 G# Z! n7 Q" S5 Q5 ~' M(1) exp: 将三角函数转换成指数
( U) J4 ]2 _* Z/ S) B* H(2) expln: 把数学式转换成指数与对数1 ]# K7 v5 x8 b3 z( Z; j
(3) expsincos: 分别把三角函数与双曲函数转换成sin、cos与指数的形式
! p. f: [: c$ u3 C4 B7 H(4) ln: 将反三角函数转换成对数
. V/ H' H5 i9 P(5) sincos: 将三角函数转换成sin与cos的形式, 而把双曲函数转换成sinh与cosh的形式
2 v" q' j! }4 B$ k! s(6) tan: 将三角函数转换成tan的形式
8 [0 U# b5 }+ ]1 O9 L4 x% b0 _/ P(7) trig: 将指数函数转换成三角函数与对数函数9 i, D/ V$ c' ~3 O- [
> convert(sinh(x),exp);   #将sinh(x)转换成exp类型
6 _* S% t% q* F) L/ O6 _1 s # ]/ d* z& z8 \$ l8 [5 g8 y: l+ D- P
> convert(cos(x)*sinh(y),exp);3 k9 q; F9 w! m2 t+ A
' o2 ^4 T  O) s1 w" g8 R
> convert(cos(x)*sinh(y),exp,y);) K: J) t& P# [! k4 P
6 {, C0 a& m0 k" r
> convert(exp(x)*exp(x^(-2)),trig);+ b* r1 g6 u* n" n
) ?$ B7 P1 ~7 p* }
> convert(arcsinh(x)*cos(x),expln);
; t5 |7 L' K2 i# }
; @; W, b0 z5 Y" ]; L> convert(cot(x)+sinh(x),expsincos);
$ ]9 }0 Z2 ]4 X/ i
% @( R* D8 d  v- V9 o> convert(arctanh(x),ln);
8 Q. G/ i7 V: A4 i! I0 o
# o+ Z3 P' H2 Y3 w$ Aconvert在有理式的转换中也起着重要的作用. 在有关多项式运算的过程中, 利用秦九韶算法可以减少多项式求值的计算量. 在Maple中, 可以用函数convert将多项式转换为这种形式, 而cost则可以获取求值所需的计算量. 注意: cost命令是一个库函数, 第一次调用时需要使用with(codegen)加载. 例举如下:   
0 |; @) u- W$ w& U' _> with(codegen):
9 T: @' P% e  M* T' B> p:=4*x^4+3*x^3+2*x^2-x;
) {! b( K! K9 q1 _* o 3 C$ P/ V- w+ M7 p# e, s
> cost(p);
$ F7 X: z1 h4 m$ `# N/ y 4 b3 U0 G2 a: x) f  V- Z/ @0 \9 ~
> convert(p,'horner');  #将展开的表达式转换成嵌套形式  R/ @: C$ |. n7 a  m3 Z

2 }' h' B& |3 O' ~( U. H& ]0 ]> cost(%);
+ X8 f5 i: C  L; ?- B6 W  P6 l; C8 S
& `; f2 Q0 c& E同样, 把分式化成连分式(continued fraction)形式也可以降低求值所需的计算量.
# W8 ]# U# b. [# g" {1 ~> (1+x+x^2+x^3)/p;
5 X1 @: G# K8 @: B& f $ t; V  b6 a+ D) C, f6 V3 e
> cost(%);
2 L. V6 t! f' J- Q% v
' p! K/ V( y( h  J> convert(%%,'confrac',x);
) ~7 l2 w3 R+ W8 H
) |! l& k% O, z: u& H) Z% d$ L1 ~> cost(%);
6 V/ J7 i2 U, ]0 P) @9 c8 t9 i 9 }& f" `) s% v& R+ [0 G3 b
在某些场合下(比如求微分、积分时), 把分式化成部分分式(partial fraction)也就是几个最简分式的和式的形式也可以简化运算, 但简化程度不及连分数形式. : |0 K% K: A" X( v( Y
> convert(%%, 'parfrac',x);) |$ A5 u' k3 x( l. n$ f, M: {' X6 ~
0 [, ~3 I9 i# B% r
> cost(%);
2 q$ b" X8 K: z' c' a 1 A+ P0 r5 j( ]  z! h- W
而把分数转换成连分数的方法为:! L( `. x( Z$ x( [# h; V' e
> with(numtheory):
1 c% T$ U( Q' z3 \> cfrac(339/284);! S( _: R/ Q% Y0 _6 \

0 B9 e. g( v1 O2 g. l2.2.5 函数的映射—map指令6 f/ y& O4 j3 e* m) e7 _
在符号运算的世界里, 映射指令map可以说是相当重要的一个指令, 它可以把函数或指令映射到这些结构里的元素, 而不破坏整个结构的完整性. 命令格式为:) j2 w5 S+ `5 T
map(f, expr);      #将函数f映射到expr的每个操作数0 @1 a6 q4 `# q0 h3 F. P
map(f, expr, a);    #将函数f映射到expr的每个操作数, 并取出a为f的第2个自变量8 v3 I# }7 F' \& u% R
map(f, expr, a1, a2,…, an); #将函数f映射到expr的每个操作数, 并取a1~an为f的第2~n+1个自变量, ]& ]$ O1 W2 q
map2(f, a1, expr, a2, …, an);    #以a1为第1个自变量, expr的操作数为第2个自变量, a2为8 Y8 q) B! p0 ~
第3个自变量…, an为第n+1个自变量来映射函数f
% I6 T% w% i7 h# `3 P" D) g> map(f,x1+x2+x3+x4,a1,a2,a3,a4);. R* G$ v7 v. A" }& g3 M5 I
9 V  c) c9 e5 C" X) K: |* |
> f:=x->sqrt(x)+x^2;" G5 ~' I# J9 O  H0 q  G

8 u) R2 X8 S& d' i. s> map(f,[a,b,c]);2 B: `# Y% @5 Q4 x
5 M# Y) D3 B. L: p% k
> map(h, [a,b,c],x,y); 4 b' D( ~% W$ m

) |2 a3 n" [& P7 [) B; r! w& e3 X> map(convert,[arcsinh(x/2),arccosh(x/2)],ln);
- u7 Y2 c* y; ?6 B, \
& \3 x% m: [5 W) }+ Q) P! I> map(x->convert(x,exp),[sin(x),cos(x)]);* A! o) C) J. {: o% h, g& ?: ]
* {3 o7 X" k# w; I! b/ x; u
上式的映射关系可通过下式理解:
* ]7 `( U* r/ z8 E8 t; X> [convert(sin(x),exp),convert(cos(x),exp)];
$ |- }. |  v5 w
- [% D- J6 o! E# E$ }3 z0 @, A> restart:
6 w7 E' J) @' P5 G. I/ s8 Amap2(f,a1,x1+x2+x3+x4,a2,a3,a4);! C9 X5 f, [  f8 g# o' A9 `
; s5 }) {8 s; Q0 E! G
> map2(max,k,[a,b,c,d]);
: c, N7 Z4 l7 ?, Q# C3 ^# j
4 q8 m6 K+ K' h" ^/ l: T# h再看下面示例:   
* G- S3 [8 e( y* N> L:=[seq(i,i=1..10)];
' L2 d+ O- H- ~ 7 }. s/ p, j# ^: x; L) q
> nops(L);
- i( Q5 g/ _% m1 W
: L" M( H  b3 s, i7 w7 M3 }> sqr:=(x)->x^2;5 l/ k3 E6 w7 @# C
6 G% l* x  T" H+ f( g' ^
> map(sqr,L);
3 H8 H2 z( r! d: V6 s: p
8 }) q; \: @/ i: p3 A& {> map((x)->x+1,L);
7 `, R  I1 g) ?3 M
" _  Y& s! f7 ?& S- n/ B& r: }> map(f,L);
; s/ P# C1 F6 {/ @+ b& b/ _/ h, W 2 {, k7 e. o) v  w" ]
> map(f,{a,b,c});6 k) M4 j+ L- @2 y
; h3 C: R5 ^. V' J
> map(sqr,x+y*z);) T/ V( a' R. r) {+ O
. |# \( I, i! x7 Z5 W, v. l4 i  X6 e& Q
> M:=linalg[matrix](3,3,(i,j)->i+j);
/ S3 s8 r' V* s) |; A
1 `: U- ^7 A# I9 E> map((x)->1/x,M);
3 X' z! `& i' {  @2 S* Z) C
2 B0 q6 N" S& K+ D! [3 求 值1 g2 S3 ~' ]/ i' e# |/ g6 X+ g% m
3.1 赋值
: f+ P3 {; D9 T4 \. a/ j在Maple中, 不需要申明变量的类型, 甚至在使用变量前不需要将它赋值, 这是Maple与其它高级程序设计语言不同的一点, 也正是Maple符号演算的魅力所在, 这个特性是由Maple与众不同的赋值方法决定的. 为了理解其赋值机制, 先看下面的例子.
0 _. d1 h' S3 A1 l. Z> p:=9*x^3-37*x^2+47*x-19;  B4 l. }9 i) N  F* D# d. O& f4 Z

. p( g- Q; ?: K! T> roots(p);  c9 y0 R* b& `5 K6 D7 r5 G. _0 |+ F
6 k$ S: \$ _9 R) m( u
> subs(x=19/9,p);. m# |% H# s$ A% ?6 U% ^" D
! n5 L& n; n& g( j
在这个例子中, 第一条语句是一个赋值语句, 它的作用是把变量p和多项式9x3-37x2+47x-19相关联, 在此之后, 每当Maple遇到变量p时就取与之唯一关联的“值”, 比如随后的语句roots(p)就被理解为roots(9x3-37x2+47x-19)了, 而变量x还没被赋值, 只有符号“x”, 通过subs语句得到将p所关联的多项式中的所有x都替换成19/9后的结果, 这正是我们在数学中常用的方法—变量替换, 但此时无论x还是p的值仍未改变, 通过“> x; p;”这样的简单语句即可验证. ! X3 ~9 X. D+ c
3.2 变量代换4 C, o% @8 I- e' k! ]2 C5 o6 c
在表达式化简中, 变量代换是一个得力工具. 我们可以利用函数subs根据自己的意愿进行变量代换, 最简单的调用这个函数的形式是这样的:   
: |# d" x- q' k4 ^subs ( var = repacedment, expression);7 Y$ C  ?6 n7 q4 r7 ?' X
调用的结果是将表达式expression中所有变量var出现的地方替换成 replacement. 2 c- g' c! _6 o
> f:=x^2+exp(x^3)-8;
# m  `7 t- \8 e. }! X& t9 J , K, v' A) ?8 Z  P. G; j  l
> subs(x=1,f);
7 T& g2 j# C8 c* _0 ` * h6 ?3 C1 G- P# I
> subs(x=0,cos(x)*(sin(x)+x^2+5));# {8 O' `4 \8 Z

. [  g9 S$ h& K/ R& J$ p* g    由此可见, 变量替换只得到替换后的结果, 而不改变表达式的内容, 而且Maple只对替换的结果进行化简而不求值计算, 如果需要计算, 必须调用求值函数evalf. 如:   
6 c" ~& d( b$ J> evalf(%);
: ^0 w( F# `+ J! l& Z
! w# l) T" Y4 y- c变量替换函数subs也可以进行多重的变量替换, 以两重代换为例:   
3 |7 J  i- l  J# c' Jsubs (var1 = repacedment1, var2 = repacedment2, expression)
: t- c3 L- ~- I" X. g* H调用的结果和按从左到右的顺序连续两次调用是一样的, 也就是先将expression中的var1替换成replacement1, 再将其结果中的var2替换成replacement2, 把这种替换称作顺序替换;    与此相对, 还可以进行同步替换, 即同时将expression中的var1替换成replacement1, 而var2替换成replacement2. 同步替换的调用形式为:   % O: \2 s9 l7 p1 C" n
subs ( {var1 = repacedment1, var2 = repacedment2 }, expression)! I* J$ s. x; M
下面通过例子说明这几种形式的替换.
9 B* A" I0 o1 M> subs(x=y,y=z,x^2*y);              (顺序替换)* A# H& t9 K8 R9 D
( ?) Z( S. W" h* {3 A8 J3 ~' j! d
> subs({x=y,y=z},x^2*y);            (同步替换)5 e6 A5 [, @9 }1 v' Z) U
4 t5 Y0 _1 q2 \9 a, n$ ~) }, c, [* k
> subs((a=b,b=c,c=a),a+2*b+3*c);   (顺序替换)& |, k6 ?# T- Y! Y3 f

; Y8 ?; _  P) c. v> subs({a=b,b=c,c=a},a+2*b+3*c);    (轮  换)
: W" X" _) l0 u : ~% @: ?* E: C. c) ]
> subs({p=q,q=p},f(p,q));             (互  换)
. G9 ?/ f& I, h+ e+ A6 u # ?3 K. s) k, m, B/ n% s
3.3 假设机制
$ H+ p9 `% \( P8 k7 d5 x' EMaple是一种计算机代数语言, 显然, 很多人会尝试用Maple(或其他计算机代数语言)解决分析问题. 但由于分析问题与处理问题的考虑方法不同, 使得问题的解决存在某些困难. 例如考虑方程 的解. 如果k是实数, 结果显然是x=1, 但如果k是 的复根, 为了保证解x=1的正确性, 必需添加附带条件: 也就是当 时x=1. 这是一个对结果进行正确分析的例子. 然而从代数的角度考虑这个问题时就会把k当作不定元, 此时k没有值, 从方程两端去除k的多项式是合法的, 只要这个多项式不是零多项式即可(这一点是可以保证的, 因为其所有系数不全为0). 在此情况下x=1就不需要任何附加条件. 计算机代数系统经常采用这种分析的观点. - Z: R3 G$ S6 b! C( O# r
在Maple中, 采用分析观点解决这类带有一定附加条件的实用工具是函数assume, 其命令格式为: assume(x, prop);: Q- ]" ^0 @9 X+ o& j9 B1 p
函数assume界定了变量与变量之间的关系式属性. assume最普遍的用法是assume(a>0), 该语句假设符号a为一个正实常数; 若假定某一符号c为常数,使用命令assume(c,constant); 另一方面, assume可以带多对参数或多个关系式. 当给定多个参数时, 所有假定均同时生效. 例如, 要定义a<b<c, 可以用assume(a<b, b<c); 同样地, 要定义0<x<1, 可以用assume(0<x,x<1). 当assume对x作出假定时, 以前所有对x的假定都将被删除. 这就允许在Maple中先写“assume(x>0);”后再写“assume(x<0);”也不会产生矛盾.
5 i& {0 `! E0 v0 v' f+ ?& @> Int(exp(-s*t),t=0..infinity);/ E/ K: ?5 C( I# S7 N, v4 G

) m, j1 `7 J+ K0 u' t> value(%);
) ]1 u$ |. O& wDefinite integration: Can't determine if the integral is convergent.
; ^" l8 F. ]8 E- K2 a5 @6 E5 oNeed to know the sign of --> s) X+ X+ u' h8 [0 O; f
Will now try indefinite integration and then take limits.4 D9 b, Z) H4 a2 ~2 U+ U, i

  A/ U- ]: Q1 q6 Y* T  _: ?> assume(s>0);
1 s+ m; v* @2 v; Y# G7 X> Int(exp(-s*t),t=0..infinity);
' R% p1 p3 C" n7 t3 z' S
+ e+ y# d7 x9 |( o2 u> value(%);8 l# R0 I5 E7 B/ `3 T

* N1 X6 ^0 n: v; {( I0 }0 [3.4 求值规则
( t* `" p' ~; n) @# f在多数情况下, Maple的求值规则设计为做用户期望的事情, 但要做到这一点很困难,因为不同的人在相同的情形下会有不同的期望. 在大多数情况下, 全局变量被完全求值, 局部变量被一层求值. 而由符号' '界定一个暂时不求值的表达式, 单步求值仅去掉引号, 不作计算, 这也是允许取消指定名字或清除变量的原因. 如下例:   
/ h$ B- i5 P4 |/ r. ~# `0 ^> x:=y;( k7 \7 }- O5 h; q

) n& J' p" O! ?7 u+ w+ d3 o> y:=z;' ?( _* t0 ?- ?! W

2 O- e- H0 E# L! F+ U) K; n6 _> z:=3;
' N. j  C7 W% d5 y / S. t" C0 L& h1 b# }! d5 q; f
> x;
+ x/ k6 a4 g2 T: O  u6 E) X3 E
8 [4 ^% i1 }" ^* Y8 ^. E, y> y;1 i* l% Z5 T/ Q2 c, `* p) E' k

( X1 g( e. Y( N$ M> x:='x';
% t) \2 O1 \) D& D6 ]9 H9 q* T 7 v0 O  a9 J. S4 v: `
> x;
( O3 T6 C1 Z; j8 c  C' h" K ( `9 ^+ Z5 T7 K6 k4 U0 f6 m
> y;, g/ ~$ M$ K) _7 v

: U" k' g% p: l7 ]对于不同的问题, Maple设计了不同的求值命令. 现分述如下:   $ ?7 @" b' [, E: V
1) 对表达式求值, T" I9 O( M: c1 C. [6 }
命令格式: eval(e, x=a);  #求表达式e在x=a处的值
! z2 q- I  w5 P( K6 J3 X             eval(e, eqns); #对方程或方程组eqns求值
3 w1 p8 }1 b8 k9 ~* d- T             eval(e);      #表达式e求值到上面两层
* l4 C9 }! C5 @# _, O; v             eval(x,n);    #给出求值名称的第n层求值
! }  t0 d+ y: p, [> p:=x^5+x^4+x^3+x^2+x+73;
- E, j3 e, k. n6 Q& y; `7 y
4 H$ g' e: |6 @% v5 v" k> eval(p,x=7);
$ y" Y/ u0 R6 r3 X * j" b; ^6 V: b; Y
> P:=exp(y)+x*y+exp(x);" J: R2 D+ B) ?7 e+ |) S

4 Z, ~+ H" n" Z> eval(P,[x=2,y=3]);
! n/ I+ G: Z0 p9 F' G' `& W1 ?
2 z9 I  K; M4 |    当表达式在异常点处求值时, eval会给一个错误消息. 如下:   
4 y, }8 Z9 k& `( @> eval(sin(x)/x,x=0);
' r, p8 m4 |1 Q) E& {. C) B, JError, numeric exception: division by zero2 f# I6 c8 `9 |6 M4 v9 c
    下面再看使用eval进行全层求值或者对名称几层求值的示例:   * e, V4 g4 s( l9 d8 z
> a:=b: b:=c: c:=x+1:
8 _1 S7 ^  K( G* p> a;              #默认的全层递归求值
3 J8 `) s: F+ l! I: J' O( {
, Z) g, l, ?( }5 A> eval(a);        #强制全层递归求值
! i, x( f) _7 C# V2 z, E; S8 j, {3 \
. k) s/ W0 G, F0 y5 \& n> eval(a,1);       #对a一层求值# G+ v: k  Y) h: B

1 w4 c4 c) F( J& @  \. B. }> eval(a,2);       #对a二层求值
) \% a8 |. _6 g( F2 S3 B- m
+ I" P' n: ~* g6 e3 i' L> eval(a,3);       #对a三层求值2 V) x2 M5 a/ {: x5 O. M. b
% [" m* k: H$ O3 f# E
> eval(a,4);       #对a四层求值
0 x5 K& s: f9 C9 I2 z! z$ x- X. X7 u 3 p" u8 n* M3 {) {& b9 [
    2) 在代数数(或者函数)域求值
0 k7 K- Q* _& v9 `- T' N( X命令格式: evala(expr);       # 对表达式或者未求值函数求值* r# E8 h8 d( [! D
             evala(expr,opts);   #求值时可加选项(opts)9 ]7 C# V0 c  r0 w3 L
所谓代数数(Algebraic number)就是整系数单变量多项式的根, 其范围比有理数大, 真包含于实数域, 也就是说任意实数都是整系数多项式的根(如 就不是任何整系数多项式的根). 另一方面, 代数数也不是都可以表示成为根式的, 如多项式 的根就不能表示成为根式的形式. - p% w; p8 Y, I% _# d
代数数的计算, 算法复杂, 而且相当费时. 在Maple中, 代数数用函数RootOf()来表示. 如 作为一个代数数, 可以表示为:   # M) o1 G9 W" Y7 H' B
> alpha:=RootOf(x^2-3,x);
" b; E3 v* q, e: ]$ r6 c( ]: f ) z. z  o$ L- l- O. x  i
> simplify(alpha^2);; e$ P* w! q' u  Z- V8 R

& x2 t3 c9 z  q在Maple内部, 代数数 不再表示为根式, 而在化简时, 仅仅利用到 这样的事实. 这里, Maple用到一个内部变量_Z. 再看下面一个例子,其中alias是缩写的定义函数,而参数lenstra指lenstra椭圆曲线方法:
# [3 q( s3 O! @# k% R> alias(alpha=RootOf(x^2-2)):0 \+ H1 U8 T/ x1 [2 L+ F: b
> evala(factor(x^2-2,alpha),lenstra);: a; V1 Q: e/ b. x( k; o

0 ^3 q9 ^1 S; L; R> evala(quo(x^2-x+3,x-alpha,x,'r')); # w  o% x/ J8 p- i: T) |

5 v  g3 U1 a: K9 x  k> r;' I0 b. g& }) g/ i$ o. Q4 t" \! H

' T6 `( p" O5 K, a  c> simplify(%);% @3 L+ v; A; ^

5 o/ r( P& p' Q- x6 }; g  S7 r& _3) 在复数域上符号求值, G5 ]/ y6 m9 ?  q
操纵复数型表达式并将其分离给出expr的实部和虚部的函数为evalc, 命令格式为:
& L+ u' F% Y4 i8 U  }evalc(expr);   
; w+ L3 x/ k, m. o9 v* Levalc假定所有变量表示数值, 且实数变量的函数是实数类型. 其输出规范形式为: expr1+I*expr2. 8 \+ F' {( a5 J2 d2 I& v7 v4 Q
> evalc(sin(6+8*I));- v) ?* X: i4 \2 {! b8 ?  \. ^5 h

! N) f6 t- Q. c; |. ^1 V> evalc(f(exp(alpha+x*I)));6 c2 B( g, Z- u" k$ [
7 y& p- G" ~! @; J" I0 T; X
> evalc(abs(x+y*I)=cos(u(x)+I*v(y)));9 V& J: b# j: Z0 z/ j
6 s* t8 V; A. s, q
4) 使用浮点算法求值; P4 j9 z; Y- X3 L; h' h* [
浮点算法是数值计算的一种基本方法,在任何情况下均可以对表达式expr使用evalf命令计算精度为n的浮点数(n=Digits), 如果n缺省, 则取系统默认值, 命令格式为: evalf(expr, n);     
4 s0 d/ C9 t) Q3 n) h3 n% p' [> evalf(Pi,50);    0 D) J, [3 N+ O; E, k$ n0 K

+ x; S2 G: j3 M3 {3 M> evalf(sin(3+4*I));   
1 B  R# d2 R# `# v6 y7 {5 s ' m  M7 |- I! c; @3 A! @6 V
> evalf(int(sin(x)/x,x=0..1),20);
0 ~! Q( I1 j! q( J0 r4 u9 i " L$ k4 S3 R0 E% B! v
5) 对惰性函数求值
- s! e8 z( H% t* k; x" l$ n把只用表达式表示而暂不求值的函数称为惰性函数, 除了第一个字母大写外, Maple中的惰性函数和活性函数的名字是相同的. 惰性函数调用的典型用法是预防对问题的符号求值, 这样可以节省对输入进行符号处理的时间, 而value函数强制对其求值. 对任意代数表达式f求值的命令格式为: value(f);   & Z" X8 z& @  d4 x
> F:=Int(exp(x),x);
; e, k2 o5 _8 A( v) p: g+ |
9 `, [$ P. z. o5 ~4 b" t$ A> value(%);* o6 V. _! b+ n
* V. s/ w8 o' H1 E
> f:=Limit(sin(x)/x,x=0);" X5 [/ h! t6 s& o5 b

) S3 L( a5 E- S* l> value(%);" y. `, S  J1 A% O, |
4 d" j6 h, H) @+ Q
另外, 将惰性函数的大写字母改为小写字母亦即可求值. 如下例:     b4 e- q7 X" c" P9 m0 u" Z
> Limit(sin(x)/x,x=0)=limit(sin(x)/x,x=0);7 f5 @8 E) a/ p& m
( m: z$ e. m2 B3 P% U
4 数据结构
3 v7 K. S* W! e( d7 @5 c" H6 BMaple中有许多内建的与FORTRAN、C或Pascal不同的数据结构. 主要的数据结构有序列(sequence)、列表(list)、集合(set)、代数数( algebraic number)、未求值或惰性函数调用、表(table)、级数(series)、串(string)、索引名(index)、关系(relation)、过程体(process)以及整数(integer)、分数(fraction)、浮点数(float)、复数(complex number)等数据结构, 而矩阵(matrix)在Maple中表示为阵列, 是一种特殊的表.
% X/ p5 A. A" S- M( v4.1 数据类型查询
/ d( k0 ~4 A0 Z& \# w# l! j在Maple中, 用whattype指令来查询某个变量的数据类型或特定类型, 命令格式为: , |4 u- R: f6 }. V% S
whattype(expr)        # 查询expr的数据类型
5 Z) p" p# ^' g) P6 x8 Htype(expr, t)           # 查询expr是否为t类型, 若是则返回true, 否则返回false1 N) x( l( G( b6 H
> whattype(12);
% h" V7 f0 |( A5 w2 J * q- r( g! ~$ A4 @% P
> whattype(Pi);. J" Q6 p" I# r! p1 s

9 v% [3 \8 o1 E' z  `; @> type(1.1,fraction);; F" _6 F; Z, j

) c& s% a# V4 @! c/ D( D> whattype(1.1);2 _  j  b; B" e, @0 x$ W) q

& j; a& D3 L' O- r4.2 序列, 列表和集合" T- K! d7 u3 G* t
4.2.1 序列
, g( _. [9 R2 j! i4 \* I- M# P% y2 v* `7 e  C所谓序列(Sequence), 就是一组用逗号隔开的表达式列. 如:   5 o0 b% B" N/ E
> s:=1,4,9,16,25;
& ]2 S0 {8 j# [1 V
; w3 P' |7 ~5 X5 Y1 O> t:=sin,com,tan,cot;& w2 d) V. E4 v* p
. d& b  d; T% p  b
一个序列也可以由若干个序列复合而成, 如:   2 S% \6 e0 z1 `) E! T( ]: M
> s:=1,(4,9,16),25;
* ~8 h' d& l3 m+ D 2 L7 ]# n0 a% x) j2 X
> s,s;3 F8 H3 e' Z' M0 Q4 Q/ a

8 f7 R) ]: \) |" e而符号NULL表示一个空序列. 序列有很多用途, 如构成列表、集合等. 事实上, 有些函数命令也是由序列构成. 例如:   9 G' k' j) K( z$ N+ ?3 q
> max(s);" q; @9 X1 ?. }, r
* c0 {# m: j* A: A
> min(s,0,s);
* Y2 g, K. t8 `6 s4 f2 A6 K" } 2 s5 i! u9 G% D5 t) v0 m# \
值得注意的是, op和nops函数命令不适用于序列, 如op(s)或nops(s)都是错误的, 如果要使用op(s)或nops(s)前应先把序列s置于列表中. 0 a3 v% `1 f- I3 c
> s:=1, 2, abc, x^2+1, `hi world`, Pi, x -> x^2, 1/2, 1;0 `8 @. }+ V! P5 q& h
7 j0 P4 e# u& `) {4 q# J8 t
> op(s);
- ~5 O# Y1 u" w7 B& n# w) ?Error, wrong number (or type) of parameters in function op6 F* s1 t4 `. C0 i1 B! G8 G
> nops(s);
, S  H' I6 D, N8 J1 n' T. wError, wrong number (or type) of parameters in function nops& `+ S- U0 ]* x$ I' U$ {5 s
> op([s]);
- I! T0 G. \1 l. _
% V8 {: v+ Q, Z1 i6 T> nops([stuff]);( U. W# i; c5 c4 c

3 Q6 n' X$ o, k" t  `+ H+ B函数seq是最有用的生成序列的命令, 通常用于写出具有一定规律的序列的通项, 命令格式为:   ; V; G% C" X! y$ L- n
seq(f(i), i=m..n);  # 生成序列f(m), f(m+1), …, f(n) (m,n为任意有理数)3 {) v( _6 X4 D. n# R" ^
seq(f(i), i=expr);  # 生成一个f映射expr操作数的序列% g! v1 H0 u% y& `8 R) _+ S
seq(f(op(i,expr)), i=1..nops(expr));  # 生成nops(expr)个元素组成的序列
) ]/ x4 ]& m. O/ g2 F: L% i. b% N> seq(i^2,i=1..10);, p1 q9 c9 I$ q* e

2 C% Q& m6 k% j* x3 m/ Q& S5 T+ O> seq(ithprime(i),i=1..20);
2 n( d3 R1 r# i : A; e9 W/ F  o0 B
> seq(i^3,i=x+y+z);
, _7 J, m1 }) Q8 f6 L; X, L ; ^# t3 J, p* C) ]' X
> seq(D(f),f=[sin,cos,tan,cot]);
  T5 _  R. I" h' Z2 G( j& y. e+ M6 A ) r! o7 o; g* S% K) j3 s$ Y
> seq(f(op(i,x1+x2+x3+x4)),i=1..nops(x1+x2+x3+x4));6 d: _  U: `8 ?; r
0 r! `5 |8 P# y) R  P5 l
获得一个序列中的特定元素选用操作符[  ], 如:   . k" c  i/ D) d4 r: l( [. n$ N, R
> seq(ithprime(i),i=1..20);
1 |% ~. Y( _; N4 j3 t9 E1 M* E 2 ^/ }0 X8 s- @4 ~
> %[6],%[17];
8 o; Z- i1 a, v* b
- j; s  o$ G0 w$ |; P' y3 u& Q4.2.2 列表
% [+ E3 R( c  t, N! K/ z' J列表(list), 就是把对象(元素)放在一起的一种数据结构, 一般地, 用方括号[  ]表示列表. 如下例:   
# m4 Z1 x5 u6 F& C# f. D% A6 T! v> l:=[x,1,1-z,x];
2 w. `$ Z! V9 ]3 x$ e 6 E9 ]5 p1 C3 o- C
> whattype(%);
( D! g$ s, h3 Y6 u1 ^& b5 D ; @! D: x5 y7 S. T4 p" r% t# o8 s
空列表定义为[ ]. * q* k* W" e  N  s, w
但下述两个列表是不一样的, 因为对于列表而言, 次序是重要的:   
9 U1 s9 Y6 G4 z8 g3 u# D0 i> L:=[1,2,3,4];5 R1 q$ b5 S: m; Q' I
* T& s( p2 d: c- @/ H, B; _
> M:=[2,3,4,1];$ Q' v9 G9 V' Y7 n

- S9 H9 X# F5 }/ E3 C( h# E4.2.3 集合
( S3 W. q5 A. C3 T1 g- {! b集合(set)也是把对象(元素)放在一起的数据结构, 与列表不同的是集合中不可以有相同的元素(如果有, Maple也会自动将其当作同一个元素), 另外, 集合中的元素不管次序. 一般地, 用花括号表示集合.
  L8 f- F; |' x2 O: ~3 y! a> s:={x,1,1-z,x};
; Y% @3 X$ C1 F" ^" Z4 V& j& A4 ~
  f4 H# u4 _& J& Q  m; \/ b> whattype(%);
; Z4 |! u" P/ ~ : K" J7 E/ k; u9 ?
空集定义为{ }. ' A% I! M% e/ K% D; \! A
函数nop返回列表或集合的元素数, 而op则可返回其第I个元素.
1 g0 ~4 o, W& q% ]7 n> op(1,s);6 n# u, G8 w' p7 h% M' n# ]8 E

) D9 [5 Y: b4 y: g9 A; D> s[1];
. Y1 @: G0 G, a8 `
1 j# r( s: X% P, s3 i/ @> op(1..3,s);
2 i5 ?2 Q4 _! ^0 Z8 ] 7 ^' z  X/ u. t* @
> s[1..3];4 Z6 X* j) U6 |+ J: U1 r: s

1 W3 n8 `3 d  W, F# l% M函数member可以判定元素是否属于一个列表或集合, 如果属于, 返回true, 否则返回false.
* n; @7 v" S) b> member(1+x,s);9 y- l4 @7 L7 w+ k8 A5 ~

' P# V4 A0 b: _可以通过下述方法在列表中增减元素:   + X  H" J4 E5 z. C, I2 j& W
> t:=[op(s),x];6 ]7 G# Z  K8 z" l9 a) I

2 \) e% z1 Y" Z> u:=[s[1..5],s[7..nops(s)]];
% K% D4 Q; t) l: L+ T5 H 7 E5 r7 u. h8 U/ G3 s
Maple中集合的基本运算有交(intersect)、并(union)、差(minus):   # s$ M  z" Q) G
> A:={seq(i^3,i=1..10)};B:={seq(i^2,i=1..10)};
: L: \  a7 B% a: l9 {/ v
1 l, Y( ^. n; z0 o6 \ 7 e2 D- [& q# a$ A- Y, ~/ N
> A intersect B;
. ^' ~- e) X! n / {, x% v/ |; E, T9 H6 W8 i
> A union B; ) k6 y2 _& z5 _: k

5 R$ H5 A: G# A* `& s  _> A minus B;0 S  Y' G+ E  [& i3 Y) h; j+ r. M

( D7 e9 a. ?! [/ @& J4.3 数组和表
- A; Q( a1 c+ E/ Q1 ~在Maple中, 数组(array)由命令array产生, 其下标变量(index)可以自由指定. 下标由1开始的一维数组称为向量(vector), 二维以上的数组称为矩阵(matrix). 数组的元素按顺序排列, 任意存取一数组的元素要比列表或序列快的多. 区分一个数据结构是数组还是列表要用“type”命令. 3 |$ J# h! z( ]+ G
    表(table)在建立时使用圆括号, 变量能对一个表赋值, 但一个在存取在算子中的未赋值变量会被自动地假定是表, 表的索引可以成为任意Maple表达式. 表中元素的次序不是固定的. ) I+ o. p; c5 @; s+ x
> A:=array(1..4);" G, }: ?4 t8 ?3 I9 Q) b

: `: P; ~! c4 E) E7 W7 B> for i from 1 to 4 do A[i]:=i: od:5 N8 w! I5 H% U+ N9 m& U+ v% B
> eval(A);5 Z, R& A3 |. f" n* f3 n+ k

* r3 d1 J: X9 ^: I, {& V> type(A,array);
7 p0 K, @/ L7 Z
/ P# ?9 L% z. s& N' |> type(A,list);
1 [$ B* K8 D/ L3 b/ Y 1 \  q: v# M/ f: h% p& ?: S
> T:=table();
3 l" ]  E# w  W# G1 i
7 L' u8 J( K  `. G> T[1]:= 1;
: X9 [  d% U% F" j
& c- m" V% c$ w! X( ~7 c> T[5]:= 5;
' `, F/ E! L, m
) E4 _# K* Z  f( d* ]> T[3]:= 3;
" n- l) z9 p) B0 W( W$ }3 J ! F* J0 I8 J8 I' y- A
> T[sam]:=sally;! \2 `' {8 p, o+ U1 H/ s2 P
' c$ t( _- R7 p' x
> T[Pi]:=exp(1);. o2 @9 r) ?6 p. n  t
8 x6 J- W+ E; J! j$ R
> x:='x';
) f, a+ i- i. l" r
  [# H4 f+ `2 Y1 r) Z/ R5 M> T[(1+x+x^3)*sin(x)] := 0;
: Y2 C1 Z- b2 Z# C" ^7 E, s " g& B, k" ?3 T
> eval(T);3 }6 n) N5 A1 ]6 ?. X3 I5 e
: I4 P- ?$ Z) F; F; }% [
> T[3]:='T[3]';
3 a1 Y4 g! P% P' }+ x# H" |
% \% o+ O& R$ v; D> eval(T);0 E: i$ e4 j) R# i0 ?8 Q. _

. s6 H% r0 @/ ~/ h: ~2 w* q) u4.4 其他数据结构0 H& P) [8 G% \) x: G
串在Maple中是很重要的, 他们主要用于取名字和显示信息. 一个Maple的串可以作为变量名, 它们中的大多数是简单的、不需要加引号的串, 但是如果变量名中包含/. 例如“diff/T”则必须把变量名用引号括起来. : ]/ y8 j9 S+ Y/ K4 Q4 z
索引名是像Database[1,2,drawer]或A[3]这样的对象, 在使用索引前不需要直接建立表, 如果不得不做, Maple会自动建立表. 索引名通常被用于矩阵和向量. 为了保证Maple建立表的正确次序, 建议在赋值前直接建立. ; x6 r6 f+ ^0 X' G6 Z
> x:=T[3];# b4 I8 r$ T2 t; S: m+ C

: e0 k: L5 Z8 A( J> eval(T);2 N& U; b# G- q$ }; k7 ]2 A5 q5 u! H) z" f: z

1 X: }) s9 b6 W8 D( x> T[5]:=y;1 y# X! b; j8 |0 b8 ?  \; @% R
  V' U6 J2 ?- c
> eval(T);  E( {! T8 F' r, t5 A. Y

( _- ~" j: l5 q由此可见, Maple并不直接建立T的表, 直到给T[5]赋了值.     
, e$ j1 h" p2 Z0 E数值数据结构(整数、分数、有理数、浮点数、硬件浮点数和复数等)在它们的使用中是大量透明的. 浮点数是有传染性的, 这意味着如果数值结构中有一个是浮点数, 则整个结构自动转换为浮点数.
" F7 ^3 ]7 c2 d4 @$ @' B4.5 数据类型转换和合并
) M! ^. q1 S  x  w. X& Oconvert是一个功能强大的类型转换函数, 它可以实现列表和数组的类型转换:   + Z4 G8 O/ ^2 `
> L:=[1,2,3,4];
6 v* y4 c0 ~/ G( ^5 R1 |
7 W: j2 x* G. ]4 R  o3 b> type(L,list);4 [8 N, O: q! x/ K1 c# ~

" Z3 y1 _0 B8 ~& j: x( G; m% h> A:=convert(L,array);
& N# d! r$ k( j6 ^$ n0 x 9 g) p  ]' O- t5 J7 |9 h0 i  M
> type(A,list);: X" X; ^' u3 Y- {
# n( v9 f: X% m( m" [% e
> type(A,array);
$ F  i7 {# T$ W/ Q( ^3 f 5 h$ n7 G' }, ~* p8 [
另一个有用的函数zip则可把两个列表或向量合并:   % e0 f: c8 i, J; q; Q% f  S* `) M
>L:=[seq(i,i=1..10)];
, @! e4 Y# y9 e& c" M" g
+ N- ^/ j+ k* s1 m" e/ f/ V> Sqr:=(x)->x^2;
5 M5 I( T* |8 ?+ [ : I7 Q- i4 }/ ?9 F& K
> M:=map(sqr,L);
- l9 U. t! T. M+ _' o- B
; W, g" r* j) s7 A- c> LM:=zip((x,y)->[x,y],L,M);
0 A& X& I6 n  R  H* u! k 2 w0 b# O/ b4 s& F4 F) M: j
> map(op,LM);# h  P, N. x" c* ?( ?
1 k( U/ D! n2 J! t' Z  N% k3 N
5 Maple高级输入与输出操作6 o  j* x; f; C6 k2 N0 d2 J% W& @
Maple提供了良好的接口来编辑与计算数学式. 许多时候, 我们可能需要把Maple的运算结果输出到一个文件中, 或者在一个文本编辑器里先编好一个较大的Maple程序, 再将它加载到Maple的环境里. & Z' m. w% ~) ^, C6 ^' H6 x: Y6 O
5.1 写入文件
8 n" o3 F. P1 S5.1.1 将数值数据写入到一个文件
1 y4 N5 T' ], ?1 Q如果Maple的计算结果是一长串的数值串行或数组, 而想把它写到一个文件时, 用writedata命令.
" J  n) P5 p0 p" K, f若Maple的计算结果data为集合、矩阵、列表、向量等形式时, 将其写入名为filename的文件时命令格式为: writedata("filename", data);* {. b3 R4 z1 s6 z
> with(linalg):
& ]" _2 t' v" a& J> M:=matrix(3,3,[1,2,3,4,5,6,7,8,9]);5 }% Y# @7 b. @% W
- D$ N* E4 u  z
> writedata("e:\\filename.txt",M);
, `% {) W; l! A; V  f6 w- j而将结果附加在一个已存在的文件后时,使用命令: writedata[APPEND]("filename", data);
2 w, h) y' z6 E4 W  F  p> W:=matrix(2,2,[1,2,3,4]);7 T% k" Q: V) [: f' Z/ \* O1 M( r7 x
9 m" d1 O: G% l& Z
> writedata[APPEND]("e:\\filename.txt",W);# H5 v0 ~. j6 K2 o7 Q: o4 m: O
需要注意的是, 这里的APPEND是必需的, 否则W结果将会覆盖M结果.
) |, F" Y2 O4 e' Y# P" Q/ d& n另外, 若想将结果显示在屏幕上时, 用命令: writedata('terminal', data);5 |$ R$ f1 v8 B
> writedata[APPEND]("e:\\filename.txt",W); , d6 [: R1 T4 [. U5 O
> writedata('terminal',M);3 r! Y4 ]% u, Z: P1 D( U1 b/ c
1                   2                   3           
/ ?6 o" w! V. o# X4                   5                   6           * `. G6 X7 G; J1 i; t
7                   8                   9    9 f) l0 I$ t1 j" J$ W. s
5.1.2 将Maple语句写入一个文件
$ F1 a7 F) Y5 f8 ?如果所要写入文件的是表达式、函数的定义或者是一个完整的程序, 则使用命令save, 写入一个或多个语句的命令格式分别如下:
$ A2 J9 U- ~# b1 C! j9 J1 n: ^- D: _9 Lsave name, "filename";
- x* g  D3 `! I8 msave name1, name2, …, "filename";
, P0 U* U8 d' Y& @( Y# h若filename的扩展名为.m, 则Maple会以内定的格式储存, 若扩展名为.txt, 则以纯文本文件储存. 以内定的格式储存的文件作纯文本编辑器无法读取, 但在大多数情况下, 它会比纯文本文件的加载速度更快, 且文件容量小.
; n* L7 ]! U1 i> myfunc:=(k,n)->sum(x^k/k!,x=1..n);4 a" N+ h+ h# T5 M

/ J: h2 J! f5 m/ ^4 y5 m- O4 s> myresult:=myfunc(6,8);
3 R7 q4 ]$ `" s8 M! s! L ) t4 m4 H$ D" \8 k6 O
> save myfunc,myresult,"e:\\test.m";
& B" j( G9 h- U' F9 r调用已存m文件用命令read. 试看下述实验:
* w2 A( U2 K, i  |1 u> restart:
" r6 M4 Y, P; n: g> myfunc(6,8);2 \9 Q! W$ {0 A
. N# m$ v2 s9 \+ }7 m
> read "e:\\test.m";
: C, d4 \8 X: w# I> myfunc(6,8);7 n3 I( t5 z0 }; `5 U7 I
) V& f+ @0 m6 W* Z- f: }) J6 w2 ~6 |
> myresult;
, c, @4 B- V5 Z5 t* ?7 V( z" n 1 ^* w% N4 ^! D
    而存为txt文件时则将整个语句存为一个文件:
/ P' ]$ j* f" K4 L# h  W- ?> save myfunc,myresult,"e:\\test.txt";
' K0 [6 T5 `0 e1 U* \# z& o2 h> restart: read"e:\\test.txt";
9 z$ p$ @$ E! ^( l  V6 J 5 v) k% g$ q9 O7 ~

& H8 H' v& ^- b4 ]3 O  o/ i5.2 读取文件
/ K- i% R1 }+ I# ^# v' x9 {) V$ U- }2 t. B在Maple里最常用的两个读取文件的命令, 一个是读取数值数据, 另一个是是读取Maple的指令.6 L/ @4 Q8 z, O% p
5.2.1 读取数值数据
) v+ A! H5 c* k+ K% w如果想把大量的数据导入Maple里进行进一步的运算或者要运用大量的实验数据在Maple环境绘图时, 可以用readdata( )命令完成.2 y. K# d% v; s3 w# H6 H
从filename文件里读取n行数据时使用命令: readdata("filename",n);
7 g) A8 t- C7 H) g# v6 B6 f以指定的格式读取数据时使用命令: readdata("filename",[tyep1,type2,…]);" f% k7 S6 D* F% `9 t" I
> readdata("e:\\filename.txt",3);
$ Y/ P# Y( C' m7 a6 f/ d9 Y
. m# ?2 K; }8 R( H6 |6 L" r, e    读取filename的前三列, 第一列为整数形式, 第二、三列为浮点数形式:
' |" i0 |% `: @* o> readdata("e:\\filename.txt",[integer,float,float]);
# n& |) `' _' }3 H/ [
8 y0 K( t8 a# G/ ~1 x- l下面再看一个运用大量的实验数据在Maple环境绘图的实验:
0 `0 n+ |- ~0 i6 _( n* j. ]> mypts:=[seq([x/1000,cos(x^2/100000)],x=1..1000)]:' k4 q2 {1 O# U* g. ]5 P0 L0 _/ s
> writedata("e:\\data.txt",evalf(mypts));# d+ B& h: p3 z1 A9 a  ?' D" r
> dots:=readdata("e:\\data.txt",100):
7 g, ~. ~* ?7 |0 j. g5 ?. g> nops(dots);
- T$ a% z# q8 i0 Q0 K$ Z8 w , a7 k  T% b8 H' @; x3 G) P
> dots[1..4];, Y1 z- Q! D9 G
9 D7 k" n$ Y/ q% U' D$ w
> plot(dots,style=line);8 \, L, y" j9 g/ U5 k$ h( g$ g

  A  N: P$ Q$ k3 d5.2.2 读取Maple的指令$ M' n. m6 [) _; _4 r; t
在编写程序时, 在普通软件中先编好程序再将其读入Maple环境中常常比直接在Maple中编写更为方便. 如果要将程序代码或Maple指令加载用read命令:
/ ~4 n& U( a; U) Q7 o! {0 Kread "filename";2 K) t$ h8 m% ]6 @8 i
如下例:; a: ~% x6 @6 \, i
> reatart:
( B; z8 l. i# D, `> myfunc:=(a::list)->add(i,i=a);/ \- _8 O& C* l9 F0 G

( N! a3 P$ c8 H0 M3 G> avg:=(a::list)->myfunc(a)/nops(a);3 c9 k6 [( _$ @% {+ C0 _

( |; }: z, S. }1 R> save myfunc,avg,"e:\\function.m";
8 l7 r. `# k* {> restart:
' o- X! ~& r7 R. B! r> read "e:\\function.m";6 }' q! j# \2 a  P
> myfunc([1,2,3,4,5,6,7,8,9]);
) w4 i3 _* I% d! W5 Z1 ~! p4 d ' P, S2 T# N+ J- E- S" L# N
> avg([1,2,3,4,5,6,7,8,9]);
. G+ G0 L3 P5 O, @
* W9 F3 b  r# j8 ]7 S9 q5.3 与其它程序语言的连接' u& _0 d( W3 E0 m* i3 K9 x
5.3.1 转换成FORTRAN或C语言' a3 D! ]* P. x) W
调用codegen程序包中的fortran命令可以把Maple的结果转换成FORTRAN语言:
6 V7 C8 y' _" p$ J& M6 k> with(codegen,fortran):$ ]9 f9 K8 B: X/ C
f:= 1-2*x+3*x^2-2*x^3+x^4;
( d$ e6 |) U  H. J$ m4 p
0 u3 d& \2 J& E7 a, e. u2 w% f2 W> fortran(%);; e% ^) \  y/ Q" E
      t0 = 1-2*x+3*x**2-2*x**3+x**4
; P2 h- P, V. K > fortran(f,optimized);- O: x3 h2 g8 v# n; `& k
      t2 = x**2: ~+ x3 r0 t% ?! ^# ~
      t6 = t2**2
, P+ A1 [" o$ m* X, C      t7 = 1-2*x+3*t2-2*t2*x+t6
3 g% A0 e$ `* R0 ]> fortran(convert(f,horner,x));* }5 W3 b' Y6 J& t$ I" c
      t0 = 1+(-2+(3+(-2+x)*x)*x)*x
- a& `7 b4 c4 M而codegen程序包中的C命令可以把Maple结果转换成C语言格式:
2 f. m' v( I4 j+ V3 C3 h5 L> with(codegen,C):; ~" D' P+ N$ F/ _# p  q
f:=1-x/2+3*x^2-x^3+x^4;" X6 o8 F: `) F! @
7 O7 o* `/ I1 T& F: @  Y
> C(f);
3 t5 J9 e1 V8 E' e      t0 = 1.0-x/2.0+3.0*x*x-x*x*x+x*x*x*x;
: _. X  w% ^7 S$ a> C(f,optimized);
/ \8 j3 s; \# E; t" T' d+ a      t2 = x*x;2 K! c- _+ D2 p2 n( y# ]
      t5 = t2*t2;
  g1 c1 |! b( B      t6 = 1.0-x/2.0+3.0*t2-t2*x+t5;
2 o$ C! D4 ^) @% `$ goptimized命令表示要对转换的表达式进行优化, 如果不加此可选参数, 则直接对表达式进行一一对应的转换.4 O5 z1 m1 n/ y5 |- u% j
5.3.2 生成LATEX
) P& y8 z- w7 V  V% _) }Maple可以把它的表达式转换成LATEX, 使用latex命令即可:
5 M* \6 j) r0 }. D/ I> latex(x^2+y^2=z^2);+ k! a8 U7 K! v% h8 T
{x}^{2}+{y}^{2}={z}^{2}4 j  q' b( J. r. w4 u
    还可以将转换结果存为一个文件(LatexFile):3 |4 u2 U2 }# v' t- T5 n- \
> latex(x^2 + y^2 = z^2, LatexFile);
$ ?1 ~. N4 s' s    再如下例:- x$ _8 \/ K" Z
> latex(Int(1/(x^2+1),x)=int(1/(x^2+1),x));) G2 N3 l% D" ?  V& d
\int \! \left( {x}^{2}+1 \right) ^{-1}{dx}=\arctan\left( x \right)
- ?4 l. W! J4 t$ m5 r) c' u. m. Y1 C9 K8 n0 E0 o# G
zan
已有 1 人评分体力 收起 理由
darker50 + 2 用word发不是很好吗?呵呵!

总评分: 体力 + 2   查看全部评分

转播转播0 分享淘帖0 分享分享0 收藏收藏1 支持支持0 反对反对0 微信微信

0

主题

13

听众

27

积分

升级  23.16%

  • TA的每日心情
    奋斗
    2015-9-29 17:01
  • 签到天数: 10 天

    [LV.3]偶尔看看II

    社区QQ达人

    群组国赛讨论

    回复

    使用道具 举报

    0

    主题

    4

    听众

    181

    积分

    升级  40.5%

  • TA的每日心情
    开心
    2012-10-11 12:35
  • 签到天数: 51 天

    [LV.5]常住居民I

    群组学术交流A

    群组学术交流B

    回复

    使用道具 举报

    0

    主题

    2

    听众

    19

    积分

    升级  14.74%

    该用户从未签到

    新人进步奖

    回复

    使用道具 举报

    46

    主题

    3

    听众

    1967

    积分

    升级  96.7%

  • TA的每日心情

    2014-4-15 00:06
  • 签到天数: 5 天

    [LV.2]偶尔看看I

    社区QQ达人 新人进步奖

    群组数学建模

    群组数学趣味、游戏、IQ等

    群组LINGO

    听说女人如衣服,兄弟如手足。回想起来,我竟然七手八脚的裸奔了20年!
    & J. U6 p2 v# E5 q* F5 s3 c
    8 T9 s, w6 ~& V( e  L. Y! _4 e& B. m+ [' }  w; m
    回复

    使用道具 举报

    33

    主题

    10

    听众

    1691

    积分

    升级  69.1%

  • TA的每日心情
    开心
    2014-7-8 08:29
  • 签到天数: 201 天

    [LV.7]常住居民III

    发帖功臣 新人进步奖

    群组PLC和单片机

    群组2012第三期美赛培训

    群组MCM优秀论文解析专题

    群组沈阳理工应用技术学院

    群组学术交流B

    回复

    使用道具 举报

    33

    主题

    10

    听众

    1691

    积分

    升级  69.1%

  • TA的每日心情
    开心
    2014-7-8 08:29
  • 签到天数: 201 天

    [LV.7]常住居民III

    发帖功臣 新人进步奖

    群组PLC和单片机

    群组2012第三期美赛培训

    群组MCM优秀论文解析专题

    群组沈阳理工应用技术学院

    群组学术交流B

    回复

    使用道具 举报

    darker50        

    107

    主题

    45

    听众

    1万

    积分

  • TA的每日心情
    开心
    2015-4-9 15:42
  • 签到天数: 47 天

    [LV.5]常住居民I

    自我介绍
    开朗,爱各种娱乐的不老男生就是我了,喜欢数学建模,喜欢那种帮助别人的感觉。

    社区QQ达人 助人为乐奖 新人进步奖

    回复

    使用道具 举报

    您需要登录后才可以回帖 登录 | 注册地址

    qq
    收缩
    • 电话咨询

    • 04714969085
    fastpost

    关于我们| 联系我们| 诚征英才| 对外合作| 产品服务| QQ

    手机版|Archiver| |繁體中文 手机客户端  

    蒙公网安备 15010502000194号

    Powered by Discuz! X2.5   © 2001-2013 数学建模网-数学中国 ( 蒙ICP备14002410号-3 蒙BBS备-0002号 )     论坛法律顾问:王兆丰

    GMT+8, 2025-7-26 14:37 , Processed in 0.836503 second(s), 100 queries .

    回顶部