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]