在线时间 0 小时 最后登录 2012-6-12 注册时间 2012-6-11 听众数 5 收听数 0 能力 0 分 体力 5 点 威望 0 点 阅读权限 10 积分 4 相册 0 日志 0 记录 0 帖子 5 主题 1 精华 0 分享 0 好友 4
升级 80%
该用户从未签到
自我介绍 爱学习
3 Z. e- C( v [! k* j7 t% T
第一章 Maple基础
& U( Q8 x9 I# C* o/ s& K3 I5 I
3 i: X* H: d( w+ f5 ` 1 初识计算机代数系统Maple; X+ t, p f# x* ^) U" Z
1.1 Maple简说1 e/ s( Q, e; }" U
1980年9月, 加拿大Waterloo大学的符号计算机研究小组成立, 开始了符号计算在计算机上实现的研究项目, 数学软件Maple是这个项目的产品. 目前, 这仍是一个正在研究的项目.
; m$ m1 w4 z6 n! U6 c Maple的第一个商业版本是1985年出版的. 随后几经更新, 到1992年, Windows系统下的Maple 2面世后, Maple被广泛地使用, 得到越来越多的用户. 特别是1994年, Maple 3出版后, 兴起了Maple热. 1996年初, Maple 4问世, 1998年初, Maple 5正式发行. 目前广泛流行的是Maple 7以及2002年5月面市的Maple 8.
2 u s3 z6 q# j: ` Maple是一个具有强大符号运算能力、数值计算能力、图形处理能力的交互式计算机代数系统(Computer Algebra System). 它可以借助键盘和显示器代替原来的笔和纸进行各种科学计算、数学推理、猜想的证明以及智能化文字处理.
5 ]6 o3 a- {+ L; Z" b Maple这个超强数学工具不仅适合数学家、物理学家、工程师, 还适合化学家、生物学家和社会学家, 总之, 它适合于所有需要科学计算的人.
4 W( G. N2 v U1 U6 s2 O7 } 1.2 Maple结构
4 \" V, n5 R2 D! G Q3 s! _% N Z Maple软件主要由三个部分组成: 用户界面(Iris)、代数运算器(Kernel)、外部函数库(External library). 用户界面和代数运算器是用C语言写成的, 只占整个软件的一小部分, 当系统启动时, 即被装入, 主要负责输入命令和算式的初步处理、显示结果、函数图象的显示等. 代数运算器负责输入的编译、基本的代数运算(如有理数运算、初等代数运算等)以及内存的管理. Maple的大部分数学函数和过程是用Maple自身的语言写成的, 存于外部函数库中. 当一个函数被调用时, 在多数情况下, Maple会自动将该函数的过程调入内存, 一些不常用的函数才需要用户自己调入, 如线性代数包、统计包等, 这使得Maple在资源的利用上具有很大的优势, 只有最有用的东西才留驻内存, 这保证了Maple可以在较小内存的计算机上正常运行. 用户可以查看Maple的非内存函数的源程序, 也可以将自己编的函数、过程加到Maple的程序库中, 或建立自己的函数库.
0 }: O( P( N" @ 1.3 Maple输入输出方式0 x9 A; S: R, V6 C, G% S( J; F% I
为了满足不同用户的需要, Maple可以更换输入输出格式: 从菜单“Options | Input Display和Out Display下可以选择所需的输入输出格式.
) S ]& e: \7 O7 c Maple 7有2种输入方式: Maple语言(Maple Notation)和标准数学记法(Standard Math Notation). Maple语言是一种结构良好、方便实用的内建高级语言, 它的语法和Pascal或C有一定程度的相似, 但有很大差别. 它支持多种数据操作命令, 如函数、序列、集合、列表、数组、表, 还包含许多数据操作命令, 如类型检验、选择、组合等. 标准数学记法就是我们常用的数学语言. & J9 m* c7 O, z
启动Maple, 会出现新建文档中的“[>”提示符, 这是Maple中可执行块的标志, 在“>”后即可输入命令, 结束用“;”(显示输出结果)或者“:”(不显示输出结果). 但是, 值得注意的是, 并不是说Maple的每一行只能执行一句命令, 而是在一个完整的可执行块中健入回车之后, Maple会执行当前执行块中所有命令(可以是若干条命令或者是一段程序). 如果要输入的命令很长, 不能在一行输完, 可以换行输入, 此时换行命令用“shift+Enter”组合键, 而在最后一行加入结束标志“;”或“:”, 也可在非末行尾加符号“\”完成.
8 v! X2 C8 o) t2 S+ c3 R1 g5 c& K Maple 7有4种输出方式: Maple语言、格式化文本(Character Notation)、固定格式记法(Typeset Notation)、标准数学记法(Standard Math Notation). 通常采用标准数学记法. 7 {8 \! A8 C" D, ?9 o, `/ x
Maple会认识一些输入的变量名称, 如希腊字母等. 为了使用方便, 现将希腊字母表罗列如下,输入时只需录入相应的英文,要输入大写希腊字母, 只需把英文首字母大写:
# v- e( V! K6 l& D I- t: N6 y
0 }. D: f) _) I( N% Z4 N
" X! k3 q5 i/ R8 x. m
) F" o. N+ Y9 d
& O9 F% M+ c5 M1 K 9 o3 r, j" ]& u; w# D+ i
' A. I2 m3 x! ]0 U' Y( ~
, O% l3 K: ^& L
4 p9 `1 Y2 L5 B; t( K+ ?, ^$ N( P/ a
1 |% N0 C* g r" i9 r* A
% j6 i+ y+ z( D! A5 N" b
; R* n. Y) i- D+ W b
) l! ~; E2 ?: P, v) Q9 Y 1 {; L" O3 h$ ]) I& j0 M# {- [' R
alpha beta gamma delta epsilon zeta eta theta iota kappa lambda mu
3 k, \8 u* s( B5 v( |" Z0 k ; r4 k I) q, u, [
2 v7 d9 p Q# q6 L4 S" b) R - d; J; s7 F4 f# F- d4 H
2 x/ Y' e2 z3 | & O+ i0 B/ ~3 k9 Y; D' C
4 ]5 O8 H) _4 I( g! x
: c. {, |% C7 g$ U* w" y
# }8 r1 I1 R+ `; |: D4 ~! m7 B ) H7 u* z+ x& i" o% a% x' ]) F
# S# _4 D2 t* L. G
& M( k& ]( a: q) B 0 w1 Z# ~2 w% n, F" J% G
- b- m& n2 A# v% F& O8 ` nu xi omicron pi rho sigma tau upsilon phi chi psi omega
7 z: J" Z m3 U2 [ 有时候为了美观或特殊需要,可以采用Maple中的函数或程序设计方式控制其输出方式,如下例:' l+ p# c! d" o) v0 h
> for i to 10 do
: @4 @+ j9 K: X) y/ i printf("i=%+2d and i^(1/2)=%+6.3f", i, eval(sqrt(i))); C/ R7 V9 y/ Q- l x
od;
3 {( F& B8 B. y4 V3 o i=+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
$ I* Z% c/ m7 ]7 K h +2d的含义是带符号的十进位整数,域宽为2. 显然,这种输出方式不是我们想要的,为了得到更美观的输出效果,在语句中加入换行控制符“\n”即可:# }7 u, Z1 l6 M: L
> for i to 10 do
5 z9 n( s' X1 c# c8 h. m8 X printf("i=%+2d and i^(1/2)=%+6.3f\n", i, eval(sqrt(i)));
/ `# A) k- E5 x; r: V! } od;6 i8 h. u6 |8 o; D, M, b" H
i=+1 and i^(1/2)=+1.000- r' ?# D0 C+ z. U% P
i=+2 and i^(1/2)=+1.414, ]( X2 m3 \) I4 m, u4 K7 Z' I7 ^* G
i=+3 and i^(1/2)=+1.732+ T2 a2 h w; A. c4 o% N
i=+4 and i^(1/2)=+2.000# I- J9 c! y; `0 G& l' Y
i=+5 and i^(1/2)=+2.236/ _7 X/ h- T: [, V! A" Z5 e
i=+6 and i^(1/2)=+2.4494 ~" X; U0 F$ i) ~ w- e1 y
i=+7 and i^(1/2)=+2.646
6 Z# ^3 B( Z$ p0 w2 A1 Q6 o" o5 T i=+8 and i^(1/2)=+2.828
9 G) f- p; H6 M i=+9 and i^(1/2)=+3.000. p( B3 I4 h& ]- X* ]8 N8 ^4 M
i=+10 and i^(1/2)=+3.1627 h7 C8 ~# `9 ]( W
再看下例:将输入的两个数字用特殊形式打印:5 e: R( J& o. u3 R8 \3 A& o6 @( r- S
> niceP:=proc(x,y)! a9 g( m6 x; F' C' Z# j
printf("value of x=%6.4f, value of y=%6.4f",x,y);. @' C$ U8 X. D3 [& C- a y
end proc;
+ s. @9 X& l! c& }
. \2 b. q `8 ^5 G > niceP(2.4,2002.204);
/ o- X* G1 b+ c2 V value of x=2.4000, value of y=2002.20401 r+ w6 v1 Z: j. r3 v
1.4 Maple联机帮助
( r/ z! v7 M- T7 Z* \4 K 学会寻求联机帮助是掌握一个软件的钥匙. Maple有一个非常好的联机帮助系统, 它包含了90%以上命令的使用说明. 要了解Maple的功能可用菜单帮助“Help”, 它给出Maple内容的浏览表, 这是一种树结构的目录表, 跟有…的词条说明其后还有子目录, 点击这样的词条后子目录就会出现(也可以用Tab键和up, down选定). 可以从底栏中看到函数命令全称, 例如, 我们选graphics…, 出现该条的子目录, 从中选2D…, 再选plot就可得到作函数图象的命令plot的完整帮助信息. 一般帮助信息都有实例, 我们可以将实例中的命令部分拷贝到作业面进行计算、演示, 由此可了解该命令的作用.
) H+ L. B6 x0 q& J 在使用过程中, 如果对一个命令把握不准, 可用键盘命令对某个命令进行查询. 例如, 在命令区输入命令“?plot”(或help(plot);), 然后回车将给出plot命令的帮助信息, 或者将鼠标放在选定的要查询的命令的任何位置再点击菜单中的“Help”即可. 2 x1 X; r/ ?( R$ [' i/ x8 \
2 Maple的基本运算
: H6 b p; l4 T% a( e; c1 H 2.1 数值计算问题+ J. A1 t+ R3 H/ e! t' W0 N" ~
算术是数学中最古老、最基础和最初等的一个分支, 它研究数的性质及其运算, 主要包括自然数、分数、小数的性质以及他们的加、减、乘、除四则运算. 在应用Maple做算术运算时, 只需将Maple当作一个“计算器”使用, 所不同的是命令结束时需加“;”或“:”. ( P: F5 k% s/ Y) B8 \ W2 U% \
在Maple中, 主要的算术运算符有“+”(加)、“–”(减)、“*”(乘)、“/”(除)以及“^”(乘方或幂,或记为**), 算术运算符与数字或字母一起组成任意表达式, 但其中“+”、“*”是最基本的运算, 其余运算均可归诸于求和或乘积形式. 算述表达式运算的次序为: 从左到右, 圆括号最先, 幂运算优先, 其次是乘除,最后是加减. 值得注意的是, “^”的表达式只能有两个操作数, 换言之, 是错误的, 而“+”或“*”的任意表达式可以有两个或者两个以上的操作数.
1 r/ b' p x6 i6 o/ G; J Maple有能力精确计算任意位的整数、有理数或者实数、复数的四则运算, 以及模算术、硬件浮点数和任意精度的浮点数甚至于矩阵的计算等等. 总之, Maple可以进行任意数值计算.
! F2 r @9 T+ K9 P' G- ^0 E 但是, 任何软件或程序毕竟只是人们进行科学研究的一种必要的辅助, 即便它有很多优点, 但也有它的局限性, 为了客观地认识数学软件、认识Maple, 下面通过两个简单例子予以说明.
: I5 s$ P4 Q+ e9 c 第一个简单的数值计算实例想说明Maple数值计算的答案的正确性: & D; b" [3 `. e% J0 p% y# ?! L' @
> 3!!!;
" W2 Y7 R. D. I" g7 r 2601218943565795100204903227081043611191521875016945785727541837850835631156947382240678577958130457082619920575892247259536641565162052015873791984587740832529105244690388811884123764341191951045505346658616243271940197113909845536727278537099345629855586719369774070003700430783758997420676784016967207846280629229032107161669867260548988445514257193985499448939594496064045132362140265986193073249369770477606067680670176491669403034819961881455625195592566918830825514942947596537274845624628824234526597789737740896466553992435928786212515967483220976029505696699927284670563747137533019248313587076125412683415860129447566011455420749589952563543068288634631084965650682771552996256790845235702552186222358130016700834523443236821935793184701956510729781804354173890560727428048583995919729021726612291298420516067579036232337699453964191475175567557695392233803056825308599977441675784352815913461340394604901269542028838347101363733824484506660093348484440711931292537694657354337375724772230181534032647177531984537341478674327048457983786618703257405938924215709695994630557521063203263493209220738320923356309923267504401701760572026010829288042335606643089888710297380797578013056049576342838683057190662205291174822510536697756603029574043387983471518552602805333866357139101046336419769097397432285994219837046979109956303389604675889865795711176566670039156748153115943980043625399399731203066490601325311304719028898491856203766669164468791125249193754425845895000311561682974304641142538074897281723375955380661719801404677935614793635266265683339509760000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000
$ Y$ H( \# z+ Y 上述运算结果在IBM PC机(1G, 128M)上计算只需要0.01秒, 得到如此复杂的结果(1747位), 一个自然的问题是: 答案正确吗?
3 L6 Q! C. R' y- l* ~9 N 为了回答这个问题, 我们借助于数值分析方法, 由Stiring公式
5 Z4 u; E" C7 X7 A* ]3 } , B, c! @+ @& m7 d4 s/ P
可得: , 前三位数字与Maple输出结果相同, 且两者结果均为1747位. 另外, 在720!的计算中, 5的因子的个数为: ! y1 p0 z U Q1 [' R% Y
8 P" z* W% W4 E5 ?% @9 A" r
这些5与足够多的2相乘将得到178个0, 而Maple的输出结果中最后178位数为零. 由此, 可以相信Maple结果的正确性. * r# U6 g; G1 w% z' V
另一个例子则想说明Maple计算的局限性: ' Y6 k; b) ^) `# T
5 D( c3 ?+ X! k# | Maple在处理问题时, 为了避免失根, 从不求算术式的近似值, 分数则化简为既约分数. 因此, 在Maple中很容易得到:
2 d) A' w# I0 ~; b/ c$ }( z+ z4 e 5 T0 `/ L- y8 A/ ~/ s2 D
显然这是错误的. 这一点可以从代数的角度予以分析. ( \2 @4 o, J' I- K2 [" x; Y6 P
不妨设 , 则 , 即 , 显然 有3个结果, -2是其实数结果.
( {; Z# j, D7 E/ X9 i* L0 w 另一方面, 设 , 则 , 即:
q. r( f# D1 A' R- n( H
7 Y) D/ x* ? T! E& U 显然 有6个结果, -2、2是其实数结果.
: ?5 N. g: t* z. j2 j$ y! l/ @ 这个简单的例子说明了Maple在数值计算方面绝对不是万能的, 其计算结果也不是完全正确的, 但是, 通过更多的实验可以发现: Maple只可能丢失部分结果, 而不会增加或很少给出完全错误的结果(如上例中Maple的浮点数结果皆为 ). 这一点提醒我们, 在利用Maple或其他任何数学软件或应用程序进行科学计算时, 必须运用相关数学基础知识校验结果的正确性. & {8 U' t3 l3 ]' K: e* R1 ~. g9 }
尽管Maple存在缺陷(实际上, 任何一个数学软件或程序都存在缺陷), 但无数的事实说明Maple仍然不失为一个具有强大科学计算功能的计算机代数系统. 事实上, Maple同其他数学软件或程序一样只是科学计算的一个辅助工具, 数学基础才是数学科学中最重要的. 6 J O Q' I) m9 A7 l5 i$ ^
2.1.1 有理数运算" |# U7 K+ s) `, h
作为一个符号代数系统, Maple可以绝对避免算术运算的舍入误差. 与计算器不同, Maple从来不自作主张把算术式近似成浮点数, 而只是把两个有公因数的整数的商作化简处理. 如果要求出两个整数运算的近似值时, 只需在任意一个整数后加“.”(或“.0”), 或者利用“evalf”命令把表达式转换成浮点形式, 默认浮点数位是10 (即: Digits:=10, 据此可任意改变浮点数位, 如Digits:=20).
8 p+ O- U& q, H) m9 T5 x7 ? > 12!+(7*8^2)-12345/125;! ]+ X" d! f8 x2 w9 w* k8 Z
! f( e6 O6 `8 z& B
> 123456789/987654321;
! f3 h) k6 d5 i F. I. y9 w + F% x9 b U. `! g7 y
> evalf(%);1 |- h" @3 F$ I- K
. ?* t; e8 t% M > 10!; 100*100+1000+10+1; (100+100)*100-9;" j% c* u& ?3 C0 e+ z! A; F( q, f6 y! ?
' K) t0 p" r( o9 z5 U
0 k* p" _/ i/ U# C# c* \# F 0 k/ K' k* p7 y A
> big_number:=3^(3^3);
" F3 P2 @3 i& n8 M& ~, l
& X2 q2 p# e1 q, m+ J1 d+ [. O) |+ ^2 ^ > length(%);; Q0 q! s( X# ?0 U n' r
! L0 h. T- _% ]6 M5 a) t) i
上述实验中使用了一个变量“big_number”并用“:=”对其赋值, 与Pascal语言一样为一个变量赋值用的是“:=”. 而另一个函数“length”作用在整数上时是整数的十进制位数即数字的长度. “%”是一个非常有用的简写形式, 表示最后一次执行结果, 在本例中是上一行输出结果. 再看下面数值计算例子: 0 f M* }! Z& U1 N7 ^ T; @
1)整数的余(irem)/商(iquo)0 C0 u; h' [; K$ J5 _0 R7 D/ X
命令格式:
) s; K* H& A- `2 k% d irem(m,n); #求m除以n的余数
' x% U) m D8 ] irem(m,n,'q'); #求m除以n的余数, 并将商赋给q
! n- X3 Q: b9 S2 w iquo(m,n); #求m除以n的商数
' @5 s7 e; g" L4 q, } iquo(m,n,'r'); #求m除以n的商数, 并将余数赋给r
, |5 `5 R1 Q \" q7 z( { 其中, m, n是整数或整数函数, 也可以是代数值, 此时, irem保留为未求值. % C7 y% S9 K1 q* q- {+ q* X
> irem(2002,101,'q'); # 求2002除以101的余数, 将商赋给q
' V! u/ d0 F# d/ D2 J 5 K% x! u/ t* T4 |, h
> q; #显示q/ c2 U' f1 f7 T4 B& H
8 U2 @, L* s5 e
> iquo(2002,101,'r'); # 求2002除以101的商, 将余数赋给r
" U. l: \: `1 L, T3 y2 M, m: z# ~
. `0 s% c8 _8 f* Y% A, i! X5 f% ] > r; #显示r! m" n9 ]. i% N8 P `+ J* a
" o' q$ G: n& }/ i/ v* R > irem(x,3);
0 w" S8 x9 W( l2 X6 |( I* Z; ?( J
0 }- j! `8 m3 {6 [/ z 2)素数判别(isprime)' d1 ^$ S! c2 A4 _; B) n/ w! P
素数判别一直是初等数论的一个难点, 也是整数分解问题的基础. Maple提供的isprime命令可以判定一个整数n是否为素数. 命令格式: isprime(n);
6 Q& w: c ~3 q+ U; ? 如果判定n可分解, 则返回false, 如果返回true, 则n“很可能”是素数. ; N% w4 l4 @% u; ?' q
> isprime(2^(2^4)+1);
+ R; Q/ T" g% r, g - `0 v0 h7 Y6 K$ _# b( L$ ~
> isprime(2^(2^5)+1);
% L3 b: I) o) I* |* b
5 ^& X3 [% _( T/ R; e! V% H# f1 X 上述两个例子是一个有趣的数论难题。形如 的数称为Fermat数, 其中的素数称为Fermat素数, 显然, F0=3、F1=5、F2=17、F3=257、F4=65537都是素数. Fermat曾经猜想所有的Fn都是素数, 但是Euler在1732年证明了F5=641•6700417不是素数. 目前, 这仍是一个未解决的问题, 人们不知道还有没有Fermat素数, 更不知道这样的素数是否有无穷多.
8 j% g& V. s1 i: ~3 J+ G 3) 确定第i个素数(ithprime)1 |" w, [4 ?+ o6 h% T
若记第1个素数为2,判断第i个素数的命令格式: ithprime(i); ) [) q6 ^5 F- o- g9 ]8 g
> ithprime(2002);4 X" _) L( J* U2 w5 M% \
& g- O8 m r# ^4 Z" i > ithprime(10000);3 \ v, r: S2 `: P* Y/ o, ]3 @4 k r( l$ U
9 y. c, {* z J5 D) h
4) 确定下一个较大(nextprime)/较小(prevprime)素数. o0 z1 M1 z. y6 Z
当n为整数时,判断比n稍大或稍小的素数的命令格式为: + J. q" Y+ ]% Z0 G R
nextprime(n); . i4 Q# J3 S8 u& P
prevprime(n);
( X) f& D% p: x* P& u$ l/ ]5 o > nextprime(2002);3 K. ]0 N1 t# O6 @/ F
2 O6 Q @4 Z3 e, Q+ _ > prevprime(2002);! q6 N& s( h8 p2 g6 Z
8 k U. Q) |+ F* c 5) 一组数的最大值(max)/最小值(min). b; D; ]0 g* n; i2 o9 I+ \9 L
命令格式: max(x1,x2,…,xn); #求x1,x2,…,xn中的最大值
3 {9 m0 m! I. c# Q min(x1,x2,…,xn); #求x1,x2,…,xn中的最小值6 ` Y; X B& s8 \% N/ J8 y
> max(1/5,ln(3),9/17,-infinity);8 c3 `& u$ {+ w. n% n
6 ?! @; F+ f% w# c/ g
> min(x+1,x+2,y);4 k( s# @" g7 V1 l3 E3 s- r: ^
# q1 X$ b( i" T- a
6)模运算(mod/modp/mods)
% C9 Y3 W' c* I* \1 z( y 命令格式: e mod m; # 表达式e对m的整数的模运算
* R! y; o! P& `7 Y modp(e,m); # e对正数m的模运算- W' a- d+ n6 ?. u! s* S
mods(e,m); # e对m负对称数(即 -m)的模运算+ h" K. U+ i" B6 q( _, u
`mod`(e,m); # 表达式e对m的整数的模运算, 与e mod m等价3 A% n& \1 Z- x: C) W
值得注意的是, 要计算i^n mod m(其中i是一整数), 使用这种“明显的”语法是不必要的, 因为在计算模m之前, 指数要先在整数(可能导致一个非常大的整数)上计算. 更适合的是使用惰性运算符“&^”即: i &^n mod m, 此时, 指数运算将由mod运算符智能地处理. 另一方面, mod运算符的左面优先比其他运算符低, 而右面优先高于+和-, 但低于*和/. 8 J1 D! K) H1 p% m! a' ~, f' G3 f
> 2002 mod 101;
& q; h/ \* L- z0 ~
' B9 f( y! v t# T1 H# b > modp(2002,101);" R5 i! |. w& q# e
( u, Z9 K: t3 O7 D. q { > mods(49,100);7 {* l3 E7 Z) T( k0 p/ O3 m+ V
. j7 ?7 H; H4 W, H$ y# A9 }: f* P# w > mods(51,100);
, Y* F" }$ d: C# n
p6 B' p. a1 X+ P9 x6 M6 H > 2^101 mod 2002; # 同 2 &^101 mod 2002; {$ e R$ _6 z3 |8 C7 G5 ^+ D
1 f f; J- t( _+ C, g
7)随机数生成器(rand)5 {6 ]# u, [& ]# o! A; f; k. Q
命令格式: 2 [& w- ^2 \5 N6 j& j$ ^2 k9 q+ J+ R
rand( ); #随机返回一个12位数字的非负整数
: r) y6 I& s4 g* G o) W j6 l) v4 D rand(a..b); #调用rand(a..b)返回一个程序, 它在调用时生成一个在范围[a, b]内的随机数7 {/ T4 p/ ^8 N3 b D
> rand();# x1 U7 ~, o4 c( k5 q G5 M6 ]
/ |4 K7 L3 O5 r: I2 b' g
> myproc:=rand(1..2002):
% Y' F& [3 t; F0 ~( P3 h > myproc();
+ n% J3 [, P3 n" ]
* {/ ?1 R/ |- n& X" g [8 m > myproc();
3 y2 ^! z! q: Q, S* t% a$ W / c. Y# Q9 c) G& g7 W9 H, U
注意, rand(n)是rand(0..n-1)的简写形式.
* j* H# q: w/ S" P 2.1.2 复数运算
+ U# x& _, b4 H! u 复数是Maple中的基本数据类型. 虚数单位i在Maple中用I表示. 在运算中, 数值类型转化成复数类型是自动的, 所有的算术运算符对复数类型均适用. 另外还可以用Re( )、Im( )、conjugate( )和argument( )等函数分别计算实数的实部、虚部、共轭复数和幅角主值等运算. 试作如下实验: i: k3 r" m' x( `6 w3 ~
> complex_number:=(1+2*I)*(3+4*I);
6 R# H+ X5 x* |* w5 a7 r
" b a% K v- S, j. l > Re(%);Im(%%);conjugate(%%%);argument(complex_number);- T3 T9 H2 I# f5 M. f: J2 P
' M2 h4 [% a( L3 D: l$ Y5 G
& s. g; {* r d: {# U
$ ]+ b. w8 i6 ~7 \/ m1 x
6 @8 P% Z9 d* \: e, c% V/ m3 h 值得注意的是上行命令中均以“;”结束, 因此不能将命令中的2个%或3个%(最多只能用3个%)改为1个%, 因为%表示上一次输出结果, 若上行命令改为“,”结束, 则均可用1个%. ' n- c+ ~3 ?, P5 y" N. O
为了在符号表达式中进行复数运算, 可以用函数evalc( ), 函数evalc把表达式中所有的符号变量都当成实数, 也就是认为所有的复变量都写成 的形式, 其中a、b都是实变量. 另外还有一些实用命令, 分述如下: ' I! W, X( @* v0 _! j" m8 y
1) 绝对值函数. C! e+ [* p5 p; E- E* y. J% O# e
命令格式: abs(expr);
; x9 r- U0 V( ^. j5 Y& X 当expr为实数时,返回其绝对值,当expr为复数时,返回复数的模.. y7 g* W7 O2 D5 F" z1 m# e/ D
> abs(-2002); #常数的绝对值. D5 ]* Z, h7 c+ w5 T' v3 j3 P
- c# J5 _( p4 C; G% s2 V
> abs(1+2*I); #复数的模
9 c9 A0 K& S P' M0 ]0 T 0 Z1 D! Q- e+ p# g) v% G* L2 u
> abs(sqrt(3)*I*u^2*v); #复数表达式的绝对值. z3 e- B9 B. C/ d+ W0 G
/ L, N9 J9 m+ T7 ~% H! a$ g: U* w! A) e
> abs(2*x-5); #函数表达式的绝对值: o. u! g( c/ V1 k$ U8 P
; I6 j( Y' z: h$ Y: d/ M9 Q
2)复数的幅角函数2 j8 n- y1 J4 q+ r1 Z( P0 G/ F
命令格式: argument(x); #返回复数x的幅角的主值
8 u; q6 r- t& B& _' k4 R > argument(6+11*I);& [0 V& d2 x+ N7 u* d
* [9 w% m+ a9 X5 e8 j
> argument(exp(4*Pi/3*I));4 E: e! j* ?. I0 ]+ j9 Y
: R& E; i) G# w1 b
3)共轭复数
7 J- T" n- v7 E2 J9 A 命令格式: conjugate(x); #返回x的共轭复数: z/ f& j0 E& J7 X8 U
> conjugate(6+8*I);
7 Q4 A8 l( A/ a3 D) @
. w. z/ R, f7 Z5 C$ d > conjugate(exp(4*Pi/3*I));4 R8 T1 R; q3 R( |5 t% T
% i3 i) g8 X N) `( y$ P- m0 ~
2.1.3 数的进制转换+ Z+ [; Y7 o O8 ~
数的进制是数值运算中的一个重要问题. 而在Maple中数的进制转换非常容易, 使用convert命令即可. 4 u% X# q3 e( j& K0 v
命令格式: convert(expr, form, arg3, ...); 8 q: Y: Q8 F- v
其中, expr为任意表达式, form为一名称, arg3, ... 可选项.
* [6 F1 e. F/ s8 S 下面对其中常用数的转换予以概述. 而convert的其它功能将在后叙章节详述.
* ~) a; e! @, h7 S/ x 1)基数之间的转换 m) {5 `* v; K; h
命令格式:
; c# x4 I% W; \! @1 e convert(n, base, beta); #将基数为10的数n转换为基数为beta的数7 t3 K# e8 f8 C2 T) Q! f. N
convert(n, base, alpha, beta);#将基数为alpha的数字n转换为基数为beta的数% w9 |' |* J6 O5 X
> convert(2003,base,7); #将10进制数2002转换为7进制数, 结果为: (5561)7
+ B; x; ?9 z" ^& Y 3 [; ~0 q; q' l: f, B
> convert([1,6,5,5],base,7,10); #将7进制数5561转换为10进制数) Q4 G; C a( Y, O3 y% N" M* C8 i
. o1 \) d) v/ ?" v" Y* ?' A. _
> convert(2002,base,60); #将十进制数2002转换为60进制数, 得33(分钟)22(秒)
. d2 F- h& f- f; d; N1 Q$ j$ k U 7 L5 Z& B* O" z% x
2)转换为二进制形式
& B0 s/ B6 a: @ 命令格式: convert(n, binary);
7 N# H: y) N/ \) C0 \1 T6 f 其功能是将十进制数n转换为2进制数. 值得注意的是, 数可以是正的, 也可以是负的, 或者是整数, 或者是浮点数, 是浮点数时情况较为复杂. ' D. g# ] V1 A4 \" y& H) z
> convert(2002,binary);
5 b9 G' d+ \8 @ 7 j& q! ]$ a F0 U
> convert(-1999,binary); # S- y `4 V& }3 d
$ k3 ~, u8 n; D0 Z" h > convert(1999.7,binary);
( h( G4 B( B% C7 a
; q2 u; T- e3 H* f" k( h: b 3)转换为十进制形式- M& N2 d5 i9 a
其它数值转换为十进制的命令格式为: + f4 k# K8 C* o. r. y
convert(n, decimal, binary); #将一个2进制数n转换为10进制数
9 Y B* ^9 g- y5 u7 S convert(n, decimal, octal); #将一个8进制数n转换为10进制数# ] E: Z O2 L" t' N8 R* Y/ G
convert(string, decimal, hex); #将一个16进制字符串string转换为10进制数
! w! ~$ y7 c8 E( D5 V; r, \# b > convert(11111010010, decimal, binary);
, c8 a' r. Q& Z4 P4 `6 a0 ~
# G* e- a( |, w" |# I% Q( g6 I# F! ~ > convert(-1234, decimal, octal); ' N3 p# @0 ]8 G6 G- X- m. [
+ N+ w; N) ~4 [- I2 J# `; \7 X > convert("2A.C", decimal, hex); & H% J4 J8 W+ e
$ E7 K, ?; L- `
4) 转换为16进制数
0 X. E( j: k9 S9 ^. j. e4 l 将自然数n转换为16进制数的命令格式为: convert(n, hex);
{: M1 `7 M- `0 \5 s. f, ~ > convert(2002,hex); convert(1999,hex);; Y- z: m" J% s2 H' ^; o( O8 B8 h
% a; W2 h; k# Q+ j$ o! v
" U. S3 I0 E! @+ g& | 5)转换为浮点数& _4 C2 g M( a
命令格式: convert(expr, float);5 i0 J$ T. w `' s$ X6 }) A
注意, convert/float命令将任意表达式转换为精度为全局变量Digits的浮点数, 且仅是对evalf的调用.
; M' c% ~) ]& i( @5 F) Z. g > convert(1999/2002,float);
) `* E, Z, [' d2 y C: q. q
4 n* R9 t( u" V8 q& u > convert(Pi,float);" {# t7 i& \: D2 G0 {& b
! e2 D8 q9 I; X# f0 ~ 2.2 初等数学; o4 Z+ G0 i$ [. H) A
初等数学是数学的基础之一, 也是数学中最有魅力的一部分内容. 通过下面的内容我们可以领略Maple对初等数学的驾驭能力, 也可以通过这些实验对Maple产生一些感性认识.
" f5 R8 a4 Z4 U$ r 2.2.1 常用函数) `$ r4 u `2 U% R
作为一个数学工具, 基本的数学函数是必不可少的, Maple中的数学函数很多, 现例举一二如下:
. K8 {" \# ~1 T: b 指数函数: exp
7 j8 K' E+ N5 h2 T- q# l! ?- D, ]# f+ O 一般对数: log[a]
2 J, Y; }6 G( g0 P" f& u1 ]6 @* C 自然函数: ln
' y3 ], o* ~+ R# T# i; U; g 常用对数: log10* |9 R* O9 @9 P! w
平方根: sqrt
; }; s5 X# X4 W6 @7 n 绝对值: abs+ L8 ^) I+ V+ A- o# l2 r+ `
三角函数: sin、cos、tan、sec、csc、cot
/ u A; ]( H+ x2 f 反三角函数: arcsin、arccos、arctan、arcsec、arccsc、arccot; S& Y1 h3 q6 @5 V
双曲函数: sinh、cosh、tanh、sech、csch、coth
! n, A& r8 o2 Q% m- @8 C 反双曲函数: arcsinh、arccosh、arctanh、arcsech、arccsch、arccoth3 A7 u4 g6 c3 W: o: C: H2 k
贝赛尔函数: BesselI、BesselJ、BesselK、BesselY
- K' }: w! t# N4 { Gamma函数: GAMMA2 U6 W! @6 X2 _# | S
误差函数: erf
% K8 O1 \" }" S 函数是数学研究与应用的基础之一, 现通过一些实验说明Maple中的函数的用法及功能. : L Y5 ?( [$ v9 w; k
1) 确定乘积和不确定乘积$ ~* J/ I. K+ I
命令格式: product(f,k);
& m& }5 V& O' I product(f,k=m..n); ' ?6 `$ f! l1 S/ }1 h3 c% p
product(f,k=alpha); , b' a7 b# n5 x8 S- f( m
product(f,k=expr);
2 l" S4 ?) ?6 Y 其中, f—任意表达式, k—乘积指数名称, m,n—整数或任意表达式, alpha—代数数RootOf, expr—包含k的任意表达式.
) u( v( C! g2 h2 i$ ? > product(k^2,k=1..10); #计算 关于1..10的连乘0 y3 e) `9 B, H: W* L
j) ]' t ?0 F; S$ O > product(k^2,k); #计算 的不确定乘积( B. r) a- G8 a- m
5 k3 o' b, l# G" T M& N2 s2 Q9 R/ \
> product(a[k],k=0..5); #计算ai(i=0..5)的连乘- K) d& u- D+ k- H& z
/ X0 `8 E: }; h# G > product(a[k],k=0..n); #计算ai(i=0..n)的连乘, I* x& S& w3 T" J2 H+ V7 y, g
; \6 z, d, U6 M3 z > Product(n+k,k=0..m)=product(n+k,k=0..m); #计算(n+k)的连乘, 并写出其惰性表达式" C# w9 D4 y: b2 m0 R7 L
" y% Q& N1 O. q. O1 z > product(k,k=RootOf(x^3-2)); #计算 的三个根的乘积* n: e/ N* S1 s) ~9 ?$ j
1 c6 u: N5 ]* ^7 v; `" R; Z
product命令计算符号乘积, 常常用来计算一个公式的确实或不确实的乘积. 如果这个公式不能求值计算, Maple返回 函数. 典型的例子是:
2 n { k1 M+ d' r8 d > product(x+k,k=0..n-1);
% B/ Y/ p6 Y8 F; R9 V i" k
1 V; G- |8 @, t' u P+ J8 v 如果求一个有限序列值的乘积而不是计算一个公式, 则用mul命令. 如:
$ \: L% ~# |. Z6 w > mul(x+k,k=0..3);' O+ V; L' b+ L# f" m! C
. O2 Z( m" u( m; @! ]: M/ q 2)指数函数0 {" d K; ^7 t1 d
计算指数函数exp关于x的表达式的命令格式为: exp(x); + D# d3 ? Q7 W4 `& M3 Z% n
> exp(1);
+ D: E* @8 i# @6 J 4 G8 u; `7 x0 {$ c
> evalf(%);& {, i, o/ _ m+ C2 h
5 e% U, x8 g8 l+ m1 `/ l1 ?
> exp(1.29+2*I);
Y" D/ R+ Z# L) q6 D- T) }; Z9 ^6 W2 {
- s( j% V$ Z" H% u > evalc(exp(x+I*y));
% D6 A. i' a2 v: c
" @# e* C) ?9 Z+ u2 w8 h; j3 D# G& h) k 3)确定求和与不确定求和sum. f5 @# R/ D3 ~4 o3 L/ z% q
命令格式: sum(f,k); & b. w w7 |. b5 _
sum(f,k=m..n); ( f0 d9 k) H: z* ^
sum(f,k=alpha); 2 `) a/ F2 {+ v0 {) E1 ?
sum(f,k=expr);
5 ?1 ~( j% j1 @4 |! u' b" I4 V* q 其中, f—任意表达式, k—乘积指数名称, m,n—整数或任意表达式, alpha—代数数RootOf, expr—不含k的表达式.
& f- Z5 C& ~: e3 w( W > Sum(k^2,k=1..n)=sum(k^2,k=1..n);
3 |6 b w0 a& m. y1 S, `# S( Q! O/ u
: \' X* x; }3 f/ b' y* R > Sum(k^3,k=1..n)=sum(k^3,k=1..n);
8 B) ^. k; Y& l o) w
4 `( a4 T4 b* F3 I6 n* _ > Sum(k^4,k=1..n)=sum(k^4,k=1..n);
. w' ]* B% D0 F: n3 L+ T 5 } d# m! ~1 G4 X
> Sum(1/k!,k=0..infinity)=sum(1/k!,k=0..infinity);$ s: D- R- u/ y7 }8 ^
" |/ y0 n) l* T8 ]3 C/ f4 I( x# ]( x > sum(a[k]*x[k],k=0..n);
5 D0 C$ N: @: c& W' X 7 Q! f, a/ P* {8 L) ?, n! K
> Sum(k/(k+1),k)=sum(k/(k+1),k);9 H$ U9 D% }# ~% `
, J8 |3 w0 l/ v9 i! K7 b! R > sum(k/(k+1),k=RootOf(x^2-3));) I& |- n1 |$ g# W% \' T8 y
/ N$ q# l5 X, \. V
sum函数可计算一个公式的确定和与不确定和, 如果Maple无法计算封闭形式, 则返回未求值的结果. 值得注意的是, 在sum命令中将f和k用单引号括起来, 可避免过早求值. 这一点在某些情况下是必需的.
6 E" l" d' A H6 Z/ g4 v8 n' [ > Sum('k','k'=0..n)=sum('k','k'=0..n);" S& C! K6 a& R" H: d, K
B. l* k/ q" f1 W9 V5 t, Q 如果计算一个有限序列的值, 而不是计算一个公式, 可用add命令. 如: " J1 v- _( Q) R0 j) n
> add(k,k=1..100);$ z/ P% U+ X1 K& _* s P! Z/ F6 u
7 @; J; G* t* Z. c$ ?* r: O- s
尽管sum命令常常用于计算显式求和, 但在程序设计中计算一个显式和应该使用add命令. ) T$ _- E5 k$ Z
另外, sum知道各种求和方法, 并会对各类发散的求和给出正确的结果, 如果要将求和限制为收敛求和, 就必须检查显式的收敛性. * s: h. W5 Y/ X( \, l
3)三角函数/双曲函数( Y. ?( P( u6 \% D* D
命令格式: sin(x); cos(x); tan(x); cot(x); sec(x); csc(x);2 w9 I$ Y* N% P$ p3 p4 |+ B: I2 ]( {
sinh(x); cosh(x); tanh(x); coth(x); sech(x); csch(x);" Y& L0 ]3 {- q! V
其中, x为任意表达式. . a: t7 Q9 N5 X f6 _9 }4 p
值得注意的是三角函数/双曲函数的参数以弧度为单位. Maple提供了利用常见三角函数/双曲函数恒等式进行化简和展开的程序, 也有将其转化为其它函数的命令convert.& w0 P3 w" d+ V5 P' F
> Sin(Pi)=sin(Pi);) g" [3 ^1 v7 R7 _/ A% d$ F
- l8 A" m, q* {
> coth(1.9+2.1*I);6 e7 i8 G, r) N0 Q' \& c
0 V9 c5 g! y! ?, ]) W0 E3 L > expand(sin(x+y)); #展开表达式, n- i3 p8 [! L+ `8 h9 N. t& j
2 V2 E( V2 l2 T* k! C, U; Q& Q3 J > combine(%); #合并表达式
( H3 ~, W6 y: l7 I( E
4 E. ^0 s+ | Q+ D2 _1 S9 D > convert(sin(7*Pi/60),'radical');
& A. c) W4 `( H + g4 e4 H" v5 M& _( m% D
> evalf(%);
' t* I5 U! L9 n+ b3 R
( p. |% {5 m- s5 K 但有趣的是, combine只对sin, cos有效, 对tan, cot竟无能为力.
2 }! g* y# ]2 u- E- h" j" j* J 4)反三角函数/反双曲函数
: ]9 A: `3 p$ a& P* s8 {% b2 X 命令格式: arcsin(x); arccos(x); arctan(x); arccot(x); arcsec(x); arccsc(x);
$ _- W7 S8 t2 _& ~7 p6 Y arcsinh(x); arccosh(x); arctanh(x); arccoth(x); arcsech(x); arccsch(x); 1 |3 D* @/ @; z) G$ K# S
arctan(y,x);2 U! B! q; B/ i
其中, x, y为表达式. 反三角函数/反双曲函数的参数必须按弧度计算.
' H' x) N& h8 B" s 算子记法可用于对于反三角函数和反双曲函数. 例如, sin@@(-1)求值为arcsin.
' h/ u% |7 h# I) X2 g' d3 T > arcsinh(1);
q2 k' J# [: i/ U6 L! K 6 q* W# V. p0 R: l4 ]7 ?+ M# [
> cos(arcsin(x));; F T9 f3 T* D! B) ?5 W4 x
d. c* C/ z! B, {' f' i# o > arcsin(1.9+2.1*I);0 Z; k# Q5 x( Z1 K
& ^- `% o k0 f- j
5)对数函数
: M" L' k& [8 u) J# q 命令格式: ln(x); #自然对数
+ H; A/ z5 Q! O6 v' a log[a](x); #一般对数
5 y" y) b/ p- x log10(x); #常用对数2 `3 R7 X6 Y9 M- m8 k( H: Y1 O4 b
一般地, 在ln(x)中要求x>0. 但对于复数型表达式x, 有: 0 R7 X( B3 x& L
(其中, )* l3 B( s. ]2 x5 b/ ]
> ln(2002.0);
' M+ V" ]7 p" a$ W3 ~: }
' {$ R2 f' Z0 H4 v/ D3 J* V > ln(3+4*I);
; F: n8 L W1 Y' i / c6 D1 [4 d" P, J
> evalc(%); # 求出上式的实部、虚部
0 P5 K8 ], O9 k7 P. n
" v2 I7 Q( A9 b% ` > log10(1000000);" A3 O8 d5 q9 @% J7 z1 U% i
5 n1 f w& z/ f; T/ G% o2 r) i > simplify(%); #化简上式
0 X4 G: X1 g8 T 0 V0 C( A- [" {7 ` r5 P
2.2.2 函数的定义& ~+ V6 n( d& e4 [- F" s( w# R
Maple是一个计算机代数系统, 带未知或者已知字母变量的表达式是它的基本数据形式. 一个简单的问题是, 既然表达式中可以包含未知变量, 那么它是不是函数呢?试看下面一个例子:
+ G7 B- m2 V! c* ]9 y( ~1 I > f(x):=a*x^2+b*x+c;: q6 L$ H z$ d% w
7 l I B% o- }% R, E 可以看出, Maple接受了这样的赋值语句, 但f(x)是不是一个函数呢?要回答这个问题,一个简单的方法是求函数值: ' p$ W \3 S3 @; k4 \- }/ Y. V
> f(x),f(0),f(1/a);4 ^6 x/ p" n1 t2 g! O
; K0 E( Q' Q( [ [: S7 b
由上述结果可以看出, 用赋值方法定义的f(x)是一个表达式而不是一个函数, 因为f(x)不能把所定义的“自变量”或者“参数”转换成别的变量或表达式. 但从赋值“过程”可以看出, f(x)虽然也算是一个“函数”, 但却是一个没有具体定义的函数:
5 u( h3 ?1 Z0 [$ s3 ] > print(f);
- y( u% q! k: M1 J- E9 {; l. R& ~ 2 A9 ?4 O& ?2 y( T6 k# P
事实上, 我们所做的赋值运算, 只不过是在函数f的记忆表(remember table)中加入了f(x)在x上的值, 当我们把自变量换作0或1/a时, f(x)的记忆表中没有对应的表项, 所以输出结果就是抽象的表达式.
$ [) J3 g& i6 f0 N/ ^- p! O$ f 在Maple中, 要真正完成一个函数的定义, 需要用算子(也称箭头操作符):
& N( w! b) \6 R/ D! C r > f:=x->a*x^2+b*x+c;
4 T3 x( [2 ^! R, m7 W$ C( n7 z9 z
& v. n! D6 |& C& R8 p0 {: N2 k, S > f(x),f(0),f(1/a);* g- k# ?" ?0 S& S
" ~- @$ D' _# p, l# H0 U 多变量的函数也可以用同样的方法予以定义, 只不过要把所有的自变量定成一个序列, 并用一个括号“()”将它们括起来(这个括号是必须的, 因为括号运算优先于分隔符“,”).
! y2 `' _$ r+ L+ p0 ` > f:=(x,y)->x^2+y^2;
7 F2 S1 D v z , K7 c' `% I$ P) i- [
> f(1,2);, A0 t8 C4 N, H
9 l( Y+ G3 R: u* e) e
> f:=(x,y)->a*x*y*exp(x^2+y^2);* i4 E, n, N ?1 s7 l
' y' n" x# Y: m7 X2 W& r0 N 综上所述, 箭头操作符定义函数的方式一般为:
8 C( X0 g3 }9 y6 [; y. Q 一元函数: 参数->函数表达式/ Q d) I; h! ^3 C8 k; {
多多函数: (参数序列)->函数表达式3 m4 w7 N( T# S/ i6 D$ A
无参数函数也许不好理解, 但可以用来定义常函数: - F+ i; f( f0 P4 m: s- ]
> E:=()->exp(1);% p) _" B+ n1 E3 _8 s
, b+ Z; Z! B2 R( N, j/ d5 J > E();
& O/ k2 E: A: q- k7 r8 m' g & I. {1 q/ p6 |# ]- ~
> E(x);- n! U$ u1 G+ z
6 L; f2 z/ K. P 另一个定义函数的命令是unapply,其作用是从一个表达式建立一个算子或函数. # @0 ?8 M' V5 r8 R
定义一个表达式为expr的关于x的函数f的命令格式为: f:=unapply(expr, x);
6 C6 f) T D a" @ 定义一个表达式为expr的关于x,y,…的多元函数f的命令格式为: f:=unapply(expr, x, y, …); ; V2 {. `, ~2 | y' d) v6 U( f( y" [
> f:=unapply(x^4+x^3+x^2+x+1,x);
1 W9 y( ^4 Y9 N8 U7 s) c7 b5 f
, p8 j% Q- m5 i% z" C > f(4);
! |3 y3 F: I7 `. x# M# E8 [- \2 t - Q. ^8 `/ \4 O( Z3 U. j
> f:=unapply(x*y/(x^2+y^2),x,y);
2 M8 ?0 F0 r8 t( K) q8 F
# F) n: T6 `. s# y > f(1,1);. O+ m( U$ t. d7 H+ W2 G; N+ W
; u+ r, V5 V9 _ D7 c, Y8 m
借助函数piecewise可以生成简单分段函数:
, X" u5 k( p2 _9 s* _9 @7 V* ^3 t* r > abs(x)=piecewise(x>0,x,x=0,0,x<0,-x);& p; Z" h y u1 p5 f7 v
3 V: G: {; \, a+ P! V/ s
清除函数的定义用命令unassign.
% N" j C1 B6 o2 K, a > unassign(f);
1 }* }2 U- O- n" t0 [2 G7 N- [' U2 C; m > f(1,1);7 d: A) h$ @- e3 }0 P
* z: K/ B, m0 V: A8 R% m7 p* F
除此之外, 还可以通过程序设计方式定义函数(参见第6章). $ `! W5 K2 V8 C8 i" u
定义了一个函数后, 就可以使用op或nops指令查看有关函数中操作数的信息. nops(expr)返回操作数的个数, 函数op的主要功能是获取表达式的操作数,其命令格式为:
/ [( h* I' x0 u! A$ i: u4 E" N% Z op(expr);
6 P$ E. y1 e- J: n3 Y2 y op(i, expr); 9 d! c, r6 d5 F* X8 ~+ Z; `7 D
op(i .. j, expr); : P* X6 ~8 e4 ~9 Y
nops(expr);% f1 K$ ^6 x9 A R
如果函数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的类型.
1 H1 C1 ^) D, e7 u0 S! I3 q 命令op(i .. j, expr); 执行的结果是expr的第i到第j个操作数, i..j中含负整数时的情形同上.
1 d+ g2 n8 [: Q 命令op(expr); 等价于op(1..nops(expr), expr); 8 E- @- ]3 k j7 \/ j
特别地, 当op函数中i为列表[a1, a2, ..., an], 则op([a1, a2, ..., an], expr); 等价于op(an, op(..., op(a2, op(a1, e))...)); # r3 ]+ B4 a. L8 j, T
而当expr为一般表达式时,nops(expr)命令返回的是表达式的项数, 当expr是级数时返回级数每一项的系数和指数的总和.
* f* Q+ j" l7 g. O6 g > expr:=6+cos(x)+sin(x)*cos(x)^2;/ b, ]% n$ n0 r, `$ b) d
- ]! |' X1 X, z: f2 @4 ?: f" n
> op(expr);9 N; l3 X' _$ f, E) ?+ c( f3 M. W
5 `. p2 l% ^9 |! o+ C4 {
> nops(expr);
7 r M& V! t/ h8 Q) _5 \ ! S' m- B5 o8 F n
> p:=x^2*y+3*x^3*z+2;
% J6 h8 |: V5 Q! ]3 Z - p0 G6 d2 O& Q8 F, L) ? t1 n
> op(1,p);
0 f- S& R1 `9 X# a& D' H 8 O. b2 [/ |' q. G$ A4 h7 q
> op(1..nops(p),p);
7 N/ ^- |3 n1 o. z0 r9 h 8 S* _! \( p' q5 D
> op(op(2,p));
+ q) S- V8 |0 ]! J5 y$ m) N! q
" q, u7 {- k" {7 L: _! [ > u:=[1,4,9];
* e* m& \. r2 [1 @3 d( z # w# k$ {) w l9 Y* ~3 s" }( R
> op(0,u);
& S6 w# T; ]: x. K5 D- Z+ g7 A + `& V1 [ Q5 X6 o: d2 t
> s:=series(sin(x),x=1,3);
) w; V5 T' T! ]) A/ s0 z9 ~( t
3 D% g2 j% e' }, C' K > op(0,s);/ d5 c6 J7 \: J+ p$ X" N
3 U; v( A. }& _/ o9 [
> nops(s);7 P' I- ?" L( C' `) h6 x$ X
, R# U# d5 T) ?) d 下面一个有趣的例子说明了Maple在处理算术运算时的“个性”:1 U+ L {" G0 s' n1 H
> op(x*y*z);
% M {& f' i( Z' w, u) k 0 a+ T; o( W `. s- h- v
> op(x*y*z+1);4 `0 G5 e, B6 N% d! Q
/ T1 f: x1 U, q ?$ A# F
2.2.3 Maple中的常量与变量名
8 ?* X. w/ S3 I. V3 z, I 为了解决数学问题, 一些常用的数学常数是必要的. Maple系统中已经存储了一些数学常数在表达式序列constants中: 1 L$ H8 R1 }% ?) S
> constants;
+ m& Z' [3 u0 a- X# W6 E f
) W$ m/ u0 Q& K4 J: ]8 C& L# e! P 为了方便使用, 现将上述常数的具体含义列示如下: 7 T. A/ W. p$ M& y, M7 F& E
常 数 名 称 近似值4 u% V) P `+ H1 D2 n1 J
圆周率
9 z' h6 J) k8 d( Q6 y8 E Pi 3.1415926535
* E7 r( E1 s: w Catalan常数
% m4 z3 w( W$ J/ W3 x; J( q Catalan 0.9159655942) q' T9 {. N# c" E+ P; G
Euler-Mascheroni常数 3 z/ _* ?, |. d$ i' b1 ]9 r
gamma 0.5772156649
' j4 K9 J8 q5 L
1 b: [7 O5 h7 c( d/ g3 ^! o% W+ R infinity {3 {% c8 O. i# \
" _9 P+ u9 K, E 需要注意的是, 自然对数的底数e未作为一个常数出现, 但这个常数是存在的, 可以通过exp(1)来获取.
3 {$ y# E4 p# N; m- l5 l 在Maple中, 最简单的变量名是字符串, 变量名是由字母、数码或下划线组成的序列, 其中第一个字符必须是字母或是下划线. 名字的长度限制是499个字符. 在定义变量名时常用连接符“.”将两个字符串连接成一个名. 主要有三种形式: “名.自然数”、“名.字符串”、“名.表达式”. , \% q% O! ]# D1 c9 r# A$ A
值得注意的是, 在Maple中是区分字母大小写的. 在使用变量、常量和函数时应记住这一点. 数学常量 用Pi表示, 而pi则仅为符号 无任何意义. 如g, G, new_term, New_Team, x13a, x13A都是不同的变量名.
- }; G7 V+ U# A# g' z( E8 ?% @# ] 在Maple中有一些保留字不可以被用作变量名:
$ z( c; X' z' s5 K5 v2 W by do done elif else end fi for
9 T9 Y( S- ]6 H1 ^1 K4 U from if in local od option options proc
v" h" ]& o: Y quit read save stop then to while D
/ x' w0 _7 m( G i/ j; ] Maple中的内部函数如sin, cos, exp, sqrt, ……等也不可以作变量名. 9 ^' I' m7 T$ v5 j. c& ^& q$ M
另外一个值得注意的是在Maple中三种类型引号的不同作用:
2 U, ?" ?9 D9 \ ` `: 界定一个包含特殊字符的符号, 是为了输入特殊字符串用的; i% X* w* \, Q
' ': 界定一个暂时不求值的表达式;
# h5 t ^8 P* g " ": 界定一个字符串, 它不能被赋值. # T U6 p/ \' U* _
2.2.4 函数类型转换
+ D! g+ A8 e7 V! H; s 函数类型转换是数学应用中一个重要问题, 譬如, 将三角函数转换成指数函数, 双曲函数转换成指数函数, 等等. 在Maple中, 实现函数类型转换的命令是convert. 命令格式: " K- L7 `* d! R* Z, w9 C6 I# r1 P7 A9 h4 v
convert(expr, form); #把数学式expr转换成form的形式* m" y% w$ l8 K' ^' j6 @; `* a
convert(expr, form, x); #指定变量x, 此时form只适于exp、sin、cos
: k& g/ G% g0 _2 o P convert指令所提供的三角函数、指数与函数的转换共有exp等7种: $ ? K$ x" ~: e% `) [4 y/ J t
(1) exp: 将三角函数转换成指数
$ b. D. }3 v1 J6 ~3 a# Y4 p) W9 i (2) expln: 把数学式转换成指数与对数9 m: X( X% E& P1 l, x9 h
(3) expsincos: 分别把三角函数与双曲函数转换成sin、cos与指数的形式
6 P: v# r3 c$ b/ r. B (4) ln: 将反三角函数转换成对数
/ B/ N& m$ M& ^5 K9 p. A5 b (5) sincos: 将三角函数转换成sin与cos的形式, 而把双曲函数转换成sinh与cosh的形式
9 C& {, L: U/ C0 X1 | (6) tan: 将三角函数转换成tan的形式
& v/ e) m& U& o: G k9 T (7) trig: 将指数函数转换成三角函数与对数函数
9 X T9 _! a% ?0 _" Z/ O' ~ > convert(sinh(x),exp); #将sinh(x)转换成exp类型
$ G1 m1 Y8 l; I, p, G: W6 L2 z $ M1 v4 h7 ]4 J) F+ n8 z3 U
> convert(cos(x)*sinh(y),exp);
3 h% y6 B$ h" T% H5 g
2 C1 V+ T1 m$ Q > convert(cos(x)*sinh(y),exp,y);5 c: h3 y: I4 B( U' u
8 t" g, d& B( ~% g4 ~0 y > convert(exp(x)*exp(x^(-2)),trig);. N8 _; A; R0 \4 `9 ]* w
+ S8 k! E6 \5 h' G3 e8 ?. L > convert(arcsinh(x)*cos(x),expln);7 U; N8 k9 f! L$ X$ j b) M3 M/ ?6 j/ ?
/ i |( F+ t6 h2 |( b7 {, ? > convert(cot(x)+sinh(x),expsincos);
$ x/ ~, p' x0 @7 _ 6 ~* J8 a2 t/ S0 J% S: ]
> convert(arctanh(x),ln);
}" x* B4 H' Y% z: L: l$ g- X
0 J( G* F9 v, [+ N0 _3 U$ C convert在有理式的转换中也起着重要的作用. 在有关多项式运算的过程中, 利用秦九韶算法可以减少多项式求值的计算量. 在Maple中, 可以用函数convert将多项式转换为这种形式, 而cost则可以获取求值所需的计算量. 注意: cost命令是一个库函数, 第一次调用时需要使用with(codegen)加载. 例举如下:
# Z( A6 g7 B2 U8 I > with(codegen):$ U( B) i7 Z6 h2 l- a+ R) u
> p:=4*x^4+3*x^3+2*x^2-x;
# _0 S, \6 A7 H* _$ i4 ^7 s& y* g . O* [- g8 o+ f0 _0 k$ f
> cost(p);
! Q' D/ B& Z) I2 `
2 i" ~& B: o/ ~ > convert(p,'horner'); #将展开的表达式转换成嵌套形式
7 E; h$ {% b# A6 d5 Y
* O% U% g v9 M3 ]1 z1 Q+ R5 z > cost(%);
( a$ b6 K5 J2 z8 u
7 P1 R7 w$ t- x& @ 同样, 把分式化成连分式(continued fraction)形式也可以降低求值所需的计算量.
: ^3 }* z8 m. S/ w k$ q > (1+x+x^2+x^3)/p;9 D3 p+ i9 K8 [0 U* E5 _# O: E* V
. }% m5 w, G. Q8 q2 D# r/ B > cost(%);
8 _0 S. c9 C" e( W* f + l% Y, ^5 y: f
> convert(%%,'confrac',x);) u0 Q7 N4 l9 B, B" R* s1 B7 v7 G
0 c1 `6 N: a" _% w" V T > cost(%);* H' b4 v- J5 L# y$ v3 V, I8 `
& W- O J2 G% ]9 v: F0 ^
在某些场合下(比如求微分、积分时), 把分式化成部分分式(partial fraction)也就是几个最简分式的和式的形式也可以简化运算, 但简化程度不及连分数形式. - ]' ]# q0 B. T- J
> convert(%%, 'parfrac',x);9 |2 j' e0 p2 x1 X0 A
" J( `$ R: e8 P! I" R0 k
> cost(%);, _6 l. i; n/ D' N& t$ {+ C' h
) S* X) u/ G' Q/ U Z9 R% A* a, B
而把分数转换成连分数的方法为:+ |3 g( ]1 u& A$ h9 e1 P# l: [
> with(numtheory):
0 w: Q# k, F9 _9 O1 H > cfrac(339/284);- W4 W& {4 n+ `3 ~1 j" i! Z( c
" M3 @+ Q* G+ G W' O( S( y
2.2.5 函数的映射—map指令9 s) o# q0 i* j7 ]4 K% @) |
在符号运算的世界里, 映射指令map可以说是相当重要的一个指令, 它可以把函数或指令映射到这些结构里的元素, 而不破坏整个结构的完整性. 命令格式为:+ U% T% R+ d2 q- [: S% F6 a! D
map(f, expr); #将函数f映射到expr的每个操作数
, `) ^! `& B. O" X% m- x" u* w* _ map(f, expr, a); #将函数f映射到expr的每个操作数, 并取出a为f的第2个自变量: w& F3 [1 Q! x
map(f, expr, a1, a2,…, an); #将函数f映射到expr的每个操作数, 并取a1~an为f的第2~n+1个自变量
. O8 T' h6 @# u map2(f, a1, expr, a2, …, an); #以a1为第1个自变量, expr的操作数为第2个自变量, a2为
! z6 C+ q% \1 t# x E( e% ~. s- H 第3个自变量…, an为第n+1个自变量来映射函数f
" n: K Q0 _0 c > map(f,x1+x2+x3+x4,a1,a2,a3,a4);6 ?' L" \: d* A2 E; f) {
+ y; |2 i' w9 u) p9 Y) A2 t5 i > f:=x->sqrt(x)+x^2;
" f2 {6 d( O2 p; n5 ?
: }. _/ w7 g+ W) @2 q$ t- n4 g3 ` > map(f,[a,b,c]);
# M& U% X2 a- [- T( j; L$ M3 I $ b# I* p1 \3 T4 X
> map(h, [a,b,c],x,y);
3 n7 l" j6 u# d1 l1 E/ T) r
% H& U" @9 s% O- D5 ? > map(convert,[arcsinh(x/2),arccosh(x/2)],ln);& K' G4 m, N# X3 t$ N j; {. E% B" ]
5 r% T3 A; _5 P( h
> map(x->convert(x,exp),[sin(x),cos(x)]);4 Q* a4 u* c" O2 e
) f: b; Z7 ~ a 上式的映射关系可通过下式理解:& G5 R) U4 d/ c* a6 p: B
> [convert(sin(x),exp),convert(cos(x),exp)];6 P, f* U8 s$ U: q& j0 s3 @# r- M7 k
( q: l/ {' q0 _) k9 N9 a
> restart:
* w3 Y0 C2 n) @6 A* q map2(f,a1,x1+x2+x3+x4,a2,a3,a4);+ ~: X/ y" Z4 ]7 t( K9 u& ?
. [; i* m' Z/ N- j. m& Q7 }
> map2(max,k,[a,b,c,d]);
! M* y4 j1 G: c; A
; b F8 @( z: Y9 a6 ]: E( t 再看下面示例: # o: G N3 z" Q+ J
> L:=[seq(i,i=1..10)];$ d) } z5 M* _5 G( A I+ M8 s
/ K( j$ Z3 B; q* J0 N > nops(L);6 R! K/ v, o( M- `3 V" r) s1 ?
) S; _! b" e: U" c7 a# x% y
> sqr:=(x)->x^2;
" N ^& ~9 Q; \' R* G
- s/ G: W! X+ q) X" W$ E& p > map(sqr,L);
# `) I# `# g* J. I
: i4 c/ |7 ^7 F4 j > map((x)->x+1,L);$ P! c* I1 z: L7 e+ J4 X# u
, C1 o8 d* X" y' y s9 C > map(f,L); H8 k1 w1 C/ P* W3 i2 H
, M/ S; `# S8 J7 l > map(f,{a,b,c});- ~) V7 w% f$ X7 G0 L$ s: }* ]5 {
& T: c& H+ g6 W7 [, Q5 A0 K$ P9 _" _ > map(sqr,x+y*z);
+ d G9 o& o S. W f4 K, R, d
: I) k& u, r* Z > M:=linalg[matrix](3,3,(i,j)->i+j);; a n* a$ v1 @6 j/ N
" O }% O$ c3 H0 f5 F7 v, I! N: s
> map((x)->1/x,M);. o; f0 ]! A0 f( ^# h' c4 y
$ @; v. n( U8 R, a( O 3 求 值% U- {# C- n1 }+ H) o
3.1 赋值" l" h$ [7 \- ~* M0 [
在Maple中, 不需要申明变量的类型, 甚至在使用变量前不需要将它赋值, 这是Maple与其它高级程序设计语言不同的一点, 也正是Maple符号演算的魅力所在, 这个特性是由Maple与众不同的赋值方法决定的. 为了理解其赋值机制, 先看下面的例子.
7 R- {6 X+ n0 s) \; T2 { l* T > p:=9*x^3-37*x^2+47*x-19;" x8 C3 G7 U) {9 R) v4 J% a
' Z( l; b3 j) T: m > roots(p);
0 I7 K1 T* g1 f9 g
3 p) ~2 ~, f" f7 H6 t- a% ? > subs(x=19/9,p);
$ c4 v M; n2 s% W2 f' a% Z4 p) e2 N( \ * q. R9 o( i3 @8 Y! M
在这个例子中, 第一条语句是一个赋值语句, 它的作用是把变量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;”这样的简单语句即可验证. ; k/ g, O5 e+ N9 N2 `, r
3.2 变量代换) d8 ~1 U& F! e% D) u
在表达式化简中, 变量代换是一个得力工具. 我们可以利用函数subs根据自己的意愿进行变量代换, 最简单的调用这个函数的形式是这样的:
4 [3 f! ^ c/ r' U5 Q4 a subs ( var = repacedment, expression);
6 L% e: }% \) a: R 调用的结果是将表达式expression中所有变量var出现的地方替换成 replacement.
3 A8 }5 @- f! _4 ^* C2 | > f:=x^2+exp(x^3)-8;9 M- H, o! L7 @% {
3 n% F; f7 C- R; i& P+ ^2 j! D
> subs(x=1,f);
7 g* _( o* f$ k7 [; r3 Y' w % l5 I( c) S" L8 p$ d
> subs(x=0,cos(x)*(sin(x)+x^2+5));) ], d r& C/ z
6 c/ z$ Q) p. b- F4 C2 v" z1 e 由此可见, 变量替换只得到替换后的结果, 而不改变表达式的内容, 而且Maple只对替换的结果进行化简而不求值计算, 如果需要计算, 必须调用求值函数evalf. 如: 0 K5 d! d! P L2 c" B( e
> evalf(%);
L0 b# B( o" b" S. N
' R: h& Y) Q% M4 v& a2 F* b& @ 变量替换函数subs也可以进行多重的变量替换, 以两重代换为例:
! I; v. m' O5 @/ y subs (var1 = repacedment1, var2 = repacedment2, expression)6 e, c: j8 O! N6 r: I
调用的结果和按从左到右的顺序连续两次调用是一样的, 也就是先将expression中的var1替换成replacement1, 再将其结果中的var2替换成replacement2, 把这种替换称作顺序替换; 与此相对, 还可以进行同步替换, 即同时将expression中的var1替换成replacement1, 而var2替换成replacement2. 同步替换的调用形式为:
$ L6 N$ W% v' ^$ T4 L+ N8 s subs ( {var1 = repacedment1, var2 = repacedment2 }, expression)
& g5 w. P4 j& R3 }7 r5 ?- e+ G 下面通过例子说明这几种形式的替换.
) c+ i: T/ T& l) c( s > subs(x=y,y=z,x^2*y); (顺序替换)" Z/ C3 s+ A G: X
' [; o/ A/ Z! ?' `' b > subs({x=y,y=z},x^2*y); (同步替换)2 g0 s1 H2 f: F
) G0 O5 e+ N$ ^6 B# ~: d
> subs((a=b,b=c,c=a),a+2*b+3*c); (顺序替换)% D0 ~& S/ M4 H8 |
- k; U4 f0 s8 g3 L > subs({a=b,b=c,c=a},a+2*b+3*c); (轮 换)* H6 G/ U4 E; Q% q: P
0 R' k! Y" q9 E6 f: O+ ~: L7 \ > subs({p=q,q=p},f(p,q)); (互 换)
' X C& J. u* @) S/ b: E; r * q/ y" n5 b+ l! G% |
3.3 假设机制
1 ^3 G. p1 x7 O! ~" h u& E Maple是一种计算机代数语言, 显然, 很多人会尝试用Maple(或其他计算机代数语言)解决分析问题. 但由于分析问题与处理问题的考虑方法不同, 使得问题的解决存在某些困难. 例如考虑方程 的解. 如果k是实数, 结果显然是x=1, 但如果k是 的复根, 为了保证解x=1的正确性, 必需添加附带条件: 也就是当 时x=1. 这是一个对结果进行正确分析的例子. 然而从代数的角度考虑这个问题时就会把k当作不定元, 此时k没有值, 从方程两端去除k的多项式是合法的, 只要这个多项式不是零多项式即可(这一点是可以保证的, 因为其所有系数不全为0). 在此情况下x=1就不需要任何附加条件. 计算机代数系统经常采用这种分析的观点. 1 X1 i& E9 M& c, V
在Maple中, 采用分析观点解决这类带有一定附加条件的实用工具是函数assume, 其命令格式为: assume(x, prop);6 v; x( A& b# }1 ~ D
函数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);”也不会产生矛盾.
% h& U3 m) X) I# X/ j( ?4 b2 N > Int(exp(-s*t),t=0..infinity);5 e$ ^2 N+ R& Z! V/ o4 ?7 {
4 j% ]) e- v0 l9 _
> value(%);
7 |; C7 N1 i) L9 P/ a& b Definite integration: Can't determine if the integral is convergent.( w1 Y0 g% V- {' z7 Y' w0 m v3 L
Need to know the sign of --> s+ h2 \8 W" Z& g- Z4 V- ?& ?$ z- Q
Will now try indefinite integration and then take limits.7 S! y7 i4 W& z! |" @9 T3 e
% T$ a) o/ ?5 d f; O
> assume(s>0);
8 ~& W8 i8 W! K' m3 Z > Int(exp(-s*t),t=0..infinity);7 R7 a9 r8 B6 i; f, g w
2 b! I: ^' Q5 b& k* K
> value(%);
4 w/ s% l. l0 W6 q
; F- g1 k9 C) f% R! {1 S 3.4 求值规则7 Q( r# ^1 v- K& ~* ~" E; Y
在多数情况下, Maple的求值规则设计为做用户期望的事情, 但要做到这一点很困难,因为不同的人在相同的情形下会有不同的期望. 在大多数情况下, 全局变量被完全求值, 局部变量被一层求值. 而由符号' '界定一个暂时不求值的表达式, 单步求值仅去掉引号, 不作计算, 这也是允许取消指定名字或清除变量的原因. 如下例:
! W l& }& S' Z9 ~# G& Z9 r3 s+ A > x:=y;
& k; T$ M8 y' X 6 G- u) I) x$ F; B" a! n
> y:=z;
0 D' q# u- ?$ k+ z! \6 B 2 ^. C; z- x8 {0 a0 V: C
> z:=3;
: [4 f2 \9 Y2 c' V$ q- a ! o, ~; H8 w+ O6 T1 F# T2 L
> x;
7 O$ v! o! p; m- J! s' }
) M" u/ d' G) O5 A; V > y;
3 I1 G6 S/ D- x7 F0 C t+ n, N
/ x+ _, m, t0 A6 u, V+ \ > x:='x';
! e& ~& E! ~8 G, r# G6 `6 f: j 3 Y' ?* h" {* ^
> x;
; X4 ?# |- c1 n! R, l8 v/ S1 W; D 6 j0 m5 q6 I. }2 B- l
> y;# x4 E& g* }2 z$ ^
# }$ U: |, d) T# ?( p' M% U
对于不同的问题, Maple设计了不同的求值命令. 现分述如下: 5 y" Z G1 }/ m; e# G+ y3 [
1) 对表达式求值; X; ]# F* V- s
命令格式: eval(e, x=a); #求表达式e在x=a处的值
, Y2 I2 ?) B6 o eval(e, eqns); #对方程或方程组eqns求值. |/ }* j$ H/ V Y. t, s1 j2 h* U+ C
eval(e); #表达式e求值到上面两层; A' L: g3 S6 @, D% p$ h
eval(x,n); #给出求值名称的第n层求值
* a- ?& W5 Y3 L) Y( f > p:=x^5+x^4+x^3+x^2+x+73;
7 Y9 _0 B' g5 @* j- ]+ z6 S
( i. {5 K; ^" T3 X j; V x* L( v' Q > eval(p,x=7);. ?2 T. X6 \" E9 B2 v
3 R; T7 U1 Q0 n! G
> P:=exp(y)+x*y+exp(x);
( S8 m3 ` x' A9 g) ~
7 a) [3 T4 p- M- S4 Q > eval(P,[x=2,y=3]);
: M' R2 t6 @0 E- X - E' A* O! x+ i. l" F) L
当表达式在异常点处求值时, eval会给一个错误消息. 如下: / X2 J4 l( p% Q& I/ ]6 O5 Y7 O
> eval(sin(x)/x,x=0); U$ i: f; o% S q# `& w
Error, numeric exception: division by zero% j ]# M7 Z' E D( [: ?5 u S
下面再看使用eval进行全层求值或者对名称几层求值的示例: I+ P6 M$ {( S% W% I8 [% k
> a:=b: b:=c: c:=x+1:7 s! q+ ^" ^- Z+ |
> a; #默认的全层递归求值) o: P! o% i$ V& b1 A
/ a, ]- X3 B- ]& w& K* b( ] > eval(a); #强制全层递归求值
$ R' ^, q9 e0 X0 K9 n5 @- T 3 J& {: r( i5 c0 g+ [
> eval(a,1); #对a一层求值
7 D' D8 r3 y5 J) `
/ a! P7 N+ ]' t4 L( V* _: C& c: I$ C > eval(a,2); #对a二层求值% [7 L2 `- j3 [! x" O0 J
# B) z$ `* P: x1 R O
> eval(a,3); #对a三层求值
$ ~4 }/ C/ Q9 S& n& y$ ? 3 L+ [" ^. R' E! Q
> eval(a,4); #对a四层求值
4 H5 A! b9 z$ W# @2 z1 H* _( E4 A 0 R, D& r/ ?* g2 W5 o. U: @; ^' f. D
2) 在代数数(或者函数)域求值
% L4 w/ `4 W! ?, h, A" W 命令格式: evala(expr); # 对表达式或者未求值函数求值
5 E: w- E) E5 g+ T, I6 @$ n" L evala(expr,opts); #求值时可加选项(opts)
5 F9 ?9 H Q. O4 e) R 所谓代数数(Algebraic number)就是整系数单变量多项式的根, 其范围比有理数大, 真包含于实数域, 也就是说任意实数都是整系数多项式的根(如 就不是任何整系数多项式的根). 另一方面, 代数数也不是都可以表示成为根式的, 如多项式 的根就不能表示成为根式的形式.
2 \; v/ c2 n. D$ K) `, x 代数数的计算, 算法复杂, 而且相当费时. 在Maple中, 代数数用函数RootOf()来表示. 如 作为一个代数数, 可以表示为:
, Q% J0 {% o5 h" v; d1 c > alpha:=RootOf(x^2-3,x);
' _+ [2 H9 z U. \
" q8 \# l& m2 I7 t, B > simplify(alpha^2);5 V6 j% e1 W6 N1 z" v# o
1 ~: g$ M2 p) J) x9 Q7 ` 在Maple内部, 代数数 不再表示为根式, 而在化简时, 仅仅利用到 这样的事实. 这里, Maple用到一个内部变量_Z. 再看下面一个例子,其中alias是缩写的定义函数,而参数lenstra指lenstra椭圆曲线方法:
- O! m! X7 s% {2 _( A: O; t > alias(alpha=RootOf(x^2-2)):1 [' C1 h3 R( {( g
> evala(factor(x^2-2,alpha),lenstra);; R) O! F0 L8 ^7 F* k; c k" `) J
0 ]6 E6 D4 _6 V4 X! Q4 k > evala(quo(x^2-x+3,x-alpha,x,'r')); / L* j/ a) v5 D6 i
_5 F7 Y3 v, N) l$ T > r;1 Y, Q% H" V: G) ~# `2 I6 Y# u
" J6 r' G+ Y# y5 |8 @
> simplify(%);/ k% }6 H1 U% A& \4 s* y' s6 b
7 F2 }5 q0 t$ _8 {! |$ b1 W
3) 在复数域上符号求值
& d# E. y6 I/ R9 u1 B 操纵复数型表达式并将其分离给出expr的实部和虚部的函数为evalc, 命令格式为:( Y# }2 w& a: M: D( C
evalc(expr); ! i7 j% P9 o8 F: T5 A- S; f
evalc假定所有变量表示数值, 且实数变量的函数是实数类型. 其输出规范形式为: expr1+I*expr2. 9 X9 E5 ^" x& ^$ _- a
> evalc(sin(6+8*I));
0 D4 N" [# D; A3 I+ @
9 [5 q5 H O- m! K$ V' R > evalc(f(exp(alpha+x*I)));2 }, v; x4 q$ x
6 K+ Q. C: Y, _2 }8 x
> evalc(abs(x+y*I)=cos(u(x)+I*v(y)));
/ A' U% U3 [8 {: X$ w- ^ + q8 O, F( H7 L
4) 使用浮点算法求值: d. f6 N: ?7 j7 E- G
浮点算法是数值计算的一种基本方法,在任何情况下均可以对表达式expr使用evalf命令计算精度为n的浮点数(n=Digits), 如果n缺省, 则取系统默认值, 命令格式为: evalf(expr, n);
}4 K1 W" _# ]/ N$ {7 M0 `- A > evalf(Pi,50);
6 ?, P* V+ V) i9 R6 A. e3 A
1 Q0 s- U: ]6 s& G > evalf(sin(3+4*I));
6 e$ D$ b3 y( z# v( c # e" H; y& Y2 s, n
> evalf(int(sin(x)/x,x=0..1),20);- D" d1 W% J, X9 m8 Z; Z& ] O
) H$ Q* Y6 w6 p/ N
5) 对惰性函数求值1 k) v: V* V3 v
把只用表达式表示而暂不求值的函数称为惰性函数, 除了第一个字母大写外, Maple中的惰性函数和活性函数的名字是相同的. 惰性函数调用的典型用法是预防对问题的符号求值, 这样可以节省对输入进行符号处理的时间, 而value函数强制对其求值. 对任意代数表达式f求值的命令格式为: value(f); 3 Y4 b2 E9 V1 d' d2 ?8 A* o" Y: W
> F:=Int(exp(x),x);% a8 e: ?1 H' g: Q: l$ S7 }8 }
V/ ?* m' L4 [5 c; H
> value(%);
! C8 d) G9 _, a: z; s & y5 y/ K7 Z7 v' M+ B, G0 T
> f:=Limit(sin(x)/x,x=0);) }9 Z# G( W0 d; K9 W
5 V( m# m# r$ V > value(%);
( x8 X: \. y8 r4 G 2 o( G* C' V8 M# E: v) [! y" }2 \
另外, 将惰性函数的大写字母改为小写字母亦即可求值. 如下例: 6 Y. R+ @" b, G: g8 N2 o! Y
> Limit(sin(x)/x,x=0)=limit(sin(x)/x,x=0);
& _) S3 O- f, p! q# V3 p7 B5 j8 I2 | * t" X4 w# I4 b V: i- ?# A
4 数据结构( M1 R6 |9 \) O6 F( s
Maple中有许多内建的与FORTRAN、C或Pascal不同的数据结构. 主要的数据结构有序列(sequence)、列表(list)、集合(set)、代数数( algebraic number)、未求值或惰性函数调用、表(table)、级数(series)、串(string)、索引名(index)、关系(relation)、过程体(process)以及整数(integer)、分数(fraction)、浮点数(float)、复数(complex number)等数据结构, 而矩阵(matrix)在Maple中表示为阵列, 是一种特殊的表.
( X! c% _! b& C# ]3 [) }/ U 4.1 数据类型查询. V3 h# I q$ k8 E- R+ @6 w5 E
在Maple中, 用whattype指令来查询某个变量的数据类型或特定类型, 命令格式为:
4 {" X6 d1 g; n' S whattype(expr) # 查询expr的数据类型4 l3 P& j! _2 z( i( A/ ~+ ~& A
type(expr, t) # 查询expr是否为t类型, 若是则返回true, 否则返回false: K; I, d* ^. O( x/ |/ t
> whattype(12);
2 ?6 @* a6 b6 J( L3 M / f. z$ X4 [& \# k$ `, p% P
> whattype(Pi);
& ]5 z& I* C- d5 W
9 P7 f' u; c/ h! U/ k. y > type(1.1,fraction);
) K) L7 ~! L' a4 C' b ( h, H( C1 N y/ B
> whattype(1.1);7 e6 v4 L+ z1 A
" P6 t1 ]* ~, k6 o" c( N6 q
4.2 序列, 列表和集合! {. |4 H9 Y4 A4 S* m; ^' L" J
4.2.1 序列
/ h' g; F! J& t; E3 O5 n 所谓序列(Sequence), 就是一组用逗号隔开的表达式列. 如:
2 I) K' I9 ~/ g. [% r9 T) P > s:=1,4,9,16,25;- n' D4 ?, @0 J
% T0 B' l: _* V2 k > t:=sin,com,tan,cot;" r" g9 j, \; \7 T: y, z- V* |% m& k
) _, k( _4 M; a8 R! }3 [# @ 一个序列也可以由若干个序列复合而成, 如: ; ^1 `) Y& ^/ D+ F u" J9 ^
> s:=1,(4,9,16),25;
- ? g7 U$ A1 g4 J6 r. B 2 F$ a8 V. |5 n0 S e! N
> s,s;7 k8 z+ b" e" f- S( Q# s$ Y
# z- W3 B. ^6 j. w, N$ J 而符号NULL表示一个空序列. 序列有很多用途, 如构成列表、集合等. 事实上, 有些函数命令也是由序列构成. 例如:
0 o9 u% J+ K. | > max(s);. n5 M7 p1 T/ W4 S7 f9 l5 v; v
6 Q! L% n- n7 j7 z: }% u > min(s,0,s);3 s) A* s1 u9 R' m# t% Y& D
4 G/ h/ B% d# k/ \, L6 n 值得注意的是, op和nops函数命令不适用于序列, 如op(s)或nops(s)都是错误的, 如果要使用op(s)或nops(s)前应先把序列s置于列表中. ! D3 e/ o @4 T" {
> s:=1, 2, abc, x^2+1, `hi world`, Pi, x -> x^2, 1/2, 1;
' N2 ]# J% ^1 C d1 _: j2 u$ L ( \3 J' v+ ~! _$ q
> op(s);
( z5 A4 [ ~) f% H1 U8 {6 j Error, wrong number (or type) of parameters in function op6 c8 d+ s; f v1 h L9 s
> nops(s);. V" u2 J6 S- k
Error, wrong number (or type) of parameters in function nops
1 p8 b5 ^/ K2 G, l > op([s]);2 d$ T/ L, C+ ~) p" I4 ?" d
- v6 i+ _& ?, H6 \ > nops([stuff]);4 b' ^1 }" [& ?; K) y& ~
1 ^! R: L- S7 B+ R- Q 函数seq是最有用的生成序列的命令, 通常用于写出具有一定规律的序列的通项, 命令格式为: " u$ f( o- ?- A- d1 p% r
seq(f(i), i=m..n); # 生成序列f(m), f(m+1), …, f(n) (m,n为任意有理数)
* w' S0 @) A. w# p seq(f(i), i=expr); # 生成一个f映射expr操作数的序列5 r$ j( `- f, Y. z$ i$ g
seq(f(op(i,expr)), i=1..nops(expr)); # 生成nops(expr)个元素组成的序列
4 m! L" v1 _. D5 B6 d) e3 V/ s > seq(i^2,i=1..10);- p+ \" x$ {3 M' P
& l2 B6 s" O+ H* {" n0 a) U k8 p
> seq(ithprime(i),i=1..20);
& @, Y0 ]2 {( r# H
7 T- |% g" ^2 T' a1 R0 T7 t. M > seq(i^3,i=x+y+z);( q9 I3 w, y- P) {
; _ T7 w" N: K) O* u: U" u > seq(D(f),f=[sin,cos,tan,cot]);8 n: p5 n: h6 Y
9 _, P" s+ E4 Q2 I; g+ F. N
> seq(f(op(i,x1+x2+x3+x4)),i=1..nops(x1+x2+x3+x4));
% C+ j, J* f; m% _$ @9 w+ X' o6 P
4 y) s* `7 k$ Z+ ~ j' u: T 获得一个序列中的特定元素选用操作符[ ], 如:
1 H, W9 M. t! \9 B > seq(ithprime(i),i=1..20);
, n+ ?% J k; ?7 C: i4 R 3 i# x& W' o) a- h' v. V9 H8 l
> %[6],%[17];
; I- ?; i3 d1 y( |
' q+ _' X/ z+ \$ x3 H. I' X 4.2.2 列表
J0 D) x3 a7 v 列表(list), 就是把对象(元素)放在一起的一种数据结构, 一般地, 用方括号[ ]表示列表. 如下例:
, B. u( B- f4 o > l:=[x,1,1-z,x];
! m- d- _: w' S% ]8 v& g4 [; _/ R # r5 D" C( d- J) U4 O
> whattype(%);
8 Z* e: b9 f3 o5 _+ H! s& D0 v( X 5 J" n9 C, ]2 v( R5 }& H
空列表定义为[ ]. , A0 @# B+ d) T1 c# a+ Z7 M; p
但下述两个列表是不一样的, 因为对于列表而言, 次序是重要的: 0 _4 m' n) p! @5 I0 f
> L:=[1,2,3,4];
% ~, D; t" i% }' b4 K# E
- b: f6 ?3 ?4 w > M:=[2,3,4,1];
8 Y- N5 k9 S) E3 w 8 ^7 G) u; V8 C9 u4 {6 q- V
4.2.3 集合2 [6 A+ @% e8 p3 k) i
集合(set)也是把对象(元素)放在一起的数据结构, 与列表不同的是集合中不可以有相同的元素(如果有, Maple也会自动将其当作同一个元素), 另外, 集合中的元素不管次序. 一般地, 用花括号表示集合. 7 f" q- R" |* K' @9 S5 d; r
> s:={x,1,1-z,x};
* U! ^& _! `+ l# T4 ~8 _# E% v" ?
) G$ v% j5 |( e% ^& a > whattype(%);
. J J7 U/ J4 `) o$ X" ? / @! _* }6 V6 k3 O. p/ f- ^$ T2 j& E
空集定义为{ }. + ]* l2 ~6 h E) \! M1 O' n
函数nop返回列表或集合的元素数, 而op则可返回其第I个元素. 9 v- [/ S& C& Q" _" Y" B' s- }
> op(1,s);7 H. `# p1 C8 }" {' T
& m0 B5 L5 e# _
> s[1];. x/ g4 I5 K! |7 F
! `5 }5 n, _; F+ X' b8 ^, b > op(1..3,s);; a& H$ C) p0 t7 r3 u
, O. u. T+ Y' d" l9 H# c
> s[1..3];
! d& l9 X( d4 T0 @; i: C
# _/ Q" F+ x0 i 函数member可以判定元素是否属于一个列表或集合, 如果属于, 返回true, 否则返回false.
9 Z+ u7 R2 a- Y: w > member(1+x,s);
1 [. v3 d2 H V; w
& D4 R0 R5 E( Y( `4 C 可以通过下述方法在列表中增减元素: % b. P; k% k3 R* J9 n
> t:=[op(s),x];8 ^$ {+ T1 ^ R2 O% M$ W
+ N' r, j) U! s! R9 [7 C* u7 e > u:=[s[1..5],s[7..nops(s)]];7 ]6 O1 e( q) f! i/ l
: x* y( f- h' X. R7 V/ O6 K
Maple中集合的基本运算有交(intersect)、并(union)、差(minus):
2 z% J6 Q- L0 W; P > A:={seq(i^3,i=1..10)};B:={seq(i^2,i=1..10)};
, v$ W& ]2 w: A 0 r5 v) j/ Q' m, J
/ I0 t4 n# v$ g7 S- E/ a# n
> A intersect B;
$ F- ^4 J& E( s( s
6 b# _0 Q7 w0 k2 A) T- Q+ X. b > A union B;
; C- y$ W7 M2 [- o , C2 G- [: L+ @* E1 M6 H
> A minus B;
R5 Z! j% x' ~) x
6 v" ^* U, a. {7 T% v5 X 4.3 数组和表
6 B" ~* Q0 W) j o 在Maple中, 数组(array)由命令array产生, 其下标变量(index)可以自由指定. 下标由1开始的一维数组称为向量(vector), 二维以上的数组称为矩阵(matrix). 数组的元素按顺序排列, 任意存取一数组的元素要比列表或序列快的多. 区分一个数据结构是数组还是列表要用“type”命令. / D" H* p- e2 D; |: V! H, E) g
表(table)在建立时使用圆括号, 变量能对一个表赋值, 但一个在存取在算子中的未赋值变量会被自动地假定是表, 表的索引可以成为任意Maple表达式. 表中元素的次序不是固定的.
7 W- J5 A$ G! u/ ~( ] > A:=array(1..4);7 J2 ]' S0 _ X: }
5 P, u6 [/ f, f; R- G. l0 {) W! T7 Y > for i from 1 to 4 do A[i]:=i: od:" B' W) ~* m9 y# [' ?- {
> eval(A);" f0 \& i+ d8 c- h
# ?. ]1 t( `2 g$ }8 P3 U
> type(A,array);: L5 s0 O2 V1 {! t- y8 M
0 S& ~7 w; P" B. P% a2 K$ r4 g > type(A,list);
# z1 [8 T" q( ^" N3 b# ] & |2 p" b2 h0 d- E v, D+ o) V
> T:=table();
0 _5 N. h; y$ [3 ~! x! L
% ? \8 L. _+ {% I2 J > T[1]:= 1;
5 o) s7 Y( N+ N9 ?, z" n5 J - T+ R- U* `+ L
> T[5]:= 5;( n! Q' |1 I* T7 m, Q$ q+ j* P
, g! @+ L9 t) [0 C c3 N3 J! f > T[3]:= 3;
; d5 F5 b( g1 V4 ^
4 I1 b0 u6 E, ? \) |" r, L9 u; i > T[sam]:=sally;5 ]2 {+ `1 N6 A3 \- R, k0 e
8 g T$ g5 L1 R" b; o
> T[Pi]:=exp(1);' z8 ^: r, D, p; ]) C
( C0 l/ u8 X. T5 k+ r9 a
> x:='x';
: z6 N) x P3 N0 X! u. O& E
* K8 r! Q" V$ h. _ > T[(1+x+x^3)*sin(x)] := 0;6 D4 c/ h) }: f0 c( Y% L7 i
* C/ C6 ~! e/ z# {* x+ N# s* W
> eval(T);
) ~( i1 L0 U4 j ) j) J7 Y* t1 Y/ L2 {% R
> T[3]:='T[3]';5 z) w/ @0 f Q l+ j* Z
1 P% \9 c P3 c9 A/ H8 T > eval(T);0 S* b# j$ W- O, {$ |
4 z- \3 J1 Z- w' G/ J( r. q) o 4.4 其他数据结构
6 U( G/ b- z8 e$ d) E# E: r 串在Maple中是很重要的, 他们主要用于取名字和显示信息. 一个Maple的串可以作为变量名, 它们中的大多数是简单的、不需要加引号的串, 但是如果变量名中包含/. 例如“diff/T”则必须把变量名用引号括起来. 0 @! Q! I# H# w$ }' X
索引名是像Database[1,2,drawer]或A[3]这样的对象, 在使用索引前不需要直接建立表, 如果不得不做, Maple会自动建立表. 索引名通常被用于矩阵和向量. 为了保证Maple建立表的正确次序, 建议在赋值前直接建立.
) {# y" B" ?; O! O# |9 l( B y) M: N& [ > x:=T[3];
/ D- p7 L) y, P. N
+ F0 h. V) X! H1 M1 U' k& [ > eval(T);
* ]$ {. U! W$ y$ @8 W1 Q+ I } - `+ {9 `8 e# h, p2 g; B2 \& l
> T[5]:=y;9 @' q3 j* T; z! D& e' ^; y* k
" Z. g$ z& ~' X0 } > eval(T);0 ]+ a, V/ l5 D4 A
0 d" f1 k* w0 J, ]6 ~
由此可见, Maple并不直接建立T的表, 直到给T[5]赋了值. $ W( Z6 Q- O) H# @& |) D
数值数据结构(整数、分数、有理数、浮点数、硬件浮点数和复数等)在它们的使用中是大量透明的. 浮点数是有传染性的, 这意味着如果数值结构中有一个是浮点数, 则整个结构自动转换为浮点数.
- v& ^3 Y4 `5 K( F+ ` 4.5 数据类型转换和合并
* p3 b' n+ W3 s+ u& z5 @ convert是一个功能强大的类型转换函数, 它可以实现列表和数组的类型转换:
( W& ^# ~4 j, t. B/ Z > L:=[1,2,3,4];3 K5 y) a/ Q3 U
/ L5 I$ H! P) b, P) d > type(L,list);
- q) ?/ U8 v2 D2 h# Q' n1 E4 E . d3 B2 T- w" T( ?& P
> A:=convert(L,array);
9 v* B* m5 e6 `0 R i" |. D & N; G" E7 \( v0 F- P5 x I7 Z* j
> type(A,list);: f; P5 ~6 X. Q, ^/ D! A4 J y
) R0 b, k. O7 z: z1 v ]
> type(A,array);) y# D( d; g- t/ L! R+ M
1 \5 d* ^6 I1 r4 y \! {) w# r1 ^
另一个有用的函数zip则可把两个列表或向量合并:
' |$ R- t$ m A% Y7 D >L:=[seq(i,i=1..10)];
- X3 O) ]& y% @% @5 h L, V& w3 W8 Y9 q( V' X, R N
> Sqr:=(x)->x^2;
A. b" Q C, Q" f ' f$ a5 Q/ U/ Q% T, k
> M:=map(sqr,L);+ c' d5 w+ i/ B- X+ K
f8 l, f* T* c > LM:=zip((x,y)->[x,y],L,M);
8 r# ~5 l# W, k+ K: Z# m ; L* @2 L2 z' `* h! e6 Y& V1 \
> map(op,LM);- u d" h/ C+ e% @; l% e( c6 H; K
: a U" g4 [ U+ w% F; d
5 Maple高级输入与输出操作$ `. k- {4 q' }4 ~3 `& g
Maple提供了良好的接口来编辑与计算数学式. 许多时候, 我们可能需要把Maple的运算结果输出到一个文件中, 或者在一个文本编辑器里先编好一个较大的Maple程序, 再将它加载到Maple的环境里. - ~( G* A1 s( O
5.1 写入文件4 }( t& D; ~* m) w
5.1.1 将数值数据写入到一个文件
$ a8 k) ~+ {' w% T% U 如果Maple的计算结果是一长串的数值串行或数组, 而想把它写到一个文件时, 用writedata命令.
/ H% d" k! L9 Z( c' t/ x" v) k 若Maple的计算结果data为集合、矩阵、列表、向量等形式时, 将其写入名为filename的文件时命令格式为: writedata("filename", data);
7 `4 u* |+ e# C" j4 m' M$ ] > with(linalg):% _! G8 B' E1 p$ l+ z
> M:=matrix(3,3,[1,2,3,4,5,6,7,8,9]);/ D ?& M; ~5 f5 r
# x& C# n, r+ h! y > writedata("e:\\filename.txt",M);
6 Y" Q, M9 u! B* n5 J8 h, q 而将结果附加在一个已存在的文件后时,使用命令: writedata[APPEND]("filename", data);
# w$ p8 H+ Z: ?% ?! ?" T( [4 M > W:=matrix(2,2,[1,2,3,4]);: C+ j2 Y: | I0 \
: v. `4 t0 ~' e. W# ^9 K > writedata[APPEND]("e:\\filename.txt",W);$ Q2 e; A7 Q1 j( l- n8 g
需要注意的是, 这里的APPEND是必需的, 否则W结果将会覆盖M结果.
, a, d8 o" x7 Z$ Z; N$ `, D5 s 另外, 若想将结果显示在屏幕上时, 用命令: writedata('terminal', data);
7 g' F: _/ `" A* l) e: b4 F/ O > writedata[APPEND]("e:\\filename.txt",W); % c' i* A4 p6 T' K, q& S V! I
> writedata('terminal',M);
! G* J: I: u& z. c* y 1 2 3
9 b4 C+ e+ }+ W; M. t 4 5 6
8 A$ m6 }8 i) Z$ K7 ?# K# K! a 7 8 9
7 b1 F6 ]$ `# x, p/ \9 g 5.1.2 将Maple语句写入一个文件 R6 r& s% p8 b
如果所要写入文件的是表达式、函数的定义或者是一个完整的程序, 则使用命令save, 写入一个或多个语句的命令格式分别如下:
+ \6 C6 Q ~; O+ s4 E- A save name, "filename";) E# g5 a3 R! B( }( R; J& b: ]) h/ n! r
save name1, name2, …, "filename";
V y/ h' V) v3 M3 O0 k/ q4 V# b 若filename的扩展名为.m, 则Maple会以内定的格式储存, 若扩展名为.txt, 则以纯文本文件储存. 以内定的格式储存的文件作纯文本编辑器无法读取, 但在大多数情况下, 它会比纯文本文件的加载速度更快, 且文件容量小.% {9 s4 D. t$ t- P* z; a+ w
> myfunc:=(k,n)->sum(x^k/k!,x=1..n);+ a+ c D! l3 o8 G5 m$ x, ?1 _
' x# r% Z s2 @! Y4 F' d1 u
> myresult:=myfunc(6,8);
* C; \. v) k7 i( O0 E
. Z' a# u& o8 D5 @5 N% C > save myfunc,myresult,"e:\\test.m";
7 @8 r8 K) y- \8 J5 _ 调用已存m文件用命令read. 试看下述实验:: |- E T' d5 m$ K
> restart:
, z; U$ d8 n/ }1 d. A& v" o; Z > myfunc(6,8);1 u, y$ S( W5 y+ O: P9 F# Q) u6 o
" r; J4 k. i6 V
> read "e:\\test.m";
( G5 y7 M- E8 N Z) i- _* z > myfunc(6,8);
( g* Z- B! ]+ E( a* T- ` ) Y* g( I2 Q6 u3 B+ x, ^
> myresult;
% ?, M. s: I+ I8 A- h7 Q$ T# l( J8 j7 Y
2 P- @- B& q, A" v" Z6 S) j 而存为txt文件时则将整个语句存为一个文件:
6 ?2 G% t5 l4 L7 l R > save myfunc,myresult,"e:\\test.txt";" F" s8 S+ c# d8 G- O
> restart: read"e:\\test.txt";6 T& D8 e! R. [+ `" o. U7 w
3 S4 L3 U) x' o. Y% Y+ p Z
- v* g9 M0 N y
5.2 读取文件
+ l% M/ p) V% K. ^/ S9 }* k$ b6 S 在Maple里最常用的两个读取文件的命令, 一个是读取数值数据, 另一个是是读取Maple的指令. z: V c# k# `! G+ f8 {% m
5.2.1 读取数值数据
( \( H* ^) c$ L1 J# n1 b 如果想把大量的数据导入Maple里进行进一步的运算或者要运用大量的实验数据在Maple环境绘图时, 可以用readdata( )命令完成.
( W) E5 K4 z( z7 s. Q9 _+ t 从filename文件里读取n行数据时使用命令: readdata("filename",n);
6 M5 u0 O/ p$ T9 p" U4 Y+ c1 C 以指定的格式读取数据时使用命令: readdata("filename",[tyep1,type2,…]);# K% `4 B+ `7 Z. P
> readdata("e:\\filename.txt",3);
* _( C8 I7 i5 o& w4 `
. m! Z$ E8 {$ c8 D* C 读取filename的前三列, 第一列为整数形式, 第二、三列为浮点数形式:
9 q' m% \) X( L > readdata("e:\\filename.txt",[integer,float,float]);
, o" m; h* r) c9 F3 H7 A
* J. p* n2 N, l8 u1 B 下面再看一个运用大量的实验数据在Maple环境绘图的实验:
+ Y! U6 M) U2 o4 a, D$ K( w > mypts:=[seq([x/1000,cos(x^2/100000)],x=1..1000)]:, y7 J, f# w ? k6 \$ D" ^) b
> writedata("e:\\data.txt",evalf(mypts));
+ @; ~8 m9 V7 [ > dots:=readdata("e:\\data.txt",100):1 u9 o: `4 q2 K4 x9 _+ J' _3 F
> nops(dots);
+ ]' [# P3 f) M& Z
# W- J. a$ T# r/ S7 B* l8 G > dots[1..4];
$ e; b7 b4 F( P1 R" B: j9 |2 C) m / d; f( @5 i" G, k' @3 T& F
> plot(dots,style=line);" o y8 l2 c1 O* ~, K
+ w% X5 c* H" E
5.2.2 读取Maple的指令; K, i2 z: c/ @+ m/ B T/ U. ~
在编写程序时, 在普通软件中先编好程序再将其读入Maple环境中常常比直接在Maple中编写更为方便. 如果要将程序代码或Maple指令加载用read命令:" U$ t' p' j) R7 @
read "filename";
) M/ d5 Q# i: _* d7 r6 o. f# S 如下例:+ H1 O4 ^6 x( U4 q
> reatart:# g& y' z/ L! @, [+ G& u2 C# [
> myfunc:=(a::list)->add(i,i=a);0 a: [) @6 O0 E/ j) s
! R+ l- Y0 p1 M$ S4 P, ?2 l
> avg:=(a::list)->myfunc(a)/nops(a);- [ L2 N$ Z9 z* _5 e1 U0 V6 E
( d) B/ g# ?; a" \ q6 p+ N
> save myfunc,avg,"e:\\function.m";
+ R. f, Y6 d% P! h$ E7 y > restart:
( o' {5 @5 r. R+ Y > read "e:\\function.m";/ H: }% J( F" y! c/ o9 b l C
> myfunc([1,2,3,4,5,6,7,8,9]);
0 A8 Z1 ?* A- c& Q) n , {9 Q3 E1 H F" ~4 q, C
> avg([1,2,3,4,5,6,7,8,9]);1 p/ v! r' o5 a2 N$ `9 R( u* k u# O
% P/ m% h. G0 [+ p( g' g0 H& i
5.3 与其它程序语言的连接0 |2 D1 t5 Q' `; z& I; b
5.3.1 转换成FORTRAN或C语言
9 Z! @# y9 u; p, d9 \ 调用codegen程序包中的fortran命令可以把Maple的结果转换成FORTRAN语言:) N' j& k/ i% j/ `: ~+ O# G5 e3 n
> with(codegen,fortran):2 }. v: P) s, t. U. m8 }
f:= 1-2*x+3*x^2-2*x^3+x^4;
F7 L2 @! i- ? n5 e% v
* A6 ~, l1 p6 o& X$ G/ k > fortran(%);
6 X5 P& ^! h, o. o8 _. o t0 = 1-2*x+3*x**2-2*x**3+x**4" {, |4 h& Q) W; [
> fortran(f,optimized);
' C3 k, R7 } R- J0 V5 S t2 = x**2
- Y# A% H7 {# | t6 = t2**2
) ~' N+ a8 C* ~, q8 M/ a @' W t7 = 1-2*x+3*t2-2*t2*x+t6
2 w8 J1 G5 U5 n! S8 G, z > fortran(convert(f,horner,x));! C4 F* \$ P7 `& H8 W @
t0 = 1+(-2+(3+(-2+x)*x)*x)*x
; e* a. z" J3 q7 J, E( k: X 而codegen程序包中的C命令可以把Maple结果转换成C语言格式:8 c6 B# p6 {/ L7 u9 ]
> with(codegen,C):
3 E: } L- Z' C f:=1-x/2+3*x^2-x^3+x^4;
/ D) o( q! s* A# b6 M5 w7 o T $ u& R) v" C- b' S- K7 U
> C(f);4 p* E; t! I' o) q: F
t0 = 1.0-x/2.0+3.0*x*x-x*x*x+x*x*x*x;; O4 g. j% @! D0 ]4 }7 K5 Z
> C(f,optimized); N: E) }' {4 x) Q/ \. G, i' m
t2 = x*x;0 N x/ h" t2 d5 j
t5 = t2*t2;
2 k1 }4 s: @( ~% ]7 r; X t6 = 1.0-x/2.0+3.0*t2-t2*x+t5;
, [! J" ?# I0 K- S optimized命令表示要对转换的表达式进行优化, 如果不加此可选参数, 则直接对表达式进行一一对应的转换.3 v# Q) n) z, W! |$ j& F- ?
5.3.2 生成LATEX
5 J# U+ x7 |! V7 Z# Y7 ~. p. p Maple可以把它的表达式转换成LATEX, 使用latex命令即可:: A3 n" n5 h9 _ A8 I
> latex(x^2+y^2=z^2);
7 d2 V% K% z6 a! ]0 ]) v$ C8 ` {x}^{2}+{y}^{2}={z}^{2} f2 b; |1 A4 w, _% z
还可以将转换结果存为一个文件(LatexFile):2 ?5 O9 e! _ [: \" ^5 k% c( n
> latex(x^2 + y^2 = z^2, LatexFile);
0 M! v) U) V! g6 c3 Q8 s4 Z 再如下例:
2 `7 ?8 l! {5 r' y4 v$ |4 C( }! t' w > latex(Int(1/(x^2+1),x)=int(1/(x^2+1),x));
2 V+ {4 f' Q5 O7 l0 u# R9 a \int \! \left( {x}^{2}+1 \right) ^{-1}{dx}=\arctan\left( x \right)
4 |& p9 G1 R! h1 V/ v! T; h# [
: ?2 U- X, i5 b
zan
总评分: 体力 + 2
查看全部评分