làm quen với mathematica 9.0 pdf

MỤC LỤC
Làm quen với Mathematica ........................................................................................................ 3
Làm việc với ma trận .................................................................................................................... 4
Làm việc với List ............................................................................................................................. 4
Hàm số ............................................................................................................................................... 6
Vẽ đồ thị và điểm ........................................................................................................................... 7
Vẽ đồ thị tham số ........................................................................................................................... 8
Vẽ đồ thị trong không gian 3 chiều ......................................................................................... 9
Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0 ........................................................... 11
Vẽ miền đúng của bất đẳng thức ........................................................................................... 13
Các vòng lặp dạng Do, For, While ......................................................................................... 15
Lệnh IF ............................................................................................................................................. 16
Những kí hiệu “kì qi” .............................................................................................................. 16
Phương pháp học tốt Mathematica ........................................................................................ 17
Tích Kronecker với lệnh KroneckerProduct......................................................................... 18
Phân tích số tự nhiên thành thừa số nguyên tố ............................................................... 19
Giải phương trình và hệ phương trình .................................................................................. 19
Tích phân, đạo hàm, chuỗi và giới hạn. Phương trình vi phân. ................................. 22
Chuyển từ số thực sang số hữu tỉ và ngược lại. Chuyển cơ số. ................................. 24
Lệnh Roots và lệnh Solve .......................................................................................................... 24
Lệnh khử biến và một số cách thế giá trị vào biểu thức ............................................... 25
Lệnh Chop ....................................................................................................................................... 25
Thread, Inner, Outer, Transpose, và Distribute ............................................................... 26
Lệnh Root và lệnh FindRoot ..................................................................................................... 31
Các lệnh liên quan đến thông báo khi tính tốn: Quiet, Off, On, Check ................ 31
Giải phương trình vi phân thường - Lệnh NDSolve ......................................................... 34
Vài câu lệnh làm việc với String ............................................................................................. 34
Ghi chú trên đồ thị ....................................................................................................................... 35
Vẽ đồ thị động với lệnh Manipulate ....................................................................................... 36
Các đơn vị đo lường trong thống kê mô tả ........................................................................ 37

Tìm hiểu sự sai khác khi tính tốn với số phức ................................................................ 38
Phép đổi biến trong tích phân ................................................................................................. 39
Thử lại tính đúng đắn nghiệm của phương trình .............................................................. 41
Ghi chú khi vẽ đồ thị điểm ........................................................................................................ 41
Tam giác Pascal ............................................................................................................................ 42
Vẽ đồng hồ treo tường ............................................................................................................... 45
Thao tác các biểu thức đại số .................................................................................................. 46
Mọi thứ là một biểu thức ........................................................................................................... 48
Một phương trình với nghiệm chính xác khơng được tìm thấy ................................... 52
Ngun tắc xuất ảnh động có đi gif ................................................................................. 52
Ý nghĩa hình học của khai triển Taylor ................................................................................ 55
Numerical method ........................................................................................................................ 57


Làm quen với Mathematica
Để làm quen với Mathematica thì đầu tiên bạn phải có phần mềm này và cài đặt
nó, hiện tại tôi vẫn đang dùng phiên bản thứ 6 dù phiên bản 7 đã ra đời. Tơi
khơng muốn nói nhiều về hình thức của chương trình, cách cài đặt hay giao
diện ban đầu như thế nào (bạn đọc tự biết nhé), tôi chỉ muốn chốt lại một số
điểm cần chú ý trong Mathematica theo sự hiểu biết cá nhân:

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 vng, 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ện 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, bạn 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.

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* để
với ?*Qhay ?*Int*.

tìm

tất

cả

các

hàm

bắt

đầu

bằng

"Int",

tương

tự

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 tố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 2: Sử dụng móc nhọn {}
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
Cách 3: Dùng hàm Table[]
Ví dụ: Table[i*j,{i,1,10},{j,1,10}] sẽ cho một ma trận 10 dòng 10 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ừ (-)

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,...}
Ngồ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} đặt blist 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
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
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
x^2+3x+1
Định nghĩa hàm 2:

ta viết f[x_] =

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ố
Có nhiều cách, điều đó được thể hiện qua các ví dụ sau đây:
Ví dụ 1
----------------------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ụ 2
------------------------------h[x_]=f[x]+g[x];
Map[h,{a,b,c}]
Map[f[#]+g[#]&,{a,b,c}]
------------------------------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}}]
-----------------------------------------------------Ví dụ 4
----------------------------------------------h[x_] = Nest[Function[q,1/(1+q)],x,3];


