Làm quen với Mathematica

Chia sẻ: Camthudanvip Camthudanvip | Ngày: | Loại File: PDF | Số trang:59

Thêm vào BST

Báo xấu

328
lượt xem 58
download

Download Vui lòng tải xuống để xem tài liệu đầy đủ

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

Chủ đề:

Bình luận(0) Đăng nhập để gửi bình luận!

Lưu

Nội dung Text: Làm quen với Mathematica

MỤC LỤC Làm quen với Mathematica ........................................................................................................ 3 Làm việc với ma trận .................................................................................................................... 4 Làm việc với List ............................................................................................................................. 4 Hàm số ............................................................................................................................................... 6 Vẽ đồ thị và điểm ........................................................................................................................... 7 Vẽ đồ thị tham số ........................................................................................................................... 8 Vẽ đồ thị trong không gian 3 chiều ......................................................................................... 9 Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0 ........................................................... 11 Vẽ miền đúng của bất đẳng thức ........................................................................................... 13 Các vòng lặp dạng Do, For, While ......................................................................................... 15 Lệnh IF ............................................................................................................................................. 16 Những kí hiệu “kì quái” .............................................................................................................. 16 Phương pháp học tốt Mathematica ........................................................................................ 17 Tích Kronecker với lệnh KroneckerProduct......................................................................... 18 Phân tích số tự nhiên thành thừa số nguyên tố ............................................................... 19 Giải phương trình và hệ phương trình .................................................................................. 19 Tích phân, đạo hàm, chuỗi và giới hạn. Phương trình vi phân. ................................. 22 Chuyển từ số thực sang số hữu tỉ và ngược lại. Chuyển cơ số. ................................. 24 Lệnh Roots và lệnh Solve .......................................................................................................... 24 Lệnh khử biến và một số cách thế giá trị vào biểu thức ............................................... 25 Lệnh Chop ....................................................................................................................................... 25 Thread, Inner, Outer, Transpose, và Distribute ............................................................... 26 Lệnh Root và lệnh FindRoot ..................................................................................................... 31 Các lệnh liên quan đến thông báo khi tính toán: Quiet, Off, On, Check ................ 31 Giải phương trình vi phân thường - Lệnh NDSolve ......................................................... 34 Vài câu lệnh làm việc với String ............................................................................................. 34 Ghi chú trên đồ thị ....................................................................................................................... 35 Vẽ đồ thị động với lệnh Manipulate ....................................................................................... 36 Các đơn vị đo lường trong thống kê mô tả ........................................................................ 37
Tìm hiểu sự sai khác khi tính toán với số phức ................................................................ 38 Phép đổi biến trong tích phân ................................................................................................. 39 Thử lại tính đúng đắn nghiệm của phương trình .............................................................. 41 Ghi chú khi vẽ đồ thị điểm ........................................................................................................ 41 Tam giác Pascal ............................................................................................................................ 42 Vẽ đồng hồ treo tường ............................................................................................................... 45 Thao tác các biểu thức đại số .................................................................................................. 46 Mọi thứ là một biểu thức ........................................................................................................... 48 Một phương trình với nghiệm chính xác không được tìm thấy ................................... 52 Nguyên tắc xuất ảnh động có đuôi gif ................................................................................. 52 Ý nghĩa hình học của khai triển Taylor ................................................................................ 55 Numerical method ........................................................................................................................ 57
Làm quen với Mathematica Để làm quen với Mathematica thì đầu tiên bạn phải có phần mềm này và cài đặt nó, hiện tại tôi vẫn đang dùng phiên bản thứ 6 dù phiên bản 7 đã ra đời. Tôi không muốn nói nhiều về hình thức của chương trình, cách cài đặt hay giao diện ban đầu như thế nào (bạn đọc tự biết nhé), tôi chỉ muốn chốt lại một số điểm cần chú ý trong Mathematica theo sự hiểu biết cá nhân: 1. Mathematica phân biệt chữ hoa chữ thường, các hàm của nó đều bắt đầu bằng chữ hoa. 2. Các biến đi theo hàm đều được đặt trong ngoặc vuông, cú pháp hình thức như sau: Hàm[expr]. Có thể lấy ví dụ như Cos[x], Sin[x]. 3. Để thực hiện một câu lệnh, ta dùng tổ hợp phím "Shift + Enter". 4. Để kết thúc một câu lệnh ta đặt dấu chấm phẩy (;), nếu không có dấu (;) thì kết quả sẽ được hiển thị bên dưới. 5. Cần phân biệt các dấu [], [[]], {}, (). 6. Lện N[expr] dùng để hiện thị kết quả thành số thập phân. Ví dụ: nếu bạn gõ Cos[1] thì kết quả hiển thị chỉ là Cos[1], nếu bạn gõ N[Cos[1],6] thì kết quả sẽ là 0.540302. 7. Không được chạy nhiều chương trình cùng một lúc vì các biến vẫn còn lưu giá trị của nó, khi đó kết quả của bạn sẽ bị sai, để khắc phục, bạn chỉnh lại như sau Evaluation/Quit Kernel/Local. 8. Cách đặt biến bình thường như a, b, c, x, y, z, ... , không được đặtXY_a, XY-a, không được dùng các chữ cái sau để đặt tên biến I, E, C. 9. Tổ hợp Ctrl + K để tìm các hàm có tên giống nhau ở phần đầu.
10. Lệnh ?Int* để tìm tất cả các hàm bắt đầu bằng "Int", tương tự với ?*Qhay ?*Int*. 11. Cần phân biệt List và Matrix trong Mathematica. Nếu viết {1,2,3,4} thì đây là một List gồm 4 phần tử, còn nếu viết {{1},{2},{3},{4}} thì đây là một matrix 4 dòng 1 cột, đối với 1 List thì không thể dùng hàm chuyển vịTranspose được, tuy nhiên bạn có thể sử dụng các phép toán ma trận giữa Matrix và List, kết quả vẫn đúng như khi tính toán giữa các ma trận. Làm việc với ma trận 1. Cách cho một ma trận Cách 1: Insert->Table/Matrix->New Cách 2: Sử dụng móc nhọn {} Ví dụ: {{1,2,3},{a,b,c},{x,y,z}} sẽ cho một ma trận có 3 dòng 3 cột Cách 3: Dùng hàm Table[] Ví dụ: Table[i*j,{i,1,10},{j,1,10}] sẽ cho một ma trận 10 dòng 10 cột 2. Các phép toán với ma trận Cộng 2 ma trận, sử dụng dấu cộng (+) Trừ 2 ma trận. sử dụng dấu trừ (-) Nhân 2 ma trận, sử dụng dấu chấm (.) 3. Các hàm với ma trận Tr[A]: tổng các phần tử trên đường chéo của ma trận vuông A Det[A]: định thức của ma trận A Transpose[A]: ma trận chuyển vị của ma trận A Inverse[A]: ma trận nghịch đảo của ma trận A Eigenvalues[A]: giá trị riêng của ma trận A Eigenvectors[A]: vec tơ riêng của ma trận A MatrixPower[A,n]: lũy thừa n của ma trận A MatrixExp[A]: ma trận mủ của ma trận A Drop[A,{i},{}]: xóa dòng thứ i từ ma trận A Drop[A,{},{j}]: xóa cột thứ j từ ma trận A Union[A,B]: hợp 2 ma trận A và B 4. Tạo một ma trận với tính chất cho trước: Tạo ma trận đơn vị cấp n: IdentityMatrix[n] Tạo ma trận đường chéo: DiagonalMatrix[v], v là vec tơ đường chéo có dạng v = {a,b,c,d,...} Ngoài ra có thêm hàm: SparseArray[], bạn đọc tự tìm hiểu thêm qua thẻ Help(hoặc nhấn F1) Làm việc với List 1. Cách cho một list Cách 1: {} cho một list rỗng
{a,1,b,2,c,3} đặt blist gồm 6 phần tử Cách 2: Table[expr,{i,n}] cho 1 list các giá trị của expr từ 1 đến n Cách 3: Array[f,n] cho 1 list có n phần tử lần lượt là f[1], f[2], ... , f[n] Cách 4: Range[n] cho 1 list {1, 2, ... , n} Cách 5: NestList[f,x,n] cho 1 list n+1 phần tử có dạng {x, f[x], f[f[x]], ...} 2. Cách gọi phần tử của list First[list]: gọi phần tử đầu tiên cùa list Last[list]: gọi phần tử cuối cùng của list t[[i]] hoặc Part[t,i]: lấy phần tử thứ i của list t t[[i;;j]] hoặc Part[t,i;;j]: lấy các phần tử của list t từ vị trí i đến vị trí j t[[{i1,i2,...}]] hoặc Part[t,{i1,i2,...}]: lấy các phần tử từ list t ứng với các vị trí i1, i2, ... t[[i,j,...]] hoặc Part[i,j,...]: lấy phần tử từ list t có dạng t[[i]][[j]]... Take[list,n]: lấy ra n phần tử đầu tiên của list Take[list,-n]: lấy ra n phần tử cuối cùng của list Take[list,{m,n}]: lấy ra các phần từ của list từ vị trí m đến vị trí n Min[list]: lấy ra phần tử bé nhất của list Max[list]: lấy ra phần tử lớn nhất của list 3. Các hàm xử lí đối với list Kết quả nhận được sau khi sử dụng các hàm này đa phần là List Table[expr,{i,list}]: cho các giá trị của expr với i lấy giá trị từ list Map[f,list]: thực hiện hàm f với từng giá trị của list Select[list,text]: chọn ra các giá trị từ list với điều kiện text[elem] đúng TakeWhile[list,text]: giống với hàm Select[] Length[list]: đếm số phần tử của list Column[list]: in giá trị của list theo dạng cột Position[list,form]: tìm vị trí các phần tử của list có cùng form Count[list,form]: đếm số phần tử của list có cùng form MemberQ[list,form]: kiểm tra xem form có trong list hay không (cho giá trị logic) Prepend[list,elem]: thêm elem vào vị trí đầu tiên của list PrependTo[list,elem]: giống với Prepend[] Append[list,elem]: thêm elem vào vị trí cuối cùng của list AppendTo[list,elem]: giống với Append[] Insert[list,elem,i]: thêm elem vào vị trí thứ i của list Insert[list,elem,-i]: thêm elem vào vị trí thứ i (tính từ cuối đến đầu list) của list Riffle[list,elem]: chèn elem vào các vị trí xen kẽ giữa các phần tử của list Delete[list,i]: xóa elem nằm ở vị trí thứ i của list ReplacePart[list,i->new]: thay giá trị cho phần tử thứ i của list bởi new Rest[list]: trả lại giá trị cho list sau khi xóa phần tử đầu tiên Most[list]: trả lại giá trị cho list sau khi xóa phần tử cuối cùng Drop[list,n]: trả lại giá trị cho list sau khi xóa n phần tử đầu tiên Drop[list,-n]: trả lại giá trị cho list sau khi xóa n phần tử cuối cùng Drop[list,{m,n}]: trả lại giá trị cho list sau khi xóa các phần tử từ vị trí m đến n 4. Sắp xếp thứ tự một list Sort[list]: sắp xếp list theo trật tự chuẩn Union[list]: sắp xếp list và xóa các phần tử trùng nhau
Ordering[list]: cho biết vị trí ban đầu của các phần tử list sau khi đã được sắp xếp bởi Union[] Hàm số 1. Định nghĩa hàm số trên Mathematica Cách 1: Muốn định nghĩa hàm parabol ta viết f[x_] = x^2+3x+1 Định nghĩa hàm 2: ta viết g[x_,y_] = x^2+y^2 Tương tự đối với hàm nhiều biến. Cách 2: Function[x,body]: khai báo hàm một biến Function[{x1,x2,…},body]: khai báo hàm nhiều biến Lấy ví dụ ở trên, ta có thể khai báo như sau: Function[x, x^2+3x+1] Function[{x,y}, x^2+y^2] Cách 3: Dùng dấu #& Lấy ví dụ ở trên, ta có thể khai báo như sau: (#^2+3#+1)& (#1^2+#2^2)& 2. Tính giá trị hàm số Có nhiều cách, điều đó được thể hiện qua các ví dụ sau đây: Ví dụ 1 ----------------------- f[x_] = x^2+3x+1; f[2] f[x]/.x->2 f[x]/.x->{1,2,3} f@{2} f@{1,2,3} f/@{2} f/@{1,2,3} ----------------------- Ví dụ 2 ------------------------------- h[x_]=f[x]+g[x]; Map[h,{a,b,c}] Map[f[#]+g[#]&,{a,b,c}] ------------------------------- Ví dụ 3 ------------------------------------------------------ Map[Function[x,x^2+3x+1],a+b+c] Function[{x,y},x^2+y^2][a,b] Map[#^2&,a+b+c] Map[Take[#,2]&,{{2,1,7},{4,1,5},{3,1,2}}] ------------------------------------------------------ Ví dụ 4 ----------------------------------------------- h[x_] = Nest[Function[q,1/(1+q)],x,3];
h[x] ----------------------------------------------- Kết quả của ví dụ 4 sẽ là 3. Hàm có sẵn trong Mathematica Hàm logarit: Log[a,x] (cơ số a) Hàm lượng giác: Sin, Cos, Tan, Cot, Sinh, Cosh, Tanh, Coth, ArcCos, ArcSin, ArcTan, ArcCot Hàm đặc biệt: Gamma, Beta, Zeta, BesselJ, BesselY Ngoài ra còn vô số các hàm đặc biệt khác, vì trong chuyên ngành của tôi tạm thời chưa cần đến nên tôi chưa tìm hiểu, bạn đọc có thể tìm qua thẻHelp với từ khóa tutorial/SpecialFunctions (phiên bản 6). Vẽ đồ thị và điểm 1. Lệnh Plot Lệnh vẽ đồ thị của một hàm số là Plot[]. Cú pháp hình thức có thể viết như sau: Plot[f, {x, xmin, xmax}]: vẽ đồ thị hàm f trên đoạn [xmin,xmax]. Plot[{f1, f2,...}, {x, xmin, xmax}]: vẽ trên cùng một hệ trục tọa độ các hàm f1, f2, … trên đoạn [xmin,xmax]. Ví dụ 1: Plot[Sin[x]/x,{x,0,20}] Để biết được danh sách các tham số được dùng kèm với hàm Plot, ta gõ câu lệnh Options[Plot]. Các tham số này được khai báo ở dạng: name→value. Các giá trị hay dùng nhất của tham số là: - Automatic: sự chọn lựa sẽ được tự động - None: tham số không được sử dụng - All: được sử dụng trong trường hợp bất kì - True: được sử dụng - False: không được sử dụng
Ví dụ 2: Plot[Sin[x]/x,{x,0,20},PlotRange→{-0.25,1.2}] Giải thích: Tham số PlotRange→{-0.25,1.2} được dùng để giới hạn đồ thị hàm số theo trục dọc từ -0.25 đến 1.2 Một số tham số hay dùng: Axes->None: không hiển thị hệ trục tọa độ AxesLabel: ghi chú tên cùa trục tọa độ PlotStyle: chỉnh các thông số về màu sắc, cách hiển thị đậm nhạt 2. Lệnh ListPlot Cú pháp hình thức: ListPlot[{yl, у2,...}] – hiển thị các giá trị y1, y2, … lên hệ trục tọa độ, giá trị của x tương ứng là 1, 2, … ListPlot[{{x1, y1},{х2, у2 },...}] – hiển thị các điểm có tọa độ {xi,yi} lên hệ trục tọa độ. Chú ý: - Đối với lệnh ListPlot cũng có các tham số như lệnh Plot. - Nếu các điểm không được hiển thị đầy đủ, bạn bổ sung thêm tham sốPlotRange→All. - Muốn hiển thị nhiều đồ thị tên cùng một hệ trục tọa độ ta dùng lệnhShow[]. Vẽ đồ thị tham số Để vẽ một hàm số được biểu diễn dưới dạng tham số x = fx(t), y = fy(t), t thuộc đoạn [a,b] ta dùng các cấu trúc lệnh sau: ParametricPlot[{fx,fy},{t,tmin,tmax}] – xây dựng đồ thị tham số với các tọa độ {fx,fy} nhận được như một hàm theo t. ParametricPlot[{{fx,fy},{gx,gy},…},{t,tmin,tmax}] – xây dựng một vài đường tham số trên cùng một hệ trục tọa độ. Ví dụ 1: ParametricPlot[{Cos[5*t],Sin[3*t]},{t,0,20},AspectRatio->Automatic]
Ví dụ 2: ParametricPlot[{{2Cos[t],2Sin[t]},{2Cos[t],Sin[t]},{Cos[t],2Sin[t]},{Cos[t],S in[t]}},{t,0,2 Pi}] Vẽ đồ thị trong không gian 3 chiều 1. Lệnh Plot3D Chức năng: vẽ hình dạng của hàm 2 biến z = f(x,y) trong hệ trục tọa độ Oxyz. Cú pháp hình thức: Plot3D[f,{x,xmin,xmax),{у,ymin,ymax}] – xây dựng đồ thị 3 chiều của hàm 2 biến x, y. Plot3D[{f1,f2,…},{x,xmin,xmax},{y,ymin,ymax}] – xây dựng đồ thị 3 chiều của các hàm f1, f2, … trong cùng một hệ trục tọa độ. Ví dụ 1: Plot3D[Sin[x y],{x,0,4},{y,0,4}]
Ví dụ 2: Plot3D[{x^2+y^2,-x^2-y^2},{x,-2,2},{y,-2,2}] 2. Lệnh ListPlot3D ListPlot3D[{{x1,y1,z1},{x2,y2,z2},…}] – hiển thị các điểm có tọa độ {xi,yi,zi} Ví dụ 3: ListPlot3D[{{0,0,1},{1,0,0},{0,1,0}},Mesh->All]
Vẽ đồ thị hàm số dạng f(x,y) = 0 và f(x,y,z) = 0 1. Mục đích Như chúng ta đã biết, để vẽ đồ thị của một hàm số trong hệ trục tọa Decac vuông góc ta thường dùng lệnh Plot[], tuy nhiên đối với trường hợp này hàm số phải có dạng chuẩn là y = f(x). Trong nhiều trường hợp khác, chúng ta lại cần vẽ đồ thị của hàm số có dạng f(x,y) = 0, ví dụ như vẽ hình elip chẳng hạn, giải pháp tối ưu nhất là dùng lệnh ContourPlot[]. Tương tự đối với hàm số dạng f(x,y,z) = 0 ta dùng lệnh ContourPlot3D[]. 2. Cú pháp hình thức ContourPlot[f == 0,{x,xmin,xmax},{у,ymin,ymax}] – xây dựng đồ thị hàm sốf(x,y) = 0 trong miền [xmin, xmax]×[ymin,ymax]. ContourPlot[{f == 0,g == 0,…},{x,xmin,xmax},{у,ymin,ymax}] – xây dựng nhiều đồ thị trên cùng một hệ trục tọa độ. Tương tự ta có: ContourPlot3D[f == 0,{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}] ContourPlot3D[{f == 0,g == 0,…},{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}] 3. Một số ví dụ áp dụng Ví dụ 1: ContourPlot[x^2-y == 0,{x,-2,2},{y,-0.15,4},Axes->True,Frame->False] Ví dụ 2: ContourPlot[x^2/9+y^2/4 == 1,{x,-3.5,3.5},{y,-2.5,2.5},Axes->True,Frame- >False,AspectRatio->Automatic]
Ví dụ 3: ContourPlot[{Abs[Sin[x] Sin[y]] == 0.5,Abs[Cos[x] Cos[y]] == 0.5},{x,- 3,3},{y,-3,3}] Ví dụ 4: ContourPlot3D[x^3+y^2-z^2 == 0,{x,-2,2},{y,-2,2},{z,-2,2}] 4. Một số điểm lưu ý - Dấu “bằng” phải được viết 2 lần (==).
- Cú pháp dạng ContourPlot[f == g,{x,xmin,xmax},{у,ymin,ymax}] hoặcContourPlot[f == g,{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}] vẫn được thực hiện. - Nếu không thêm các tham số thì Mathematica sẽ mặc định đồ thị nằm trong khung tỉ lệ, nếu muốn hệ trục tọa độ hiện thị thì ta thêm các tham số như trong ví dụ trên Axes->True, Frame->False. - Cú pháp dạng ContourPlot[f ,{x,xmin,xmax},{у,ymin,ymax}] – vẽ đồ thị miền là các giá trị của f tường ứng với x và y trong miền [xmin, xmax]×[ymin,ymax]. Tương tự đối với hàm ContourPlot3D (xem ví dụ 5 và 6). Ví dụ 5: ContourPlot[x^2/9+y^2/4,{x,-3.5,3.5},{y,-2.5,2.5}, Axes->True, Frame->False, AspectRatio->Automatic] Ví dụ 6: ContourPlot3D[x^3+y^2-z^2,{x,-2,2},{y,-2,2},{z,-2,2}] Vẽ miền đúng của bất đẳng thức 1. Mục đích
Trong nhiều trường hợp chúng ta cần phải xác định miền nào là miền thỏa mãn của bất đẳng thức cho trước, tức là bất đẳng thức đúng. Một trong số các giải pháp là dùng lệnh RegionPlot[], tương tự, trong không gian 3 chiều ta cũng có lệnh RegionPlot3D[]. 2. Cú pháp hình thức RegionPlot[pred,{x,xmin,xmax},{у,ymin,ymax}] – xây dựng miền đồ thị sao cho pred nhận giá trị True. RegionPlot3D[pred,{x,xmin,xmax},{у,ymin,ymax},{z,zmin,zmax}] – đối với trường hợp 3 biến. 3. Một số ví dụ áp dụng Ví dụ 1: RegionPlot[x^2+y^30,{x,-2,2},{y,-2,2},{z,-2,2}]
Ví dụ 4: RegionPlot3D[x^2+y^2+z^2All] Các vòng lặp dạng Do, For, While 1. Vòng lặp dạng Do Do [expr, {imax}] – thực hiện expr imax lần. Do [expr, {i, imax}] – tính expr với biến i nhận giá trị lần lượt từ 1 đếnimax (bước nhảy bằng 1) Do [expr, {i, imin, imax}] – tính expr với biến i nhận giá trị lần lượt từimin đến imax (bước nhảy bằng 1). Do [expr, {i, imin, imax, di}] – tính expr với biến i nhận giá trị lần lượt từ imin đến imax (bước nhảy bằng di). Do [expr, {i, imin, imax}, {j, jmin, j max},...] – tính expr với các vòng lặp lồng nhau theo các biến j, i, … 2. Vòng lặp dạng For
For[start, test, incr, body] – bắt đầu với giá trị start, sau đó thực hiện lần lượt incr và body cho đến khi test nhận giá trị logic False. 3. Vòng lặp dạng While While [test, expr] – thực hiện expr cho đến khi nào test nhận giá trị logic False. 4. Các ví dụ Do[Print["hello"], {3}] For[i=0,i
:)]. Không có gì bất ngờ rằng các phép tính toán học +,-,*,/ được giữ nguyên không có gì thay đổi. Bạn hãy chú ý rằng phép nhân 2 ma trận với nhau đc kí hiệu dấu chấm A.B (điều này khá quan trọng vì nếu bạn nhầm sang dấu * thì bạn sẽ mất nhiều thời gian để gãi đầu gãi tai :)). Các kí hiệu logic cũng cần chú ý đến, nó rất có ích cho chúng ta khi dùng vòng lặp While hayIf: And – &&, Or – ||, Not – !. Câu lệnh “Nếu A bằng B thì …” được viết trong Mathematica như sau:If[A==B,…]. Ở đây bạn chú ý kí hiệu 2 dấu bằng “==”, nếu chỉ viết 1 dấu bằng thì câu lệnh sẽ bị sai. Câu lệnh “Nếu A khác B thì …” được viết trong Mathematica như sau: If[A!=B,…]. Một kí hiệu rất “tếu” trong Mathematica là “===” – 3 dấu bằng – tương ứng với lệnh SameQ[]. Nó được dùng để so sánh sự giống nhau của 2 đối tượng, ngược lại với nó sẽ có lệnh UnsameQ[], kí hiệu tắt là “=!=”. Một trong những kí hiệu mà tôi cho là hay dùng khi viết một chương trình đó là @. Kí hiệu này sẽ giúp cho chương trình của bạn bớt rườm rà hơn, ví dụ: Thay vì ta viết: Panel[Grid[Table[{i,j},{i,3},{j,3}]]] Ta viết lại: Panel@Grid@Table[{i,j},{i,3},{j,3}] Số dấu móc vuông sẽ giảm bớt giúp ta quản lí các lỗi của chương trình một cách dễ dàng. Tương tự ta có kí hiệu “//”, bạn sẽ thấy được tác dụng của kí hiệu qua ví dụ sau: Cũng với câu lệnh trên có thể viết lại: Table[{i,j},{i,3},{j,3}]//Grid//Panel Để kết thúc bài viết này, tôi xin đưa ra thêm một kí hiệu “ngộ nghĩnh” nữa, hy vọng là các bạn mới học ngôn ngữ này sẽ cảm thấy thích thú vì đã khám phá được những điều mới [mặc dù là người ta đã khám phá hết trơn rồi :)], đó là kí hiệu 2 con @@. Kí hiệu này tương ứng với lệnh Apply[]. Ví dụ sau đây sẽ giúp bạn hiểu tác dụng của nó dễ dàng: FactorInteger[20!] {{2,18},{3,8},{5,4},{7,2},{11,1},{13,1},{17,1},{19,1}} CenterDot@@(Superscript@@@%) 21^8•3^8•5^4•7^2•11^1•13^1•17^1•19^1 Các câu lệnh ở trên nhằm mục đích phân tích số 20! thành tích các thừa số nguyên tố. Có thể giải thích quá trình tính toán như sau: đầu tiên lệnhFactorInteger[] liệt kê một list các cặp số dạng {thừa số nguyên tố, số mũ tương ứng}, sau đó lệnh Superscript@@@% được áp dụng thực để hiện phép lũy thừa cho từng phần tử [cặp số] của list, kí hiệu % tương ứng với kết quả trước đó, kí hiệu @@@ tương đương với Apply ở mức độ 1 [level 1] [sẽ hiểu sâu hơn ở bài viết dành riêng cho lệnh Apply]. Cuối cùng lệnh CenterDot[]thực hiện phép nhân các phần tử của list kết quả. Đọc đến đoạn này, suy nghĩ một tí, bạn sẽ thấy kí hiệu @ và @@ đôi lúc có cùng tác dụng, ví dú nhé: f[x_]=Sin[x]; f@3 f@@{3} Cả hai đều cho kết quả là Sin[3]. Phương pháp học tốt Mathematica Bài viết này không ngoài mục đích giúp các bạn tìm được cách tiếp thu ngôn ngữ Mathematica một cách hiệu quả. Theo lẽ thường thì khi chúng ta học một môn học mới, chúng ta ngay lập tức nghĩ trong đầu rằng phải chạy nhanh ra
quán để tìm sách tham khảo. Lẽ dĩ nhiên, đọc nhiều sách thì sẽ có lợi, thu lượm được nhiều điều hay, nhưng có một mặt ngược lại [hay còn gọi là nhược điểm] đó là tính rập khuôn. Cái đó chính là rào cản của sự “mày mò”, sáng tạo đối với người học. Đối với ngôn ngữ lập trình nói chung, và Mathematica nói riêng, thẻ Helpđược xem như là một từ điển động và là cuốn “sách giáo khoa” hữu ích nhất dành cho người sử dụng. Các ví dụ tuy đơn giản, ngắn gọn nhưng lại mang phong cách viết chuyên nghiệp, dễ hiểu. Đối với mỗi lệnh đều có kèm theo các Option thường dùng tương ứng, gọi là “thường dùng” vì có những Optioncó thể áp dụng cho lệnh này nhưng lại không được liệt kê, thay vào đó nó lại được nhắc đến ở một lệnh khác, chính điều đó đã gây khó khăn cho người mới “nhập môn”. Có thể lấy một ví dụ đơn giản đối với Option ImageSize, chúng ta thấy tính chất này trong lệnh Graphics[] và một số nơi khác, nhưng lại không được tìm thấy trong lệnh Plot[], Show[]. Và một câu hỏi đặt ra rằng, muốn cố định kích cỡ hình ảnh của đồ thị trong lệnh Plot thì làm thế nào? Lúc này đây, các “phép thử” của bạn là những bài học quí báu giúp cho chính bạn hiểu sâu được vấn đề, và mọi việc thật đơn giản: Plot[Sin[x],{x,0,Pi},ImageSize->{300,200}] Show[Plot[Sin[x],{x,0,Pi}], ImageSize->{300,200}] Nhân tiện nói đến các “phép thử”, tôi có một ý kiến thế này và muốn chia sẽ với mọi người, học các lệnh trong Mathematica đôi khi thấy rời rạc nhàm chán, và chỉ những lúc cần làm Lab thì chúng ta mới đem nó ra rồi tìm trong thẻ Help các lệnh cần cho công việc của mình, cách học như thế sẽ không giúp cho bạn tiến bộ, sự hiểu biết của bạn đối với ngôn ngữ này chỉ “giậm chân tại chỗ”, theo ý kiến của mình, tôi nghĩ rằng chúng ta cần có những bài toán riêng cho bản thân [các bài toán này có thể phát sinh từ những ví dụ trong Help], và áp dụng những lệnh đã biết để giải quyết nó, nếu làm được như thế thì có nghĩa là bạn đã làm được từ “lí thuyết” sang “thực hành”. Một ví dụ dễ hiểu như sau, sau khi đã biết các lệnh cơ bảnFor[], While[] … thì bạn có thể viết ngay một chương trình nhỏ để sắp xếp các phần tử trong một mảng, các bạn cần phải thử và đừng nghĩ rằng việc sắp xếp ấy trong Mathematica đã có sẵn lệnh Sort[]. Hoặc sau khi biết lệnhModule[], bạn có thể thử vận dụng để viết một chương trình con đối với phương pháp giải hệ tuyến tính Gauss chẳng hạn,… những cái tôi đưa ra ở đây chỉ mang tính minh họa cho những điều tôi muốn truyền đạt đến bạn đọc, không nhất thiết phải giống “y chang” như thế! :) Cuối cùng, một kinh nghiệm học của tôi khi học Mathematica, đó chính là sự “ghi chép” ngay lập tức những câu lệnh mình chưa biết. Chắc hẳn bạn đôi lúc cũng “tham quan” trong thẻ Help, và đi đến nhiều “ngõ ngách” của những câu lệnh lạ, lúc đó bạn đọc nó chỉ vì sự tò mò, hay đơn giản là vì không hiểu lệnh đó làm công việc gì, và bạn thấy nó không cần thiết, không ghi chép lại, đó là sai lầm! Đến lúc làm việc, bạn cần một câu lệnh tương tự, cứ nhớ một cách không rõ ràng trong đầu đã đọc ở đâu đó, rồi vùi đầu tìm trong thẻ Help... khó như tìm “kim trong bể nước”. Bài viết tuy dài dòng nhưng cũng mong giúp được “chút ít” nào đó đối với người mới làm quen Mathematica, còn đối với những người quá rành với ngôn ngữ này thì chắc là không còn cần thiết nữa. :P Tích Kronecker với lệnh KroneckerProduct Cho hai ma trận Tích Kronecker của 2 ma trận A và B là một ma trận có dạng . Kí hiệu: Ví dụ 1: A={{1,2},{3,4}}; KroneckerProduct[IdentityMatrix[3],A]//MatrixForm
Ví dụ 2: A={{a,b},{c,d}}; B={{x,y},{z,u}}; KroneckerProduct[A,B]//MatrixForm Ví dụ 3: Có thể kiểm tra tính chất của tích Kronecker: {a,b,c,d} = RandomReal[1,{4,3,3}]; Chop[KroneckerProduct[a,b].KroneckerProduct[c,d] - KroneckerProduct[a.c, b.d]] //MatrixForm Phân tích số tự nhiên thành thừa số nguyên tố Các số tự nhiên có thể được phân tích ra các thừa số nguyên tố một cách nhanh chóng nếu chúng không quá dài (không quá dài có nghĩa là không quá 30 kí tự) FactorInteger[2434500] {{2,2},{3,2},{5,3},{541,1}} Lệnh FactorInteger[] viết các thừa số nguyên tố của một số tự nhiên theo dạng một list của từng cặp. Thành phần đầu tiên của mỗi cặp là thừa số nguyên tố, và thành phần thứ hai là số lần nó được tìm thấy trong phép nhân tử hóa. Chúng ta có thể kiểm tra thừa sô cuối cùng trong dãy phân tích trên có phải là một số nguyên tố hay không bằng lệnh PrimeQ[]. PrimeQ[541] True Giải phương trình và hệ phương trình Đầu tiên chúng ta làm quen với lệnh Solve: cú pháp và cách lấy giá trị nghiệm. Hãy chú ý đến trường hợp có nghiệm bội như trong ví dụ dưới đây:
Theo trên thì ta nhận thấy rằng, cú pháp để giải một phương trình đơn một biến là: Solve[equation, variable] Cú pháp tổng quát đối với các đối số của lệnh Solve bao gồm một list các phương trình phụ thuộc vào một list các biến. Có nghĩa là: Solve[equation_list, variable_list] Ví dụ sau đây sẽ cho ta thấy được điều đó: