tự học maple

TRƯỜNG ĐẠI HỌC ĐÀ LẠT
KHOA TOÁN - TIN HỌC
Y  Z



VÕ TIẾN






GIỚI THIỆU PHẦN MỀM TOÁN HỌC

(Bài Giảng Tóm Tắt)

Lưu hành nội bộ
Y Đà Lạt 2008 Z


MỤC LỤC

NỘI DUNG TRANG
Chương I : Các tính toán cơ bản
2
A. Số học 2
I. Giới thiệu 2
II. Tính toán số học thông dụng 3
B. Đại số 8
C. Vẽ đồ thị 11
Chương 2: Phép tính vi- tích phân
16
1. Tính giới hạn 16
2. Tính đạo hàm 16
3. Tính tích phân 18
4. Một số ứng dụng 19
Chương 3: Đại số tuyến tính và hình học giải tích
26
A. Hình học giải tích 26
1. Các tính toán trong hình học phẳng 26
2. Các tính toán trong hình học không gian 33
B. Đại số tuyến tính 36
1.Tạo Vector, matrận 36
2. Thao tác trên ma trận 37

3. các phép toán trên ma trận 37
4. Tìm cơ sở 37
5. Một số toán tử 38
6. Đa thức đặc trưng 38
7. Hệ phương trình tuyến tính 38
8. Một số ma trận đặc biệt 38
Chương 4: Phương trình vi phân
40
1. Ký hiệu 40
2. Giải phương trình, hệ phương trình vi phân 40
3.Thừa số tích phân 40
4.Phân loại 40
5.Vẽ đồ thị nghiệm 40
6. Phương trình đạo hàm riêng 41
Tài liệu tham khảo
42


2

CHƯƠNG 1. CÁC TÍNH TOÁN CƠ BẢN

A. SỐ HỌC:
I. GIỚI THIỆU VỀ MAPLE

• Maple là một phần mềm Toán học do Đại Học Tổng Hợp Waterloo(Canada) xây
dựng và đưa vào sử dụng năm 1985. Sau nhiều lần cải tiến và phát triển qua nhiều
phiên bản khác nhau và ngày càng được hoàn thiện, hiện nay đã có Maple 11.
• Với phần mềm Maple, chúng ta có thể:
+ Thực hiện các tính toán với khối lượng lớn, với thời gian nhanh và độ chính xác

cao.
+ Sử dụng các gói chuyên dụng của Maple để giải quyết các bài toán cụ th
ể như: vẽ
đồ thị (gói plots), hình học giải tích (gói geometry), đại số tuyến tính (gói linalg), GiảI
tích (gói student), phương trình vi phân(gói DEtools), lý thuyết số(gói numtheory), Dữ
liệu rời rạc(gói DiscreteTransforms),
+ Thiết kế các đối tượng 3 chiều.
+ Và các vấn đề khác,…
• Lệnh của Maple : phải kết thúc bằng ; hay : và enter. Chú ý nhóm lệnh:
SHIFT+ENTER

¾ Tính toán các số lớn, các biểu thức cần độ chính xác cao
> 100!;
> 2^64;
> evalf(Pi,500);

¾ Vẽ đồ thị các hàm số
> with(plots);
Warning, the name arrow has been redefined

animate animate3d animatecurve arro
w
changecoords complexplo
t
complexplot3d,, ,, , , ,[
conformal conformal3d contourplot contourplot3d coordplot coordplot3d,,, ,,,
cylinderplot densityplot display display3d fieldplot fieldplot3d gradplot,,,,,,,
gradplot3d implicitplot implicitplot3d inequal listcontplot listcontplot3d,, ,,, ,
listdensityplot listplot listplot3d loglogplot logplot matrixplot odeplot pareto,, , ,, , ,,
pointplot pointplot3d polarplot polygonplot polygonplot3d polyhedra_supported,,, , , ,

polyhedraplot replot rootlocus semilogplot setoptions setoptions3d spacecurve,, , , , , ,
sparsematrixplot sphereplot surfdata textplot textplot3d tubeplot,,,,,]

> plot(x^3+4*x^2-1,x=-10 5,y=-10 15,thickness=2,numpoints=1000);
Và :
> with(plottools);
Warning, the name arrow has been redefined


3
arc arrow circle cone cuboid curve cutin cutout cylinde
r
dis
k
dodecahedron,,,, ,,,, ,, ,[
ellipse ellipticArc hemisphere hexahedron homothety hyperbola icosahedron,, , ,,, ,
line octahedron pieslice point polygon project rectangle reflect rotate scale,,,,,,,,,,
semitorus sphere stellate tetrahedron torus transform translate vrml,, , ,, , ,]

> c := circle([1,1], 1, color=red):
> plots[display](c);
> with(plottools):
> c := disk([1,1], 5, color=red):
> plots[display](c);

¾ Tính đạo hàm, tích phân các hàm số
> with(student);
D Dif
f
Doublein

t
I
nt
L
imit
L
inein
t
Produc
t
Sum Triplein
t
changeva
r
,, ,, , , ,, , ,[
completesquare distance equate integrand intercept intparts leftbox leftsum,,, , ,,,,
makeproc middlebox middlesum midpoint powsubs rightbox rightsum,,,,,,,
showtangent simpson slope summand trapezoid,,, , ]

> diff(sin(2*x^2-1),x):
> int(sin(x)*cos(x)^2,x);

¾ Thiết kế đối tượng 3 chiều:
>tubeplot([10*cos(t),10*sin(t),0,t=0 2*Pi,radius=2*cos(7*t),numpoints=120,tubepoin
ts=24],scaling=CONSTRAINED);
>tubeplot({[10*cos(t),10*sin(t),0,t=0 2*Pi,radius=2*cos(7*t),numpoints=120,tubepoi
nts=24],[0,10+5*cos(t),5*sin(t),t=0 2*Pi,radius=1.5,numpoints=50,tubepoints=18]},
scaling=CONSTRAINED);

Chú ý :

+ Bắt đầu một tính toán mới dùng : restart; để xóa các dữ liệu cũ.
+ Mở gói : with(têngói); Đóng 1gói : unwith(têngói );
+ Hiển thị các gói đang mở :
packages();

II. TÍNH TOÁN SỐ HỌC THÔNG DỤNG