h[x]
----------------------------------------------Kết quả của ví dụ 4 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
Ngồi ra cịn vơ số các hàm đặc biệt khác, vì trong chuyên ngành của tơi tạm
thời chưa cần đến nên tơi chưa tìm hiểu, bạn đọc có thể tìm qua thẻHelp với
từ khóa tutorial/SpecialFunctions (phiên bản 6).

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
- 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
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ị tên cùng một hệ trục tọa độ ta dùng lệnhShow[].

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ụ
ParametricPlot[{Cos[5*t],Sin[3*t]},{t,0,20},AspectRatio->Automatic]

1:


Ví
dụ
2:
ParametricPlot[{{2Cos[t],2Sin[t]},{2Cos[t],Sin[t]},{Cos[t],2Sin[t]},{Cos[t],S
in[t]}},{t,0,2
Pi}]

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í
Plot3D[Sin[x

dụ

1:
y],{x,0,4},{y,0,4}]


Ví
dụ
Plot3D[{x^2+y^2,-x^2-y^2},{x,-2,2},{y,-2,2}]

2.

2:

Lệnh

ListPlot3D[{{x1,y1,z1},{x2,y2,z2},…}] –
{xi,yi,zi}

ListPlot3D
hiển

Ví
dụ
ListPlot3D[{{0,0,1},{1,0,0},{0,1,0}},Mesh->All]

thị

các

điểm

có

tọa

độ
3:


Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0
1. Mục đích
Như chúng ta đã biết, để vẽ đồ thị của một hàm số trong hệ trục tọa Decac
vng 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
ContourPlot3D[f
ContourPlot3D[{f
3.

==

tự
==
0,g ==

Một

Ví
ContourPlot[x^2-y

số
==

Ví
ContourPlot[x^2/9+y^2/4
==
>False,AspectRatio->Automatic]

ta
có:
0,{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}]
0,…},{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}]
ví

dụ

áp

dụng

dụ
1:
0,{x,-2,2},{y,-0.15,4},Axes->True,Frame->False]

dụ
2:
1,{x,-3.5,3.5},{y,-2.5,2.5},Axes->True,Frame-


Ví
ContourPlot[{Abs[Sin[x]
3,3},{y,-3,3}]

Sin[y]]

Ví
ContourPlot3D[x^3+y^2-z^2

4.
-

Một
Dấu

“bằng”

dụ
0.5,Abs[Cos[x]

==

dụ

phải

điểm
được

==

3:
0.5},{x,-

4:
0,{x,-2,2},{y,-2,2},{z,-2,2}]

==

số

Cos[y]]

viết

lưu
2

lần

ý
(==).


Cú
pháp
dạng ContourPlot[f
==
g,{x,xmin,xmax},{у,ymin,ymax}] hoặcContourPlot[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à 6).
Ví
dụ
ContourPlot[x^2/9+y^2/4,{x,-3.5,3.5},{y,-2.5,2.5},
AspectRatio->Automatic]

Axes->True,

Ví
dụ
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

5:
Frame->False,

