Trang chủ > Mastering mathematica > Thread, Inner, Outer, Transpose, và Distribute

Thread, Inner, Outer, Transpose, và Distribute

Tháng Mười Hai 27, 2009 Để lại bình luận Go to comments

1. Thread

Listable là một thuộc tính có thể ấn định cho một kí hiệu f rằng hàm f sẽ tự động thực hiện “xuyên qua” các list và xuất hiện với các đối số của nó.
• Các hàm listable (được hiểu là hàm có thuộc tính này) sẽ được thực hiện một cách riêng rẽ đối với mỗi phần tử của list, hoặc với các phần tử tương ứng trên mỗi list nếu trong trường hợp có nhiều hơn một list.
• Hầu hết các hàm được xây dựng trong Mathematica là listable.
• Tất các các đối số (các list) trong hàm listable cần phải có cùng chiều dài.
• Các đối số mà không phải là list sẽ được copy nhiều lần vào các phần tử của các list khác.

Log[{a,b,c}]
{Log[a],Log[b],Log[c]}
Attributes[Log]
{Listable,NumericFunction,Protected}

Hàm listable sẽ kết hợp các phần tử tương ứng của lists

{a,b,c}+{x,y,z}
{a+x,b+y,c+z}

Các đối số ko phải là lists thì sẽ được lặp lại

{a,b,c}+x
{a+x,b+x,c+x}
{{a,b},{c,d}}+x
{{a+x,b+x},{c+x,d+x}}

Chúng ta có thể định nghĩa một hàm có thuộc tính listable bằng lệnh SetAttributes

f[x_]:=If[x>0,Sqrt[x],Sqrt[-x]];
SetAttributes[f,Listable];
f[{3,0,-2}]//N

{1.73205,0.,1.41421}

Một hàm thực hiện bằng một phép toán listable thì có thể không cần thuộc tính Listable

g[x_]:=x^2
g[{1,2,3}]

{1,4,9}

Hàm Thread thực hiện các công việc tương tự như trên đối với một dạng tùy ý, mặc dù nó không phải là một listable. Sau đây là một số cú pháp quan trọng:

Thread[f[args]] – “xâu” hàm f qua một vài list xuất hiện trong args.
Thread[f[args], h] – xâu f qua một vài đối tượng xuất hiện trong args với dạng h.
Thread[f[args], h, n] – xâu f qua một vài đối tượng với dạng h xuất hiện trong n args đầu tiên.

Thread[f[{a,b,c}]]
{f[a],f[b],f[c]}
Thread[f[{a,b,c},x]]
{f[a,x],f[b,x],f[c,x]}
Thread[f[{a,b,c},{x,y,z}]]
{f[a,x],f[b,y],f[c,z]}

Thread sẽ chuyển phương trình của một list thành list của các phương trình

Thread[{a,b,c}=={x,y,z}]
{a==x,b==y,c==z}

Thực hiện một hàm với 2 vế của một phương trình hoặc với các số hạng của một tổng

Thread[Log[x==y],Equal]
Log[x]==Log[y]
Thread[Log[x+y],Plus]
Log[x]+Log[y]

Theo bình thường thì không thể xâu các dạng toán (head) qua list

Thread[f[{a+b,c+d}],Plus]
f[{a+b,c+d}]

Theo bình thường, không thể xâu qua các head ngoại trừ list

Thread[f[a+b,c+d]]
f[a+b,c+d]

Một ví dụ Thread với Plus

Thread[f[a+b,c+d],Plus]
f[a,c]+f[b,d]

Thread chỉ với 2 đối số đầu tiên

Thread[f[{a,b},{r,s},{u,v},{x,y}],List,2]
{f[a,r,{u,v},{x,y}],f[b,s,{u,v},{x,y}]}

Thread chỉ với 2 đối số cuối cùng

Thread[f[{a,b},{r,s},{u,v},{x,y}],List,-2]
{f[{a,b},{r,s},u,x],f[{a,b},{r,s},v,y]}