1. Tính toán số học thông dụng:
• Các phép toán số học: +, -, *, /, ^ hay **
• Các phép toán logic : not, and, or, implies, xor và các hằng: true, false, FAIL.
• Các phép toán so sánh : <, <=, >, >=, =, và <>
Chú ý
: Các ký hiệu : %, %%, %%%
• Một số hàm thư viện :
- abs(x) - Gía trị tuyệt đối.
- binomial(n, r) - Tổ hợp

4
- trunc(x) : số ngun lớn nhất, nhỏ hơn hoặc bằng x nếu >= 0, trunc(x)=-trunc(-x)với
x<0.
- round(x) làm tròn thành số ngun gần x nhất.
- frac(x) phần thập phân của x ,dạng phân số , frac(x) = x - trunc(x).
- floor(x) Số ngun lớn nhất, nhỏ hơn hoặc bằng x.
- ceil(x) Số ngun nhỏ nhất, lớn hơn hoặc bằng x.
- exp(x), hàm e
x
, e = 2.718281828
- n! hay factorial(n) : hàm giai thừa
- ilog[b](x) hàm cho phần ngun của logarit cơ số b, mặc nhiên cơ số exp(1).
Nếu x thực, ilog[b](x) trả về r mà b^r <= abs(x) < b^(r+1).

• ilog2(x) số ngun logarit cơ số 2 của x.
Nếu x số thực và r = ilog2(x), thì r hoặc nguyên hoặc giá trò kí hiệu đặc biệt thỏa
2^r <= abs(x) < 2^(r+1).
Nếu x số phức, ilog2(x) trả về max(ilog2(Re(x)), ilog2(Im(x))).
Nếu x là kí hi
ệu đặc biệt, thì kết quả chỉ định được trả vềâ'.
1. ilog2(undefined) = undefined
2. ilog2(+-infinity) = infinity
3. ilog2(+-0) = -infinity
• ilog10(x) trả về số ngun của logarit cơ số 10 của x.
1. ilog10(undefined) = undefined
2. ilog10(+-infinity) = infinity
3. ilog10(+-0) = -infinity
Vídụ:
> ilog2(10); cho 3
- ln(x) logarit Nepe (cơ số exp(1) = 2.7182818284590452354 )
• log[b](x) = y <==> x = b^y. với log[b](x) = ln(x)/ln(b).
• log10(x) = log[10](x).
• max(x1, x2, ); min(x1, x2, ); maximum/minimum của dãy giá trị thực.
Chú ý
: max(); cho -∞ và min() cho ∞
- signum() Hàm dấu.
- sqrt(x) Căn bậc 2
- surd(x,n) Căn bậc n của x, n lẻ -∞ < x <+∞
- root(x,n) hay root[n](x)
root(x,n,symbolic) hay root[n](x,symbolic) : Căn bậc n của của biếu thức đại số.
Chú ý
: root(x,n) = exp(1/n * ln(x))

5

- Các hàm lượng giác và hyperbolic lượng giác:
sin
, cos, tan, sec,csc, cot, sinh, cosh, tanh, sech, csch, coth
- Hàm lượng giác ngược và hyperbolic lượng giác ngược:
arcsin
, arccos, arctan, arcsec, arccsc, arccot, arcsinh, arccosh, arctanh, arcsech,
arccsch
, arccoth
Ví dụ :

> (-10+5^2)*(4-sqrt(36));
> 7!!;
> cot(Pi/4);
2. Tính toán với độ chính xác theo yêu cầu
• Hàm evalf
- Cú pháp 1: evalf(bieu_thuc) - tính toán chính xác giá trị của biểu thức và biểu diễn kết
quả với mặc định là 10 chữ số. Ta có thể thay mặc định bằng Digits=n;
- Cú pháp 2: evalf(bieu_thuc, k) - tính toán chính xác giá trị của biểu thức và biểu diễn
kết quả với k chữ số.
> sqrt(2)/surd(5,3);
> evalf(%);
> evalf(Pi,500);
> evalf(exp(1),100);
3. Các thao tác với số nguyên tố
- Phân tích một số n thành thừa số nguyên tố: hàm ifactor(n);
- Kiểm tra m
ột số n có phải là số nguyên tố không?: hàm isprime(n);
- Tìm số nguyên tố đứng sau một số n cho trước: hàm nextprime(n);
- Tìm số nguyên tố đứng trước một số n cho trước: hàm prevprime(n);
- Tìm ước số chung lớn nhất của 2 số nguyên dương a, b: hàm igcd(a,b);

- Tìm bội số chung nhỏ nhất của 2 số nguyên dương a, b: hàm ilcm(a,b);
- Tìm số dư khi chia a cho b: hàm irem(a,b);
- Tìm thương nguyên khi chia a cho b: hàm iquo(a,b);
> isprime(2^64-1);
> ifactor(122333444455555666666777777788888888999999999);
> igcd(157940,78864);
> ilcm(12,15);
> prevprime(1234567);
> nextprime(1234567);
> nextprime(%);
> irem(145,7);
> iquo(145,7);
> y:=irem(145,7,'x');
>x;

4. Giải phương trình nghi
ệm nguyên
• Lệnh isolve:

6
- Cú pháp 1: isolve(phuong_trinh/he_phuong_trinh);
- Cú pháp 2: isolve(phuong_trinh/he_phuong_trinh, danh_sach_tham_so);
> isolve({x^2+y^2=50,x+y=8},(x,y});
> isolve(x^2+y^2=5,{x,y});
• Giải PT hay hệ PT theo modulo :
msolve(eqns,vars,m); hay msolve(eqns,m);
Ví dụ :
> msolve({3*x-4*y=1,7*x+y=2},19);
> msolve(8^j=2,x,17);
• Tính toán theo modulo : e mod m tương đương `mod`(e, m)

modp(e, m) :∈ [0,abs(m)-1]
mods(e, m) : ∈[-iquo(abs(m)-1,2), iquo(abs(m),2)]
Ví dụ :
> modp(12,7); cho 5
> 12 mod 7; cho 5
> mods(12,7); cho -2

