Upload
truong-le
View
462
Download
15
Embed Size (px)
Citation preview
Chương I
Tổng quan về ngôn ngữ lập trình Mathematica
I. Giới thiệu sơ bộ về ngôn ngữ lập trình Mathematica:
1. Giới thiệu:
Mathematica lần đầu tiên được hãng Wolfram Research phát hành vào năm 1988, là một hệ thống nhằm thực hiện các tính toán toán học trên máy tính điện tử.Nó là một tổ hợp các tính toán bằng ký hiệu, tính toán bằng số, vẽ đồ thị và là ngôn ngữ lập trình tinh vi . Công trình này được xem là thành tựu chính trong lĩnh vực khoa học tính toán
Mathematica là ngôn ngữ tích hợp đầy đủ nhất các tính toán kỹ thuật. Là dạng ngôn ngữ dựa trên nguyên lý xử lý các dữ liệu tượng trưng.
Thế hệ ngôn ngữ giải tích đầu tiên đó là Macsyma, Reduce... ra đời từ những năm 60 của thế kỷ XX. Các ngôn ngữ này chủ yếu dùng cho các bài toán vật lý năng lượng cao. Nhược điểm của chúng là chủ yếu được định hướng chạy trên các máy tính lớn.
Thế hệ tiếp theo là các ngôn ngữ Maple, Mathlab, Mathematica... Các ngôn ngữ này có ưu điểm là chạy nhanh hơn và chấp nhận bộ nhớ nhỏ hơn, chạy hoàn hảo trên máy tính cá nhân. Trong các ngôn ngữ tính toán loại này, nổi bật lên ngôn ngữ Mathematica với ưu điểm vượt trội về giao diện thân thiện, về khả năng đồ thị siêu việt và xử lý dữ liệu không thua kém các ngôn ngữ tính toán khác.
Nhờ khả năng mô hình hoá và mô phỏng các hệ lớn, kể cả các hệ động mà Mathematica không chỉ được ứng dụng trong lĩnh vực vật lý, kỹ thuật và toán mà còn được mở rộng ứng dụng trong các lĩnh vực như sinh học, các khoa học xã hội, kể cả trong lĩnh vực tài chính phức tạp..v.v..
Phiên bản 7.0 là phiên bản mới nhất hiện nay.
2. Giao diện tương tác của Mathematica:
Mathematica đưa ra một giao diện rất thân thiện với người sử dụng được đặt tên là bản ghi (notebook - thường được gọi tắt là nb). Các bản ghi là dạng cửa sổ biểu diễn một lượt sử dụng Mathematica bao gồm đầy đủ các ghi chép cả về chương trình nguồn, cả về kếtquả thực hiện trên cùng một bản ghi và được ghi lại dưới dạng file riêng của Mathematicacó đuôi là *.nb.
Các bản ghi được tổ chức thành các ô (cells) một cách có trật tự và thứ bậc. Ta có thểnhóm một nhóm ô lại sao cho chỉ thấy ô đầu của nhóm ô đó (với số nhóm lồng tuỳ ý).
Mathematica còn đưa ra một giao diện phụ là các bảng lệnh (Palettes) và các nút lệnh (Button). Người sử dụng chỉ cần nhấp chuột rất đơn giản và có thể tuỳ biến theo ý mình.
II. Các quy tắc cơ bản về ngữ pháp của Mathamatica: Các biến đi theo hàm đều được đặt trong ngoặc vuông, và được dùng để nhóm
các toán tử, các vectơ, ma trận. Cú pháp hình thức như sau: Hàm[expr]..
Ví dụ: Sin[x],
Danh mục được liệt kê trong dấu móc nhọn {…}.
Ví dụ: {1,2,3,..}, {Sin[t], Cos[t]}…
Dấu (..) chỉ dùng để nhóm các biểu thức lại.
Ví dụ: Sin[x/(x+3)] Mathematica phân biệt chữ hoa và chữ thường,c hữ đầu của tên hàm phải được
viết hoa. Ví dụ: Plot, Cos, Integrate… Nếu tên chứa hai hoặc nhiều tên kết hợp thì kí tự đầu tiên của mỗi tên đều phải viết hoa.
VD: Plot3D, Show, ListPlot… Phép nhân được hiển thị bởi một khoảng trắng hoặc bởi kí tự “ * ”. Khi kết thúc một lệnh của Mathematica bằng dấu chấm phẩy “ ; ” thì kết quả sẽ
không được hiển thị lên màn hình. Sau khi viết lệnh nhấn Shitf_Enter để thực hiện lệnh 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.
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.
Cách đặt biến bình thường như a, b, c, x, y, z, … , không được đặt XY_a, XY-a, không được dùng các chữ cái sau để đặt tên biến I, E, C.
Tổ hợp Ctrl + K để tìm các hàm có tên giống nhau ở phần đầu. 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.
III. Sử Dụng Lệnh Trực Tiếp Với Mathematica:- Lệnh trong Mathematica là các Cell gồm:
Input[n]:= Nhập lệnh Output[n] = Trả về kết quả. Trong đó n là số thứ tự của lệnh.- Lệnh của Mathematica có thể sử dụng trực tiếp.Ví dụ: Để tính 5+6, ta nhập In[1]:= 5 + 6, sẽ cho kết quả là Out[1]= 11- Kí hiệu % dùng để lấy kết quả của cell lền kề trước đó.Ví dụ 1: In[2]:= % + 2
Out[2]= 13Ví dụ 2: In[3]:= %1 + a
Out[3]= 11 + a- Trong Mathematica, ta có thể gán kết quả cho một tên.
Ví dụ: In[4]:= x = 5Out[4]= 5
Khi gán x = 5, ta có thể gọi lại giá trị 5 qua tên xIn[5]:= xOut[5]= 5
Các phép toán cơ bản trong biểu thức là:+ : Phép cộng ! : Giai thừa- : Phép trừ <= : Nhỏ hơn hoặc bằng*: Phép nhân <: Nhỏ hơn/: Phép chia >=: Lớn hơn hoặc bằng^: Phép luỹ thừa >: Lớn hơn
Ví dụ:In[6]:= 2^10Out[6]= 1024In[7]:= 3 > 6Out[7]= False
- Trong Mathematica phần giữa (* *) thì không có giá trị, nó chỉ là một lời chú thích.
Ví dụ:In[8]:= 10/5 (*Đây là phép chia*)Out[8]= 2
- Để biết thông tin về hàm đang sử dụng, ta dùng dấu ? trước tên hàm đóVí dụ: Sử dụng ?FactorInteger để nhận được thông tin về hàm FactorInteger như
sau:FactorInteger[n] gives a list of the prime factors of the integer n, together with their exponents.(Hàm FactorInteger[n] cho kết quả là các thừa số nguyên tố của số nguyên n,
cùng với số mũ của chúng).In[1]:= FactorInteger[75] Out[1]= {{3,1},{5,2}}Sử dụng ?PolynomialQuotient để nhận được thông tin về hàm PolynomialQuotient
như sau:PolynomialQuotient[p, q, x] gives the quotient of p and q, treated as polynomials in x, with any remainder
dropped. (Hàm PolynomialQuotient[p, q, x] sẽ cho kết quả là thương nhận được khi ta chia
đa thức p cho đa thức q (cả 2 với biến x)).Ví dụ: In[1]:= PolynomialQuotient[x^3+1, x-1, x] Out[1]= 1+x+x2 là kết quả của phép chia đa thức x3+1 cho x-1- Để tìm tất cả các hàm bắt đầu bằng một tên hàm nào đó ta dùng ?tên hàm*Ví dụ:
?Factor*Kết quả: Factor FactorList
FactorComplete FactorSquareFreeFactorial FactorSquareFreeListFactorial2 FactorTerms
FactorInteger FactorTermsList- Trong Mathematica, ta còn có thể dùng lệnh ?* tên hàm* để tìm tất cả các
tên hàm khác bắt nguồn từ một tên hàm.Ví dụ:
?*Plot*ContourPlot ParametricPlot PlotJoinedDensityPlot ParametricPlot3D PlotLabelListContourPlot Plot PlotPointsListDensityPlot Plot3D PlotRangeListPlot Plot3Matrix PlotRegionListPlot3D PlotDivision PlotStyle
- Có hơn 700 hàm được xây dựng sẵn trong Mathematica. Tên của một hàm trong Mathematica nói chung là chỉ ra mục đích sử dụng hàm đó.
Chương II
TÍNH TOÁN CƠ BẢN TRONG MATHEMATICA
I. Các phép tính toán đại số
1. Các kiểu số trong Mathematica
Có 4 kiểu số thông dụng được xây dựng trong Mathematica
Integer: Số nguyên.
Rational: Số hữu tỷ.
Real: Số thực.
Complex: Số phức.
- Để kiểm tra một số thuộc kiểu số nào đó ta dùng hàm Head
Ví dụ: Head[1234] trả về là Integer
- Ngoài những kiểu số trên ta còn một kiểu số đặc biệt được gọi là số ngẫu nhiên. Để tìm số ngẫu nhiên Mathematica cung cấp cho ta hàm Random
+ Random[]: cho một số thực biến thiên trong đoạn [0, 1]
Ví dụ: Random[] cho kết quả là 0.17682
+ Random[Integer]: Cho giá trị ngẫu nhiên là 0 hoặc 1.
+ Random[Kiểu số, khoảng biến thiên]: Cho giá trị ngẫu nhiên có kiểu là “kiểu số” và giá trị nằm trong “khoảng biến thiên”.
Ví dụ: Random[Integer,{0,1000}] cho kết quả 547
2. Các phép tính toán số học
Như một máy tính tay, Mathematica có thể thực hiện được tất cả các phép toán: cộng, trừ, nhân, chia, nâng lên luỹ thừa,…
2.1 Số nguyên
Khi làm việc với số nguyên, Mathematica luôn hiển thị kết quả chính xác và đầy đủ trên màn hình, ngay cả khi tính toán với những số lớn
Ví dụ
In[1]:= 35^53
Out[1]¿684867173670403024721982273365516709
9544352005136005345775629393756389617919921875
2.2 Số hữu tỷ
Số hữu tỷ là một số được biểu diễn bởi tỷ số của một số nguyên chia cho một số nguyên khác 0. Thông thường khi sử dụng máy tính hay các phần mềm khác ta chỉ nhận được kết quả xấp xỉ, chẳng hạn khi tính 2/4+24/144 ta sẽ nhận được kết quả là:0.6666667
Đối với Mathematica, khi nói về số hữu tỷ là nói về phân số. Do đó, kết quả sau các phép tính trong Mathematica vẫn là số hữu tỷ.
Ví dụ:
In[1]:= 2/4 +24/144
Out[1]=
2
3
2.3 Số vô tỷ
Mathematica luôn hiển thị kết quả một cách chính xác hoặc theo yêu cầu chính xác của người sử dụng nó. Nhưng số vô tỷ thì không thể được biểu diễn một cách chính xác như số nguyên hoặc như số hữu tỷ. Vì vậy, Mathematica sẽ cho kết quả chính xác theo yêu cầu của người sử dụng.
Ví dụ:
Sqrt[17]
√17
Nếu cho tham số căn bậc 2 là một số chấm động thì Mathematica sẽ cho ta một kết quả xấp xỉ.
Sqrt[17.]
4.12311
2.4 Số phức
Một số hàm thường dùng để làm việc với số phức
Re: Lấy phần thực của số phức.
Im: Lấy phần ảo của số phức.
Cojugate: Tìm liên hợp của số phức.
Abs: cho modul của số phức.
Round: Làm tròn số cả phần thực và phần ảo của số phức.
Ví dụ:
In[1]:= Re[5 + 6I]
Out[1]= 5
In[2]:= Im[5 + 6I]
Out[2]= 6
In[3]:= Conjugate[5 + 6I]
Out[3]= 5 – 6I
In[4]:= Abs[5 + 6I]
Out[4]=
In[5]:= Round[2.8 + 7.2I]
Out[5]= 3 + 7I
2.5 Tính xấp xỉ
Để biểu diễn kết quả xấp xỉ của một số ta dùng hàm n.
Ví dụ
N[Sqrt[17]]
Out[1]=4.1231
Nếu gõ lệnh 5ˆ(1/9) thì cho kết quả là 51/9. Nếu dùng N[5ˆ(1/9) ] thì cho kết quả xấp xỉ là 1.19581
2.6 Chuyển đổi từ giá trị xấp xỉ sang giá trị chính xác
Rationalize[x]: hữu tỷ hóa một số x
In[1]:=Rationalize[3.1416]
Out[1]=
In[1]:=Rationalize[3.1415926536]
Out[1]=3.14159
Ceiling[x]: Cho số nguyên nhỏ nhất >= x.
In[1]:=Ceiling[5.3]
Out[1]=6
Floor[x]: Cho số nguyên lớn nhất <= x.
In[1]:=Floor[5.6]
Out[1]=5
Round[x]: Làm tròn số thập phân
In[1]:=Round[3.756]
Out[1]=4
In[1]:=Round[3.256]
Out[1]=3
Chop[x]: Biến đổi một giá trị xấp xỉ gần số 0 về số 0.
In[1]:=Chop[0.00000000003]
Out[1]=0
In[1]:=Chop[0.0002]
Out[1]=0.0002
II. Danh sách trong Mathematica:
Danh sách là một tập hợp gồm nhiều phần tử được sắp xếp theo một trật tự nhất định.
1 Xây dựng danh sách
1.1 Hàm Range
Range[n]: Cho danh sách số nguyên chạy từ 1 đến số nguyên lớn nhất nhỏ hơn hoặc bằng n.
Range[m, n]: Cho danh sách số nguyên chạy từ m đến số nguyên lớn nhất nhỏ hơn hoặc bằng n.
Range[m, n, d]: Cho danh sách số nguyên chạy từ m đến số nguyên lớn nhất nhỏ hơn hoặc bằng n và khoảng cách giữa các phần tử trong danh sách là d.
Ví dụ:
In[1]:=Range[6]
Out[1]={1, 2, 3, 4, 5, 6}
In[1]:=Range[2, 6]
Out[1]={2, 3, 4, 5, 6}
In[1]:=Range[6.5]
Out[1]={1, 2, 3, 4, 5, 6}
In[1]:=Range[3, 10, 3]
Out[1]={3, 6, 9}
In[1]:=Range[2.6, 7.8]
Out[1]={2.6, 3.6, 4.6, 5.6, 6.6, 7.6}
In[1]:=Range[2.6, 7.2]
Out[1]={2.6, 3.6, 4.6, 5.6, 6.6}
In[1]:=Range[2.3, 16, 1.5]
Out[1]={2.3, 3.8, 5.3, 6.8, 8.3, 9.8, 11.3, 12.8, 14.3, 15.8}
1.2 Hàm Table
Table[Biểu thức, {n}]: Cho danh sách bằng cách copy lại biểu thức n .
Table[Biểu thức, {i, imax}]: Cho danh sách có biểu thức chạy từ 1 đến imax.
Table[Biểu thức, {i, imin, imax}]: Cho danh sách có biểu thức chạy từ imin đến imax.
Table[Biểu thức, {i, imin, imax, di}]: Cho danh sách có biểu thức chạy từ imin đến imax và khoảng cách giữa các phần tử trong danh sách là di.
Ví dụ:
In[1]:=Table[a, {6}]
Out[1]={a, a, a, a, a, a}
In[1]:=Table[i!, {i, 5}]
Out[1]={1, 2, 6, 24, 120}
In[1]:=Table[i!, {a, 5}]
Out[1]={i!, i!, i!, i!, i!}
In[1]:=Table[2*i!, {i, 3, 5}]
Out[1]={12, 48, 240}
In[1]:=Table[a[i] + b[i], {i, 1, 3}, {j, 2, 5}]
Out[1]={{a[1] + b[1], a[1] + b[1], a[1] + b[1], a[1] + b[1]}, {a[2] + b[2], a[2] + b[2], a[2] + b[2], a[2] + b[2]}, {a[3] + b[3], a[3] + b[3], a[3] + b[3], a[3] + b[3]}}
In[1]:=Table[a[i] + b[j], {i, 1, 3}, {j, 2, 5}]
Out[1]={{a[1] + b[2], a[1] + b[3], a[1] + b[4], a[1] + b[5]}, {a[2] + b[2], a[2] + b[3], a[2] + b[4], a[2] + b[5]}, {a[3] + b[2], a[3] + b[3], a[3] + b[4], a[3] + b[5]}}
1.3 Hàm Array
Hàm Array cho một danh sách gồm nhiều danh sách con hoặc những giá trị được biểu diễn dưới dạng phần tử của ma trận.
Array[f, n]: cho danh sách gồm những phần tử f[i] có độ dài n.
In[1]:=Array[a, 4]
Out[1]={a[1], a[2], a[3], a[4]}
In[1]:=Array[a, {2, 4}]
Out[1]={{a[1, 1], a[1, 2], a[1, 3], a[1, 4]}, {a[2, 1], a[2, 2], a[2, 3], a[2, 4]}}
2 Sắp xếp danh sách
Nếu danh sách đã cho chưa có thứ tự hoặc thứ tự chưa hợp lý ta có thể sắp xếp lại theo đúng thứ tự mình muốn.
Ví dụ: Ta có danh sách tên VD sau:
VD = In[1]:=Table[Random[Integer, {0, 15}], {10}]
Out[1]={2, 4, 7, 9, 10, 9, 5, 9, 14, 4}
2.1 Hàm Sort
Sort[danh sách]: Sắp xếp lại các phần tử của danh sách theo thứ tự chính tắc (thứ tự tăng dần).
Sort[danh sách,p]: Sắp xếp lại các phần tử của danh sách theo thứ tự chính tắc của hàm p.
Ví dụ:
In[1]:=Sort[VD]
Out[1]={2, 4, 4, 5, 7, 9, 9, 9, 10, 14}
In[1]:=Sort[VD, Greater]
Out[1]={14, 10, 9, 9, 9, 7, 5, 4, 4, 2}
2.2 Hàm Reverse
Reverse[danh sách]: Sắp xếp lại các phần tử của danh sách theo thứ tự ngược lại của danh sách đã cho.
Ví dụ:
In[1]:=Reverse[VD]
Out[1]={4, 14, 9, 5, 9, 10, 9, 7, 4, 2}
2.3 Hàm RotateLeft
RotateLeft[Danh sách]: Xoay vòng đúng một vị trí về phía trái.
RotateLeft[Danh sách,n]: Xoay vòng các phần tử trong danh sách bắt đầu vị trí thứ n về phía trái.
Ví dụ:
In[1]:=RotateLeft[VD]
Out[1]={4, 7, 9, 10, 9, 5, 9, 14, 4, 2}
In[1]:=RotateLeft[VD, 4]
Out[1]={10, 9, 5, 9, 14, 4, 2, 4, 7, 9}
2.4 Hàm RotateRight
RotateRight[Danh sách]: Xoay vòng đúng một vị trí về phía phải.
RotateRight[Danh sách,n]: Xoay vòng các phần tử trong danh sách bắt đầu vị trí thứ n về phía phải.
Ví dụ:
In[1]:=RotateRight[VD]
Out[1]={4, 2, 4, 7, 9, 10, 9, 5, 9, 14}
In[1]:=RotateRight[VD, 4]
Out[1]={5, 9, 14, 4, 2, 4, 7, 9, 10, 9}
In[1]:=RotateRight[VD, -4]
Out[1]={10, 9, 5, 9, 14, 4, 2, 4, 7, 9}
2.5 Hàm Permutations
Permutations[danh sách]: Cho một danh sách gồm tất cả các hoán vị của danh sách.
Ví dụ
In[1]:=Permutations[{a, b, c}]
Out[1]={{a, b, c}, {a, c, b}, {b, a, c}, {b, c, a}, {c, a, b}, {c, b, a}}
3 Thay đổi số phần tử trong danh sách
Nếu danh sách đã cho có những phần tử trùng lặp cần loại bỏ hoặc cần thêm vào hay loại bỏ những phần tử không cần thiết để được danh sách theo ý muốn thì Mathematica sẽ cung cấp cho ta một số hàm sau để thực hiện các vấn đề vừa nêu.
3.1 Hàm Rest
Rest[Danh sách]: Cho danh sách sau khi bỏ phần tử đầu tiên.
Ví dụ:
In[1]:=Rest[VD]
Out[1]={4, 7, 9, 10, 9, 5, 9, 14, 4}
3.2 Hàm Drop
Drop[Danh sách, n]: Cho danh sách mới khi đã bỏ n phần tử đầu tiên.
Drop[Danh sách, -n]: Cho danh sách mới khi đã bỏ n phần tử cuối.
Drop[Danh sách, {n}]: Cho danh sách mới khi đã bỏ phần tử thứ n.
Drop[Danh sách, {m, n}]: Cho danh sách mới khi đã bỏ các phần tử từ m đến n.
Ví dụ:
In[1]:=Drop[VD, 5]
Out[1]={9, 5, 9, 14, 4}
In[1]:=Drop[VD, -5]
Out[1]={2, 4, 7, 9, 10}
In[1]:=Drop[VD, {5}]
Out[1]={2, 4, 7, 9, 9, 5, 9, 14, 4}
In[1]:=Drop[VD, {2, 6}]
Out[1]={2, 5, 9, 14, 4}
3.2 Hàm Take
Take[Danh sách, n]: Cho danh sách mới gồm n phần tử đầu tiên của danh sách đã cho.
Take[Danh sách, -n]: Cho danh sách mới gồm n phần tử đầu tiên của danh sách đã cho.
Take[Danh sách, {n}]: Cho danh sách mới là phần tử thứ n.
Take[Danh sách, {m, n}]: Cho danh sách mới gồm các phần tử từ m đến n.
Ví dụ:
In[1]:=Take[VD, 4]
Out[1]={2, 4, 7, 9}
In[1]:=Take[VD, -4]
Out[1]={5, 9, 14, 4}
In[1]:=Take[VD, {3, 6}]
Out[1]={7, 9, 10, 9}
3.3 Hàm Append và AppendTo
Append[Danh sách, phần tử n]: Cho danh sách mới sau khi thêm phần tử n vào cuối danh sách đã cho.
AppendTo[Danh sách, phần tử n]
Ví dụ:
In[1]:=Append[VD, 4]
Out[1]={2, 4, 7, 9, 10, 9, 5, 9, 14, 4, 4}
In[1]:=AppendTo[VD, 4]
Out[1]={2, 4, 7, 9, 10, 9, 5, 9, 14, 4, 4}
3.4 Hàm Prepend và PrependTo
Prepend[Danh sách, phần tử n]: Cho danh sách mới sau khi thêm phần tử n vào đầu danh sách đã cho.
PrependTo[Danh sách, phần tử n]
Ví dụ:
In[1]:=Prepend[VD, 5]
Out[1]={5, 2, 4, 7, 9, 10, 9, 5, 9, 14, 4, 4}
In[1]:=PrependTo[VD, 5]
Out[1]={5, 2, 4, 7, 9, 10, 9, 5, 9, 14, 4, 4}
3.4 Hàm Insert
Insert[Danh sách, phần tử , n]: Cho danh sách mới sau khi thêm phần tử vào vị trí thứ n của danh sách đã cho.
Ví dụ: Cho danh sách A như sau:
In[1]:= A = Table[Random[Integer, {0, 20}], {15}]
Out[1]={12, 2, 14, 16, 2, 11, 11, 5, 15, 13, 8, 14, 11, 13, 0}
Khi đó
In[1]:=Insert[A, 8, 4]
Out[1]={12, 2, 14, 8, 16, 2, 11, 11, 5, 15, 13, 8, 14, 11, 13, 0}
In[1]:=Insert[A, 8, -4]
Out[1]={12, 2, 14, 16, 2, 11, 11, 5, 15, 13, 8, 14, 8, 11, 13, 0}
4 Đếm các phần tử trong danh sách
Để xác định kích cỡ của danh sách trong, Mathematica sử dụng hàm Length và Dimensions
4.1 Hàm Length
Length[danh sách]: Cho kết quả là số phần tử trong danh sách.
Ví dụ:
In[1]:=Length[A]
Out[1]=15
In[1]:=Length[{2, -3, d, 6, b^3}]
Out[1]=5
4.2 Hàm Dimensions
Dimensions[danh sách]: Cho kết quả là một danh sách mới mà phần tử của nó là độ dài của danh sách đã cho.
Ví dụ:
In[1]:=Dimensions[{2, -3, d, 6, b^3}]
Out[1]={5}
5. Kết hợp danh sách
Để kết hợp các danh sách lại với nhau, Mathematica dùng các hàm sau:
5.1 Hàm Complement
Complement[ds1, ds2, ds3,…]: Cho một danh sách gồm các phần tử có trong ds1 nhưng không có trong ds2, ds3,…
Ví dụ:
In[1]:=Complement[{1, 2, 6, 3, 9}, {-1, 2}]
Out[1]={1, 3, 6, 9}
5.2 Hàm Intersection
Intersection[ds1, ds2, ds3,…]: Cho một danh sách gồm các phần tử có trong tất cả các danh sách ds1, ds2, ds3,…
Ví dụ:
In[1]:=Intersection[{1, 2, 6, 3, 9}, {-1, 2}]
Out[1]={2}
5.3 Hàm Union
Union[danh sách] : Cho một danh sách sau khi đã loại bỏ các phần tử trùng nhau trong danh sách đã cho.
Union[ds1, ds2, ds3,…]: Cho một danh sách gồm tất cả các phần tử phân biệt có trong tất cả các danh sách
Ví dụ:
In[1]:=Union[{1, 2, 6, 3, 9}, {-1, 2}]
Out[1]={-1, 1, 2, 3, 6, 9}
In[1]:=Union[{1, 5, 3, 2, 2, 8, 4, 8, 5}]
Out[1]={1, 2, 3, 4, 5, 8}
5.4 Hàm Join
Join[ds1, ds2, ds3,…]: Cho một danh sách gồm các phần tử có trong tất cả các danh sách ds1, ds2, ds3,…
Ví dụ:
In[1]:=Join[{1, 2, 6, 3, 9}, {-1, 2}]
Out[1]={1, 2, 6, 3, 9, -1, 2}
6. Chuyển đổi dạng một danh sách
6.1 Partition
Partition[ds, n]: Phân hoạch danh sách thành những danh sách con không giao nhau có chiều dài n.
Partition[ds, n, d]: Phân hoạch danh sách thành những danh sách con có chiều dài n với độ lệch d.
Ví dụ:
Cho danh sách
VD = {1,4,7,7,9,10,10,9,5,5,9,14}
In[1]:=Partition[VD,5]
Out[1]= {1,4,7,7,9,10 , Null ,10,9,5,5,9,14 }
Out[2]= {{1,4,7,7,9 }, {10 , Null ,10,9,5 }}
Partition[VD,3]
Out[1]= {1,4,7,7,9,10 , Null ,10,9,5,5,9,14 }
Out[2]= {{1,4,7 }, {7,9,10 }, {Null ,10,9 },{5,5,9}}
Partition[VD,3,2]
Out[1]= {1,4,7,7,9,10 , Null ,10,9,5,5,9,14 }
Out[2]= {{1,4,7 }, {7,7,9 },{9,10 , Null}, {Null ,10,9 },{9,5,5 }, {5,9,14 }}
6.2 Flatten
Flatten[ds]: san bằng những danh sách được lồng bên trong danh sách.
Ví dụ:
In[1]:= Flatten[{{a , b },{c , {d }, e },{f , {g , h }}}]
Out[1]= {a , b , c , d , e , f , g , h }
6.3 Transpose
Transpose[ds]: chuyển vị ma trận, biến hàng thành cột và biến cột thành hàng.
Ví dụ:
In[1]:= Transpose[{{a , b , c }, {x , y , z}}]
Out[1]= {{a , x }, {b , y }, {c , z}}
7. Truy xuất các phần tử trong danh sách
7.1 First
First[ds]: Tìm phần tử đầu tiên của danh sách.
Ví dụ:
In[1]:=A={1,2,3,4,5,6,7,8,9}
In[2]:=First[A]
Out[2]=1
7.2 Last
Last[ds]: Tìm phần tử cuối cùng của danh sách.
Ví dụ:
In[1]:=A={1,2,3,4,5,6,7,8,9}
In[2]:=Last[A]
Out[2]=9
7.3 Part
Part[danh sách, i]: cho phần tử thứ i của danh sách.
Part[danh sách, i]: cho phần tử thứ i của danh sách.
Part[danh sách, i]: cho phần tử thứ i của danh sách.
Chú ý: Part[danh sách, i] danh sách [[i]]
Part[danh sách, i, j,…] danh sách [[i]][[j]]….
danh sách [[i]]
Part[danh sách, {i, j,…}] danh sách [[i]]
Ví dụ 1:
In[1] := ds ={1,3,5,8,7,4,2,6,5}
In[2]=Part[ds,4]
Out[2]= 8
Ví dụ 2:
In[2]:= {{a ,b , c }, {d , e , f }, {g , h ,i }}[[2,3]]
Out[2]= f
8. Chọn dữ liệu trong danh sách
8.1. MemberQ
MemberQ[danh sách, form]: Cho True nếu một phần tử của danh sách có dạng giống form and False nếu khác.
Ví dụ: ds= {1,5,8,7,9,13,56,31}
In[1]:=MemberQ[ds,3]
Out[1]=False
In[1]:=MemberQ[ds,31]
Out[1]=True
8.2. Select
Selest[danh sách,crit]: chọn ra tất cả các phần tử ei của danh sách sao cho crit [ei]
là đúng.
Selet [list,crit, n] chọn ra n phần tử đầu tiên sao cho crit [ei ] thì đúng.
Ví dụ.
In[1]:=Select [{-3,2,4.5,7,a,5,-5}, Potive]
Out[1]={ 2,4.5,7,5}
In[1]:=Select [{x},Positive]
Out[1]={}
In[1]:=Select[{-3,Pi,a,4.5},exact]
Out[1]={}
9. Tính toán với danh sách:
9.1. Sum
Sum[f, {i, i max}]:tính tổng
Sum[f, {i, i min, i max}]:tính tổng
Sum[f ,{i,imin,imax , di}]: tính tổng với bước nhảy di
Sum [ f, {i,imin,imax,di}],{ j,j min ,jmax},…]: tính tổng bội
Ví dụ:
In[1]:=∑ [ i2 , {i ,10 }]
Out[1]= 385
In[2]:= ∑ [ i2 , {i ,1 , n }]
Out[2]=16
n (1+n)(1+2 n)
9.2. Plus
Plus [n,m,….] cho tổng các phần tử n+m+… trong hàm.
Ví dụ :
In[1]:=Plus [a,b,c]
Out[1]=a+b+c
In[1]:=Plus [{a,b,c}]
Out[1]={a, b,c}
Chú ý : Dùng hàm Apply có thể tính tổng các phần tử trong một danh sách bằng cách ứng dụng toán tử Plus cho danh sách.
Ví dụ:
In[1]:=Apply[Plus,{a,b,c}]
a+b+c
9.3. ListTable
Với một danh sách, ta có thể thực hiện một phép toán trong một tập các giá trị. Nhiều hàm số học có thể thực hiện các phép toán trên danh sách có thuộc tính Listable. Chẳng hạn khi hỏi Log của một danh sách thì ta sẽ thu được Log của từng phần tử trong danh sách.
In[1]:=Log[{3, 2,4,5,3}]
Out[1]={log [3] , log [2] , log [4 ] , log [5] , log [3]}
Dùng hàm N ta thu được các giá trị xấp xỉ:
In[2]:= N[%]
Out[2]={1.09861,0.693147,1.38629,1.60944,1.09861}
Khi hàm có thuộc tính Plus là Listable ,ta có thể cộng hai vectơ lại với nhau:
In[3]:={1,2,3}+ {a,b,c}
Out[3]={1+a, 2+b, 3+c}
Những hàm có thuộc tính Listable.
Attributes[{Exp, Log, Sin, Plus}]
{{Listable , NumericFunction ,Protected , ReadProtected },
{ Listable ,NumericFunction , Protected ,ReadProtected } ,
{ Listable , NumericFunction , Protected } ,
{Flat , Listable, NumericFunction ,OneIdentity ,Orderless , Protected }}
9.4. Listable và ánh xạ
Có hai phương pháp mà Mathematica ánh xạ một hàm số cho mỗi phần tử của danh sách:
(1). Ánh xạ hàm số lên mỗi phần tử của danh sách .
(2). Cho hàm số có thuộc tính Listable.
Khi cho hàm f không có thuộc tính Listable, Mathematica không ánh xạ f lên mỗi phần tử của danh sách.
Ví dụ:
In[1]:=f[{2,4,5,6}]
Out[1]= f[{2,4,5,6}]
Khi cho hàm Map thì f sẽ tác động lên mỗi phần tử của danh sách hoặc biểu thức
In[2]:=Map[ f, {3, 2,4,5,3}]
Out[2]= {f [3] , f [2] , f [4] , f [5] , f [3]}
In[3]:=Map[f,a+bx ]
Out[3]= f [a]+ f [bx ]
9.5. Định dạng danh sách
Để định dạng danh sách, Mathematica thường sử dụng các hàm: ColumnForm, MatrixForm và TableForm.
Ví dụ :
In[1]:= ColumnForm [{12345678,12345,12}, center ]
Out[1]= 12345678
1234512
Chương III
Đồ họa với Mathematica
Dùng mathematica ta có thể vẽ đồ thị của những hàm số và những số liệu ngẫu nhiên trong mặt phẳng và trong không gian, tạo ra những biểu đồ số liệu và biểu đồ mật độ. Ngoài ra, cũng có thể vẽ được những hình và vật thể tùy ý.
I. Vẽ đồ thị trong mặt phẳng
I.1. Vẽ đồ thị hàm một biến
Plot[f,{x,xmin,xmax},option->value]
Plot [f[x],{x, xmin, xmax}]: Vẽ đồ thị của hàm f(x) trên khoảng [xmin,xmax].
Ví dụ: Vẽ đồ thị hàm f(x) = x2 + 3x-5
In[1]:= Plot [x2+3 x−5 , {x ,−10,7 }]
Out[1]= 10 5 5
10
20
30
40
50
60
Để 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
Vẽ đồ thị f(x) có nhiều màu khác nhau, ta dùng lệnh:
Plot [f[x],{x, xmin, xmax}, PlotstyleGrayLevel[w]]: trong đó w là 0 hoặc 1.
PlotstyleGrayLevel[0] hiển thị màu đen, còn PlotstyleGrayLevel[1] hiển thị màu trắng.
Muốn vẽ nhiều màu hơn nữa, có thể dùng lệnh: Plot [f[x],{x, xmin, xmax}, PlotstyleRGBColor[r, g,b] trong đó r, g, b là 0 hoặc 1.
Table[Plot[Sin[x], {x, 0, 2 Pi}, PlotStyle -> ps], {ps, {Red, Thick, Dashed, Directive[Red, Thick]}}]
1 2 3 4 5 6
1 .0
0 .5
0 .5
1 .0
,
1 2 3 4 5 6
1 .0
0 .5
0 .5
1 .0
,
1 2 3 4 5 6
1 .0
0 .5
0 .5
1 .0
,
1 2 3 4 5 6
1 .0
0 .5
0 .5
1 .0
I.2 Vẽ đồ thị nhiều hàm
Plot [{f1[x], f2[x],..} ,{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ụ: Vẽ đồ thị hàm y=sinx, y=sin2x, y= sin3x
In[1]:= Plot[{Sin[x], Sin[2 x], Sin[3 x]}, {x, 0, 2 Pi}, PlotStyle-> {Red, Green, Blue}]
Out[1]=
1 2 3 4 5 6
1 .0
0 .5
0 .5
1 .0
II. Đồ thị các hàm cho theo tham số trong mặt phẳng
Để 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 độ.ParametricPlot [{x[t],y[t]},{t, tmin, tmax}]: vẽ đường cong cho bởi phương trình x=x[t], y=y[t] khi t biến thiên từ tmin đến tmax.
Ví dụ:In[1]:= ParametricPlot[{Sin[u], Sin[2 u]}, {u, 0, 2 Pi}]
Out[1]=
1 .0 0 .5 0 .5 1 .0
1 .0
0 .5
0 .5
1 .0
Ví dụ 2:ParametricPlot[{{2Cos[t],2Sin[t]},{2Cos[t],Sin[t]},{Cos[t],2Sin[t]},{Cos[t],Sin[t]}},{t,0,2 Pi}]
III. Đồ thị trong không gian ba chiều1. 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ụ:
In[1]:= Plot3D[Sin[x y],{x,0,4},{y,0,4}]
Out[1]=
In[2]:= Plot 3 D [{x2+ y2 ,−x2− y2 }, {x ,−2,2 },{ y ,−2,2 }]
Out[2]=
Các thông tin về lệnh Plot3D, cú pháp sử dụng và danh sách các biến lựa chọn (Option) sẽ được hiển thị khi dùng ??Plot3D hoặc Information[Plot3D]
Lựa chọn :
ViewPoint : Dùng để hiển thị đồ thị từ điểm ta quy định.
BoxRatios : Xác định kích thước của hình hộp mà trong đó đồ thị được hiển thị.
PlotPoints -> n : Buộc Mathermatica tính giá trị hàm tại n2 điểm để vẽ đồ thị.
Shading ->False : Không tô đậm các hình vuông trong đồ thị.
2. ListPlot :a. Vẽ đồ thị trong mặt phẳng với số liệu ngẫu nhiên :
ListPlot {f[1],f[2],…}] ;ListPlot [{f[1],f[2],…}, Options]ListPlot [{{x1, f[x1]},{x2, f[x2]},….}]
Ví dụ:
Cho dữ liệu ngẫu nhiên :dulieu= N[Table [{ x,Sin[x] + x + 0.5 Random[]}, {x, 0.5 Pi,Pi/8}] ];Dùng hàm ListPlot vẽ bookData, đồ thị nhận được là đồ thị rời rạc .dthidulieu= ListPlot[dulieu];
2.5 5 7.5 10 12.5 15
2.5
5
7.5
10
12.5
15
Để được đồ thị là đường liền nét ta dùng PlotJoined TrueListPlot[dulieu,PlotJoined True];
2.5 5 7.5 10 12.5 15
2.5
5
7.5
10
12.5
15
Để đồ thị có kích cỡ và màu sắc theo ý muốn ta dùng PlotStyle.ListPlot[dulieu, PlotStyle -> {PointSize[0.02], RGBColor[0, 0, 1]}]
2.5 5 7.5 10 12.5 15
2.5
5
7.5
10
12.5
15
b. Vẽ đồ thị trong không gian với dữ liệu ngẫu nhiên:ListPlot 3D[array]ListPlot 3D[array, shades]
Ví dụ: sử dụng một mảng các giá trị để xác định chiều cao cho bề mặtIn[1]:= ListPlot 3 D [{{1,1,1,1 }, {1,2,1,2 }, {1,1,3,1 },{1,2,1,4 }}, Mesh → All ]
Chương III
LẬP TRÌNH VỚI MATHEMMATICA
I. Mở đầu
Nếu trong Mathemmatica không có hàm mà ta cần, ta có thể viết một hàm cho riêng ta. Dạng chung của một hàm được định nghĩa như sau:
f[arg1_,arg2,…]:= body
Ví dụ:
Square[x_]:=x^2
Square[y]
y2
S Đ
Đ
S
S
B
S2’S1
’
B
S1;
Sn
Chương trình cấu trúc= {tuần tự, chọn, lặp}
II. Lập trình cấu trúc với Mathematica
II.1. Nhập/ xuất
id= Input[“Lời chú thích”]
Print[expr1, expr2,…]
Ví dụ:
x=Input[“Nhập một giá trị”]
Print[x^2]
Print[x^3]
2
4
8
II.2. Gán
=
: =
Ví dụ:
In[1]:=a = 5
Out[1]= 5
In[2]:= 2*a + 7
Out[2]= 17
Chú ý: “ =” Tương đương với một tham số
II.3 Thay đổi giá trị của các biến
= , + + id, id + +, op =
op là các phép toán +,-,*, /
Ví dụ:
In[1]:=i = 1
Out[1]=1
In[2]:= ++i
Out[2]= 2
II.4. Khối (lệnh) và biến cục bộ
Block[{Biến}, thân chương trình]
Module[{Biến}, thân chương trình]
Ví dụ:
x=5;y=6
t=x;x=y;y=t;
Print[x]
Print[y]
Print[t]
6
5
5
Block[{t},t =x,x=y,y=t];
Print[x]
Print[y]
Print[t]
6
5
5
II..5 Cấu trúc chọn
Các phép toán logic
&& : Và
║ : Hoặc
! :Không
Xor [p,q]
Ví dụ:
(3 > 2) ║(1/0 > 5)
True
II.6 Cấu trúc điều kiện
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.Ví dụ 1: Định nghĩa hàm giá trị tuyệt đốiabs[x_]:=If[x<0,-x,x];
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ụ 2 : In[1] := If[a>b,1,0,Indeterminate]Out[1]= Indeterminate
Ví dụ:
Định nghĩa hàm f(x) = {1 , Khi x>0¿ ¿¿¿
f[x_]:= If[x > 0,1,-1];
f[5]
1
Trong trường hợp có nhiều khả năng lựa chọn ta dùng cấu trúc Which
Which [Trường hợp 1, giá trị 1, Trường hợp 2, giá trị 2, …]
Ví dụ:
Định nghĩa hàm g(x)={1 , x>0 ¿ {0 , x=0 ¿ ¿¿¿
g[x_]:=Which[x > 0, 1, x ==0, 0, x<0, -1];
g[-3]
-1
II.7 Cấu trúc lặp
Vòng lặp dạng While : Cú pháp:
While [test, expr] – thực hiện expr cho đến khi nào test nhận giá trị logic False.
Ví dụ:
i=1;
While[I<=3,(Print[i^2]; i++)]
1
4
9
Vòng lặp dạng For :
Cú pháp:
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.
Ví dụ:
For[i=1, i<=3, ++i, Print[i^2]]
1
4
9
Vòng lặp dạng Do : Cú pháp:
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, j max},...] – tính expr với các vòng lặp lồng nhau theo các biến j, i, …
Ví dụ:
Do[Print[i^2], {i, 3}]
1
4
9
III. Một số ví dụ:
Ví dụ 1: Giải phương trình bậc 1
Cách 1
ptbac1[a_, b_] :=
Module[{},
If[a == 0,
If[b == 0, "phuong trinh vo so nghiem", "phuong trinh vo nghiem"],
Print["phuong trinh co mot nghiem la x =", -(b/a)]]
]
Cách 2
ptbac1c2[] :=
Module[{a, b},
a = Input["Nhap vao he so a ="];
b = Input["Nhap vao he so b ="];
If[a == 0,
If[b == 0, "phuong trinh vo so nghiem", "phuong trinh vo nghiem"],
Print["phuong trinh co mot nghiem la x =", -(b/a)]]
]
Ví dụ 2: Giải phương trình bậc 2
ptbac2[a_, b_, c_] :=
Module[{delta = b*b - 4*a*c},
If[delta < 0, Print["Pt vo nghiem"],
If[delta == 0, Print["Pt co nghiem kep x1=x2=", -(b/2*a)],
Print["phuong trinh co 2 nghiem phan biet x1=",
(-b+ Sqrt[delta])/2*a,
" ; x2=", (-b - Sqrt[delta])/2*a]]]
]
Chương IV
Ứng Dụng Mathematica Trong Các Lĩnh Vực
Kỹ thuật :Khoa học :Công nghệ sinh học và y dược :Công nghệ phần mềm và phát triển ứng dụng :Thiết kế, nghệ thuật và giải trí :Tài chính thống kê và phân tích kinh doanh :
Chuong IV
Xử Lý Ảnh
I. Giới thiệu về khả năng xử lý ảnh của mathematica
Giải pháp sử lý hình ảnh của Mathematica hoàn toàn phù hợp với khả năng chuyên biệt trong lĩnh vực nghệ thuật được xây dựng với các chức năng xử lý ảnh, dễ dàng nhập dữ liệu và một giao diện tương tác với độ tin cậy của biểu tượng và thuật toán.
Các lệnh đơn thao tác cho phép bạn tạo một phạm vi đáng kinh ngạc của các ứng dụng tương tác với chỉ một vài dòng đầu vào. Thao tác được thiết kế để được sử dụng thoải mái các lệnh cơ bản bởi bất cứ ai, nó không yêu cầu học tập bất cứ khái niệm mới phức tạp , cũng không phải bất kỳ sự hiểu biết về ý tưởng lập trình giao diện người dùng.
II. Các Thao Tác Cơ bản:
Xuất và nhập hình ảnh:
Import["file"]: Nhập dữ liệu từ một tập tin
Import["file", elems]: Nhập hình ảnh với các quy định yếu tố từ một tập tin.
Import["http://url", ...] và Import["ftp://url", ...] : Nhập từ bất kỳ URL truy cập được.
Ví dụ:
In[1]:= Import[“ExampleData/rose.gif”,”ImageSize”]
Out[1]= (223,164)
Export ["file.ext", expr]: xuất dữ liệu vào một tập tin, chuyển đổi nó sang định dạng tương ứng với phần mở rộng tập tin.
Export [file, expr, "format"]: xuất khẩu dữ liệu trong các định dạng cụ thể.
Ví dụ:
In[1]:= Export [ test.gif , Plot [sin [ x ] ,{x , 0,10 }]]
Out[1]= test . gif
Image :
Image[data]: Trình bày các hình ảnh với giá trị điểm ảnh được cho bởi các mảng dữ liệu.
Ví dụ:
Int[1]:= Image [ { {0,1,0 }, {1,0,1 } , {0,1,0 }}]
Out[1]=
Image[graphics]: Tạo một hình ảnh từ các đối tượng đồ họa
Image[obj,options]: Hiển thị một hình ảnh với tùy chọn chỉ định
Ví dụ:
Int[1]:= Import [ “ baby . jpg ” ]
Out[1]=
Image[%,”Real”]
Ví dụ: Hình ảnh với ba kênh màu:
Int[2]:= Image [RandomReal [1 ,{8,12,3 }] ]
Out[2]=
ImageData :
ImageData[image]:Cung cấp các mảng các giá trị pixel trong Image
ImageData[image,"type"]:Cung cấp các mảng các giá trị pixel theo chỉ định của Type
Ví dụ: Cung cấp 5 giá trị pixel của hàng đầu tiên
ImageData[ ][[1,1;;5]]
{{0.862745,0.54902,0.262745},{0.854902,0.533333,0.247059},
{0.839216,0.52549,0.239216},{0.839216,0.52549,0.254902},
{0.847059,0.533333,0.262745}}
ImageDimensions:
ImageDimensions [ image ]: Cung cấp kích thước của một hình ảnh
Ví dụ:
In[1]:=ImageDimensions[
]
Out[1]= {240,80 }
Thumbnail:
Thumbnail [ image]: Hiển thị hình ảnh dưới dạng thu nhỏ
Thumbnail [ image,size]: Hiển thị hình ảnh với kích thước Size
Các thao tác cơ bản trên hình ảnh:
ImageCrop:
ImageCrop[image]:Cắt hình ảnh bằng cách loại bỏ các đường viền của màu sắc đồng nhất
ImageCrop[image,{w,h)]: Cắt hình ảnh với chiều rộng w pixel và chiều cao h pixel
In[1]:= ImageCrop[ ,{100,50}]
Out[1]=
ImageCrop[image,size]: cắt hình ảnh với kích thước Size
ImageCrop[image,size,spec]:cắ hình ảnh với kích thước Size theo chỉ định spec
ImageCrop[ ,100, Left]
ImagePad :
ImagePad[image,m]: Thêm vào tất cả các mặt bên của hình ảnh với điểm ảnh nền m.ImagePad[image,m,padding]: Thêm vào tất cả các mặt bên của hình ảnh với điểm ảnh nền m theo trị được định sẳn padding.ImagePad[image,{{left,right},{bottom,top}},…]:Thêm vào hình ảnh với số Pixel được chỉ đình cho mỗi mặt.Ví dụ:
ImagePad[ , 2, Yellow]
Ví dụ: Thêm bằng cách phản chiếu các hàng và cột ở viển:
ImagePad[ , 60, "Reflected"]
ImageTake:ImageTake[image,n]:Cho một hình ảnh bao gồm n hàng đầu tiên của hình ảnh.ImageTake[ image, -n]: Cho một hình ảnh bao gồm n hàng cuối của hình ảnh.ImageTake[image,{row1,row2}]: Cho một hình ảnh từ hàng 1 đến hàng 2 của ảnh.ImageTake[image,{row1,row2},{col1,col2}]: Cho một hình ảnh từ hàng 1 đến hàng 2, cột 1 đến cột 2 của ảnh.
Ví dụ: Lấy 70 Pixel đầu tiên của hình ảnh
ImageTake[ ,70]
Ví dụ: Lấy pixel từ 80-200 của hàng và 100- 200 của cột
ImageTake[ ,{80,200}, {100,200}]
Geometric Operation:
ImageResize:
ImageResize[image,w]: Cho một hình ảnh với kích thước mới với độ rộng Pixel w
ImageResize[image,{s}]: Cho một hình ảnh với kích thước mới với độ rộng hoặc chiều cao Pixel tối đa s
ImageResize[image,{w,h}]: Cho một hình ảnh với kích thước mới với độ rộng hoặc chiều cao Pixel được chỉ đinh bởi {w,h}
ImageResize[image,{{wmax},{hmax}}]: Cho một hình ảnh với kích thước mới với độ
rộng hoặc chiều cao Pixel tối đa được chỉ đinh bởi {w,h}
ImageRotate :
ImageRotate[image]: Xoay hình ảnh ngược chiều kim đồng hồ một góc 90 độ.
ImageRotate[image,side]: Xoay đầu của hình ảnh theo hướng được quy định.
ImageRotate[image,side1->side2]: Xoay hình ảnh sao cho mặt 1 nằm vào hướng của mặt 2.
Ví dụ:
ImageRotate[ , Right]
Ví dụ:
ImageRotate [% ,¿Top ]
ImageReflect:
ImageReflect[image]: Đảo ngược hình ảnh theo dạng gương phản chiếu.
ImageReflect[image,side]: Đảo ngược hình ảnh sao cho mặt được chỉ định quay theo hướng đối diện.
ImageReflect[image,side1->side2]: Đảo ngược hình ảnh sao cho mặt 1 và mặt 2 đổi chổ cho nhau.
Ví dụ:
ImageReflect[ , Left Top]
Xử lý hình ảnh cơ bản:
ImageEffect :
ImageEffect[image,"effect"]: Áp dụng các hiệu ứng được chỉ định vào hình ảnh
ImageEffect[image,{"effect",params}]: Áp dụng các hiệu ứng với các thông số được chỉ định vào hình ảnh
Ví dụ:
ImageEffect[ , {"OilPainting",5}]
ImageAdjust:
ImageAdjust[image]: Điều chỉnh các mức độ hình ảnh, điều chỉnh lại tỉ lệ trong khoãng từ 0 ->1
ImageAdjust[image,c]: điều chỉnh độ tương phản của hình ảnh bằng một số c
ImageAdjust[image,{c,b}]: điều chỉnh độ tương phản bằng một số c và độ sáng bằng một số b.
ImageAdjust[image,{c,b,}]: Điều chỉnh gamma bằng cách tăng biến
Ví dụ: Tăng độ tương phản và giảm độ sáng của hình ảnh
ImageAdjust[ ,{0.5,-0.3}]
Sharpen:
Sharpen[image]: Đưa ra một hình ảnh với phiên bản sắc nét.
Sharpen[image,r]: Đưa ra một hình ảnh sắc nét với bán kính pixel r.
Ví dụ: Sharpen[ ]
Blur:
Blur [ image ]: Đưa ra một hình ảnh mờ hơn sao với ban đầu.
Blur [ image,r]: Đưa ra một hình ảnh mờ hơn với bán kính pixel r.
Lighter :
Lighter[color]: Đưa ra phiên bản với màu sắc sáng hơn ban đầu.
Lighter[color,f]: Đưa ra phiên bản với màu sắc sáng hơn được chỉ định bởi phân số f.
Lighter[image,…]: Đưa ra một phiên bản hình ảnh sáng hơn so với ban đầu.
Ví dụ:
Lighter[ ]
Darker:
Darker [ color ]: Đưa ra một phiên bản tối hơn so với màu quy định.
Darker [ color,f ]: Đưa ra một phiên bản tối hơn được chỉ định bởi phân số f
Darker[image,…]: Đưa ra một phiên bản hình ảnh tối hơn
Ví dụ:
Darker[ ]
Xử lý màu
ColorConvert:
ColorConvert [ expr , colspace]: chuyển đổi các thông số kỹ thuật màu sắc trong expr để chỉ không gian màu đại diện bởi colspace.
Ví dụ: chuyển hình ảnh màu ban đầu sang màu xám
ColorConvert[ ,"Grayscale"]
ColorSeparate :
ColorSeparate [image]: đưa ra một danh sách các kênh màu sắc đơn tương ứng với mỗi kênh màu trong hình ảnh.
Ví dụ:
ColorSeparate[ ]
{ , , }
ColorQuantize:
ColorQuantize [ image , n ]: Đưa ra hình ảnh gần giống hình ảnh ban đầu mà chỉ sử dụng n màu sắc
Ví dụ:
ColorQuantize[ ,10]
ListAnimate:
ListAnimate[{expr1,expr2,…}]: Tạo ra một hình ảnh động có khung là những expr
tiếp i
Ví dụ:
In[1]:= ListAnimate [Table[ Plot [sin [nx] , {x ,0,10 }] ,{n ,2 }]]
Out[1]=
2 4 6 8 10
1 .0
0 .5
0 .5
1 .0
GraphicsGrid:
GraphicsGrid[{{g11,g12,…},…}]: Hiển thị hình ảnh trong đó những hình ảnh được tạo ra được đặt dưới dạng lưới 2 chiều.
Ví dụ:
In[1]:= GraphicsGrid ¿
{Graphics [Disk [ ]] , Graphics [ Rectangle[ ]]}}¿
Out[1]=
TabView:
TabView[{expr1, expr2, ...}]: Trình bày một đối tượng trong đó khi chọn vào tab thứ i sẽ hiển thị đối tượng thứ i.
TabView[{lbl1->expr1, lbl2->expr2, …}]:Tab lbl1 sẽ hiển thị đối tượng expr1.
Ví dụ:
In[1]:= TabView [ {x → a, y→ b , z→ c } ]
Out[1]= a
x y z
SlideView:
SlideView[{expr1,expr2,…}]: Đối tượng thứ expr1 được hiển thị trong slide thứ i
SlideView[{expr1,expr2,…},i]: Hiển thị mặc định đối tượng thứ i
Ví dụ:
SlideView[{Import [C:\Users\Ironface.Ironface-PC\Desktop\1.jpg ] , Import [C:\Users\Ironface.Ironface-PC\Desktop\2.jpg ] , Import [C:\Users\Ironface.Ironface-PC\Desktop\3.jpg ] , Import [C:\Users\Ironface.Ironface-PC\Desktop\4.jpg ]}]
FlipView:
FlipView[{expr1,expr2}]: Hiển thị biểu thức thứ i+1 khi click vào biểu thức thứ i.
Ví dụ:
IN[1]:= FlipView [Table[ Plot [sin [nx ] ,{x ,0,10 }] ,{n ,5}]]
OUT[1]=
2 4 6 8 10
1 .0
0 .5
0 .5
1 .0
Binarize:Binarize[image]: Tạo ảnh nhị phân bằng cách chuyển đổi giá trị các pixel thành 0 hoặc 1.
Ví dụ:
Binarize[ ]
Binarize[image,t]: Tạo ảnh nhị phân bằng cách chuyển đổi giá trị các pixel thành 0 hoặc 1 trên khoãng t.
Binarize[image,{t1,t2}]: Tạo ảnh nhị phân bằng cách chuyển đổi giá trị các pixel thành 0 hoặc 1 trong khoãng t1-> t2.
ColorNegate:ColorNegate [ image ]: Đão ngược màu sắc ban đầu của hình ảnh
Ví dụ:
ColorNegate[ ]
Closing:
Closing[image,ker]: Cung cấp hình thái mới nhằm loại bỏ các vết không đúng trên ảnh và cũng làm ảnh mờ hơn.
Ví dụ:
Closing[ ,1]
Opening :
Opening[image,ker]:
Ví dụ: Sử dụng hình thái mở để trích xuất các đối tượng lớn hơn các yếu tố cấu trúc:
Opening[ ,DiskMatrix[6]]
ImageAssemble:
ImageAssemble [{{ image 11 , image 12 , ... }, { image 21 , ... }, ... }]: Tổng hợp các
hình ảnh thành 1 hình ảnh duy nhất.
ImageAssemble[{{
, , , , , , , , , },
{ , , , , , , , , , },
{ , , , , , , , , , },
{ , , , , , , , , , },
{ , , , , , , , , , },
{ , , , , , , , , , }}]
ImageCompose:
ImageCompose[image,overlay]: Hiển thị hình ảnh trong đó overplay nằm chồng trên
hình.Ví dụ:
ImageCompose[ , ]
ImagePartition:
ImagePartition[image,s]: Phân chia hình ảnh ra thành s lần
Ví dụ:
ImagePartition[ , 16]