Thread chỉ với đối số thứ 2

Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{2}]
{f[{a,b},r,{u,v},{x,y}],f[{a,b},s,{u,v},{x,y}]}

Thread các đối số từ 2 đến 4

Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{2,4}]
{f[{a,b},r,u,x],f[{a,b},s,v,y]}

Thread các đối số với bước nhảy bằng 2

Thread[f[{a,b},{r,s},{u,v},{x,y}],List,{1,-1,2}]
{f[a,{r,s},u,{x,y}],f[b,{r,s},v,{x,y}]}

Thread có thể được sử dụng để tạo một list các quy tắc và tính giá trị biểu thức

exp=x^2+y^2;
vars={x,y};points={1,2};
exp/.Thread[vars->points]

5

2. Inner

Inner[f, list1, list2, g] – là sự tổng quát hóa của Dot, trong đó f đóng vai trò của phép tính nhân và g đóng vai trò của phép tính cộng.
a.b.c hoặc Dot[a, b, c] sẽ cho chúng ta tích của các vecto, matrix hay tensor.
Cú pháp trên của lệnh Inner có vai trò giống như cú pháp của câu lệnh Apply[g, Thread[f[list1, list2]]].

{a,b,c}.{x,y,z}
ax+by+cz
Inner[Times,{a,b,c},{x,y,z},Plus]
ax+by+cz
Inner[f,{a,b},{x,y},g]
g[f[a,x],f[b,y]]
Apply[g,Thread[f[{a,b},{x,y}]]]
g[f[a,x],f[b,y]]

3. Outer, Transpose, và Distribute

Outer[f,{a,b},{x,y,z}]
{{f[a,x],f[a,y],f[a,z]},{f[b,x],f[b,y],f[b,z]}}
Outer[Times,{1,2,3,4},{a,b,c}]
{{a,b,c},{2 a,2 b,2 c},{3 a,3 b,3 c},{4 a,4 b,4 c}}
Outer[Times,{{1,2},{3,4}},{{a,b},{c,d}}]
{{{{a,b},{c,d}},{{2 a,2 b},{2 c,2 d}}},{{{3 a,3 b},{3 c,3 d}},{{4 a,4 b},{4 c,4 d}}}}
Outer[g,f[a,b],f[x,y,z]]
f[f[g[a,x],g[a,y],g[a,z]],f[g[b,x],g[b,y],g[b,z]]]

Transpose[list] – chuyển vị 2 level đầu tiên của list.
Transpose[list, {n1, n2, …}] – chuyển vị list để level thứ k trong list là level thứ nk trong kết quả.

Transpose[{{a,b,c},{x,y,z}}]
{{a,x},{b,y},{c,z}}

m=Array[a,{2,3,2}];
m//MatrixForm
m//TreeForm

Transpose[m,{1,3,2}]//MatrixForm
Transpose[m,{1,3,2}]//TreeForm

Phân phối chỉ với tích của các tổng

Distribute[(a+b+c)(u+v),Plus,Times]
au+bu+cu+av+bv+cv
Distribute[(a+b+c)^(u+v),Plus,Times]
(a+b+c)^(u+v)

Phân phối các quy tắc đối với phép toán logic

Distribute[And[Or[a,b,c],Or[u,v]],Or,And]
(a&&u)||(a&&v)||(b&&u)||(b&&v)||(c&&u)||(c&&v)

  1. Chưa có phản hồi.
  1. No trackbacks yet.

Gửi phản hồi

Mời bạn điền thông tin vào ô dưới đây hoặc kích vào một biểu tượng để đăng nhập:

WordPress.com Logo

Bạn đang bình luận bằng tài khoản WordPress.com Log Out / Thay đổi )

Twitter picture

Bạn đang bình luận bằng tài khoản Twitter Log Out / Thay đổi )

Facebook photo

Bạn đang bình luận bằng tài khoản Facebook Log Out / Thay đổi )

Google+ photo

Bạn đang bình luận bằng tài khoản Google+ Log Out / Thay đổi )

Connecting to %s

%d bloggers like this: