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.
This document is posted to help you gain knowledge. Please leave a comment to let me know what you think about it! Share it to your friends and learn new things together.
Transcript
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
- 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ụ:
- 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.
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.
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.
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
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.
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 :
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.
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.