6:


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:
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^2PlotPoints->35, PlotRange->All]

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
đếnimax (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, j max},...] – 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


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]]
n=1;
While[n<4,Print[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ủacondition 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}
{1,0,1}
Ví dụ 2: 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[ ]
х := 1; Print["i x"];
Do[{If [i == 5, Abort[], None],
i += 1; x += 2*i; Print[i, " ", N[x]]},
{i, 1, 100}]
i x
2 5
3 11.
4 19.
5 29.
$Aborted
Return[x]
Return[1]

Những kí hiệu “kì qi”
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. Đối với
ngơn ngữ Mathematica cũng vậy, cũng có những kí hiệu thật “kì qi” [đây chỉ
là cách gọi vui], tuy nhiên Mathematica không phải là một ngơn ngữ lập trình
chính thống, nghĩa là nó chỉ được ứng dụng chủ yếu trong các ngành kĩ thuật,
cho nên có rất ít các tài liệu viết về điều này cũng như đối với người mới
“nhập mơn” thì cũng khó lịng tìm được trong thẻHelp [lí do đơn giản: chưa gặp

nên chưa biết, còn nếu đã từng thấy rồi thì chắc chắn rằng bạn đã nhấn F1,


:)].
Khơng có gì bất ngờ rằng các phép tính tốn học +,-,*,/ được giữ ngun khơng
có gì thay đổi. Bạn hãy chú ý rằng phép nhân 2 ma trận với nhau đc kí hiệu
dấu chấm A.B (điều này khá quan trọng vì nếu bạn nhầm sang dấu * thì bạn sẽ
mất nhiều thời gian để gãi đầu gãi tai :)). 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 hayIf: And – &&, Or –
||,
Not
–
!.
Câu lệnh “Nếu A bằng B thì …” được viết trong Mathematica như sau:If[A==B,…].
Ở đây bạn 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 rất “tếu” 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 mà tôi cho là 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ụ:
Thay
vì
ta
viết:
Panel[Grid[Table[{i,j},{i,3},{j,3}]]]
Ta
viết
lại:
Panel@Grid@Table[{i,j},{i,3},{j,3}]
Số dấu móc vng 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.
Tương tự ta có kí hiệu “//”, bạn sẽ thấy được tác dụng của kí hiệu qua ví dụ
sau:
Cũng
với
câu
lệnh
trên
có
thể
viết
lại:
Table[{i,j},{i,3},{j,3}]//Grid//Panel
Để kết thúc bài viết này, tơi xin đưa ra thêm một kí hiệu “ngộ nghĩnh” nữa,
hy vọng là các bạn mới học ngôn ngữ này sẽ cảm thấy thích thú vì đã khám phá
được những điều mới [mặc dù là người ta đã khám phá hết trơn rồi :)], đó là

kí hiệu 2 con @@. Kí hiệu này tương ứng với lệnh Apply[]. Ví dụ sau đây sẽ
giúp
bạn
hiểu
tác
dụng
của
nó
dễ
dàng:
FactorInteger[20!]
{{2,18},{3,8},{5,4},{7,2},{11,1},{13,1},{17,1},{19,1}}
CenterDot@@(Superscript@@@%)
21^8•3^8•5^4•7^2•11^1•13^1•17^1•19^1
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ố
ngun tố. Có thể giải thích q trình tính tốn như sau: đầu tiên
lệnhFactorInteger[] 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 ở bài viết dành riêng cho 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ả.
Đọc đến đoạn này, suy nghĩ một tí, bạn sẽ thấy kí hiệu @ và @@ đơi lúc có

cùng
tác
dụng,
ví
dú
nhé:
f[x_]=Sin[x];
f@3
f@@{3}
Cả hai đều cho kết quả là Sin[3].

Phương pháp học tốt Mathematica
Bài viết này khơng ngồi mục đích giúp các bạn tìm được cách tiếp thu ngơn
ngữ Mathematica một cách hiệu quả. Theo lẽ thường thì khi chúng ta học một
môn học mới, chúng ta ngay lập tức nghĩ trong đầu rằng phải chạy nhanh ra


quán để tìm sách tham khảo. Lẽ dĩ nhiên, đọc nhiều sách thì sẽ có lợi, thu
lượm được nhiều điều hay, nhưng có một mặt ngược lại [hay cịn gọi là nhược
điểm] đó là tính rập khn. Cái đó chính là rào cản của sự “mày mò”, sáng tạo
đối
với
người
học.
Đối với ngơn ngữ lập trình nói chung, và Mathematica nói riêng, thẻ Helpđược
xem như là một từ điển động và là cuốn “sách giáo khoa” hữu ích nhất dành cho
người sử dụng. Các ví dụ tuy đơn giản, ngắn gọn nhưng lại mang phong cách
viết chuyên nghiệp, dễ hiểu. Đối với mỗi lệnh đều có kèm theo
các Option thường dùng tương ứng, gọi là “thường dùng” vì có những Optioncó
thể áp dụng cho lệnh này nhưng lại không được liệt kê, thay vào đó nó lại

được nhắc đến ở một lệnh khác, chính điều đó đã gây khó khăn cho người mới
“nhập mơn”. Có thể lấy một ví dụ đơn giản đối với Option ImageSize, chúng ta
thấy tính chất này trong lệnh Graphics[] và một số nơi khác, nhưng lại không
được tìm thấy trong lệnh Plot[], Show[]. Và một câu hỏi đặt ra rằng, muốn cố
định kích cỡ hình ảnh của đồ thị trong lệnh Plot thì làm thế nào? Lúc này
đây, các “phép thử” của bạn là những bài học q báu giúp cho chính bạn hiểu
sâu
được
vấn
đề,
và
mọi
việc
thật
đơn
giản:
Plot[Sin[x],{x,0,Pi},ImageSize->{300,200}]
Show[Plot[Sin[x],{x,0,Pi}],
ImageSize->{300,200}]
Nhân tiện nói đến các “phép thử”, tơi có một ý kiến thế này và muốn chia sẽ
với mọi người, học các lệnh trong Mathematica đôi khi thấy rời rạc nhàm chán,
và chỉ những lúc cần làm Lab thì chúng ta mới đem nó ra rồi tìm trong
thẻ Help các lệnh cần cho cơng việc của mình, cách học như thế sẽ khơng giúp
cho bạn tiến bộ, sự hiểu biết của bạn đối với ngôn ngữ này chỉ “giậm chân tại
chỗ”, theo ý kiến của mình, tơi nghĩ rằng chúng ta cần có những bài tốn
riêng cho bản thân [các bài tốn này có thể phát sinh từ những ví dụ trong
Help], và áp dụng những lệnh đã biết để giải quyết nó, nếu làm được như thế
thì có nghĩa là bạn đã làm được từ “lí thuyết” sang “thực hành”. Một ví dụ dễ
hiểu như sau, sau khi đã biết các lệnh cơ bảnFor[], While[] … thì bạn có thể
viết ngay một chương trình nhỏ để sắp xếp các phần tử trong một mảng, các bạn

cần phải thử và đừng nghĩ rằng việc sắp xếp ấy trong Mathematica đã có sẵn
lệnh Sort[]. Hoặc sau khi biết lệnhModule[], bạn có thể thử vận dụng để viết
một chương trình con đối với phương pháp giải hệ tuyến tính Gauss chẳng hạn,…
những cái tơi đưa ra ở đây chỉ mang tính minh họa cho những điều tôi muốn
truyền đạt đến bạn đọc, không nhất thiết phải giống “y chang” như thế! :)
Cuối cùng, một kinh nghiệm học của tơi khi học Mathematica, đó chính là sự
“ghi chép” ngay lập tức những câu lệnh mình chưa biết. Chắc hẳn bạn đôi lúc
cũng “tham quan” trong thẻ Help, và đi đến nhiều “ngõ ngách” của những câu
lệnh lạ, lúc đó bạn đọc nó chỉ vì sự tị mị, hay đơn giản là vì khơng hiểu
lệnh đó làm cơng việc gì, và bạn thấy nó khơng cần thiết, khơng ghi chép lại,
đó là sai lầm! Đến lúc làm việc, bạn cần một câu lệnh tương tự, cứ nhớ một
cách khơng rõ ràng trong đầu đã đọc ở đâu đó, rồi vùi đầu tìm trong thẻ
Help...
khó
như
tìm
“kim
trong
bể
nước”.
Bài viết tuy dài dịng nhưng cũng mong giúp được “chút ít” nào đó đối với
người mới làm quen Mathematica, còn đối với những người q rành với ngơn ngữ
này thì chắc là khơng cịn cần thiết nữa. :P

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ó dạng .
Kí hiệu:
Ví dụ 1:
A={{1,2},{3,4}};

KroneckerProduct[IdentityMatrix[3],A]//MatrixForm


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ố ngun tố một cách nhanh
chóng nếu chúng khơng q dài (khơng q dài có nghĩa là khơng q 30 kí tự)

FactorInteger[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ố lần nó được tìm thấy 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ố ngun tố hay khơng bằng lệnh PrimeQ[].

PrimeQ[541]
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:


Theo trên thì ta nhận
biến
Solve[equation,
Cú pháp tổng qt đối
phương
trình
phụ
Solve[equation_list,
Ví dụ sau đây sẽ cho ta

thấy rằng, cú pháp để giải một phương trình đơn một
là:
variable]
với các đối số của lệnh Solve bao gồm một list các
thuộc
vào
một list các
biến.
Có
nghĩa
là:
variable_list]
thấy được điều đó:


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[]. Tham khảo ví dụ sau đây:


Tích phân, đạo hàm, chuỗi và giới hạn. Phương trình vi
phân.
Bài viết nhằm giới thiệu một số lệnh thông dụng đối với tốn cao cấp, khơng
đi sâu chi tiết của từng lệnh, các Option bạn đọc 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ố

tích
phân
xác
định
của
hàm f(x).
Đạo hàm là phép tố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 ncủ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ụ:


Tính
tố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 mlầ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

Giải
phương
DSolve[equation, y,

trình
x] – giải

vi
phương

phân: DSolve
trình vi phân với

và
biến

độc

NDSolve
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:

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:

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 tốn.
Xét ví dụ sau đây: