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