PDL :: Threadingp - Trực tuyến trên đám mây

CHƯƠNG TRÌNH:

TÊN

PDL :: Phân luồng - Hướng dẫn cho tính năng Phân luồng của PDL

GIỚI THIỆU

Một trong những tính năng mạnh mẽ nhất của PDL là luồng, có thể tạo ra rất nhỏ gọn và
mã PDL rất nhanh bằng cách tránh nhiều vòng lặp for lồng nhau mà người dùng C và BASIC có thể
quen thuộc với. Vấn đề là nó có thể mất một số thời gian để làm quen và những người dùng mới có thể không
đánh giá cao những lợi ích của việc phân luồng.

Các ngôn ngữ dựa trên vectơ khác, chẳng hạn như MATLAB, sử dụng một tập hợp con các kỹ thuật phân luồng, nhưng
PDL tỏa sáng bằng cách tổng quát hóa hoàn toàn chúng cho tất cả các loại ứng dụng dựa trên vectơ.

THUẬT NGỮ: CHĂM

MATLAB thường đề cập đến vectơ, ma trận và mảng. Perl đã có các mảng, và
thuật ngữ "vectơ" và "ma trận" thường đề cập đến các tập hợp một và hai chiều của
dữ liệu. Không có thuật ngữ tốt để mô tả đối tượng của họ, các nhà phát triển PDL đã đặt ra thuật ngữ
"chăm"để đặt tên cho kiểu dữ liệu của chúng.

A chăm bao gồm một chuỗi số được tổ chức dưới dạng tập dữ liệu N chiều. Piddles
cung cấp khả năng lưu trữ hiệu quả và tính toán nhanh các ma trận N-chiều lớn. họ đang
tối ưu hóa cao cho công việc số.

TƯ DUY IN ĐIỀU KHOẢN OF LƯỚI

Nếu bạn đã sử dụng PDL được một thời gian, bạn có thể đã sử dụng phân luồng mà không có
nhận ra nó. Khởi động trình bao PDL (nhập "perldl" hoặc "pdl2" trên một thiết bị đầu cuối). Hầu hết các ví dụ
trong hướng dẫn này sử dụng trình bao PDL. Đảm bảo rằng PDL :: NiceSlice và PDL :: AutoLoader
đã được kích hoạt. Ví dụ:

%pdl2
vỏ perlDL v1.352
...
Đã bật ReadLines, NiceSlice, MultiLines
...
Lưu ý: AutoLoader chưa được bật (khuyến nghị 'sử dụng PDL :: AutoLoader')

pdl>

Trong ví dụ này, NiceSlice đã được tự động kích hoạt, nhưng AutoLoader thì không. Để kích hoạt
nó, gõ "use PDL :: AutoLoader".

Hãy bắt đầu với hai chiều chăm:

pdl> $ a = dãy (11,9)
pdl> p $ a
[
[0 1 2 3 4 5 6 7 8 9 10]
[11 12 13 14 15 16 17 18 19 20 21]
[22 23 24 25 26 27 28 29 30 31 32]
[33 34 35 36 37 38 39 40 41 42 43]
[44 45 46 47 48 49 50 51 52 53 54]
[55 56 57 58 59 60 61 62 63 64 65]
[66 67 68 69 70 71 72 73 74 75 76]
[77 78 79 80 81 82 83 84 85 86 87]
[88 89 90 91 92 93 94 95 96 97 98]
]

Phương thức "thông tin" cung cấp cho bạn thông tin cơ bản về chăm:

pdl> p $ a-> thông tin
PDL: Đôi D [11,9]

Điều này cho chúng ta biết rằng $ a là 11 x 9 chăm bao gồm các số chính xác kép. Nếu chúng ta
muốn thêm 3 vào tất cả các phần tử trong một piddle "nxm", một ngôn ngữ truyền thống sẽ sử dụng hai
lồng nhau cho các vòng lặp:

# Mã giả. Cách truyền thống để thêm 3 vào một mảng.
for (x = 0; x <n; x ++) {
for (y = 0; y <m; y ++) {
a (x, y) = a (x, y) + 3
}
}

Chú thích: Lưu ý rằng các chỉ số bắt đầu từ 0, như trong Perl, C và Java (và không giống như MATLAB và IDL).

Nhưng với PDL, chúng ta chỉ có thể viết:

pdl> $ b = $ a + 3
pdl> p $ b
[
[3 4 5 6 7 8 9 10 11 12 13]
[14 15 16 17 18 19 20 21 22 23 24]
[25 26 27 28 29 30 31 32 33 34 35]
[36 37 38 39 40 41 42 43 44 45 46]
[47 48 49 50 51 52 53 54 55 56 57]
[58 59 60 61 62 63 64 65 66 67 68]
[69 70 71 72 73 74 75 76 77 78 79]
[80 81 82 83 84 85 86 87 88 89 90]
[91 92 93 94 95 96 97 98 99 100 101]
]

Đây là ví dụ đơn giản nhất về phân luồng và nó là thứ mà tất cả các phần mềm số
công cụ nào. Thao tác "+ 3" đã được tự động áp dụng theo hai thứ nguyên. Bây giờ giả sử
bạn muốn trừ một dòng khỏi mỗi hàng trong $ a:

pdl> $ line = trình tự(11)
pdl> p $ dòng
[0 1 2 3 4 5 6 7 8 9 10]
pdl> $ c = $ a - $ dòng
pdl> p $ c
[
[0 0 0 0 0 0 0 0 0 0 0]
[11 11 11 11 11 11 11 11 11 11 11]
[22 22 22 22 22 22 22 22 22 22 22]
[33 33 33 33 33 33 33 33 33 33 33]
[44 44 44 44 44 44 44 44 44 44 44]
[55 55 55 55 55 55 55 55 55 55 55]
[66 66 66 66 66 66 66 66 66 66 66]
[77 77 77 77 77 77 77 77 77 77 77]
[88 88 88 88 88 88 88 88 88 88 88]
]

Hai điều cần lưu ý ở đây: Thứ nhất, giá trị của $ a vẫn không đổi. Hãy thử "p $ a" để kiểm tra.
Thứ hai, PDL tự động trừ $ dòng cho mỗi hàng trong $ a. Tại sao nó lại làm như vậy? Hãy
nhìn vào kích thước của $ a, $ line và $ c:

pdl> p $ line-> thông tin => PDL: Double D [11]
pdl> p $ a-> thông tin => PDL: Double D [11,9]
pdl> p $ c-> thông tin => PDL: Double D [11,9]

Vì vậy, cả $ a và $ dòng đều có cùng số phần tử trong chiều thứ 0! PDL sau đó là gì
đã thực hiện luồng qua các kích thước cao hơn trong $ a và lặp lại thao tác tương tự 9 lần để
tất cả các hàng trên $ a. Đây là luồng PDL đang hoạt động.

Điều gì sẽ xảy ra nếu bạn muốn trừ dòng $ khỏi dòng đầu tiên chỉ trong $ a? Bạn có thể làm điều đó bằng cách
chỉ định dòng một cách rõ ràng:

pdl> $ a (:, 0) - = $ dòng
pdl> p $ a
[
[0 0 0 0 0 0 0 0 0 0 0]
[11 12 13 14 15 16 17 18 19 20 21]
[22 23 24 25 26 27 28 29 30 31 32]
[33 34 35 36 37 38 39 40 41 42 43]
[44 45 46 47 48 49 50 51 52 53 54]
[55 56 57 58 59 60 61 62 63 64 65]
[66 67 68 69 70 71 72 73 74 75 76]
[77 78 79 80 81 82 83 84 85 86 87]
[88 89 90 91 92 93 94 95 96 97 98]
]

Xem PDL :: Lập chỉ mục và PDL :: NiceSlice để tìm hiểu thêm về cách chỉ định các tập hợp con từ các piddles.

Sức mạnh thực sự của phân luồng xuất hiện khi bạn nhận ra rằng người chơi có thể có bất kỳ số
kích thước! Hãy làm một trò chơi 4 chiều:

pdl> $ piddle_4D = chuỗi (11,3,7,2)
pdl> $ c = $ piddle_4D - $ dòng

Bây giờ $ c là một piddle có cùng thứ nguyên với $ piddle_4D.

pdl> p $ piddle_4D-> thông tin => PDL: Double D [11,3,7,2]
pdl> p $ c-> thông tin => PDL: Double D [11,3,7,2]

Lần này PDL đã tự động phân luồng qua ba thứ nguyên cao hơn, trừ đi $ dòng
tất cả các cách

Tuy nhiên, có thể bạn không muốn trừ các hàng (thứ nguyên 0), mà trừ các cột
(chiều 1). Làm cách nào để trừ một cột số trong mỗi cột bằng $ a?

pdl> $ cols = trình tự(9)
pdl> p $ a-> thông tin => PDL: Double D [11,9]
pdl> p $ cols-> thông tin => PDL: Double D [9]

Đương nhiên, chúng ta không thể chỉ gõ "$ a - $ cols". Kích thước không khớp:

pdl> p $ a - $ cols
PDL: PDL :: Ops :: trừ (a, b, c): Tham số 'b'
PDL: Thứ nguyên luồng ngầm định không khớp 0: phải là 11, là 9

Làm thế nào để chúng tôi nói với PDL rằng chúng tôi muốn trừ thứ nguyên 1 thay thế?

QUẢN LÝ Kích thước

Có nhiều hàm PDL cho phép bạn sắp xếp lại kích thước của mảng PDL. họ đang
chủ yếu được đề cập trong PDL :: Slices. Ba cái phổ biến nhất là:

xchg
mv
sắp xếp lại

Phương pháp: "xchg"
Phương thức "xchg" "trao đổi"hai chiều trong một trò chơi:

pdl> $ a = dãy (6,7,8,9)
pdl> $ a_xchg = $ a-> xchg (0,3)

pdl> p $ a-> thông tin => PDL: Double D [6,7,8,9]
pdl> p $ a_xchg-> thông tin => PDL: Double D [9,7,8,6]
| |
VV
(mờ 0) (mờ 3)

Lưu ý rằng thứ nguyên 0 và 3 đã được trao đổi mà không ảnh hưởng đến các thứ nguyên khác.
Cũng lưu ý rằng "xchg" không thay đổi $ a. Biến $ a ban đầu vẫn không bị ảnh hưởng.

Phương pháp: "mv"
Phương thức "mv" "di chuyển"một chiều, trong một thử thách, thay đổi các chiều khác như
cần thiết.

pdl> $ a = dãy (6,7,8,9) (mờ 0)
pdl> $ a_mv = $ a-> mv (0,3) |
pdl> V _____
pdl> p $ a-> thông tin => PDL: Double D [6,7,8,9]
pdl> p $ a_mv-> thông tin => PDL: Double D [7,8,9,6]
----- |
V
(mờ 3)

Lưu ý rằng khi thứ nguyên 0 được chuyển đến vị trí 3, tất cả các thứ nguyên khác phải
cũng thay đổi. Cũng lưu ý rằng "mv" không thay đổi $ a. Biến ban đầu $ a vẫn còn
không bị đụng chạm.

Phương pháp: "sắp xếp lại"
Phương thức "sắp xếp lại" là tổng quát của phương thức "xchg" và "mv". Nó "sắp xếp lại"
kích thước theo bất kỳ cách nào bạn chỉ định:

pdl> $ a = dãy (6,7,8,9)
pdl> $ a_reorder = $ a-> sắp xếp lại (3,0,2,1)
pdl>
pdl> p $ a-> thông tin => PDL: Double D [6,7,8,9]
pdl> p $ a_reorder-> thông tin => PDL: Double D [9,6,8,7]
| | | |
VV v V
kích thước: 0 1 2 3

Chú ý những gì đã xảy ra. Khi chúng tôi viết "sắp xếp lại (3,0,2,1)", chúng tôi đã hướng dẫn PDL:

* Đặt thứ nguyên 3 trước.
* Đặt thứ nguyên 0 tiếp theo.
* Đặt thứ nguyên 2 tiếp theo.
* Đặt thứ nguyên 1 tiếp theo.

Khi bạn sử dụng phương pháp "sắp xếp lại", tất cả các thứ nguyên sẽ được xáo trộn. Lưu ý rằng "sắp xếp lại"
không làm thay đổi $ a. Biến $ a ban đầu vẫn không bị ảnh hưởng.

CHẮC CHẮN: LIÊN KẾT VS CHUYỂN NHƯỢNG

Liên kết
Theo mặc định, piddles là liên kết bên nhau để các thay đổi trên một sẽ quay trở lại và ảnh hưởng đến
nguyên as cũng.

pdl> $ a = dãy (4,5)
pdl> $ a_xchg = $ a-> xchg (1,0)

Đây, $ a_xchg is không a riêng biệt vật. Nó chỉ là một cách nhìn khác về $ a. Không tí nào
thay đổi trong $ a_xchg cũng sẽ xuất hiện trong $ a.

pdl> p $ a
[
[0 1 2 3]
[4 5 6 7]
[8 9 10 11]
[12 13 14 15]
[16 17 18 19]
]
pdl> $ a_xchg + = 3
pdl> p $ a
[
[3 4 5 6]
[7 8 9 10]
[11 12 13 14]
[15 16 17 18]
[19 20 21 22]
]

Chuyển nhượng
Đôi khi, liên kết không phải là hành vi bạn muốn. Nếu bạn muốn thực hiện các trò chơi
độc lập, sử dụng phương pháp "sao chép":

pdl> $ a = dãy (4,5)
pdl> $ a_xchg = $ a-> copy-> xchg (1,0)

