330769441 Bai Giảng Mathematica Phần 1 PDF

Lập trình toán học với Mathematica - NTTH 2016
Làm quen với Mathematica......................................................................................................... 3

Làm việc với ma trận .................................................................................................................. 3
Làm việc với List ......................................................................................................................... 4
Hàm số ....................................................................................................................................... 6
Vẽ đồ thị và điểm ........................................................................................................................ 8
Vẽ đồ thị tham số ...................................................................................................................... 10
Vẽ đồ thị trong không gian 3 chiều ............................................................................................ 11
Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0 ......................................................................... 12
Vẽ miền đúng của bất đẳng thức .............................................................................................. 15
Các vòng lặp dạng Do, For, While ............................................................................................ 17
Những kí hiệu đặc biệt .............................................................................................................. 19
Tích Kronecker với lệnh KroneckerProduct ............................................................................... 20
Phân tích số tự nhiên thành thừa số nguyên tố......................................................................... 21
Giải phương trình và hệ phương trình ...................................................................................... 22
Tích phân, đạo hàm, chuỗi và giới hạn. .................................................................................... 24
Tính toán nhiều biến ................................................................................................................. 25
Giải phương trình vi phân: DSolve và NDSolve ........................................................................ 26
Chuyển từ số thực sang số hữu tỉ và ngược lại. Chuyển cơ số. ............................................... 26
Lệnh Roots và lệnh Solve ......................................................................................................... 27
Lệnh khử biến và một số cách thế giá trị vào biểu thức ............................................................ 27
Lệnh Chop ................................................................................................................................ 28
Thread, Inner, Outer, Transpose, và Distribute ......................................................................... 29
Lệnh Root và lệnh FindRoot ..................................................................................................... 33
Lệnh Quiet ................................................................................................................................ 34
Lệnh Off .................................................................................................................................... 35
Lệnh On .................................................................................................................................... 35
Lệnh Check .............................................................................................................................. 36
Giải phương trình vi phân thường - Lệnh NDSolve ................................................................... 36
Lệnh String ............................................................................................................................... 36
Ghi chú trên đồ thị..................................................................................................................... 37
Vẽ đồ thị động với lệnh Manipulate ........................................................................................... 38
Các đơn vị đo lường trong thống kê mô tả ................................................................................ 39
Sự sai khác khi tính toán với số phức ....................................................................................... 40
Phép đổi biến trong tích phân ................................................................................................... 41
1
Thử lại tính đúng đắn nghiệm của phương trình ....................................................................... 42
Ghi chú khi vẽ đồ thị điểm ......................................................................................................... 43
Tam giác Pascal ....................................................................................................................... 44
Vẽ đồng hồ treo tường .............................................................................................................. 46
Thao tác các biểu thức đại số ................................................................................................... 47
Mọi thứ là một biểu thức ........................................................................................................... 50
Một phương trình với nghiệm chính xác không được tìm thấy .................................................. 53
2
Làm quen với Mathematica
1. Mathematica phân biệt chữ hoa chữ thường, các hàm của nó đều bắt đầu bằng chữ hoa.
2. Các biến đi theo hàm đều được đặt trong ngoặc vuông, cú pháp hình thức như sau:
Hàm[expr]. Có thể lấy ví dụ như Cos[x], Sin[x].
3. Để thực hiện một câu lệnh, ta dùng tổ hợp phím "Shift + Enter".
4. Để kết thúc một câu lệnh ta đặt dấu chấm phẩy (;), nếu không có dấu (;) thì kết quả sẽ
được hiển thị bên dưới.
5. Cần phân biệt các dấu [], [[]], {}, ().
6. Lệnh N[expr] dùng để hiện thị kết quả thành số thập phân. Ví dụ: nếu bạn gõ Cos[1] thì
kết quả hiển thị chỉ là Cos[1], nếu bạn gõ N[Cos[1],6] thì kết quả sẽ là 0.540302.
7. Không được chạy nhiều chương trình cùng một lúc vì các biến vẫn còn lưu giá trị của nó,
khi đó kết quả của bạn sẽ bị sai, để khắc phục, chỉnh lại như sau Evaluation/Quit
Kernel/Local.
8. Cách đặt biến bình thường như a, b, c, x, y, z, ... , không được đặtXY_a, XY-a, không
được dùng các chữ cái sau để đặt tên biến I, E, C, D, N.
9. Tổ hợp Ctrl + K để tìm các hàm có tên giống nhau ở phần đầu.
10. Lệnh ?Int* để tìm tất cả các hàm bắt đầu bằng "Int", tương tự với ?*Q hay ?*Int*.
11. Cần phân biệt List và Matrix trong Mathematica. Nếu viết {1,2,3,4} thì đây là một List
gồm 4 phần tử, còn nếu viết {{1},{2},{3},{4}} thì đây là một matrix 4 dòng 1 cột, đối với 1
List thì không thể dùng hàm chuyển vị Transpose được, tuy nhiên bạn có thể sử dụng các
phép toán ma trận giữa Matrix và List, kết quả vẫn đúng như khi tính toán giữa các ma
trận.
Làm việc với ma trận
1. Cách cho một ma trận
Cách 1: Insert->Table/Matrix->New Cách 3: Dùng hàm Table[].
Cách 2: Sử dụng móc nhọn {}. Ví dụ: Table[i*j,{i,1,10},{j,1,10}] sẽ cho một ma trận
10 dòng 10 cột
Ví dụ: {{1,2,3},{a,b,c},{x,y,z}} sẽ cho
một ma trận có 3 dòng 3 cột
2. Các phép toán với ma trận
Cộng 2 ma trận, sử dụng dấu cộng (+)
Trừ 2 ma trận, sử dụng dấu trừ (-)
3
Nhân 2 ma trận, sử dụng dấu chấm (.)
3. Các hàm với ma trận
Tr[A]: tổng các phần tử trên đường chéo của ma trận vuông A
Det[A]: định thức của ma trận A
Transpose[A]: ma trận chuyển vị của ma trận A
Inverse[A]: ma trận nghịch đảo của ma trận A
Eigenvalues[A]: giá trị riêng của ma trận A
Eigenvectors[A]: vec tơ riêng của ma trận A
MatrixPower[A,n]: lũy thừa n của ma trận A
MatrixExp[A]: ma trận mũ của ma trận A
Drop[A,{i},{}]: xóa dòng thứ i từ ma trận A
Drop[A,{},{j}]: xóa cột thứ j từ ma trận A
Union[A,B]: hợp 2 ma trận A và B
4. Tạo một ma trận với tính chất cho trước:
Tạo ma trận đơn vị cấp n: IdentityMatrix[n]
Tạo ma trận đường chéo: DiagonalMatrix[v], v là vec tơ đường chéo có dạng v = {a,b,c,d,...}
Ngoài ra có thêm hàm: SparseArray[], bạn đọc tự tìm hiểu thêm qua thẻ Help (hoặc nhấn F1)
Làm việc với List
1. Cách cho một list
Cách 1: {} cho một list rỗng; {a,1,b,2,c,3} cho một list gồm 6 phần tử
Cách 2: Table[expr,{i,n}] cho 1 list các giá trị của expr từ 1 đến n
Cách 3: Array[f,n] cho 1 list có n phần tử lần lượt là f[1], f[2], ... , f[n]
Cách 4: Range[n] cho 1 list {1, 2, ... , n}
Cách 5: NestList[f,x,n] cho 1 list n+1 phần tử có dạng {x, f[x], f[f[x]], ...}
2. Cách gọi phần tử của list
First[list]: gọi phần tử đầu tiên cùa list
4
Last[list]: gọi phần tử cuối cùng của list t[[i]] hoặc Part[t,i]: lấy phần tử thứ i của list t
t[[i;;j]] hoặc Part[t,i;;j]: lấy các phần tử của list t từ vị trí i đến vị trí j
t[[{i1,i2,...}]] hoặc Part[t,{i1,i2,...}]: lấy các phần tử từ list t ứng với các vị trí i1, i2, ...
t[[i,j,...]] hoặc Part[i,j,...]: lấy phần tử từ list t có dạng t[[i]][[j]]...
Take[list,n]: lấy ra n phần tử đầu tiên của list
Take[list,-n]: lấy ra n phần tử cuối cùng của list
Take[list,{m,n}]: lấy ra các phần từ của list từ vị trí m đến vị trí n
Min[list]: lấy ra phần tử bé nhất của list Max[list]: lấy ra phần tử lớn nhất của list
3. Các hàm xử lí đối với list
Kết quả nhận được sau khi sử dụng các hàm này đa phần là List
Table[expr,{i,list}]: cho các giá trị của expr với i lấy giá trị từ list
Map[f,list]: thực hiện hàm f với từng giá trị của list
Select[list,text]: chọn ra các giá trị từ list với điều kiện text[elem] đúng
TakeWhile[list,text]: giống với hàm Select[]
Length[list]: đếm số phần tử của list
Column[list]: in giá trị của list theo dạng cột
Position[list,form]: tìm vị trí các phần tử của list có cùng form
Count[list,form]: đếm số phần tử của list có cùng form
MemberQ[list,form]: kiểm tra xem form có trong list hay không (cho giá trị logic)
Prepend[list,elem]: thêm elem vào vị trí đầu tiên của list
PrependTo[list,elem]: giống với Prepend[] Append[list,elem]: thêm elem vào vị trí cuối cùng
của list
AppendTo[list,elem]: giống với Append[] Insert[list,elem,i]: thêm elem vào vị trí thứ i của list
Insert[list,elem,-i]: thêm elem vào vị trí thứ i (tính từ cuối đến đầu list) của list
Riffle[list,elem]: chèn elem vào các vị trí xen kẽ giữa các phần tử của list
Delete[list,i]: xóa elem nằm ở vị trí thứ i của list
ReplacePart[list,i->new]: thay giá trị cho phần tử thứ i của list bởi new
5
Rest[list]: trả lại giá trị cho list sau khi xóa phần tử đầu tiên
Most[list]: trả lại giá trị cho list sau khi xóa phần tử cuối cùng
Drop[list,n]: trả lại giá trị cho list sau khi xóa n phần tử đầu tiên
Drop[list,-n]: trả lại giá trị cho list sau khi xóa n phần tử cuối cùng
Drop[list,{m,n}]: trả lại giá trị cho list sau khi xóa các phần tử từ vị trí m đến n
4. Sắp xếp thứ tự một list
Sort[list]: sắp xếp list theo trật tự chuẩn
Union[list]: sắp xếp list và xóa các phần tử trùng nhau
Ordering[list]: cho biết vị trí ban đầu của các phần tử list sau khi đã được sắp xếp bởi Union[]
Hàm số
1. Định nghĩa hàm số trên Mathematica
Cách 1: Muốn định nghĩa hàm parabol ta viết f[x_] = x^2+3x+1
Định nghĩa hàm 2 biến: ta viết g[x_,y_] = x^2+y^2
Tương tự đối với hàm nhiều biến.
Cách 2: Function[x,body]: khai báo hàm một biến
Function[{x1,x2,…},body]: khai báo hàm nhiều biến
Lấy ví dụ ở trên, ta có thể khai báo như sau: Function[x, x^2+3x+1]
Function[{x,y}, x^2+y^2]
Cách 3: Dùng dấu #& Lấy ví dụ ở trên, ta có thể khai báo như sau: (#^2+3#+1)& (#1^2+#2^2)&
2. Tính giá trị hàm số
Ví dụ 1
6
f[x_] = x^2+3x+1
g[x_]=x^2+2
h[x_]=f[x]+g[x]
Map[h,{a,b,c}]
Map[f[#]+g[#]&,{a,b,c}]
Ví dụ 2
f[x_] = x^2+3x+1
f[2] f[x]/.x->2
f[x]/.x->{1,2,3}
f@{2}
f@{1,2,3}
f/@{2}
f/@{1,2,3}
Ví dụ 3
Map[Function[x,x^2+3x+1],a+b+c]
Function[{x,y},x^2+y^2][a,b]
Map[#^2&,a+b+c]
Map[Take[#,2]&,{{2,1,7},{4,1,5},{3,1,2}}]
7
Ví dụ 4
h[x_] = Nest[Function[q,1/(1+q)],x,3]
Kết quả của sẽ là
3. Hàm có sẵn trong Mathematica
Hàm logarit: Log[a,x] (cơ số a)
Hàm lượng giác: Sin, Cos, Tan, Cot, Sinh, Cosh, Tanh, Coth, ArcCos, ArcSin, ArcTan,
ArcCot
Hàm đặc biệt: Gamma, Beta, Zeta, BesselJ, BesselY
Có thể tìm qua thẻ Help với từ khóa tutorial/SpecialFunctions.
Vẽ đồ thị và điểm
1. Lệnh Plot
Lệnh vẽ đồ thị của một hàm số là Plot[]. Cú pháp hình thức có thể viết như sau:
Plot[f, {x, xmin, xmax}]: vẽ đồ thị hàm f trên đoạn [xmin,xmax].
Plot[{f1, f2,...}, {x, xmin, xmax}]: vẽ trên cùng một hệ trục tọa độ các hàm f1, f2, … trên đoạn
[xmin,xmax].
Ví dụ 1:
Plot[Sin[x]/x,{x,0,20}]
Để biết được danh sách các tham số được dùng kèm với hàm Plot, ta gõ câu lệnh Options[Plot].
Các tham số này được khai báo ở dạng: name→value.
Các giá trị hay dùng nhất của tham số là:
- Automatic: sự chọn lựa sẽ được tự động
8
- None: tham số không được sử dụng

- All: được sử dụng trong trường hợp bất kì
- True: được sử dụng
- False: không được sử dụng
Ví dụ 2:
Plot[Sin[x]/x,{x,0,20}, PlotRange→{-0.25,1.2}]
Giải thích: Tham số PlotRange→{-0.25,1.2} được dùng để giới hạn đồ thị hàm số theo trục dọc
từ -0.25 đến 1.2
Một số tham số hay dùng:
- Axes->None: không hiển thị hệ trục tọa độ
- AxesLabel: ghi chú tên của trục tọa độ
- PlotStyle: chỉnh các thông số về màu sắc, cách hiển thị đậm nhạt
9
2. Lệnh ListPlot
Cú pháp hình thức:
- ListPlot[{yl, у2,...}] – hiển thị các giá trị y1, y2, … lên hệ trục tọa độ, giá trị của x tương
ứng là 1, 2, …
- ListPlot[{{x1, y1},{х2, у2 },...}] – hiển thị các điểm có tọa độ {xi,yi} lên hệ trục tọa độ.
Chú ý:
- Đối với lệnh ListPlot cũng có các tham số như lệnh Plot.
- Nếu các điểm không được hiển thị đầy đủ, bạn bổ sung thêm tham số PlotRange→All.
- Muốn hiển thị nhiều đồ thị trên cùng một hệ trục tọa độ ta dùng lệnh Show[].
Vẽ đồ thị tham số
Để vẽ một hàm số được biểu diễn dưới dạng tham số x = fx(t), y = fy(t), t thuộc đoạn [a,b] ta
dùng các cấu trúc lệnh sau:
ParametricPlot[{fx,fy},{t,tmin,tmax}] – xây dựng đồ thị tham số với các tọa độ {fx,fy} nhận
được như một hàm theo t.
ParametricPlot[{{fx,fy},{gx,gy},…},{t,tmin,tmax}] – xây dựng một vài đường tham số trên

cùng một hệ trục tọa độ.
Ví dụ 1: ParametricPlot[{Cos[5*t], Sin[3*t]}, {t,0,20}, AspectRatio->Automatic]
Ví dụ 2:
ParametricPlot[{{2Cos[t], 2Sin[t]}, {2Cos[t], Sin[t]}, {Cos[t], 2Sin[t]}, {Cos[t], Sin[t]}},

{t,0,2Pi}]
10
Vẽ đồ thị trong không gian 3 chiều
1. Lệnh Plot3D
Chức năng: vẽ hình dạng của hàm 2 biến z = f(x,y) trong hệ trục tọa độ Oxyz.
Cú pháp hình thức:
Plot3D[f,{x, xmin, xmax), {у, ymin, ymax}] – xây dựng đồ thị 3 chiều của hàm 2 biến x, y.
Plot3D[{f1,f2,…}, {x,xmin,xmax}, {y,ymin,ymax}] – xây dựng đồ thị 3 chiều của các hàm f1, f2,
… trong cùng một hệ trục tọa độ.
Ví dụ 1: Plot3D[Sin[x y], {x,0,4}, {y,0,4}]
Ví dụ 2: Plot3D[{x^2+y^2, -x^2-y^2}, {x,-2,2}, {y,-2,2}]
11
2. Lệnh ListPlot3D ListPlot3D[{{x1,y1,z1},{x2,y2,z2},…}] – hiển thị các điểm có tọa độ

{xi,yi,zi}
Ví dụ 3: ListPlot3D[{{0,0,1},{1,0,0},{0,1,0}},Mesh->All]
Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0
1. Mục đích
12
Như chúng ta đã biết, để vẽ đồ thị của một hàm số trong hệ trục tọa Đecac vuông góc ta thường
dùng lệnh Plot[], tuy nhiên đối với trường hợp này hàm số phải có dạng chuẩn là y = f(x).
Trong nhiều trường hợp khác, chúng ta lại cần vẽ đồ thị của hàm số có dạng f(x,y) = 0, ví dụ như
vẽ hình elip chẳng hạn, giải pháp tối ưu nhất là dùng lệnh ContourPlot[].
Tương tự đối với hàm số dạng f(x,y,z) = 0 ta dùng lệnh ContourPlot3D[].
2. Cú pháp hình thức
ContourPlot[f == 0, {x,xmin,xmax}, {у,ymin,ymax}] – xây dựng đồ thị hàm số f(x,y) = 0 trong miền
[xmin, xmax]×[ymin,ymax].
ContourPlot[{f == 0, g == 0, …}, {x,xmin,xmax}, {у,ymin,ymax}] – xây dựng nhiều đồ thị trên cùng
một hệ trục tọa độ.
Tương tự ta có: ContourPlot3D[f == 0, {x,xmin,xmax}, {у,ymin,ymax},{z,zmin,zmax}]
ContourPlot3D[{f == 0, g == 0, …}, {x,xmin,xmax}, {у,ymin,ymax},{z,zmin,zmax}]
3. Một số ví dụ áp dụng
Ví dụ 1: ContourPlot[x^2-y == 0, {x,-2,2}, {y,-0.15,4}, Axes->True, Frame->False]
Ví dụ 2: ContourPlot[x^2/9+y^2/4 == 1, {x,-3.5,3.5}, {y,-2.5,2.5}, Axes->True, Frame->False,

AspectRatio->Automatic]
Ví dụ 3:
13
ContourPlot[{Abs[Sin[x] Sin[y]] == 0.5, Abs[Cos[x] Cos[y]] == 0.5}, {x,-3,3}, {y,-3,3}]
Ví dụ 4: ContourPlot3D[x^3+y^2-z^2 == 0, {x,-2,2}, {y,-2,2}, {z,-2,2}]
4. Một số điểm lưu ý
- Dấu ―bằng‖ phải được viết 2 lần (==).
- Cú pháp dạng ContourPlot[f == g, {x,xmin,xmax}, {у,ymin,ymax}] hoặc ContourPlot[f == g,

{x,xmin,xmax}, {у,ymin,ymax}, {z,zmin,zmax}] vẫn được thực hiện.
- Nếu không thêm các tham số thì Mathematica sẽ mặc định đồ thị nằm trong khung tỉ lệ, nếu
muốn hệ trục tọa độ hiển thị thì ta thêm các tham số như trong ví dụ trên Axes->True, Frame-
>False.
- Cú pháp dạng ContourPlot[f, {x,xmin,xmax}, {у,ymin,ymax}] – vẽ đồ thị miền là các giá trị của f
tương ứng với x và y trong miền [xmin, xmax]×[ymin,ymax].
Tương tự đối với hàm ContourPlot3D (xem Ví dụ 5 và Ví dụ 6).
Ví dụ 5:
ContourPlot[x^2/9+y^2/4,{x,-3.5,3.5},{y,-2.5,2.5},Axes->True,Frame->False,AspectRatio-
>Automatic]
14
Ví dụ 6: ContourPlot3D[x^3+y^2-z^2,{x,-2,2},{y,-2,2}, {z,-2,2}]
Vẽ miền đúng của bất đẳng thức
1. Mục đích
Trong nhiều trường hợp chúng ta cần phải xác định miền nào là miền thỏa mãn của bất đẳng thức
cho trước, tức là bất đẳng thức đúng. Một trong số các giải pháp là dùng lệnh RegionPlot[],
tương tự, trong không gian 3 chiều ta cũng có lệnh RegionPlot3D[].
2. Cú pháp hình thức
RegionPlot[pred,{x,xmin,xmax},{у,ymin,ymax}] – xây dựng miền đồ thị sao cho pred nhận giá
trị True.
RegionPlot3D[pred,{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}] – đối với trường hợp 3

biến.
3. Một số ví dụ áp dụng
Ví dụ 1:
RegionPlot[x^2+y^3<2,{x,-2,2},{y,-2,2}]
Ví dụ 2:
15
RegionPlot[x^2+y^3<2&&x+y<1,{x,-2,2},{y,-2,2},BoundaryStyle->Dashed,PlotStyle-
>Yellow]
Ví dụ 3: RegionPlot3D[x^2+y^3-z^2>0,{x,-2,2},{y,-2,2},{z,-2,2}]
Ví dụ 4: RegionPlot3D[x^2+y^2+z^2<1 && x^2+y^2<z^2,{x,-1,1},{y,-1,1},{z,-1,1},

PlotPoints->35, PlotRange->All]
16
Các vòng lặp dạng Do, For, While
1. Vòng lặp dạng Do
Do [expr, {imax}] – thực hiện expr imax lần.
Do [expr, {i, imax}] – tính expr với biến i nhận giá trị lần lượt từ 1 đến imax (bước nhảy bằng 1)
Do [expr, {i, imin, imax}] – tính expr với biến i nhận giá trị lần lượt từ imin đến imax (bước nhảy
bằng 1).
Do [expr, {i, imin, imax, di}] – tính expr với biến i nhận giá trị lần lượt từ imin đến imax (bước nhảy
bằng di).
Do [expr, {i, imin, imax}, {j, jmin, jmax},...] – tính expr với các vòng lặp lồng nhau theo các biến j, i,
…
2. Vòng lặp dạng For
17
For[start, test, incr, body] – bắt đầu với giá trị start, sau đó thực hiện lần lượt incr và body cho
đến khi test nhận giá trị logic False.
3. Vòng lặp dạng While
While [test, expr] – thực hiện expr cho đến khi nào test nhận giá trị logic False.
4. Các ví dụ
Do[Print["hello"], {3}]
For[i=0,i<4,i++,Print[“i=”,i]]
n=1;
While[n<4,Print[“n=”,n];n++]
Lệnh IF
If [condition, t, f] : t sẽ được thực hiện nếu condition có giá trị True, ngược lại, f sẽ đc thực hiện
If [condition, t, f, u ] — tương tự như trên, nhưng nếu giá trị của condition không đúng không
sai thì u sẽ được thực hiện
Ví dụ 1: Định nghĩa hàm giá trị tuyệt

đối
abs[x_]:=If[x<0,-x,x]; abs/@{-1,0,1}
Ví dụ 2: t={} ; Do[If[PrimeQ[2^n-1],
AppendTo[t,n]],{n,100}]; t
Ví dụ 3:
18
Sử dụng hàm If lồng vào vòng

lặp Do, trong đó có sử dụng
hàm làm gián đoạn Abort[ ]
a := 1; Print["i a"];
Do[{If [i == 5,Abort[],None],
i += 1; a += 2*i; Print[i, " ",
N[a]]}, {i, 1, 100}]
Những kí hiệu đặc biệt
Trong bất kì ngôn ngữ lập trình nào cũng có những kí hiệu đặc biệt giúp cho người sử dụng thực
hiện nhanh hơn trong thao tác lập trình của mình. Chúng tìm được trong thẻ Help hoặc nhấn F1.
- Các phép tính toán học +, –, *, /, ^ được giữ nguyên không có gì thay đổi. Chú ý rằng
phép nhân 2 ma trận với nhau được kí hiệu dấu chấm A.B
Các kí hiệu logic cũng cần chú ý đến, nó rất có ích cho chúng ta khi dùng vòng lặp While hay If:
- And thay bằng &&, Or thay bằng ||, Not thay bằng !.
- Câu lệnh ―Nếu A bằng B thì …‖ được viết trong Mathematica như sau: If[A==B,…].
Chú ý kí hiệu 2 dấu bằng ―==‖, nếu chỉ viết 1 dấu bằng thì câu lệnh sẽ bị sai.
- Câu lệnh ―Nếu A khác B thì …‖ được viết trong Mathematica như sau: If[A!=B,…].
Một kí hiệu đặc biệt trong Mathematica là ―===‖ , 3 dấu bằng, tương ứng với lệnh SameQ[]. Nó
được dùng để so sánh sự giống nhau của 2 đối tượng. Ngược lại với nó sẽ có lệnh UnsameQ[], kí
hiệu tắt là “=!=”.
Một trong những kí hiệu hay dùng khi viết một chương trình đó là @. Kí hiệu này sẽ giúp cho
chương trình của bạn bớt rườm rà hơn.
Ví dụ:
Lệnh Panel[Grid[Table[{i,j},{i,3},{j,3}]]]
viết lại:
Panel@Grid@Table[{i,j},{i,3},{j,3}]
Số dấu móc vuông sẽ giảm bớt giúp ta quản lí các lỗi của chương trình một cách dễ dàng.
19
Tương tự ta có kí hiệu ―//‖. Câu lệnh trên có thể viết lại: Table[{i,j},{i,3},{j,3}]//Grid//Panel
Kí hiệu 2 con @@. Kí hiệu này tương ứng với lệnh Apply[].
Ví dụ:
FactorInteger[20!]
Kết quả là: {{2,18},{3,8},{5,4},{7,2},{11,1},{13,1},{17,1},{19,1}}
Thực hiện hai lệnh sau liên tiếp:
FactorInteger[20!]
CenterDot@@(Superscript@@@%)
– Kí hiệu % thay cho danh sách list:{{2,18},{3,8},{5,4},{7,2},{11,1},{13,1},{17,1},{19,1}}
Kết quả là:
Các câu lệnh ở trên nhằm mục đích phân tích số 20! thành tích các thừa số nguyên tố.
Có thể giải thích quá trình tính toán như sau:
- Đầu tiên lệnh FactorInteger[] liệt kê một list các cặp số dạng {thừa số nguyên tố, số mũ
tương ứng},
- Sau đó lệnh Superscript@@@% được áp dụng thực để hiện phép lũy thừa cho từng
phần tử [cặp số] của list, kí hiệu % tương ứng với kết quả trước đó, kí hiệu @@@ tương
đương với Apply ở mức độ 1 [level 1] [sẽ hiểu sâu hơn khi tìm hiểu lệnh Apply].
- Cuối cùng lệnh CenterDot[]thực hiện phép nhân các phần tử của list kết quả.
Một ví dụ khác dùng kí hiệu @ và @@:
f[x_]=Sin[x]
f@3
f@@{3}
Cả hai đều cho kết quả là Sin[3].
Tích Kronecker với lệnh KroneckerProduct
Cho hai ma trận Tích Kronecker của 2 ma trận A và B là một ma trận có kí hiệu:
Ví dụ 1:
A={{1,2},{3,4}}; KroneckerProduct[IdentityMatrix[3],A]//MatrixForm
20
Ví dụ 2:
A={{a,b},{c,d}}; B={{x,y},{z,u}}; KroneckerProduct[A,B]//MatrixForm
Ví dụ 3: Có thể kiểm tra tính chất của tích Kronecker:
{a,b,c,d} = RandomReal[1,{4,3,3}]; Chop[KroneckerProduct[a,b].KroneckerProduct[c,d] -

KroneckerProduct[a.c, b.d]] //MatrixForm
Phân tích số tự nhiên thành thừa số nguyên tố
Các số tự nhiên có thể được phân tích ra các thừa số nguyên tố một cách nhanh chóng nếu chúng
không quá dài (không quá dài có nghĩa là không quá 30 kí tự)
FactorInteger[2434500]
Kết quả là: 2434500 = {{2,2},{3,2},{5,3},{541,1}}
Lệnh FactorInteger[] viết các thừa số nguyên tố của một số tự nhiên theo dạng một list của từng
cặp. Thành phần đầu tiên của mỗi cặp là thừa số nguyên tố, và thành phần thứ hai là số mũ của
thừa số đó trong phép nhân tử hóa.
Chúng ta có thể kiểm tra thừa số cuối cùng trong dãy phân tích trên có phải là một số nguyên tố
hay không bằng lệnh PrimeQ[].
PrimeQ[541]
21
Kết quả là True
Giải phương trình và hệ phương trình
Đầu tiên chúng ta làm quen với lệnh Solve: cú pháp và cách lấy giá trị nghiệm. Hãy chú ý đến
trường hợp có nghiệm bội như trong ví dụ dưới đây:
Solve[a*x^2+b*x+2,x]
Solve[x^4-3x^3+2x^2==0,x]
Solve[a*x^2+b*x+2,a]
Solve[a*x^2+b*x+2,b]
Theo trên thì ta nhận thấy rằng, cú pháp để giải một phương trình đơn một biến là:
Solve[equation, variable]
Cú pháp tổng quát đối với các đối số của lệnh Solve bao gồm một list các phương trình phụ thuộc
vào một list các biến. Có nghĩa là:
Solve[equation_list, variable_list]
22
Đồ thị minh họa
Chú ý rằng, không phải tất các phương trình đa thức đều có nghiệm chính xác. Theo lí thuyết
phương trình thì các phương trình bậc 4 trở xuống đều có công thức nghiệm chính xác được xây
dựng từ các hệ số.
Tuy nhiên, theo Galois, đối với các phương trình bậc 5 trở lên, chúng ta lại không có những công
thức nghiệm như thế. Và Mathematica sẽ không đánh giá các phương trình bậc 5 trở lên (các
phương trình không thể phân tích thành nhân tử), tất nhiên có thể tìm tất cả các nghiệm của một
phương trình đa thức bằng phương pháp số thông qua lệnh N[].
N[%]
23
Tích phân, đạo hàm, chuỗi và giới hạn.
Các Option có thể tham khảo trong thẻ Help.
Lệnh tìm tích phân không xác định của hàm f(x) là Integrate[f[x], x].
Chú ý rằng trong kết quả tìm được không có các hằng số đi kèm.
Để tìm tích phân xác định của hàm f(x) trên đoạn từ a đến b ta sử dụng cú pháp:
Integrate[f[x], {x, a, b}].
Tương tự, lệnh NIntegrate tìm giá trị số biểu diễn thập phân của tích phân xác định của hàm f(x).
Đạo hàm là phép toán ngược với tích phân. Cú pháp:
D[f[x], x] có nghĩa là tìm đạo hàm của hàm f(x) theo biến x.
Tất nhiên có thể tìm đạo hàm bậc n của hàm f(x) bằng lệnh D[f[x], {x, n}].
Lệnh Series[f(x), {x, a, n}] sẽ cho ra n thành phần đầu tiên trong khai triển chuỗi Taylor của hàm
f(x) tại điểm a.
Lệnh Limit[f(x), x -> a] sẽ tìm giới hạn của hàm f(x) khi x tiến tới a.
Sau đây là các ví dụ:
24
Tính toán nhiều biến
Với Mathematica, đạo hàm hỗn hợp được tính một cách dễ dàng.
D[f[x, y], x, y] – đạo hàm theo cả biến x và y
D[f[x, y], {x, n}, {y, m}] – đạo hàm theo biến x n lần và theo biến y m lần
D[f, {{x1, x2, …}}] – tìm đạo hàm riêng
Đối với tích phân cũng vậy, ta có các cú pháp sau:
Integrate[f[x, y], {x, a, b}, {y, c, d}] – tính tích phân theo cả 2 biến x và y
25
Giải phương trình vi phân: DSolve và NDSolve
DSolve[equation, y, x] – giải phương trình vi phân với biến độc lập x
DSolve[equation_list, y_list, x] – giải một list các phương trình vi phân
DSolve[equation, y, {x1, x2, …}] – giải phương trình đạo hàm riêng
Chuyển từ số thực sang số hữu tỉ và ngược lại. Chuyển cơ số.
Một số lệnh rất đơn giản nhưng sẽ gây khó khăn cho người mới học. Sau đây là một số ví dụ cơ
bản:
26
Lệnh Roots và lệnh Solve
Về cơ bản thì 2 lệnh này có chức năng như nhau, đó là giải phương trình. Tuy nhiên sự khác nhau
của chúng là cách thể hiện kết quả tìm được: đối với Solve – kết quả được liệt kê theo kiểu list,
đối với Roots – kết quả biểu diễn theo kiểu logic (xem ví dụ). Tuy nhiên, kết quả của chúng sẽ
hiện thị giống nhau nếu ta dùng lệnhToRules.
Lệnh khử biến và một số cách thế giá trị vào biểu thức
Eliminate[eqns, vars] – khử các biến vars nằm trong các phương trình cùng một lúc.
Giả sử ta có một biểu thức với các biến x, y, z … Muốn tính giá trị biểu thức tại những giá trị cụ
thể của biến, có thể làm như trong ví dụ sau:
27
Ví dụ chỉ mang tính minh họa gợi ý, không tổng quát.
Lệnh Chop
Lệnh Chop sẽ khử các giá trị rất nhỏ (gần bằng 0) trong khi tính toán. Xét các ví dụ sau đây:
(1)
(2)
28
(3)
Thread, Inner, Outer, Transpose, và Distribute
1. Thread
Listable là một thuộc tính có thể ấn định cho một kí hiệu f rằng hàm f sẽ tự động thực hiện
―xuyên qua‖ các list và xuất hiện với các đối số của nó.
Các hàm listable (được hiểu là hàm có thuộc tính này) sẽ được thực hiện một cách riêng rẽ đối
với mỗi phần tử của list, hoặc với các phần tử tương ứng trên mỗi list nếu trong trường hợp có
nhiều hơn một list.
Hầu hết các hàm được xây dựng trong Mathematica là listable.
Tất các các đối số (các list) trong hàm listable cần phải có cùng chiều dài.
Các đối số mà không phải là list sẽ được copy nhiều lần vào các phần tử của các list khác.
Log[{a,b,c}] – KQ : {Log[a],Log[b],Log[c]}
Attributes[Log] {Listable,NumericFunction,Protected}
Hàm listable sẽ kết hợp các phần tử tương ứng của lists : {a,b,c}+{x,y,z} – KQ: {a+x,b+y,c+z}
Các đối số ko phải là lists thì sẽ được lặp lại {a,b,c}+x – KQ : {a+x,b+x,c+x}
{{a,b},{c,d}}+x – KQ : {{a+x,b+x},{c+x,d+x}}
Chúng ta có thể định nghĩa một hàm có thuộc tính listable bằng lệnh: SetAttributes
f[x_]:=If[x>0,Sqrt[x],Sqrt[-x]]; SetAttributes[f,Listable]; f[{3,0,-2}]//N
– KQ : {1.73205,0.,1.41421}
Một hàm thực hiện bằng một phép toán listable thì có thể không cần thuộc tính Listable:
g[x_]:=x^2
g[{1,2,3}] {1,4,9}
Hàm Thread thực hiện các công việc tương tự như trên đối với một dạng tùy ý, mặc dù nó không
phải là một listable.
29
Sau đây là một số cú pháp quan trọng:
Thread[f[args]] – ―xâu‖ hàm f qua một vài list xuất hiện trong args.
Thread[f[args], h] – xâu f qua một vài đối tượng xuất hiện trong args với dạng h.
Thread[f[args], h, n] – xâu f qua một vài đối tượng với dạng h xuất hiện trong n args đầu tiên.
Thread[f[{a,b,c}]] - {f[a],f[b],f[c]}
Thread[f[{a,b,c},x]] - {f[a,x],f[b,x],f[c,x]}
Thread[f[{a,b,c},{x,y,z}]] - {f[a,x],f[b,y],f[c,z]}
Thread sẽ chuyển phương trình của một list thành list của các phương trình
Thread[{a,b,c}=={x,y,z}] - {a==x,b==y,c==z}
- Thực hiện một hàm với 2 vế của một phương trình hoặc với các số hạng của một tổng
Thread[Log[x==y],Equal] - Log[x]==Log[y]
Thread[Log[x+y],Plus] - Log[x]+Log[y]
- Theo bình thường thì không thể xâu các dạng toán (head) qua list
Thread[f[{a+b,c+d}],Plus] - f[{a+b,c+d}]
- Theo bình thường, không thể xâu qua các head ngoại trừ list
Thread[f[a+b,c+d]] - f[a+b,c+d]
- Một ví dụ Thread với Plus
Thread[f[a+b,c+d],Plus] f[a,c]+f[b,d]
- Thread chỉ với 2 đối số đầu tiên
Thread[f[{a,b},{r,s},{u,v},{x,y}],List,2] - {f[a,r,{u,v},{x,y}],f[b,s,{u,v},{x,y}]}
- Thread chỉ với 2 đối số cuối cùng
Thread[f[{a,b},{r,s},{u,v},{x,y}],List,-2] - {f[{a,b},{r,s},u,x],f[{a,b},{r,s},v,y]}
- Thread chỉ với đối số thứ 2
Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{2}] - {f[{a,b},r,{u,v},{x,y}],f[{a,b},s,{u,v},{x,y}]}
- Thread các đối số từ 2 đến 4
Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{2,4}] - {f[{a,b},r,u,x],f[{a,b},s,v,y]}
30
- Thread các đối số với bước nhảy bằng 2
Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{1,-1,2}] - {f[a,{r,s},u,{x,y}],f[b,{r,s},v,{x,y}]}
- Thread có thể được sử dụng để tạo một list các quy tắc và tính giá trị biểu thức
exp=x^2+y^2; vars={x,y};points={1,2}; exp/.Thread[vars->points] – KQ: 5
2. Inner
Inner[f, list1, list2, g] – là sự tổng quát hóa của Dot, trong đó f đóng vai trò của phép tính nhân
và g đóng vai trò của phép tính cộng.
a.b.c hoặc Dot[a, b, c] sẽ cho chúng ta tích của các vecto, matrix hay tensor.
Cú pháp trên của lệnh Inner có vai trò giống như cú pháp của câu lệnh
Apply[g, Thread[f[list1, list2]]]. {a,b,c}.{x,y,z} – KQ : ax+by+cz
Inner[Times,{a,b,c},{x,y,z},Plus] – KQ : ax+by+cz
Inner[f,{a,b},{x,y},g] – KQ: g[f[a,x],f[b,y]]
Apply[g,Thread[f[{a,b},{x,y}]]] – KQ : g[f[a,x],f[b,y]]
3. Outer, Transpose, và Distribute
Outer[f,{a,b},{x,y,z}]
{{f[a,x],f[a,y],f[a,z]},{f[b,x],f[b,y],f[b,z]}}
Outer[Times,{1,2,3,4},{a,b,c}]
{{a,b,c},{2 a,2 b,2 c},{3 a,3 b,3 c},{4 a,4 b,4 c}}
Outer[Times,{{1,2},{3,4}},{{a,b},{c,d}}]
{{{{a,b},{c,d}},{{2 a,2 b},{2 c,2 d}}},{{{3 a,3 b},{3 c,3 d}},{{4 a,4 b},{4 c,4 d}}}}
Outer[g,f[a,b],f[x,y,z]] – KQ : f[f[g[a,x],g[a,y],g[a,z]],f[g[b,x],g[b,y],g[b,z]]]
Transpose[list] – chuyển vị 2 level đầu tiên của list.
Transpose[list, {n1, n2, …}] – chuyển vị list để level thứ k trong list là level thứ nk trong kết quả.
Transpose[{{a,b,c},{x,y,z}}] – KQ : {{a,x},{b,y},{c,z}}
m=Array[a,{2,3,2}]; m//MatrixForm
m//TreeForm
Transpose[m,{1,3,2}]//MatrixForm
31
Transpose[m,{1,3,2}]//TreeForm
Phân phối chỉ với tích của các tổng
Distribute[(a+b+c)(u+v),Plus,Times] – KQ : au+bu+cu+av+bv+cv
32
Distribute[(a+b+c)^(u+v),Plus,Times] – KQ : (a+b+c)^(u+v)
Phân phối các quy tắc đối với phép toán logic
Distribute[And[Or[a,b,c],Or[u,v]],Or,And]
Lệnh Root và lệnh FindRoot
Root[f, k] – tìm nghiệm thứ k của phương trình đa thức f[x] == 0
Root[poly, x, k] – tìm nghiệm thứ k của đa thức poly theo biến x
FindRoot[f, {x, x0}] – tìm nghiệm số của đa thức f bắt đầu từ điểm x0
FindRoot[lhs==rhs, {x, x0}] – tìm nghiệm số của phương trình lhs==rhs
FindRoot[{f1, f2, …}, {{x, x0}, {y, y0}, …}] – tìm nghiệm số đồng thời của tất cả các đa thức fi
FindRoot[{eqn1, eqn2, …}, {{x, x0}, {y, y0}, …}] – tìm nghiệm số đồng thời của tất cả các
phương trình eqni
33
Các lệnh liên quan đến thông báo khi tính toán: Quiet, Off, On, Check
Lệnh Quiet
Quiet[expr]- thực hiện đánh giá expr bỏ qua các thông báo nếu có.
Quiet[expr, {s1::t1, s2::t2, …}]- chỉ bỏ qua các thông báo đặc biệt trong khi đánh giá expr.
Giải phương trình vi phân thường - Lệnh DSolve
DSolve[eqn,y,x] - giải một phương trình vi phân đối với hàm số y với x là biến độc lập.
DSolve[{eqn1,eqn2,…},{y1,y2,…},x] - giải một list các phương trình vi phân.
DSolve[eqn,y,{x1,x2,…}] - giải phương trình đạo hàm riêng.
Có thể kiểm tra tính đúng đắn của nghiệm bằng nhiều cách:
34
Lệnh Off
Off[symbol::tag] - tắt một thông báo để hạn chế việc in các kết quả một cách dài dòng.
Lệnh On
On[symbol::tag] - Mở thông báo để nó có thể in ra màn hình.
35
Lệnh Check
Check[expr, failexpr] - đánh giá expr và trả về kết quả nếu không có các thông báo xuất hiện,
trong trường hợp có thông báo câu lệnh sẽ trả về failexpr.
Check[expr, failexpr, {s1::t1, s2::t2, …}] - chỉ kiểm tra một vài thông báo đặc biệt.
Giải phương trình vi phân thường - Lệnh NDSolve
NDSolve[eqns, y, {x, xmin, xmax}] - tìm nghiệm số của phương trình vi phân thường eqns tương
ứng với hàm số y với biến độc lập x nhận giá trị trong đoạn xmin đến xmax.
NDSolve[eqns, y, {x, xmin, xmax}, {t, tmin, tmax}] - tìm nghiệm số của phương trình đạo hàm riêng.
NDSolve[eqns, {y1, y2, …}, {x, xmin, xmax}] - tìm nghiệm số đối với các hàm yi.
Xét ví dụ sau đây: tìm quỹ đạo của một khối lượng trong trường hấp dẫn được tác động bởi một
khối lượng rất lớn tại gốc tọa độ. Nó được biểu diễn bởi một cặp phương trình vi phân:
Lệnh String
generalString="The quick brown fox";
StringDrop[generalString,{5,10}] The brown fox
StringTake[generalString,{11,15}] Brown
36
StringInsert[generalString," stupid",4] The stupid quick brown fox
StringReplace[generalString,{"b"->"g","x"->"e"}] The quick grown foe
StringJoin[generalString,StringReverse[generalString]] The quick brown foxxof nworb kciuq

ehT
Ghi chú trên đồ thị
Khi chúng ta vẽ nhiều đồ thị cùng một lúc trên cùng hệ trục tọa độ thì chúng ta cần phải đánh dấu
để phân biệt dễ dàng, chúng ta có thể làm được việc này nhờ gói lệnh có sẵn trong Mathematica
“Plot Legends Package”.
Ngoài ra còn có thêm một số tính chất nữa giúp người sử dụng ―trang trí‖ thêm cho đồ thị của
mình thêm sinh động.
LegendLabel – hiệu chỉnh nhãn cho khung ghi chú
LegendLabelSpace – hiệu chỉnh không gian cho nhãn
LegendBorder – hiệu chỉnh màu sắc, độ dày của khung ghi chú
LegendBorderSpace – hiệu chỉnh không gian của khung
LegendBackground – hiệu chỉnh màu nền
LegendPosition – hiệu chỉnh vị trí của khung ghi chú trên toàn bộ đồ thị
LegendSize – hiệu chỉnh kích thước của khung
LegendShadow – hiệu chỉnh khung ghi chú ―nổi‖ hay ―chìm‖ trên đồ thị
37
Vẽ đồ thị động với lệnh Manipulate
Cho trước các giá trị t và j. Vẽ đồ thị hàm e[T_] là một hàm phụ thuộc vàoT, t và j. Đưa đồ thị
này vào một khung, trong khung đó có mình có thể thay đổi các giá trị của t và j, lưu ý là t phải
nhận giá trị thực, còn j thì nhận giá trị nguyên.
Tham khảo:
38
Các đơn vị đo lường trong thống kê mô tả
Trong Mathematica cho phép xác định các đơn vị đo trong Thống kê mô tả, chẳng hạn như giá trị
trung bình, điểm giữa, phần tử xuất hiện phổ biến nhất, … Sau đây là một số câu lệnh đuợc sử
dụng phổ biến trong phần này.
Mean[list] – cho ra giá trị trung bình của một dãy số;
Mean[dist] – cho ra giá trị trung bình của một phân phối cho trước.
Median[list] - cho ra phần tử giữa của list
Median[dist] - cho ra phần tử giữa của phân phối dist
Commonest[list] - cho ra các phần tử xuất hiện nhiều lần nhất trong list
Commonest[list,n] - cho ra một dãy gồm n phần tử xuất hiện nhiều lần nhất trong list
RootMeanSquare[list] – tính giá trị trung bình căn của list
HarmonicMean[list] - tính giá trị trung bình điều hòa của list
GeometricMean[list] - tính giá trị trung bình hình học của list
ContraharmonicMean[list] – tính giá trị trung bình phi điều hòa của list
39
Variance[list] - phương sai của list
Variance[dist] - phương sai của phân phối dist
Ví dụ:
Mean[{1.12,2.04,1.01,4.2,5.27}]
Mean[UniformDistribution[{min,max}]]
Median[{1,2,3,4,5,6,7}] 4
Median[ExponentialDistribution[lamda]]
Commonest[{1,2,3,1,2,4}]
Commonest[{1,2,3,1,2,4,4,2,5},3]
RootMeanSquare[ {a,b,c,d}]
HarmonicMean[{a,b,c,d}]
GeometricMean[{a,b,c,d}]
ContraharmonicMean[{a,b,c,d}]
Sự sai khác khi tính toán với số phức
Khi tính toán trên Mathematica chúng ta thấy có sự sai khác: . Hãy
giải thích điều đó.
40
Nhận xét: num^(1/12) là 12 nghiệm ban đầu của num, và 2+5I là một trong số chúng.
Phép đổi biến trong tích phân
Tính tích phân không xác định bằng phương pháp đổi biến, sau đó thử lại bằng lệnh Integrate.
41
Chú ý: ở phương án trên, ta đã chọn phép đổi biến thông thường u=2x^3. Sau đây cũng là một
phương án đổi biến.
Thử lại tính đúng đắn nghiệm của phương trình
Khi thay nghiệm tìm thấy vào phương trình ban đầu thì Mathematica không tự rút gọn được, vì
vậy cần dùng một thủ thuật nhỏ để rút gọn vế bên trái của phương trình, kết quả sẽ cho giá trị
{True, True}
42
Ghi chú khi vẽ đồ thị điểm
Khi ta vẽ các đồ thị điểm trên cùng một hệ trục tọa độ thì chúng ta dễ dàng phân biệt chúng nhờ
đoạn code sau:
43
Tam giác Pascal
Hàm pascalTriangleRow[n_] cho ra dòng thứ n của tam giác Pascal, sử dụng hàm này để viết
một một hàm khác pascalTriangle[n_] để in ra n dòng đầu tiên của tam giác Pascal theo form
tam giác.
Tìm ước chung lớn nhất của dòng thứ n trong tam giác Pascal, không tính dòng đầu tiên. Làm
những công việc sau đây:
- Định nghĩa hàm pascal(n) cho ra các thành phần của dòng thứ n trừ đi phần tử 1.
- Định nghĩa hàm gcd(n) cho ra ước chung lớn nhất của các thành phần trong pascal(n).
- Kiểm tra tính chất: nếu p là một số nguyên tố thì GCD(p) = p.
Hướng dẫn: Một số hàm được xây dựng sẵn trong Mathematica, xem chi tiết ở thẻ Help: - Hàm
Binomial: tính nhị thức - Hàm GCD: cho giá trị ước chung lớn nhất - Hàm Prime: cho số
nguyên tố
44
Có thể tham khảo cách làm sau:
45
Vẽ đồng hồ treo tường
Đoạn code sau đây vẽ một cái đồng hồ treo tường có đủ 3 kim: giây, giờ và phút, trên mặt đồng
hộ có chia 12 vạch với số tương ứng, vị trí của 3 kim phải luôn chạy đúng với giờ của hệ thống
máy tính.
46
Thao tác các biểu thức đại số
Ví dụ 1:
47
Giải thích ví dụ 1:
Đầu tiên ta đưa vào một biểu thức đại số,

Mathematica tự động thay đổi ví trí 2 số hạng
theo cách riêng của nó.
Lệnh Expand khai triển biếu thức mới nhập

vào, hay nói đúng hơn là ―phá ngoặc‖.
Chúng ta có thể đếm số hạng của một biểu thức

bằng lệnh Length, và một lần nữa chúng ta lại
bắt gặp kí hiệu % - tương ứng với kết quả kề
ngay trước nó.
Nếu muốn phân tích thành nhân tử của một

biểu thức ta dùng lệnh Factor, kí hiệu %% -
tương ứng với kết quả nằm trước kết quả kề nó.
Từ ví dụ trên ta nhận thấy rằng Expand không

phân phối các lũy thừa hữu tỉ trên tích, thay
vào đó chúng ta có lệnh PowerExpand.
Ví dụ 2:
Giải thích ví dụ 2:
48
Nhập vào một biểu thức dạng phân số exp, lệnh Expand chỉ thực hiện ―phá ngoặc‖ đối với tử số,
còn ở mẫu số thì ngoặc vẫn còn nguyên.
Muốn phá hết ngoặc trong biểu thức ta dùng lệnh ExpandAll, nó có thể khai triển tất cả các biểu
thức ngay cả ở trong Căn bậc hai hay trong các hàm lượng giác Sin, Cos …
Lệnh Together thực hiện phép cộng các phân số theo một mẫu số chung.
Lệnh Apart viết lại biểu thức ban đầu về dạng tổng của các phân số với mẫu số tối tiểu.
Việc phân tích đa thức thành nhân tử sẽ được thực hiện bằng lệnh Factor.
Lệnh Simplify, nó tìm tất cả các phương án có thể để viết exp và nó trả về một phương án được
cho là đơn giản nhất trong số chúng.
Riêng lệnh FullSimplify, nó cố gắng biến đổi trong phạm vi rộng bao gồm cả các hàm cơ bản và
hàm đặc biệt.
Nếu muốn đưa ra biểu thức trên tử hay dưới mẫu một cách riêng biệt, ta dùng lệnh Numerator và
Denominator như trong ví dụ.
Ví dụ 3:
Trong ví dụ cuối cùng này, chúng ta nhập vào một biểu thức mới với tên là newexp.
Lệnh Collect[exp, var] thử viết exp như là một đa thức theo biến var mà các hệ số của nó là
những biểu thức của một vài biến khác.
49
Việc sắp xếp kết quả Out[2] không được đẹp mắt lắm, vì kết quả không được sắp xếp theo chiều
tăng lũy thừa của biến x, mặc dù số mũ của y trong các hệ số lại được sắp xếp tăng dần.
Cơ bản là, biểu thức newexp ban đầu không được sắp xếp theo lũy thừa của x. Tuy nhiên, nếu
chúng ta tập hợp các hệ số theo biến y thì việc sắp xếp sẽ được thực hiện như chúng ta mong
muốn, theo kết quả Out[3].
Lệnh Collect cũng có thể sử dụng để tập hợp 2 biến một lúc, nhưng trong trường hợp này, không
có điều gì khác xảy ra.
Có thể đưa ra các hệ số một các riêng lẽ bằng lệnh Coefficient và tìm lũy thừa cao nhất của một
biến bằng lệnh Exponent.
Mọi thứ là một biểu thức
Nguyên tử Các biểu thức sẽ được biểu diễn một cách đệ quy và sự đệ quy phải bắt đầu từ một
nơi nào đó. Nơi bắt đầu đó chính là các nguyên tử. Trong Mathematica, các nguyên tử là mỗi kí
hiệu, số hoặc chuỗi.
Kí hiệu là một dãy các kí tự và số tự nhiên (có thể là $), không bắt đầu với một số tự nhiên. Ví dụ
như a2Dd là một kí hiệu.
―Một số‖ ở đây có nghĩa là một số tự nhiên hoặc là một số thực.
Bốn dạng khác là số hữu tỷ, số nguyên Gauss, số hữu tỷ Gauss và số phức thì không phải là
những nguyên tử.
Cuối cùng, chuỗi là dãy các kí tự ASCII được đặt giữa 2 dấu ngoặc kép (―A book ‖).
Ý nghĩa của biểu thức
Có một vài cách nghĩ về biểu thức giúp chúng ta sử dụng chúng có hiệu quả.
Function[argument]....................................................ví dụ: Sin[x]
Command[argument].........................................ví dụ: Expand[(x+y)^10]
Operator[Operands]...................................................ví dụ: Plus[x,y]
Type[parts]..............................................................ví dụ: List[a, b, c, d]
Dạng (form) của biểu thức
Chúng ta có thể truy suất form bằng lệnh FullForm. Xem ví dụ sau:
Biểu thức Head FullForm

Abc Symbol abc
27 Integer 27
¾ Rational Rational[3,4]
50
Một vài biểu thức phức tạp hơn
Biểu thức FullForm

x+y+z Plus[x, y, z] Các phần của biểu thức
xyz Times[x,y,z]
x/y Times[x, Power[y, -1]] Xem ví dụ sau:
{x, y, z} List[x, y, z]
exp=f[x1, x2, x3, x4];
Các kí hiệu đặc biệt : {exp[[0]], exp[[1]], exp[[2]], exp[[3]],
Biểu thức FullForm exp[[4]]}
% Out[]
%% Out[-2] {exp[[-4]], exp[[-3]], exp[[-2]], exp[[-1]]}
%5 Out[5]
_ Blank[] KQ: {f, x1, x2, x3, x4} {x1, x2, x3, x4}
x_ Pattern[x, Blank[]]
x_Integer Pattern[x, Blank[Integer]] Như vậy, số dương trong cặp ngoặc vuông
# Slot tương ứng với việc đếm từ trái sang phải, còn
#& Function[Slot[1]] số âm thì ngược lại.
Cấu trúc cây của biểu thức
Chúng ta thử một vài ví dụ lấy các phần

của biểu thức exp1
exp1[[0]] .......................KQ: Plus
exp1[[1]]........................ KQ: x3
exp1[[1]][[2]] hoặc exp1[[1, 2]] ..........

……………........... KQ: 3
exp1[[1, 2, 1]] .........................KQ: báo lỗi

vì thành phần đó không tồn tại
exp1[[2, 1, 2]] .................................KQ: z
Nếu biểu thức quá dài thì chúng ta sẽ rất khó để thấy được dạng cấu trúc cây của nó. Chúng ta có
hai phương pháp để xem xét được biểu thức: Short và Shallow.
51
Short[exp, n] – in biểu thức ra với chiều dài là n hàng.
Các mức (level) của biểu thức, chiều sâu (depth) của biểu thức
Có thể hiểu ý nghĩa từ ―mức‖ như sau: theo cây cấu trúc ở trên, đỉnh trên cùng của cây cấu trúc là
mức 0, hàng tiếp theo là mức 1, v.v… Các mức được miêu tả bởi các số nguyên n hoặc –n nằm
trong ngoặc nhọn {n}, {-n}, hoặc {n1, n2} hoặc Infinity.
Chúng ta gọi lại biểu thức exp1 = x^3 + (1+z)^2 ở trên và phân tích một vài ví dụ:
Level[exp1, {2}]................... KQ: {x, 3, 1+z, 2}
Kết quả cho thấy rằng, các cây con có gốc ở mức 2 cũng được liệt kê dưới dạng biểu thức. Để
thấy các phần (kể cả cây con) tại mức 2 và cao hơn (nghĩa là tính luôn mức 1), chúng ta bỏ đi dấu
ngoặc nhọn:
Level[exp1, 2]....................... KQ: {x, 3, x^3, 1+z, 2, (1+z)^2}
Nếu viết dạng {n1, n2} sẽ cho các cây con mà

gốc của chúng nằm giữa n1 và n2.
Level[f0[f1[f2[f3[f4[f5]]]]], {2, 4}]
Chiều sâu của một biểu thức là số nút lớn nhất

dọc theo đường đi từ gốc đến lá trên biểu thức.
Depth[exp1]
Cũng có các mức độ âm được sử dụng để đếm từ dưới lên. Thực chất cái được đếm chính là
chiều sâu (depth) của các biểu thức con.
52
Chẳng hạn như {-1} sẽ cho các biểu thức con có

depth đúng bằng 1 (tức là những cái lá của cây cấu
trúc), còn -1 (không có ngoặc nhọn) sẽ cho ra tất cả
các biểu thức con với depth tối thiểu là 1 (tức là, liệt
kê tất cả các biểu thức con đúng nghĩa).
Level[exp1, {-1}]
Level[exp1, -1]
Nếu viết {-2} sẽ cho tất cả các cây con depth bằng 2,
còn -2 sẽ cho tất cả các cây con với depth tối thiểu
bằng 2.
Level[exp1, {-2}]
Level[exp1, -2]
Level[exp1, Infinity]
Một phương trình với nghiệm chính xác không được tìm thấy
53

330769441 Bai Giảng Mathematica Phần 1 PDF

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

330769441 Bai Giảng Mathematica Phần 1 PDF

Uploaded by

Copyright:

Available Formats

Lập trình toán học với Mathematica - NTTH 2016

Làm quen với Mathematica......................................................................................................... 3

Làm quen với Mathematica

Làm việc với ma trận

1. Cách cho một ma trận

Cách 1: Insert->Table/Matrix->New Cách 3: Dùng hàm Table[].

2. Các phép toán với ma trận

Cộng 2 ma trận, sử dụng dấu cộng (+)

Trừ 2 ma trận, sử dụng dấu trừ (-)

Nhân 2 ma trận, sử dụng dấu chấm (.)

3. Các hàm với ma trận

Det[A]: định thức của ma trận A

Transpose[A]: ma trận chuyển vị của ma trận A

Inverse[A]: ma trận nghịch đảo của ma trận A

Eigenvalues[A]: giá trị riêng của ma trận A

Eigenvectors[A]: vec tơ riêng của ma trận A

MatrixPower[A,n]: lũy thừa n của ma trận A

MatrixExp[A]: ma trận mũ của ma trận A

Drop[A,{i},{}]: xóa dòng thứ i từ ma trận A

Drop[A,{},{j}]: xóa cột thứ j từ ma trận A

Union[A,B]: hợp 2 ma trận A và B

4. Tạo một ma trận với tính chất cho trước:

Tạo ma trận đơn vị cấp n: IdentityMatrix[n]

Làm việc với List

1. Cách cho một list

Cách 4: Range[n] cho 1 list {1, 2, ... , n}

2. Cách gọi phần tử của list

First[list]: gọi phần tử đầu tiên cùa list

t[[i,j,...]] hoặc Part[i,j,...]: lấy phần tử từ list t có dạng t[[i]][[j]]...

Take[list,n]: lấy ra n phần tử đầu tiên của list

Take[list,-n]: lấy ra n phần tử cuối cùng của list

Take[list,{m,n}]: lấy ra các phần từ của list từ vị trí m đến vị trí n

3. Các hàm xử lí đối với list

TakeWhile[list,text]: giống với hàm Select[]

Length[list]: đếm số phần tử của list

Column[list]: in giá trị của list theo dạng cột

Position[list,form]: tìm vị trí các phần tử của list có cùng form

Count[list,form]: đếm số phần tử của list có cùng form

Prepend[list,elem]: thêm elem vào vị trí đầu tiên của list

Delete[list,i]: xóa elem nằm ở vị trí thứ i của list

4. Sắp xếp thứ tự một list

Sort[list]: sắp xếp list theo trật tự chuẩn

Union[list]: sắp xếp list và xóa các phần tử trùng nhau

1. Định nghĩa hàm số trên Mathematica

Cách 1: Muốn định nghĩa hàm parabol ta viết f[x_] = x^2+3x+1

Định nghĩa hàm 2 biến: ta viết g[x_,y_] = x^2+y^2

Tương tự đối với hàm nhiều biến.

Cách 2: Function[x,body]: khai báo hàm một biến

Function[{x1,x2,…},body]: khai báo hàm nhiều biến

Lấy ví dụ ở trên, ta có thể khai báo như sau: Function[x, x^2+3x+1]

2. Tính giá trị hàm số

Kết quả của sẽ là

3. Hàm có sẵn trong Mathematica

Hàm logarit: Log[a,x] (cơ số a)

Hàm đặc biệt: Gamma, Beta, Zeta, BesselJ, BesselY

Có thể tìm qua thẻ Help với từ khóa tutorial/SpecialFunctions.

Plot[f, {x, xmin, xmax}]: vẽ đồ thị hàm f trên đoạn [xmin,xmax].

Các giá trị hay dùng nhất của tham số là:

- Automatic: sự chọn lựa sẽ được tự động

- None: tham số không được sử dụng

Một số tham số hay dùng:

- Axes->None: không hiển thị hệ trục tọa độ

- AxesLabel: ghi chú tên của trục tọa độ

Ví dụ 1: ParametricPlot[{Cos[5t], Sin[3t]}, {t,0,20}, AspectRatio->Automatic]