5. Giải công thức truy hồi(đệ qui):
• Lệnh rsolve:
- Cú pháp: rsolve(pt/he_pt_truy_hoi, ten_day_so);
> rsolve({f(n)=f(n-1)+f(n-2),f(0)=1,f(1)=1},f(n));
> rsolve({f(n)=2*f(n-1)},f(n));
> rsolve({g(n)=3*g(n/2)+5*n},g);
> rsolve(f(n)-f(n-1)=n^3,f);
> simplify(%);
> eqn:=f(n)=f(n-1)+4*n:
> rsolve(eqn,f);
> simplify(%);
> A:=rsolve({f(n)=f(n-1)+f(n-2),f(0)=1,f(1)=1},f(k));
> h:=unapply(A,k);
> h(5);
> eval(A,k=5); subs(k=5,A);

6. Khái niệm biến số, hằng số
- Trong Maple, biến số không cần khai báo, định nghĩa trước, dùng lúc nào khai báo lúc
đó, Maple nhớ và ghi lại trong quá trình làm việc.
- Biến số, hằng số được đặt tên thỏa mãn một số quy tắ
c sau:
+ Không bắt đầu bằng chữ số. Bắt đầu bằng ký tự chữ.
+ Không chứa khoảng trắng và một số ký tự đặc biệt như: %,^,&,*,$,#,

+ Không được trùng với tên một số hàm và lệnh của Maple: D, sin, cos, ln, min, max,
for,if, while, I, Pi,
- Một biến số sẽ trở thành hằng số ngay khi nó được gán cho một giá trị nào đó.
- Nếu muốn biến một hằng số trở lại biến số, ta dùng phép gán: ten_bien:='ten_bien';
> isolve({x+y=36,2*x+4*y=100}):
> x:=2;

7
> isolve({x+y=36,2*x+4*y=100}):
> x:='x';
> isolve({x+y=36,2*x+4*y=100});
• Hằng : I, Pi , exp(1), infinity, true, false, FAIL.
Chú ý
: 1/ > 2e-3; cho .002
> -2.3e4; cho -23000
Và .2 , 2. là 0.2 , 2 0
2/ Dùng cặp ` ` để đặt tên "sai" . VD : `day la ten `
3/ Để biến trở lại tên ta dùng : unassign('name1', 'name2', );
assign(a, B); hay assign(a = B); cho a := B;
assign(A, B) ; A, B là các đối tượng,v d: > assign(('a', 'b') = (3, 4));
assigned(n); kiểm tra n đã gán trị chưa.

7. Tính tổng và tích
• Tính tổng: sum (tính trực tiếp ra kết quả) ;
hoặc Sum(biểu diễn dạng công thức);
Cú pháp: sum(bieu_thuc_trong_tong, bien =gia_tri_dau gia_tri_cuoi);
Sum(bieu_thuc_trong_tong, bien =gia_tri_dau gia_tri_cuoi);
Hay add(bt, i=m n);
• Tính tích: product (tính trực tiếp ra k
ết quả);

hoặc Product (biểu diễn dạng công thức);
Cú pháp: product(bieu_thuc_trong_tong, bien =gia_tri_dau gia_tri_cuoi);
Product(bieu_thuc_trong_tong, bien =gia_tri_dau gia_tri_cuoi);
Hay mul(bt, i=m n);
Chú ý:
giá trị vô cùng được biểu diễn bằng từ khóa infinity
> Sum(x^2,x=1 5);
> value(%);
> sum(x^2,x=1 5);
> Sum(1/(x^2),x=1 infinity);
> value(%);
> Product((i^2+3*i-11)/(i+3),i=0 10);
> value(%);
> product((i^2+3*i-11)/(i+3),i=0 10);
>Sum( 2^(2*k)/Pi^(1/2),k=0 infinity) =sum(2^(2*k)/Pi^(1/2),k=0 infinity);
Chú ý
: > sum(i^2,i); tương đương > sum(k^2,k=1 i-1);

8. Tập hợp, dãy, danh sách.
• Tập hợp : dùng {}, các phép toán : member, union, intersect, minus, subset.
Ví dụ
: > {a,b} union {b,c};
> {a,b} intersect {b,c};
> {a,b} minus {b,c};
• Dãy : seq(bt, i=1 n); seq(f, i = x) hay bt$i=1 n;
> seq( sin(Pi*i/6), i=0 6 );

8
,, ,, ,,0
1

2
1
2
31
1
2
3
1
2
0

> Y := [seq( i^2, i=X )];
:=
Y
[],,,, , ,0149162536

> [seq( [X[i],Y[i]], i=1 nops(X) )];
[],,,, , ,[],00 [ ],11 [ ],24 [ ],39 [ ],416 [ ],525 [ ],636

• Danh sách : Dùng [ ], các phép toán : nops(L), op(i,L) chú ý :op(L) cho dãy.
op(L1,L2); L1,L2 là các danh sách
Ví dụ :
> u := [1,4,9];
> op(2 3,u); cho 4,9
> op(-1,u); cho 9
> [op(u),16];
> w := f(g(a,b),h(c,d,e,j,k,l));
> op(1,op(2,w));

c

> op([2,1],w);

c

> op([2,2 4],w);

,,dej

> op([-1,-1],w);

l

Lệnh zip(f, u, v); zip(f, u, v, d); thực hiện phép toán f trên 2 danh sách u,v. Với d là
giá trị mặc nhiên cho dữ liệu danh sách ngắn hơn.
Chú ý
: select(f, e, b1, , bn); chọn dữ liệu từ biểu thức
remove(f, e, b1, , bn); di chuyển dữ liệu từ biểu thức
selectremove(f, e, b1, , bn): chọn và di chuyển dữ liệu từ biểu thức
f : biểu thức logic; e: biểu thức bất kỳ, b1, ,bn : các tùy chọn
Ví dụ : > integers := [$10 20];
:= integers [],,,,,,,,,,10 11 12 13 14 15 16 17 18 19 20

> select(isprime, integers); cho
[],,,11 13 17 19

> remove(isprime, integers); cho
[],,,,,,10 12 14 15 16 18 20

> selectremove(isprime, integers); cho

,[],,,11 13 17 19 [ ],,,,,,10 12 14 15 16 18 20

B. ĐẠI SỐ :
1. Khai triển, đơn giản và phân tích biểu thức đại số
• Định giá biểu thức : value(%);
• Khai triển biểu thức đại số
- Cú pháp: expand(bieu_thuc_dai_so);
> expand(bt);
> bt:=(x+y)^15;

9
> expand(bt);
• Phân tích đa thức thành nhân tử
Cú pháp: factor(bieu_thuc_dai_so);
> factor(x^4-10*x^3+35*x^2-50*x+24);
• Đơn giản biểu thức đại số
Cú pháp: simplify(bieu_thuc_dai_so);
> P:=1/(a*(a-b)*(a-c))+1/(b*(b-a)*(b-c))+1/(c*(c-b)*(c-a));
> simplify(P);
> bt:=cos(x)^5+sin(x)^4+2*cos(x)^2-2*sin(x)^2-cos(2*x);
> simplify(bt);
• Tối giản phân thức
Cú pháp: normal(phan_thuc); chú ý : radnormal(btchuacan);
> tu := x^3-y^3;
> mau := x^2+x-y-y^2;
> phanthuc := tu/mau;
> normal(phanthuc);
Chú ý
: numer(PT); denom(PT);
• Thay giá trị cho biến trong biểu thức

Cú pháp: subs(bien = gia_tri , bieu_thuc);
> bt := x^2-1;
> subs(x=2,bt);
> bt := x^2-1;
bt := x
2
-1
> subs(x=2,bt); cho 3
> subs( {x=y, y=x}, [x,y] );
Chú ý :
eval(BT,x=a);# Tính toán biểu thức khi x=a hay Eval(bt,x=a);
> poly := x*y+3*z+2;
:= poly + +
x
y 3 z 2

> eval(poly,[x=2,y=3,z=t]);
+ 83t

> expr := sin(x)/cos(x);
:= expr
()sin
x
()cos x

> subs(x=0,expr);
()sin 0
()cos 0

> eval(expr,x=0);

0

• Chuyển đổi dạng biểu thức
Cú pháp: convert(bieu_thuc, kieu_chuyen_doi);
Một số kiểu chuyển đổi: abs,algebraic, and, array, base, binary, binomial,
boolean_function, boolean_operator, bytes, Chebyshev, compose, confrac, D, decimal,
degrees, diff, dimensions, elementary, exp, expln, expsincos, factorial, float, fullparfrac,
hex, hexadecimal,Int, int, list, listlist,ln, Matrix,matrix,metric, name,octal, or, parfrac,

10
piecewise, polar, polynom,power, radians,radical, rational, ratpoly, RealRange, set,
signum ,sincos, sqrfree,string, Sum,sum,surd, symbol, tan, trig, trigh, truefalse,Vector,
vector, xor,`*`, `+`
> bt:=(a*x^2+b)/(x*(-3*x^2-x+4)):
> convert(bt,parfrac,x):
> bt:=(x^2-1)/(x+2);
> convert(bt,parfrac);
• Chuyển đổi và rút gọn : combine(f); hay combine(f,tên);
• Khử căn ở mẫu : radsimp(bt,ratdenom);
2. Định nghĩa hàm số
• Cách 1: sử dụng toán tử ->
Cú pháp: ten_ham := bien -> bieu_thuc_ham_so;
> f := x->x^2+1/2:
> f(a+b):
• Cách 2: sử dụng lệnh unapply
Cú pháp: ten_ham := unapply(bieu_thuc, bien);
> g:=unapply(x^3+2,x);
> g(4);
• Định nghĩa hàm từng khúc
Cú pháp: ten_ham := bien -> piecewise(đk_1, bt_1, đk_2, bt_2, , đk_n, bt_n);

Ý nghĩa: nếu đk_i đúng thì hàm nhận giá trị là bt_i
> f:=x->piecewise(x<=-1,x^2-1,x<=1,-abs(x)+1,sin(x-1)/x);
> f(1);
• Các phép toán trên hàm : f+g, f-g, f*g, f/g, f@g , f@@(-1)

> (sin@@2)(Pi/2); tương dương sin(sin(Pi/2));
> (sin@@(-1))(Pi/2); cho arcsin(Pi/2)
3. Giải (bất) phương trình, hệ (bất) phương trình
• Sử dụng một lệnh chung duy nhất: lệnh solve
- Cú pháp: solve(phuong_trinh , {bien_1, bien_2, });
solve ({pt_1, pt_2, }, {bien_1, bien_2, });
solve(bat_phuong_trinh , {bien_1, bien_2, });
solve ({bpt_1, bpt_2, }, {bien_1, bien_2, });
> pt:=x^3-a*x^2/2+13*x^2/3=13*a*x/6+10*x/3-5*a/3:
> solve(pt,{x}):
> pt1:=abs((z+abs(z+2))^2-1)^2=9:
> solve(pt1,{z}):
> pt2:=(cos(x)-tan(x)=0):
> solve(pt2,{x}):
> pt3:=x^4-x^3+x^2-x+1:
> solve(pt3,{x}):
> hpt1:={x+y=36, x*4+y*2 = 100}:
> solve({x+y=36, x*4+y*2 = 100},{x,y}):
> solve((x-1)*(x-2)*(x-3) < 0, {x}):
> solve((x-1+a)*(x-2+a)*(x-3+a) < 0, {x}):

11
• Giải gần đúng : fsolve( eqns, vars, options );
Trong đó : options:
avoid=s : tránh các nghiệm s dạng {var = value}.

complex : Tìm nghiệm gần đúng trên trường C.
fulldigits : mọi tính toán xấp xỉ trong fsolve dùng nhiều hơn kí số thập phân của Digits
maxsols=n : tìm ít nhất n nghiệm của đa thức
Tìm nghiệm trên khoảng a b hay x = a b hay {x=a b, y=c d, }.
Chú ý :
lhs(expr); rhs(expr);
isolate(eqn, expr);
Ví dụ : > isolate(x^2-3*x-5,x^2);

=
x
2
+ 3
x
5

• Tính toán số phức: đơn vị ảo I, dùng các phép tính số học bình thường, Tính toán
tổng quát dùng: evalc(bt); Phần ảo: Im(bt); phần thực :Re(bt);
Số phức liên hợp : conjugate(x); Tính modun : abs(sphức);
Tính argument: argument(x);
Chuyển số phức sang tọa độ cực :convert(Sphức,polar);
Ví dụ:
> abs(1+2*I);
> argument(abs(z)*exp(I*2*Pi/3));
• Giả thiết :
assume(x1, prop1, x2, prop2, );
assume(x1::prop1, x2::prop2, );
expr assuming property;
expr assuming x1::prop1, x2::prop2,
Ví dụ :

>assume(a>0, a<1); limit(a^n, n=infinity);
> e1 := ln(exp(-k[1]*t));

:= e1 ()ln e
()−
k
1
t

> e1 assuming real;

−
k
1
t

> assume(x::real);
> about(x);
Originally x, renamed x~:
is assumed to be: real
4. Đa thức :
• Sắp xếp hệ số theo lũy thừa :
collect(a, x);
collect(a, x, form, func);
• Tìm bậc đa thức : degree(P,x);
• Tìm hệ số: coeff(P,x,n);
• Dư : rem(a, b, x); hay rem(a, b, x, 'q');
• Thương : quo(a, b, x); hay quo(a, b, x, 'r');

12
C. VẼ ĐỒ THỊ:
1. Khởi tạo các hàm vẽ đồ thị
> with(plots):
Warning, the previous binding of the name arrow has been removed and it now has an
assigned value
> with(plottools):
2. Vẽ đồ thị trong không gian 2 chiều Oxy
• Vẽ đồ thị hàm thông thường:
Cú pháp: plot(ham_can_ve, x=gt_dau gt_cuoi, y=gt_dau gt_cuoi, cac_tuy_chon);
Một số tùy chọn thông dụng:
- Đặt màu cho đồ thị: color = <màu>
- Đặt độ dày k cho đồ thị: thickness = k
- Đặt số điểm vẽ cho đồ thị: numpoints = k;
> plot(x^3-3*x^2+1,x=-5 5,y=-5 5):
> f:=x->abs(x^3-x^2-2*x)/3-abs(x+1):
> plot(f(x),x=-5 5,y=-5 5):
• Vẽ nhiều đồ thị trên cùng m
ột hệ trục
Cú pháp: plot([ham_1, ham_2, ], x=gt_dau gt_cuoi, y=gt_dau gt_cuoi,
cac_tuy_chon);
> plot([x^2,sin(x)],x=-2 2,color=[red,green]):
> with(plots):
>polarplot(1);


> polarplot([cos(t),sin(t),t=0 4*Pi],color=gold);

13

>polarplot({t,[2*cos(t),sin(t),t=-Pi Pi]},t=-Pi Pi,numpoints=50);




> # Vẽ lá Maple
> S := t->100/(100+(t-Pi/2)^8): R := t -> S(t)*(2-sin(7*t)-cos(30*t)/2):
> polarplot([R,t->t,-Pi/2 3/2*Pi],numpoints=2000,axes=NONE);





14


• Vẽ đồ thị của hàm số không liên tục
Khi vẽ đồ thị của một hoặc nhiều hàm số có điểm gián đoạn, ta phải thêm tùy chọn
discont =true để đồ thị được vẽ chính xác hơn
> g:=x->(x^2-1)/(x-2):
> plot(g(x),x=-10 10,y=-5 15,discont=true,color=blue):
• Vẽ đồ thị hàm ẩn
Có những hàm số mà chúng ta không có được công thức tường minh y=f(x), khi đó để vẽ
được đồ thị của chúng, ta sẽ dùng hàm implicitplot

Cú pháp: implicitplot([bt_1, bt_2, ], x=gt_dau gt_cuoi, y=gt_dau gt_cuoi,
cac_tuy_chon);
> implicitplot(x^2/9+y^2/4=1,x=-4 4,y=-2 2);
> implicitplot(x^2-y^2-x^4=0,x=-1 1,y=-1 1);
• Ứng dụng: vẽ đồ thị của hàm hữu tỷ

> f:=x->(x^2-1)/(x-2);
> bt:=convert(f(x),parfrac);
> tcx:= unapply(quo(numer(f(x)),denom(f(x)),x),x);

> g1:=plot([f(x),tcx(x)],x=-10 10,y=-5 15,color=[blue,red],discont=true);
> g2:=implicitplot(x=2,x=-10 10,y=-5 15,color=green);

15
> display({g1,g2});
• Vẽ từng điểm : plot([x(t),y(t),t=a b]);
• Vẽ trong tọa độ cực :
polarplot(L,options);
Ví dụ
:> polarplot(2*sin(x),x=-Pi Pi);
> polarplot([cos(t),sin(t),t=0 4*Pi],color=gold);
>polarplot({t,[2*cos(t),sin(t),t=-Pi Pi]},t=-Pi Pi, numpoints=50);
hoặc plot([r(t),theta(t),t=range of t ],h,v,coords=polar)
Ví dụ :
> plot(sin(x),x=0 2*Pi, coords=polar);
> plot(sin,0 2*Pi, coords=bipolar);
> P:=polarplot([2*sin(3*t),2*sin(3*t+Pi)],t=0 2*Pi):
> display(P);

3. Vẽ đồ thị trong không gian 3 chiều Oxyz
• Vẽ đồ thị hàm thông thường
Cú pháp:
plot3d(expr1, x=a b, y=c d);
plot3d(f, a b, c d);
plot3d([exprf,exprg,exprh], s=a b, t=c d);
plot3d([f,g,h], a b, c d);

> plot3d(x*exp(x^2),x=-2 2,y=-2 2,title="Do thi trong khong gian 3 chieu"):
> plot3d(-exp(-abs(x*y)/10)*sin(x+y)-cos(x*y),x=-Pi Pi,y=-Pi Pi,grid=[51,51]):
• Vẽ đồ thị hàm ẩn
Cú pháp: implicitplot3d(ham_can_ve, x=gt_dau gt_cuoi,
y=gt_dau gt_cuoi,z=gt_dau gt_cuoi, cac_tuy_chon);
> implicitplot3d(x^2+y^2/4+z^2/9=1,x=-3 3,y=-3 3,z=-3 3):
4. Sự vận động của đồ thị
Cú pháp:
animate(ham_co_tham_so,x=gt_dau gt_cuoi, tham_so = gt_dau gt_cuoi);
animate3d(ham_co_tham_so,x=gt_dau gt_cuoi, y=gt_dau gt_cuoi, tham_so
=gt_dau gt_cuoi);
Ý nghĩa: hiển thị sự biến đổi, vận động của đồ
thị khi tham số thay đổi trong khoảng cho
trước
> animate3d(cos(t*x)*sin(t*y),x=-Pi Pi,y=-Pi Pi,t=1 5):
> animate(t*x^2,x=-3 3,t=-5 5):







16

CHƯƠNG 2. PHÉP TÍNH VI-TÍCH PHÂN
with(student);
1. Tính giới hạn
• Giới hạn, liên tục:
Cú pháp: limit(ham_so,x=a);

Limit(ham_so,x=a); value(%);
Ý nghĩa: tính giới hạn của ham_so khi x tiến đến a. Kết quả được thể hiện dưới dạng
công thức(lệnh Limit) hoặc kết quả cụ thể (lệnh limit)
> f:=x->((sin(2*x))^2-sin(x)*sin(4*x))/x^4:
> Limit(f(x),x=0);
> value(%);
> limit(f(x),x=0);
Chú ý: muốn tính giới hạn của hàm số khi x tiến đến vô cực, ta chỉ việc thay a bằng từ
khóa infinity.
• Gi
ới hạn kép : Limit(f,{x=a,y=b}); hay limit(f,{x=a,y=b});
> g := x->(2*x+3)/(7*x+5):
> Limit(g(x),x=infinity):
> value(%):
> limit(g(x),x=infinity):
Chú ý: muốn tính giới hạn của hàm số khi x tiến đến a từ bên trái hay bên phải, ta thêm
vào một trong hai tùy chọn left hoặc right.
> h := x->tan(x+Pi/2):
> Limit(h(x),x=0,left)= value(%);
> Limit(h(x),x=0,right)=limit(h(x),x=0,right);
• Liên tục :
+ Kiểm tra hàm liên tục:
iscont(expr, x = a b);
iscont(expr, x = a b, 'closed');
iscont(expr, x = a b, 'open');
+Tìm điểm gián đoạn :
discont(f, x );
Ví dụ :
> discont(1/(sin(x)-1/2),x);

{} + +
1
6
π
2
3
π _B1~ 2 π _Z3~

2. Tính đạo hàm
• Tính đạo hàm cấp 1
Cú pháp: diff(ham_so, bien);
Diff(ham_so, bien); value(%);
Ý nghĩa: tính đạo hàm cấp 1 của ham_so theo bien. Kết quả được thể hiện dưới dạng
công thức(lệnh Diff) hoặc kết quả cụ thể (lệnh diff)
> f := x->x^2*sqrt(x^2+1):
> Diff(f(x),x)= diff(f(x),x);
> simplify(%);

17
• Tính đạo hàm cấp cao
Cú pháp: diff(ham_so, bien, bien, bien, );
Diff(ham_so, bien, bien, bien, );
hoặc diff(ham_so, bien$k);
Diff(ham_so, bien$k);
Ý nghĩa: tính đạo hàm cấp k của ham_so theo bien. Kết quả được thể hiện dưới dạng
công thức (lệnh Diff) hoặc kết quả cụ thể (lệnh diff)
> g := x->5*x^3-3*x^2-2*x^(-3):
> diff(g(x),x,x);
> h := x -> x^4 + x*sin(x):
> diff(h(x),x$2);

>simplify(%);
• Toán tử đạo hàm : D(f);
D[i](f); D[i](f)(x);
Cấp n : (D@@n)(f);
Ví dụ:
F:=n->diff(ln(x),x$n);
F(100);
• Đạo hàm hàm ẩn:
implicitdiff(f, y, x); implicitdiff(f, y, x1, ,xk)
implicitdiff({f1, ,fm}, {y1, ,yn}, u, x);
implicitdiff({f1, ,fm}, {y1, ,yn}, u, x1, ,xk );
implicitdiff({f1, ,fm}, {y1, ,yn}, {u1, ,ur}, x);
implicitdiff({f1, ,fm}, {y1, ,yn}, {u1, ,ur}, x1, ,xk);
Ví dụ : > f := x^2+y^3=1;
−
2
3
x
y
2

> implicitdiff(f,x,y);
−
3
2
y
2
x

> implicitdiff(f,y,z);

0

> implicitdiff(f,y(x),x);
−
2
3
x
y
2

> f := y^2-2*x*z = 1;
:= f = − y
2
2 xz 1

> g := x^2-exp(x*z) = y;
:= g = − x
2
e
()
x
z
y

> implicitdiff({f,g},{y,z},y,x);
2
x
+ y e
()xz
1

> implicitdiff({f,g},{y,z},{y,z},x);

18
⎧
⎩
⎪
⎪
⎪
⎪
⎨
⎫
⎭
⎪
⎪
⎪
⎪
⎬
, = ()D y 2
x
+ y e
()xz
1
= ()D z
− − 2 yx ye
()
x
z
zz
x () + y e

()xz
1

> implicitdiff({f,g},{y(x),z(x)},{y,z},x,notation=Diff);
⎧
⎩
⎪
⎪
⎪
⎪
⎨
⎫
⎭
⎪
⎪
⎪
⎪
⎬
, =
∂
∂
x
y 2
x
+ y e
()xz
1
=
∂
∂

x
z
− − 2 yx ye
()
x
z
zz
x () + y e
()xz
1


2. Tính tích phân
• Tính tích phân bất định
Cú pháp: int(ham_so, bien);
Int(ham_so, bien); value(%);
Ý nghĩa: tính tích phân của ham_so theo bien. Kết quả được thể hiện dưới dạng công
thức (lệnh Diff) hoặc kết quả cụ thể (lệnh diff)
> h := x->(3*x^2+3*x+3)/(x^3-3*x+2):
> t:=x->int(h(x),x):
> t(x);

• Tính tích phân xác định
Cú pháp: int(ham_so, bien=a b);
Int(ham_so, bien=a b); value(%);
Ý nghĩa: tính tích phân của ham_so với bien đi từ a đến b. Kết quả được thể hiện dưới
dạng công thức (lệnh Diff) hoặc k
ết quả cụ thể (lệnh diff)
> f := x->1/(exp(x)+5):
> Int(f(x),x=0 ln(2)) = value(%);

> evalf(%):
> g := x->cos(x)^2*cos(4*x):
> int(g(x),x=0 Pi/2);
Chú ý:
ta có thể tính tích phân mở rộng khi a hay b có thể là vô cực (infinity)
> t := x->x/(x^4+1);
> int(t(x),x=0 infinity);
• Tính tích phân 2 lớp :
Doubleint(g, x, y);
Doubleint(g, x, y, Domain);
Doubleint(g, x = a b , y = c d);
Ví dụ :
> with (student):
> Doubleint(g(x),x,y);
> Doubleint(h*g,x=1 n,y=2 4);
> Doubleint(h*g,x,y,C);