Bây giờ $ a và $ a_xchg là các đối tượng hoàn toàn riêng biệt:

pdl> p $ a
[
[0 1 2 3]
[4 5 6 7]
[8 9 10 11]
[12 13 14 15]
[16 17 18 19]
]
pdl> $ a_xchg + = 3
pdl> p $ a
[
[0 1 2 3]
[4 5 6 7]
[8 9 10 11]
[12 13 14 15]
[16 17 18 19]
]
pdl> $ a_xchg
[
[3 7 11 15 19]
[4 8 12 16 20]
[5 9 13 17 21]
[6 10 14 18 22]
]

ĐẶT IT TẤT CẢ CÁC CÙNG VỚI NHAU

Bây giờ chúng tôi đã sẵn sàng giải quyết vấn đề thúc đẩy toàn bộ cuộc thảo luận này:

pdl> $ a = dãy (11,9)
pdl> $ cols = trình tự(9)
pdl>
pdl> p $ a-> thông tin => PDL: Double D [11,9]
pdl> p $ cols-> thông tin => PDL: Double D [9]

Làm cách nào để yêu cầu PDL trừ $ cols dọc theo thứ nguyên 1 thay vì thứ nguyên 0? Các
cách đơn giản nhất là sử dụng phương pháp "xchg" và dựa vào liên kết PDL:

pdl> p $ a
[
[0 1 2 3 4 5 6 7 8 9 10]
[11 12 13 14 15 16 17 18 19 20 21]
[22 23 24 25 26 27 28 29 30 31 32]
[33 34 35 36 37 38 39 40 41 42 43]
[44 45 46 47 48 49 50 51 52 53 54]
[55 56 57 58 59 60 61 62 63 64 65]
[66 67 68 69 70 71 72 73 74 75 76]
[77 78 79 80 81 82 83 84 85 86 87]
[88 89 90 91 92 93 94 95 96 97 98]
]
pdl> $ a-> xchg (1,0) - = $ cols
pdl> p $ a
[
[0 1 2 3 4 5 6 7 8 9 10]
[10 11 12 13 14 15 16 17 18 19 20]
[20 21 22 23 24 25 26 27 28 29 30]
[30 31 32 33 34 35 36 37 38 39 40]
[40 41 42 43 44 45 46 47 48 49 50]
[50 51 52 53 54 55 56 57 58 59 60]
[60 61 62 63 64 65 66 67 68 69 70]
[70 71 72 73 74 75 76 77 78 79 80]
[80 81 82 83 84 85 86 87 88 89 90]
]

Chiến lược chung:
Di chuyển các thứ nguyên bạn muốn hoạt động sang phần đầu của thứ nguyên piddle của bạn
danh sách. Sau đó, hãy để PDL phân luồng qua các kích thước cao hơn.

THÍ DỤ: CÓ THỂ CỦA TRÒ CHƠI OF ĐỜI SỐNG

Được rồi, đủ lý thuyết. Hãy làm điều gì đó thú vị hơn một chút: Chúng tôi sẽ viết Conway's Trò chơi
of Cuộc sống trong PDL và xem PDL có thể mạnh mẽ như thế nào!

Sản phẩm Trò chơi of Cuộc sống là một mô phỏng chạy trên một lưới hai chiều lớn. Mỗi ô trong lưới
có thể còn sống hoặc đã chết (biểu thị bằng 1 hoặc 0). Thế hệ tiếp theo của các tế bào trong
lưới được tính toán với các quy tắc đơn giản theo số lượng tế bào sống trong nó
vùng lân cận ngay lập tức:

1) Nếu một ô trống có đúng ba ô lân cận, một ô sống được tạo ra.

2) Nếu một tế bào sống có ít hơn hai người hàng xóm, nó sẽ chết vì cho ăn quá nhiều.

3) Nếu một ô sống có 4 người hàng xóm trở lên, nó sẽ chết vì đói.

Chỉ thế hệ ô đầu tiên được xác định bởi lập trình viên. Sau đó,
mô phỏng chạy hoàn toàn theo các quy tắc này. Để tính toán thế hệ tiếp theo, bạn
cần xem xét từng ô trong trường 2D (yêu cầu hai vòng lặp), tính số
ô sống liền kề với ô này (yêu cầu hai vòng lặp khác) và sau đó điền vào ô tiếp theo
lưới phát điện.

Cổ điển thực hiện
Đây là một cách cổ điển để viết chương trình này trong Perl. Chúng tôi chỉ sử dụng PDL để giải quyết
các ô riêng lẻ.

#!/ usr / bin / perl -w
sử dụng PDL;
sử dụng PDL :: NiceSlice;

# Làm một bàn cờ cho trò chơi của cuộc sống.
$ nx = 20 của tôi;
$ ny = 20 của tôi;

# Thế hệ hiện tại.
my $ a = zeroes ($ nx, $ ny);

# Thế hệ kế tiếp.
my $ n = zeroes ($ nx, $ ny);

# Đặt trong một tàu lượn đơn giản.
$ a (1: 3,1: 3). = pdl ([1,1,1],
[0,0,1],
[0,1,0]);

cho ($ i = 0 của tôi; $ i <100; $ i ++) {
$ n = số XNUMX ($ nx, $ ny);
$ new_a = $ a-> sao chép;
cho ($ x = 0; $ x <$ nx; $ x ++) {
for ($ y = 0; $ y <$ ny; $ y ++) {

# Đối với mỗi ô, hãy nhìn những người hàng xóm xung quanh.
cho ($ dx = -1; $ dx <= 1; $ dx ++) {
for ($ dy = -1; $ dy <= 1; $ dy ++) {
$ px = $ x + $ dx;
$ py = $ y + $ dy;

# Quấn xung quanh ở các cạnh.
if ($ px <0) {$ px = $ nx-1};
if ($ py <0) {$ py = $ ny-1};
if ($ px> = $ nx) {$ px = 0};
if ($ py> = $ ny) {$ py = 0};

$ n ($ x, $ y). = $ n ($ x, $ y) + $ a ($ px, $ py);
}
}
# Không đếm chính ô trung tâm.
$ n ($ x, $ y) - = $ a ($ x, $ y);

# Tìm hiểu xem tế bào sống hay chết:
# Tế bào chết sống nếu n = 3
# Tế bào sống sẽ chết nếu n không phải là 2 hoặc 3
if ($ a ($ x, $ y) == 1) {
if ($ n ($ x, $ y) <2) {$ new_a ($ x, $ y). = 0};
if ($ n ($ x, $ y)> 3) {$ new_a ($ x, $ y). = 0};
} Else {
if ($ n ($ x, $ y) == 3) {$ new_a ($ x, $ y). = 1}
}
}
}

in $ a;

$ a = $ new_a;
}

Nếu bạn chạy điều này, bạn sẽ thấy một tàu lượn nhỏ bò theo đường chéo trên lưới các số XNUMX.
Trên máy của tôi, nó in ra một vài thế hệ mỗi giây.

Có ren PDL thực hiện
Và đây là phiên bản phân luồng trong PDL. Chỉ bốn dòng mã PDL và một trong số đó là
in ra thế hệ mới nhất!

#!/ usr / bin / perl -w
sử dụng PDL;
sử dụng PDL :: NiceSlice;

của tôi $ a = số 20,20 (XNUMX);

# Đặt trong một tàu lượn đơn giản.
$ a (1: 3,1: 3). = pdl ([1,1,1],
[0,0,1],
[0,1,0]);

$ n của tôi;
cho ($ i = 0 của tôi; $ i <100; $ i ++) {
# Tính số hàng xóm trên mỗi ô.
$ n = $ a-> range (ndcoords ($ a) -1,3, "tuần hoàn") -> sắp xếp lại (2,3,0,1);
$ n = $ n-> sumover-> sumover - $ a;

# Tính thế hệ tiếp theo.
$ a = ((($ n == 2) + ($ n == 3)) * $ a) + (($ n == 3) *! $ a);

in $ a;
}

Phiên bản PDL phân luồng nhanh hơn nhiều:

Cổ điển => 32.79 giây.
Đã phân luồng => 0.41 giây.

Giải thích
Phiên bản luồng hoạt động như thế nào?

Có nhiều chức năng PDL được thiết kế để giúp bạn thực hiện phân luồng PDL. Trong này
ví dụ, các chức năng chính là:

Phương pháp: "phạm vi"

Ở cấp độ đơn giản nhất, phương pháp "phạm vi" là một cách khác để chọn một phần của
chăm. Thay vì sử dụng ký hiệu "$ a (2,3)", chúng tôi sử dụng một câu đố khác.

pdl> $ a = dãy (6,7)
pdl> p $ a
[
[0 1 2 3 4 5]
[6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]
[24 25 26 27 28 29]
[30 31 32 33 34 35]
[36 37 38 39 40 41]
]
pdl> p $ a-> dải ô (pdl [1,2])
13
pdl> p $ a (1,2)
[
[13]
]

Tại thời điểm này, phương thức "phạm vi" trông rất giống với một lát PDL thông thường. Nhưng
phương pháp "phạm vi" là tổng quát hơn. Ví dụ: bạn có thể chọn một số thành phần cùng một lúc:

pdl> $ index = pdl [[1,2], [2,3], [3,4], [4,5]]
pdl> p $ a-> dải ($ index)
[13 20 27 34]

Ngoài ra, "phạm vi" có tham số thứ hai xác định kích thước của đoạn thành
trở về:

pdl> $ size = 3
pdl> p $ a-> dải (pdl ([1,2]), $ size)
[
[13 14 15]
[19 20 21]
[25 26 27]
]

Chúng ta có thể sử dụng điều này để chọn một hoặc nhiều hộp 3x3.

Cuối cùng, "phạm vi" có thể nhận tham số thứ ba được gọi là điều kiện "biên". Nó nói với PDL
phải làm gì nếu hộp kích thước bạn yêu cầu vượt ra ngoài rìa của trò chơi. Chúng tôi sẽ không đi
trên tất cả các tùy chọn. Chúng tôi chỉ nói rằng tùy chọn "định kỳ" có nghĩa là
"bao bọc xung quanh". Ví dụ:

pdl> p $ a
[
[0 1 2 3 4 5]
[6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]
[24 25 26 27 28 29]
[30 31 32 33 34 35]
[36 37 38 39 40 41]
]
pdl> $ size = 3
pdl> p $ a-> range (pdl ([4,2]), $ size, "tuần hoàn")
[
[16 17 12]
[22 23 18]
[28 29 24]
]
pdl> p $ a-> range (pdl ([5,2]), $ size, "tuần hoàn")
[
[17 12 13]
[23 18 19]
[29 24 25]
]

Chú ý cách hộp bao quanh ranh giới của trò chơi.

Phương pháp: "ndcoords"

Phương thức "ndcoords" là một phương thức tiện lợi trả về một danh sách
tọa độ phù hợp để sử dụng với phương pháp "phạm vi".

pdl> p $ piddle = dãy (3,3)
[
[0 1 2]
[3 4 5]
[6 7 8]
]
pdl> p ndcoords ($ piddle)
[
[
[0 0]
[1 0]
[2 0]
]
[
[0 1]
[1 1]
[2 1]
]
[
[0 2]
[1 2]
[2 2]
]
]

Điều này có thể hơi khó đọc. Về cơ bản, nó nói rằng tọa độ cho mọi
phần tử trong $ piddle được cung cấp bởi:

(0,0) (1,0) (2,0)
(1,0) (1,1) (2,1)
(2,0) (2,1) (2,2)

Kết hợp "phạm vi" và "ndcoords"

Điều thực sự quan trọng là "ndcoords" được thiết kế để hoạt động cùng với "phạm vi", không có
tham số $ size, bạn sẽ lấy lại được cùng một khó khăn.

pdl> p $ piddle
[
[0 1 2]
[3 4 5]
[6 7 8]
]
pdl> p $ piddle-> range (ndcoords ($ piddle))
[
[0 1 2]
[3 4 5]
[6 7 8]
]

Tại sao điều này sẽ hữu ích? Bởi vì bây giờ chúng ta có thể yêu cầu một loạt các "hộp" cho toàn bộ
chăm. Ví dụ: hộp 2x2:

pdl> p $ piddle-> dải (ndcoords ($ piddle), 2, "định kỳ")

Đầu ra của hàm này khó đọc vì các "hộp" dọc theo hai phần cuối cùng
kích thước. Chúng tôi có thể làm cho kết quả dễ đọc hơn bằng cách sắp xếp lại các kích thước:

