Maple常用命令

Posted on Edited on Word count in article: 1.3k Reading time ≈ 5 mins.

基本操作

赋值： ：= 

1
a :=b   #表示将 a 的值赋予 b

相等： = 

1
2
a = b           # 创建了一个表达式
equn:= a=b      #将表达式 a=b 赋值给 equn

执行但不输出结果： :

上标： ^

下标： __ （双下划线）

乘： （空格）

构造矩阵： < > 

1
<<a, b, c> | <x, y,z>>
输出结果为： \[ \begin{bmatrix} a & x \\\\ b & y \\\\ c & z \end{bmatrix} \]

构造函数 F:=x->2*x 

1
2
F := (x, y) -> 2*x + y
F(2,1)
输出结果为 4

最常用的数据类型

序列： a := 1, 2, 3 特点：有顺序、可组合 b:=a,4,5 （输出结果为 1,2,3,4,5），典型应用是函数的输入参数 生成序列的函数 seq() 

1
seq(x^i,i=1..11,2)
输出结果为： \(x,x^3,x^5,x^9,x^{11}\)

列表： 是用 [ ] 封装的序列 与序列的不同：列表中嵌入列表展开方式不同 与集合的不同：列表中元素项顺序是固定的，且会保留重复项 

1
2
3
4
a:=[1,2,3]:
b:=[a,4,5]
b[1]
b[2]
输出结果为：b:=[[1,2,3],4,5] 和 [1,2,3] 和 4

表达式的处理

简化： simplify() 

1
2
3
4
5
6
equn :=a (a+b+2 a)
simplify(equn)                          #处理单个表达式或矩阵
equns := a (a+b+2 a), x+3x+y, m+n+n+n   #生成表达式序列
simplify(equns)                         #会报错
seq( simplify(equns[i]), i=1..3 )       #正常化简，生成一个化简后的序列
simplify([equns])                       #正常化简，生成一个化简后的列表

展开： expand() 

1
2
3
4
5
6
a:= x ( x+2 + x (x+3) )
expand(a)                               #结果为 x^3 + 4*x^2 + 2*x
b:= x ( x+2 + x (x+3) ), 2 y ( y+21 - 5 y (y+1) )
expand(b)                               #只展开前一项，后一项被当作输入参数
seq(expand(b[i]),i=1..2)                #正常展开，结果为序列 x^3 + 4*x^2 + 2*x, -10*y^3 - 8*y^2 + 42*y
expand([b])                             #正常展开，结果为列表 [x^3 + 4*x^2 + 2*x, -10*y^3 - 8*y^2 + 42*y]

整理：collect() 和 sort() 

1
2
3
4
equn := x*y*(x + y*(x + y + y*(x^2 + 1)))
equn := expand(equn)            #先展开 结果为 x^3*y^3 + x^2*y^2 + 2*x*y^3 + x^2*y
collect(equn, y)                #再按照 y 整理各项，结果为 (x^3 + 2*x)*y^3 + x^2*y^2 + x^2*y
sort(equn, y, ascending)        #按 y 降次排列，结果为 x^2*y + x^2*y^2 + x^3*y^3 + 2*x*y^3

变量替换：subs() 和 algsubs() 

1
2
3
4
5
6
a := x + 3*y
subs(x = z, a)          #用 z 替换表达式 a 中的 x，结果为 z + 3*y
subs(z = x, a)          #因等式中无 z，故结果为 x + 3*y；等式左端为表示中已有变量，右端为替换后的变量
subs（x = 2 z,a）       #结果为 2*z + 3*y
subs（2 y = z,a）       #结果为 x + 3*y；因为subs只用来替换单变量不进行表达式的计算，该情况使用 algsubs()
algsubs(2*y = z, a)     #结果为 x + (3*z)/2

微分： diff() 

1
2
3
4
5
6
7
8
9
10
11
# 一般求导--------------------------------------------------------
equn:=x^3 + 2*x*y^2 + x*y + y^2 + x
diff(equn,x)                    #对 equn 关于 x 求导数，结果为 3*x^2 + 2*y^2 + y + 1
# 对 x(t) 求导----------------------------------------------------
equn2：= x(t) +x(t)^2
diff(equn3, t)                  #可以对 t 直接求导，结果为diff(x(t), t) + 2*x(t)*diff(x(t), t)
diff(equn2,x)                   #结果为0，因为maple不会将 x(t) 认定为 x
diff(equn2, x(t))               #报错，不能对 x(t) 直接求导
equn3 := subs(x(t) = x, equn3)  #先用 x 代换 x(t)，再求导
equn3 := diff(equn3, x)
equn3 := subs(x = x(t), equn3)  #再反代换回去，结果为 2*x(t) + 1

积分：int() 

1
2
integrand:= x+x^2
int(integrand, x = 0 .. 1)      #被积函数是 integrand，积分下限是0，上限是1

选择特定项并移除： select() 和 remove() 

1
2
3
integers := [seq(10 .. 20)]     #结果为 [10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20]
select(isprime, integers)       #选择列表 integers 里的质数，结果为[11, 13, 17, 19]
remove(isprime, integers)       #移除列表 integers 里的质数，结果为[10, 12, 14, 15, 16, 18, 20]

解方程： solve() 

1
2
3
4
5
6
7
# solve() 的输入参数可以是序列或列表-------------------------------
equns1 := x + y + z = 3:
equns2 := 2*x + 4*y + z = 7:
equns3 := x + y + 3*z = 5:
equns := [equns1, equns2, equns3]:
vars := [x, y, z]:
solve(equns, vars)     #结果为 [[x = 1, y = 1, z = 1]]

转换： convert() 

1
2
integers:=[seq(1..5),1 ]                #此时 integers 为列表，结果为 [1, 2, 3, 4, 5, 1]
integers:=convert(integers,list)        #此时 integers 为集合，结果为 {1, 2, 3, 4, 5} 因为集合无顺序且删去重复的元素

获取等式的左边/右边：lhs() 和 rhs() 

1
2
3
equn := x + y = a - b
lhs(equn)                   #获取等式左边，结果为 x + y
rhs(equn)                   #获取等式左边，结果为 a - b

函数映射： map() 

1
2
3
4
# 将某个函数（自定义的或系统自带的）映射到某个对象（例如矩阵）的全部元素中去
test1 := <<1 | 2 | 3>, <4 | 5 | 6>, <7 | 8 | 9>>
f := x -> x^2：
test2:=map(f, test1)
结果为： \[ test1=\begin{bmatrix}1 & 2 & 3 \\\\4 & 5 & 6 \\\\7 & 8 & 9 \end{bmatrix},test2=\begin{bmatrix}1 & 4 & 9 \\\\16 & 25 & 36 \\\\49 & 64 & 81 \end{bmatrix} \]

1
2
3
test := <<1 | 2 | 3>, <4 | 5 | 6>, <7 | 8 | 9>>     #创建矩阵
int(test, x = 0 .. 2)                               #报错，不可以直接对矩阵进行积分
map(int, test, x = 0 .. 2)                          #将 int() 映射到矩阵中的每个元素，进行积分

结果为： \[ test=\begin{bmatrix}2 & 4 & 6 \\\\8 & 10 & 12 \\\\14 & 16 & 18 \end{bmatrix} \]

参考书目