• Tính tích phân 3 lớp :
Tripleint(g, x, y, z);
Tripleint(g, x, y, z, Domain);
Tripleint(g, x = a b, z = e f, y = c d);
VD:
> with (student):

19
> Tripleint(g(x,y,z),x,y,z);
> Tripleint(h*g,x=1 n,y=2 4,z=a b);
> Tripleint(h*g,x,y,z,C);
• Các phương pháp tích phân :
+ Công thức Newton-Leibniz:

>f:=x->bt;
>I1:=int(f(x),x);
>F:=makeproc(I1,x);
>T:=F(b)-F(a);
+ Đổi biến : changevar(s, f); changevar(s, f, u); changevar(t, g, v);
Trong đó : s – dạng h(x) = g(u), f - Int(F(x), x = a b), u – biến mới.
Ví dụ :

> changevar(cos(x)+1=u, Int((cos(x)+1)^3*sin(x), x), u);
+ Từng phần: intparts(f, u);
f - Int(u*dv, x)
u –thừa số tích phân sẽ được lấy vi phân
4. Một số ứng dụng

• Bài toán tính diện tích hình thang cong
Bài 1
. Tính diện tích hình thang cong giới hạn bởi hàm số f(x)=3*x-x^3 , trục Ox và hai
đường thẳng x=0, x=1.Ta dùng int(abs(f(x)),x=a b);
> restart:
> with(plots):
Warning, the name changecoords has been redefined
> with(plottools):
Warning, the assigned name arrow now has a global binding
> f := x->3*x-x^2;
> g1:=plot(f(x),x=0 3,y=0 3,filled = true);
> g2:=implicitplot(x=3,x=0 4,y=0 3,color=blue);
> display({g1,g2});
> int(abs(f(x)),x=0 3);
Bài 2
. Tính diện tích hình phẳng giới hạn bởi hai đường cong f(x) = x^2 và g(x) = x

Ta dùng : int(abs(f(x)-g(x)),x=a b);
> f := x->x^2:
> g := x->sqrt(x):
> a:=min(solve(f(x)=g(x),x)):
> b:=max(solve(f(x)=g(x),x)):
> plot([f(x),g(x)],x=a b);
> int(abs(f(x)-g(x)),x=a b);
Bài 3
. Tính diện tích miền phẳng cho bởi tham số :x=x(t), y=y(t),a≤t≤b
S:=int(abs(y(t)*diff(x(t),t)),t=a b); hay S:=int(abs(x(t)*diff(y(t),t)),t=a b);
Bài 4
. Tính diện tích miền phẳng cho bởi tọa độ cực::r=r(t),a≤t≤b
S:=1/2*int(r(t)^2,,t=a b);

20

Bài 5
. Tính độ dài đường cong hàm số f(x):
+ Cho bởi y=f(x): L:= int(sqrt(1+diff(f(x),x)^2),x=a b);
+ Cho phương trình tham số x=x(t); y=y(t):
L:= int(sqrt(diff(x(t),t)^2 + diff(y(t),t)^2),t=a b);
+ Cho bởi tọa độ cực : r = r(t);a ≤ t≤b:
L:= int(sqrt(r(t)^2 + diff(r(t),t)^2),t=a b);
Bài 6
. Tính thể tích vật thể tròn xoay quay quanh trục Ox .
V := int(Pi*f(x)^2, x=a b);
Bài 7
. Tính diện tích mặt tròn xoay của hàm quay quanh trục Ox .
S := int(2*Pi*abs(f(x))*sqrt(1+ diff(f(x),x)^2), x=a b);
• Bài toán khảo sát hàm số

Khảo sát và vẽ đồ thị hàm số f :
Ví dụ 1:
> restart;
# Khao sat ham dang y=ax^3+bx^2+cx+d
a:=readstat(`a=`);
b:=readstat(`b=`);
c:=readstat(`c=`);
d:=readstat(`d=`);
f:=unapply(a*x^3+b*x^2+c*x+d,x);
#Mien xac dinh
TXD=real ;
#Chieu bien thien:
print(`Ham tang tren `);
solve(diff(f(x),x)>0,{x});
#Giam :
print(`Ham giam tren`);
solve(diff(f(x),x)<0,{x});
L1:=[solve(diff(f(x),x$2)=0,x)]:
g:=op(L1):
g1:=f(g):
#Cuc tri
if is(b^2-3*a*c>0) then
L:=[solve(diff(f(x),x)=0,x)]:
if a>0 then
printf("Cuc dai:(%a,%a)\n",simplify(min(op(L))),simplify(f(min(op(L)))) );
printf("Cuc tieu:(%a,%a)\n",simplify(max(op(L))),simplify(f(max(op(L)))) );
else
printf("Cuc tieu:(%a,%a)\n",simplify(min(op(L))),simplify(f(min(op(L)))) );
printf("Cuc dai:(%a,%a)\n",simplify(max(op(L))),simplify(f(max(op(L)))) );
end if;fi;

print(`Ham loi tren`);
solve(diff(f(x),x$2)>0,{x});
print(`Ham lom tren`);
solve(diff(f(x),x$2)<0,{x});

21
#Do thi:
print(` Do thi :`);
plot(f(x), x=g-5 g+5,y=g1-5 g1+5);
Ví dụ 2:
> restart;
# Khao sat ham huu ty dang y=(ax^2+bx+c)/(dx+e)
a:=readstat(`a=`);
b:=readstat(`b=`);
c:=readstat(`c=`);
d:=readstat(`d=`);
e:=readstat(`e=`);
f:=unapply((a*x^2+b*x+c)/(d*x+e),x);
#Mien xac dinh
real minus {solve(d*x+e=0,x)};
#Tiem can:
g:= `if`(degree(denom(normal(f(x))))=0,0,solve(denom(normal(f(x))),x)):
print(`Tiem can dung :`);
if degree(denom(normal(f(x))))=0 then ;
else
printf("\t \t x= %a",op([g])); fi;
print(`Tiem can Xien :`);
A2:=quo(numer(f(x)),denom(f(x)),x):
g1:=eval(A2,x=g):
printf("\t \t y= %a",A2);