pdl> p $ piddle-> range (ndcoords ($ piddle), 2, "định kỳ") -> sắp xếp lại (2,3,0,1)
[
[
[
[0 1]
[3 4]
]
[
[1 2]
[4 5]
]
...
]

Qua đây bạn có thể thấy rõ hơn rằng

[0 1]
[3 4]

Hộp 2x2 có bắt đầu bằng phần tử (0,0) của $ piddle không.

Chúng tôi vẫn chưa xong. Đối với trò chơi của cuộc sống, chúng tôi muốn các hộp 3x3 từ $ a:

pdl> p $ a
[
[0 1 2 3 4 5]
[6 7 8 9 10 11]
[12 13 14 15 16 17]
[18 19 20 21 22 23]
[24 25 26 27 28 29]
[30 31 32 33 34 35]
[36 37 38 39 40 41]
]
pdl> p $ a-> range (ndcoords ($ a), 3, "định kỳ") -> sắp xếp lại (2,3,0,1)
[
[
[
[0 1 2]
[6 7 8]
[12 13 14]
]
...
]

Chúng tôi có thể xác nhận rằng đây là hộp 3x3 bắt đầu bằng phần tử (0,0) của $ a. Nhưng ở đó
là một vấn đề. Chúng tôi thực sự muốn hộp 3x3 là trung tâm trên (0,0). Đó không phải là một
vấn đề. Chỉ cần trừ 1 từ tất cả các tọa độ trong "ndcoords ($ a)". Hãy nhớ rằng
tùy chọn "định kỳ" đảm bảo việc làm cho mọi thứ quấn quanh.

pdl> p $ a-> range (ndcoords ($ a) - 1, 3, "tuần hoàn") -> sắp xếp lại (2,3,0,1)
[
[
[
[41 36 37]
[5 0 1]
[11 6 7]
]
[
[36 37 38]
[0 1 2]
[6 7 8]
]
...

Bây giờ chúng ta thấy một hộp 3x3 với phần tử (0,0) ở giữa hộp.

Phương pháp: "sumover"

Phương thức "sumover" chỉ thêm vào thứ nguyên đầu tiên. Nếu chúng tôi áp dụng nó hai lần, chúng tôi sẽ
cộng tất cả các phần tử của mỗi hộp 3x3.

pdl> $ n = $ a-> range (ndcoords ($ a) -1,3, "tuần hoàn") -> sắp xếp lại (2,3,0,1)
pdl> p $ n
[
[
[
[41 36 37]
[5 0 1]
[11 6 7]
]
[
[36 37 38]
[0 1 2]
[6 7 8]
]
...
pdl> p $ n-> sumover-> sumover
[
[144 135 144 153 162 153]
[72 63 72 81 90 81]
[126 117 126 135 144 135]
[180 171 180 189 198 189]
[234 225 234 243 252 243]
[288 279 288 297 306 297]
[216 207 216 225 234 225]
]

Sử dụng máy tính để xác nhận rằng 144 là tổng của tất cả các phần tử trong hộp 3x3 đầu tiên
và 135 là tổng của tất cả các phần tử trong hộp 3x3 thứ hai.

Đếm hàng xóm

Chúng tôi gần như ở đó!

Cộng tất cả các phần tử trong một hộp 3x3 không khá những gì chúng ta muốn. Chúng tôi không muốn đếm
hộp trung tâm. May mắn thay, đây là một sửa chữa dễ dàng:

pdl> p $ n-> sumover-> sumover - $ a
[
[144 134 142 150 158 148]
[66 56 64 72 80 70]
[114 104 112 120 128 118]
[162 152 160 168 176 166]
[210 200 208 216 224 214]
[258 248 256 264 272 262]
[180 170 178 186 194 184]
]

Khi được áp dụng cho Trò chơi cuộc sống của Conway, điều này sẽ cho chúng ta biết mỗi người hàng xóm còn sống
ô có:

pdl> $ a = số 10,10 (XNUMX)
pdl> $ a (1: 3,1: 3). = pdl ([1,1,1],
.. (> [0,0,1],
.. (> [0,1,0])
pdl> p $ a
[
[0 0 0 0 0 0 0 0 0 0]
[0 1 1 1 0 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
]
pdl> $ n = $ a-> range (ndcoords ($ a) -1,3, "tuần hoàn") -> sắp xếp lại (2,3,0,1)
pdl> $ n = $ n-> sumover-> sumover - $ a
pdl> p $ n
[
[1 2 3 2 1 0 0 0 0 0]
[1 1 3 2 2 0 0 0 0 0]
[1 3 5 3 2 0 0 0 0 0]
[0 1 1 2 1 0 0 0 0 0]
[0 1 1 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
]

Ví dụ, điều này cho chúng ta biết rằng ô (0,0) có 1 người hàng xóm còn sống, trong khi ô (2,2) có 5
hàng xóm sống.

Tính các tiếp theo thế hệ

Tại thời điểm này, biến $ n có số lượng hàng xóm còn sống cho mỗi ô. Bây giờ chúng ta
áp dụng quy luật trò chơi của cuộc sống để tính toán thế hệ sau.

Nếu một ô trống có đúng ba ô lân cận, một ô sống sẽ được tạo.
Nhận danh sách các ô có chính xác ba ô lân cận:

pdl> p ($ n == 3)
[
[0 0 1 0 0 0 0 0 0 0]
[0 0 1 0 0 0 0 0 0 0]
[0 1 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
]

Nhận danh sách trống các ô có chính xác ba hàng xóm:

pdl> p ($ n == 3) *! $ a

Nếu một ô sống có ít hơn 2 hoặc nhiều hơn 3 người hàng xóm, nó sẽ chết.
Nhận danh sách các ô có chính xác 2 hoặc 3 hàng xóm:

pdl> p (($ n == 2) + ($ n == 3))
[
[0 1 1 1 0 0 0 0 0 0]
[0 0 1 1 1 0 0 0 0 0]
[0 1 0 1 1 0 0 0 0 0]
[0 0 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
]

Nhận danh sách sống các ô có chính xác 2 hoặc 3 hàng xóm:

pdl> p (($ n == 2) + ($ n == 3)) * $ a

Kết hợp tất cả lại với nhau, thế hệ tiếp theo là:

pdl> $ a = ((($ n == 2) + ($ n == 3)) * $ a) + (($ n == 3) *! $ a)
pdl> p $ a
[
[0 0 1 0 0 0 0 0 0 0]
[0 0 1 1 0 0 0 0 0 0]
[0 1 0 1 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
[0 0 0 0 0 0 0 0 0 0]
]

Thêm các lợi ích tính năng: Đồ họa!
Nếu bạn đã cài đặt PDL :: Graphics :: TriD, bạn có thể tạo phiên bản đồ họa của chương trình
chỉ bằng cách thay đổi ba dòng:

#!/ usr / bin / perl
sử dụng PDL;
sử dụng PDL :: NiceSlice;
sử dụng PDL :: Graphics :: TriD;

của tôi $ a = số 20,20 (XNUMX);

# Đặt trong một tàu lượn đơn giản.
$ a (1: 3,1: 3). = pdl ([1,1,1],
[0,0,1],
[0,1,0]);

$ n của tôi;
cho ($ i = 0 của tôi; $ i <100; $ i ++) {
# Tính số hàng xóm trên mỗi ô.
$ n = $ a-> range (ndcoords ($ a) -1,3, "tuần hoàn") -> sắp xếp lại (2,3,0,1);
$ n = $ n-> sumover-> sumover - $ a;

# Tính thế hệ tiếp theo.
$ a = ((($ n == 2) + ($ n == 3)) * $ a) + (($ n == 3) *! $ a);

# Trưng bày.
nokeeptwiddling3d ();
imagergb [$ a];
}

Nhưng nếu chúng ta thực sự muốn thấy điều gì đó thú vị, chúng ta nên thực hiện thêm một số thay đổi:

1) Bắt đầu với một tập hợp ngẫu nhiên của 1 và 0.

2) Làm cho lưới lớn hơn.

3) Thêm một khoảng thời gian chờ nhỏ để chúng ta có thể thấy trò chơi phát triển tốt hơn.

4) Sử dụng vòng lặp while để chương trình có thể chạy bao lâu nó cần.

#!/ usr / bin / perl
sử dụng PDL;
sử dụng PDL :: NiceSlice;
sử dụng PDL :: Graphics :: TriD;
sử dụng Thời gian :: HiRes qw (usleep);

my $ a = random (100,100);
$ a = ($ a <0.5);

$ n của tôi;
trong khi (1) {
# Tính số hàng xóm trên mỗi ô.
$ n = $ a-> range (ndcoords ($ a) -1,3, "tuần hoàn") -> sắp xếp lại (2,3,0,1);
$ n = $ n-> sumover-> sumover - $ a;

# Tính thế hệ tiếp theo.
$ a = ((($ n == 2) + ($ n == 3)) * $ a) + (($ n == 3) *! $ a);

# Trưng bày.
nokeeptwiddling3d ();
imagergb [$ a];

# Ngủ trong 0.1 giây.
bạn ngủ(100000);
}

Kết luận: CÁC VẤN ĐỀ CHUNG CHIẾN LƯỢC

Chiến lược chung là: Di chuyển các kích thước bạn muốn đến hoạt động on đến các Bắt đầu of qua một vài thao tác đơn giản về
piddle's kích thước danh sách. Sau đó cho phép PDL Chủ đề kết thúc các cao hơn kích thước.

Phân luồng là một công cụ mạnh mẽ giúp loại bỏ vòng lặp for và có thể làm cho mã của bạn nhiều hơn
ngắn gọn. Hy vọng rằng hướng dẫn này đã cho thấy lý do tại sao nó đáng để nắm bắt với luồng
trong PDL.

BẢN QUYỀN

Bản quyền 2010 Matthew Kenworthy ([email được bảo vệ]) và Daniel Carrera
([email được bảo vệ]). Bạn có thể phân phối và / hoặc sửa đổi tài liệu này theo các điều khoản tương tự
như giấy phép Perl hiện tại.

Xem: http://dev.perl.org/licenses/

Sử dụng PDL :: Threadingp trực tuyến bằng các dịch vụ onworks.net