#Chieu bien thien:
#Tang :
print(`Ham tang tren `);
solve(diff(f(x),x)>0,{x});
#Giam :
print(`Ham giam tren`);
solve(diff(f(x),x)<0,{x});
#Cuc tri
L:=[solve(diff(f(x),x)=0,x)]:
if L<>[]and is(op(1,L),real) then
if a*d>0 then
printf("Cuc dai:(%a,%a)\n",simplify(min(op(L))),simplify(f(min(op(L)))));
printf("Cuc tieu:(%a,%a)\n",simplify(max(op(L))),simplify(f(max(op(L)))));
else
printf("Cuc tieu:(%a,%a)\n",simplify(min(op(L))),simplify(f(min(op(L)))));
printf("Cuc dai:(%a,%a)\n",simplify(max(op(L))),simplify(f(max(op(L)))));
end if;
fi;
#Do thi:
print(` Do thi :`);
plot([f(x),A2], x=g-5 g+5,y=g1-5 g1+5);

22
• Tính tổng tích phân
+ Tính tổng :
leftsum(f(x), x=a b); hay leftsum(f(x), x=a b, n);
rightsum(f(x), x=a b); hay rightsum(f(x), x=a b, n);
middlesum(f(x), x=a b); hay middlesum(f(x), x=a b, n);
Ví dụ : > with(student):
> leftsum(x^k*ln(x), x=1 3);

1
2
⎛
⎝
⎜
⎜
⎜
⎞
⎠
⎟
⎟
⎟
∑
= i 0
3
⎛
⎝
⎜
⎜
⎞
⎠
⎟
⎟
+ 1
1
2
i
k
⎛

⎝
⎜
⎜
⎞
⎠
⎟
⎟
ln + 1
1
2
i

+ Vẽ các hình chữ nhật xấp xỉ:
leftbox(f(x), x=a b, <plot options>);
leftbox(f(x), x=a b, n, 'shading'=<color>, <plot options>);
rightbox(f(x), x=a b, <plot options>);
rightbox(f(x), x=a b, n, 'shading'=<color>, <plot options>);
middlebox(f(x), x=a b, <plot options>);
middlebox(f(x), x=a b, n, 'shading'=<color>, <plot options>);
Ví dụ : > with(student):leftsum(x^2,x=0 1,n); limit(A,n=infinity);
> middlebox(x^4*ln(x), x=2 4, color=YELLOW);


> middlebox(sin(x)*x+sin(x), x=0 2*Pi, 5, shading=BLUE);
> middlebox(sin(x)*x+sin(x), x=0 2*Pi, 5, color=GREEN);
+Tính xấp xỉ bằng phương pháp Simpson:
ApproximateInt(f(x), x = a b, method = simpson, opts);
ApproximateInt(f(x), a b, method = simpson, opts);
ApproximateInt(Int(f(x), x = a b), method = simpson, opts);
Ví dụ:

> polynomial := interp([x[0], (x[0]+x[1])/2, x[1]], [f(0), f(1/2), f(1)], z):
>integrated := int(polynomial, z=x[0] x[1]):
>factor(integrated);
−
1
6
() − x
0
x
1
⎛
⎝
⎜
⎜
⎞
⎠
⎟
⎟
+ + ()f1 ( )f0 4
⎛
⎝
⎜
⎜
⎞
⎠
⎟
⎟
f
1
2

> with(Student[Calculus1]):
>ApproximateInt(sin(x), x=0 5, method = simpson);
>ApproximateInt(x*(x - 2)*(x - 3), x=0 5, method = simpson, output = plot);
>ApproximateInt(tan(x) - 2*x, x=-1 1, method = simpson, output = plot, partition = 50);

23
>ApproximateInt(ln(x), 1 100, method = simpson, output = animation);
+ Tính xấp xỉ bằng phương pháp hình thang:
ApproximateInt(f(x), x = a b, method = trapezoid, opts);
ApproximateInt(f(x), a b, method = trapezoid, opts);
ApproximateInt(Int(f(x), x = a b), method = trapezoid, opts);
Ví dụ
:> polynomial := interp([x[0], x[1]], [f(0), f(1)], z):
>integrated := int(polynomial, z=x[0] x[1]):
>factor(integrated);
−
1
2
()− + x
1
x
0
() + ()f0 ( )f1

> with(Student[Calculus1]):
>ApproximateInt(sin(x), x=0 5, method = trapezoid);
>ApproximateInt(x*(x - 2)*(x - 3), x=0 5, method = trapezoid, output = plot);
>ApproximateInt(tan(x) - 2*x, x=-1 1, method = trapezoid, output = plot, partition = 50);
>ApproximateInt(ln(x), 1 100, method = trapezoid, output = animation);

+ Phương pháp Newton:
ApproximateInt(f(x), x = a b, method = newtoncotes[N], opts);
ApproximateInt(f(x), a b, method = newtoncotes[N], opts);
ApproximateInt(Int(f(x), x = a b), method = newtoncotes[N], opts);
Ví dụ:

> with(Student[Calculus1]):
> ApproximateInt(x*(x - 2)*(x - 3), 0 5, method = simpson, output = plot);

> ApproximateInt(tan(x) - 2*x, x=-1 1, method = simpson, output = plot, partition = 50);

24

> ApproximateInt(ln(x), x=1 100, method = simpson, output = animation);


• Tính giá trị lớn nhất, nhỏ nhất của f(x) trên [a,b].
+ Nhỏ nhất :minimize(expr, opt1, opt2, , optn);
Ví dụ:
> minimize(cos(x), x=1 3);
> minimize(x^2-3*x+y^2+3*y+3, location);
,
-3
2
{}
⎡
⎣
⎢
⎢
⎤

⎦
⎥
⎥
,{}, = x
3
2
= y
-3
2
-3
2

+ Lớn nhất : maximize(expr, opt1, opt2, , optn);
Ví dụ :
> maximize(x^2-3*x+y^2+3*y+3, x=2 4, y=-4 2, location);
,11 { }[],{},

= y -4

=
x
411


Chú ý :
option :
+ x=a b, y=c d , nếu trên(-∞;+∞) thì bỏ qua.
+ location, hay location=true
• Cực trị có điều kiện:
extrema(expr, constraints);

extrema(expr, constraints, vars);
extrema(expr, constraints, vars, 's');