PDL::Indexingp - ອອນລາຍໃນຄລາວ

ໂຄງການ:

NAME

PDL::Indexing - ການແນະນຳການສ້າງດັດສະນີ ແລະການຕັດຊິ້ນສ່ວນ piddles.

ພາບລວມ

ຫນ້າຜູ້ຊາຍນີ້ຄວນຈະເຮັດຫນ້າທີ່ເປັນ tutorial ທໍາອິດກ່ຽວກັບການດັດສະນີແລະລັກສະນະ threading ຂອງ
PDL.

ເຊັ່ນດຽວກັນກັບພາສາ vectorized ທັງຫມົດ, PDL ອັດຕະໂນມັດ looping over arrays ໂດຍໃຊ້ variant ຂອງ
notation vector ຄະນິດສາດ. ການ looping ອັດຕະໂນມັດແມ່ນເອີ້ນວ່າ "threading", ໃນບາງສ່ວນ
ເນື່ອງຈາກວ່າໃນທີ່ສຸດ PDL ຈະປະຕິບັດການປຸງແຕ່ງຂະຫນານເພື່ອເລັ່ງ loops.

ຄວາມຍືດຫຍຸ່ນແລະພະລັງງານຫຼາຍຂອງ PDL ຂຶ້ນກັບລັກສະນະດັດສະນີແລະກະທູ້ຂອງ
ການຂະຫຍາຍ Perl. ດັດສະນີອະນຸຍາດໃຫ້ເຂົ້າເຖິງຂໍ້ມູນຂອງ piddle ທີ່ມີຄວາມຍືດຫຍຸ່ນຫຼາຍ
ທາງ. Threading ສະຫນອງ vectorization ປະສິດທິພາບຂອງການດໍາເນີນງານງ່າຍດາຍ.

ຄ່າຂອງ piddle ຖືກເກັບຮັກສາໄວ້ຢ່າງແຫນ້ນຫນາເປັນຄ່າທີ່ພິມຢູ່ໃນຫນ່ວຍຄວາມຈໍາດຽວ,
ບໍ່ແມ່ນ (ໃນບັນຊີລາຍການ Perl ປົກກະຕິ) ເປັນແຕ່ລະ Perl scalar.

ໃນພາກສ່ວນທີ່ປະຕິບັດຕາມ "ວິທີການ" ຈໍານວນຫຼາຍຖືກເອີ້ນອອກ - ເຫຼົ່ານີ້ແມ່ນຕົວປະຕິບັດການ Perl ທີ່
ນຳໃຊ້ກັບ PDLs. ຈາກ perldl (ຫຼື pdl2) shell, ທ່ານສາມາດຊອກຫາເພີ່ມເຕີມກ່ຽວກັບແຕ່ລະວິທີການ
ໂດຍການພິມ "?" ຕິດຕາມດ້ວຍຊື່ວິທີການ.

ຂະຫນາດ ລາຍການ
piddle (ຕົວແປ PDL), ໂດຍທົ່ວໄປ, ແມ່ນ N-dimensional array ທີ່ N ສາມາດເປັນ 0 (ສໍາລັບ a
scalar), 1 (ຕົວຢ່າງສໍາລັບຕົວຢ່າງສຽງ), ຫຼືຄ່າທີ່ສູງກວ່າສໍາລັບຮູບພາບແລະສະລັບສັບຊ້ອນຫຼາຍ
ໂຄງສ້າງ. ແຕ່ລະມິຕິຂອງ piddle ມີຂະຫນາດຈໍານວນບວກ. "perl"
ນາຍພາສາປະຕິບັດຕໍ່ແຕ່ລະ piddle ເປັນປະເພດພິເສດຂອງ Perl scalar (ວັດຖຸ Perl ທີ່ໄດ້ຮັບພອນ,
ຕົວຈິງແລ້ວ - ແຕ່ທ່ານບໍ່ຈໍາເປັນຕ້ອງຮູ້ວ່າຈະໃຊ້ພວກມັນ) ທີ່ສາມາດຖືກນໍາໃຊ້ທຸກບ່ອນທີ່ທ່ານສາມາດເຮັດໄດ້
ເອົາ scalar ປົກກະຕິ.

ທ່ານສາມາດເຂົ້າເຖິງຂະຫນາດຂອງ piddle ເປັນບັນຊີລາຍຊື່ Perl ແລະຖ້າບໍ່ດັ່ງນັ້ນກໍານົດຂະຫນາດ
ຂອງ piddle ທີ່​ມີ​ຫຼາຍ​ວິ​ທີ​ການ​. ສິ່ງທີ່ສໍາຄັນແມ່ນ:

nelem - ຈຳນວນອົງປະກອບທັງໝົດໃນ PDL
ndims - ຕອບຈໍານວນຂະຫນາດໃນ PDL
dims - ສົ່ງຄືນລາຍການມິຕິຂອງ PDL ເປັນລາຍຊື່ Perl
dim - ຕອບຂະໜາດຂອງມິຕິສະເພາະຂອງ PDL

Indexing ແລະ ກະແສຂໍ້ມູນ
PDL ຮັກສາແນວຄິດຂອງ "ການໄຫລຂອງຂໍ້ມູນ" ລະຫວ່າງ piddle ແລະ indexed subfields ຂອງນັ້ນ
ປິວ. ເມື່ອທ່ານຜະລິດ indexed subfield ຫຼືອົງປະກອບດຽວຂອງ piddle ພໍ່ແມ່, ໄດ້
ເດັກ ແລະ ພໍ່ແມ່ຍັງຄົງຕິດຢູ່ຈົນກວ່າເຈົ້າຈະຕັດການເຊື່ອມຕໍ່ເຂົາເຈົ້າເອງ. ນີ້ເຮັດໃຫ້ທ່ານ
ເປັນຕົວແທນຂອງຂໍ້ມູນດຽວກັນວິທີການທີ່ແຕກຕ່າງກັນພາຍໃນລະຫັດຂອງທ່ານ - ຕົວຢ່າງ, ທ່ານສາມາດພິຈາລະນາ
ຮູບພາບ RGB ພ້ອມກັນເປັນຊຸດຂອງຄ່າ (R,G,B) ໃນຮູບ 3 x 1000 x 1000,
ແລະເປັນສາມແຍກ 1000 x 1000 ຍົນສີເກັບຮັກສາໄວ້ໃນຕົວແປທີ່ແຕກຕ່າງກັນ. ການປັບປຸງ
ຕົວແປໃດໆທີ່ປ່ຽນແປງຄວາມຊົງຈໍາທີ່ຕິດພັນ, ແລະການປ່ຽນແປງແມ່ນສະທ້ອນໃຫ້ເຫັນໃນທັງຫມົດ
ການເປັນຕົວແທນຂອງຂໍ້ມູນ.

ມີສອງວິທີທີ່ສໍາຄັນທີ່ຊ່ວຍໃຫ້ທ່ານສາມາດຄວບຄຸມການເຊື່ອມຕໍ່ dataflow ລະຫວ່າງເດັກນ້ອຍ
ແລະ PDL ຂອງພໍ່ແມ່:

ສຳເນົາ - ບັງຄັບໃຫ້ສຳເນົາ PDL ຢ່າງຈະແຈ້ງ
sever - ທໍາລາຍການເຊື່ອມຕໍ່ຂໍ້ມູນລະຫວ່າງ PDL ກັບພໍ່ແມ່ຂອງມັນ (ຖ້າມີ)

ກະທູ້ ແລະ ຂະຫນາດ ຄໍາ​ສັ່ງ
ການດໍາເນີນງານ PDL ສ່ວນໃຫຍ່ປະຕິບັດຢູ່ໃນຂະຫນາດຈໍານວນຫນ້ອຍທໍາອິດຂອງການໂຕ້ຖຽງ piddle ຂອງພວກເຂົາ. ສໍາລັບ
ຕົວຢ່າງ, "sumover" sums ອົງປະກອບທັງຫມົດຕາມມິຕິທໍາອິດໃນບັນຊີລາຍຊື່ (ມິຕິ 0).
ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ອາ​ຫານ​ໃນ piddle ສາມ​ມິ​ຕິ​ລະ​ດັບ​, ຫຼັງ​ຈາກ​ນັ້ນ​ມິ​ຕິ​ທໍາ​ອິດ​ແມ່ນ​ພິ​ຈາ​ລະ​ນາ​ໄດ້​
ມິຕິ "ການເຄື່ອນໄຫວ" ແລະຂະຫນາດຕໍ່ມາແມ່ນຂະຫນາດ "ກະທູ້" ເພາະວ່າພວກເຂົາແມ່ນ
ພຽງແຕ່ looped ຫຼາຍກວ່າ. ມີ​ຫຼາຍ​ວິ​ທີ​ທີ່​ຈະ transpose ຫຼື Re​-order ບັນ​ຊີ​ລາຍ​ການ​ມິ​ຕິ​ຂອງ​ແມ່ນ​
PDL. ເຕັກນິກເຫຼົ່ານັ້ນແມ່ນໄວຫຼາຍນັບຕັ້ງແຕ່ພວກເຂົາບໍ່ໄດ້ແຕະຕ້ອງຂໍ້ມູນພື້ນຖານ, ເທົ່ານັ້ນ
ປ່ຽນວິທີທີ່ PDL ເຂົ້າເຖິງຂໍ້ມູນ. ຫນ້າທີ່ຄໍາສັ່ງຂະຫນາດຕົ້ນຕໍແມ່ນ:

mv - ຍ້າຍມິຕິໃດໜຶ່ງໄປບ່ອນອື່ນໃນລາຍການມິຕິ
xchg - ແລກປ່ຽນສອງມິຕິໃນບັນຊີລາຍຊື່ມິຕິ, ປ່ອຍໃຫ້ສ່ວນທີ່ເຫຼືອຢູ່ຄົນດຽວ
reorder - ອະ​ນຸ​ຍາດ​ໃຫ້​ການ​ຜະ​ສົມ​ຜະ​ລິດ​ຕະ​ພັນ​ຂະ​ຫນາດ​
clump - clumps ເຂົ້າ​ກັນ​ສອງ​ຂະ​ຫນາດ​ນ້ອຍ​ຫຼື​ຫຼາຍ​ກວ່າ​ເປັນ​ຫນຶ່ງ​ຂະ​ຫນາດ​ໃຫຍ່​ກວ່າ​
ບີບ - ກໍາຈັດຂະຫນາດໃດໆຂອງຂະຫນາດ 1

ທາງດ້ານຮ່າງກາຍ ແລະ dummy ຂະຫນາດ
· ເອກະສານລະດັບ Perl threading

· threadids

·ປັບປຸງແລະລາຍລະອຽດທີ່ຖືກຕ້ອງຂອງ slice

·ຟັງຊັນໃຫມ່ໃນ slice.pd (affine, lag, splitdim)

· reworking ຂອງວັກກ່ຽວກັບການ threading explicit

Indexing ແລະ ກະທູ້ ກັບ PDL

ຄວາມຍືດຫຍຸ່ນແລະພະລັງງານຫຼາຍຂອງ PDL ແມ່ນອີງໃສ່ການດັດສະນີແລະລັກສະນະຂອງການ looping ຂອງ
ການຂະຫຍາຍ Perl. ດັດສະນີອະນຸຍາດໃຫ້ເຂົ້າເຖິງຂໍ້ມູນຂອງວັດຖຸ pdl ທີ່ມີຄວາມຍືດຫຍຸ່ນຫຼາຍ
ທາງ. Threading ສະຫນອງການທໍາງານຂອງ looping implicit ປະສິດທິພາບ (ນັບຕັ້ງແຕ່ loops ແມ່ນ
ປະຕິບັດເປັນລະຫັດ C ທີ່ດີທີ່ສຸດ).

ວັດຖຸ Pdl (ຕໍ່ມາເອີ້ນວ່າ "pdls") ແມ່ນວັດຖຸ Perl ທີ່ເປັນຕົວແທນຫຼາຍມິຕິ
arrays ແລະການດໍາເນີນງານກ່ຽວກັບສິ່ງເຫຼົ່ານັ້ນ. ກົງກັນຂ້າມກັບແບບ Perl @x ແບບງ່າຍດາຍລາຍຊື່ຂໍ້ມູນ array
ຖືກເກັບຮັກສາໄວ້ຢ່າງແຫນ້ນຫນາຢູ່ໃນຕັນດຽວຂອງຫນ່ວຍຄວາມຈໍາດັ່ງນັ້ນຈຶ່ງໃຊ້ເວລາເຖິງຄວາມຈໍາຫນ້ອຍຫຼາຍແລະ
ເຮັດໃຫ້ການນໍາໃຊ້ລະຫັດ C ໄວເພື່ອປະຕິບັດການດໍາເນີນການ (ເຊັ່ນການເພີ່ມເຕີມ, ແລະອື່ນໆ) ໃນ pdls.

pdls ສາມາດເຮັດໄດ້ ມີ ເດັກນ້ອຍ
ສູນກາງຂອງຄວາມສາມາດດັດສະນີຫຼາຍຂອງ PDL ແມ່ນຄວາມສໍາພັນຂອງ "ພໍ່ແມ່" ແລະ
"ເດັກນ້ອຍ" ລະຫວ່າງ pdls. ຫຼາຍຄໍາສັ່ງດັດສະນີສ້າງ pdl ໃຫມ່ຈາກ pdl ທີ່ມີຢູ່ແລ້ວ.
pdl ໃຫມ່ແມ່ນ "ລູກ" ແລະຄົນເກົ່າແມ່ນ "ພໍ່ແມ່". ຂໍ້ມູນຂອງ pdl ໃຫມ່ແມ່ນ
ກໍາ​ນົດ​ໂດຍ​ການ​ຫັນ​ເປັນ​ທີ່​ລະ​ບຸ​ວິ​ທີ​ການ​ສ້າງ (ຄອມ​ພິວ​ເຕີ​) ຂໍ້​ມູນ​ຂອງ​ຕົນ​ຈາກ​
ຂໍ້ມູນຂອງພໍ່ແມ່. ຄວາມສໍາພັນລະຫວ່າງ pdl ຂອງເດັກແລະພໍ່ແມ່ຂອງມັນມັກຈະເປັນສອງທິດທາງ,
ຊຶ່ງຫມາຍຄວາມວ່າການປ່ຽນແປງຂອງຂໍ້ມູນຂອງເດັກຈະຖືກຂະຫຍາຍພັນກັບພໍ່ແມ່. (ໝາຍເຫດ: ເຈົ້າ
ເບິ່ງ, ພວກເຮົາກໍາລັງມຸ່ງເປົ້າຫມາຍໃນຄໍາສັບຂອງພວກເຮົາໄປສູ່ລັກສະນະການໄຫລຂອງຂໍ້ມູນໃຫມ່. ປະເພດ
ຂອງ dataflow ທີ່ຖືກນໍາໃຊ້ໂດຍຄໍາສັ່ງດັດສະນີ (ກ່ຽວກັບທີ່ທ່ານຈະຮຽນຮູ້ໃນນາທີ)
ສະເຫມີຢູ່ໃນການດໍາເນີນງານ, ບໍ່ພຽງແຕ່ໃນເວລາທີ່ທ່ານໄດ້ປ່ຽນຢ່າງຈະແຈ້ງກ່ຽວກັບ dataflow ໃນ pdl ຂອງທ່ານ
ໂດຍເວົ້າວ່າ "$a->doflow". ສໍາລັບຂໍ້ມູນເພີ່ມເຕີມກ່ຽວກັບການໄຫຼຂອງຂໍ້ມູນ, ໃຫ້ກວດເບິ່ງ manflow data
ຫນ້າ.)

ອີກວິທີຫນຶ່ງທີ່ຈະຕີຄວາມຫມາຍ pdls ທີ່ສ້າງໂດຍຄໍາສັ່ງດັດສະນີຂອງພວກເຮົາແມ່ນເບິ່ງພວກມັນເປັນ a
ປະເພດຂອງຕົວຊີ້ອັດສະລິຍະທີ່ຊີ້ໃຫ້ເຫັນບາງສ່ວນຫຼືຂໍ້ມູນທັງຫມົດຂອງພໍ່ແມ່ຂອງມັນ.
ດັ່ງນັ້ນ, ມັນບໍ່ແປກໃຈວ່າຂໍ້ມູນຂອງພໍ່ແມ່ (ຫຼືສ່ວນຫນຶ່ງຂອງມັນ) ປ່ຽນແປງເມື່ອໃດ
manipulated ຜ່ານ "ຕົວຊີ້". ຫຼັງ​ຈາກ​ຂໍ້​ສັງ​ເກດ​ແນະ​ນໍາ​ເຫຼົ່າ​ນີ້​ທີ່​ຫວັງ​ເປັນ​ຢ່າງ​ຍິ່ງ​
ກຽມ​ຕົວ​ເຈົ້າ​ສຳ​ລັບ​ສິ່ງ​ທີ່​ຈະ​ມາ​ເຖິງ (ແທນ​ທີ່​ຈະ​ເຮັດ​ໃຫ້​ເຈົ້າ​ສັບສົນ​ຫຼາຍ) ເຮົາ​ຈະ​ໄປ​ດຳ​ນ້ຳ
ທັນທີແລະເລີ່ມຕົ້ນດ້ວຍຄໍາອະທິບາຍຂອງຄໍາສັ່ງດັດສະນີແລະບາງຕົວຢ່າງປົກກະຕິ
ວິທີການທີ່ພວກເຂົາອາດຈະຖືກໃຊ້ໃນໂຄງການ PDL. ພວກເຮົາຈະສະແດງຕົວຊີ້ / dataflow ຕື່ມອີກ
ການປຽບທຽບໃນສະພາບການຂອງບາງຕົວຢ່າງຕໍ່ມາ.

ມີສອງການປະຕິບັດທີ່ແຕກຕ່າງກັນຂອງຄວາມສໍາພັນຂອງ "ຕົວຊີ້ smart" ນີ້: ທໍາອິດ
ຫນຶ່ງ, ເຊິ່ງແມ່ນເລັກນ້ອຍຊ້າກວ່າແຕ່ເຮັດວຽກສໍາລັບການຫັນເປັນພຽງແຕ່ເຮັດໄດ້
ການຫັນປ່ຽນໄປໜ້າ ແລະ ຖອຍຫຼັງຕາມຄວາມຈຳເປັນ. ອີກອັນຫນຶ່ງແມ່ນພິຈາລະນາເດັກນ້ອຍ
piddle a ``virtual´ piddle, ເຊິ່ງເກັບຮັກສາພຽງແຕ່ pointer ກັບພໍ່ແມ່ແລະການເຂົ້າເຖິງ
ຂໍ້​ມູນ​ເພື່ອ​ໃຫ້​ກິດ​ຈະ​ກໍາ​ທີ່​ນໍາ​ໃຊ້ piddle ຂອງ​ເດັກ​ໄດ້​ໂດຍ​ກົງ​ເຂົ້າ​ເຖິງ​ຂໍ້​ມູນ​ໄດ້​
ໃນພໍ່ແມ່. ຖ້າ piddle ເສມືນຖືກມອບໃຫ້ເປັນປົກກະຕິທີ່ບໍ່ສາມາດໃຊ້ມັນໄດ້, PDL
ໂປ່ງແສງກາຍຍະພາບຂອງ piddle virtual ກ່ອນທີ່ຈະປ່ອຍໃຫ້ສິ່ງທີ່ເປັນປະຈຳໃຊ້ມັນ.

ໃນປັດຈຸບັນ (1.94_01) ການຫັນປ່ຽນທັງໝົດທີ່ເປັນ ``affine'', ເຊັ່ນ: ດັດຊະນີຂອງຂໍ້ມູນ
ລາຍການໃນ piddle ພໍ່ແມ່ຖືກກໍານົດໂດຍການຫັນເປັນເສັ້ນ (+ ຄົງທີ່) ຈາກ
ຕົວຊີ້ວັດຂອງ piddle ເດັກນ້ອຍເຮັດໃຫ້ piddles virtual. ທຸກໆຕາຕະລາງການດັດສະນີອື່ນໆ (ຕົວຢ່າງ
"->index(...)") ສົ່ງຜົນໃຫ້ມີ piddles ທາງດ້ານຮ່າງກາຍ. ທຸກໆວຽກທີ່ລວບລວມໂດຍ PP ສາມາດຍອມຮັບໄດ້
piddles (ຍົກເວັ້ນການປົກກະຕິເຫຼົ່ານັ້ນທີ່ຜ່ານຕົວຊີ້ໄປຫາຫນ້າທີ່ຫ້ອງສະຫມຸດພາຍນອກ).

ໃຫ້ສັງເກດວ່າບໍ່ວ່າບາງສິ່ງບາງຢ່າງມີຄວາມກ່ຽວຂ້ອງຫຼືບໍ່ບໍ່ມີຜົນຕໍ່ຄວາມຫມາຍຂອງສິ່ງທີ່ທ່ານເຮັດ
ໃນທາງໃດກໍ່ຕາມ: ທັງສອງ

$a->index(...) .= 5;
$a->slice(...) .= 5;

ປ່ຽນຂໍ້ມູນໃນ $a. ແນວໃດກໍ່ຕາມ, ຄວາມໃກ້ຊິດມີຜົນກະທົບຢ່າງຫຼວງຫຼາຍຕໍ່ຄວາມຊົງຈໍາ
ການ​ນໍາ​ໃຊ້​ແລະ​ການ​ປະ​ຕິ​ບັດ​.

ຊິ້ນສ່ວນ pdls
ອາດ​ຈະ​ເປັນ​ການ​ນໍາ​ໃຊ້​ທີ່​ສໍາ​ຄັນ​ທີ່​ສຸດ​ຂອງ​ແນວ​ຄວາມ​ຄິດ​ຂອງ​ພໍ່​ແມ່ / ລູກ pdls ແມ່ນ​
ການເປັນຕົວແທນຂອງຕ່ອນສີ່ຫລ່ຽມຂອງ pdl ທາງດ້ານຮ່າງກາຍໂດຍ pdl virtual. ໄດ້ມີການສົນທະນາ
ຍາວພຽງພໍກ່ຽວກັບແນວຄວາມຄິດໃຫ້ເຮົາໄດ້ສະເພາະຫຼາຍ. ສົມມຸດວ່າພວກເຮົາກໍາລັງເຮັດວຽກກັບ 2D pdl
ເປັນຕົວແທນຂອງຮູບພາບ 5x5 (ມັນມີຂະຫນາດນ້ອຍຜິດປົກກະຕິດັ່ງນັ້ນພວກເຮົາສາມາດພິມມັນໂດຍບໍ່ມີການຕື່ມ
ຫນ້າ​ຈໍ​ຈໍາ​ນວນ​ຫນຶ່ງ​ທີ່​ເຕັມ​ໄປ​ດ້ວຍ​ຕົວ​ເລກ ;).

pdl> $im = ລໍາດັບ(5,5)
pdl> p $im

[
[ 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]
]

pdl> ຊ່ວຍ vars
ຕົວແປ PDL ໃນຊຸດຫຼັກ::

ຊື່ປະເພດ Dimension Flow State Mem
-------------------------------------------------- --------------
$im Double D [5,5] P 0.20Kb

[ໃນທີ່ນີ້ມັນອາດຈະເຫມາະສົມທີ່ຈະເວົ້າຢ່າງໄວວາກ່ຽວກັບຄໍາສັ່ງ "help vars" ທີ່ສະຫນອງ
ຂໍ້ມູນກ່ຽວກັບ pdls ໃນການໂຕ້ຕອບ "perldl" ຫຼື "pdl2" shell ທີ່ມາພ້ອມກັບ PDL. ]

ຕອນນີ້ສົມມຸດວ່າພວກເຮົາຕ້ອງການສ້າງ pdl 1-D ທີ່ພຽງແຕ່ອ້າງອີງເສັ້ນຫນຶ່ງຂອງຮູບພາບ, ເວົ້າ
ເສັ້ນ 2; ຫຼື pdl ທີ່ເປັນຕົວແທນຂອງເສັ້ນຄູ່ຂອງຮູບພາບ (ຈິນຕະນາການທີ່ພວກເຮົາຕ້ອງຈັດການກັບ
ຂອບ ແລະ ຄີກ ຂອງ ຮູບ interlaced ເນື່ອງ ຈາກ ພຶດ ຕິ ກໍາ peculiar ບາງ ຢ່າງ ຂອງ ພາ ຂອງ ພວກ ເຮົາ
grabber). ໃນຖານະເປັນການສະຫມັກເລື້ອຍໆຂອງ slices ອື່ນພວກເຮົາອາດຈະຕ້ອງການທີ່ຈະສ້າງ pdl ວ່າ
ເປັນຕົວແທນຂອງພາກພື້ນສີ່ຫຼ່ຽມມົນຂອງຮູບທີ່ມີດ້ານເທິງແລະລຸ່ມປີ້ນກັບກັນ. ທັງໝົດນີ້
ຜົນ​ກະ​ທົບ (ແລະ​ອື່ນໆ​ຈໍາ​ນວນ​ຫຼາຍ​) ສາ​ມາດ​ບັນ​ລຸ​ໄດ້​ຢ່າງ​ງ່າຍ​ດາຍ​ດ້ວຍ​ການ​ທໍາ​ງານ slice ທີ່​ມີ​ອໍາ​ນາດ​:

pdl> $line = $im->slice(':,(2)')
pdl> $even = $im->slice(':,1:-1:2')
pdl> $area = $im->slice('3:4,3:1')
pdl> ຊ່ວຍ vars # ຫຼືພຽງແຕ່ PDL->vars
ຕົວແປ PDL ໃນຊຸດຫຼັກ::

ຊື່ປະເພດ Dimension Flow State Mem
-------------------------------------------------- --------------
$even Double D [5,2] -C 0.00Kb
$im Double D [5,5] P 0.20Kb
$line Double D [5] -C 0.00Kb
$area Double D [2,3] -C 0.00Kb

ທັງສາມ "ເດັກນ້ອຍ" pdls ແມ່ນເດັກນ້ອຍຂອງ $im ຫຼືໃນອີກອັນຫນຶ່ງ (ທຽບເທົ່າຫຼາຍ)
ການຕີຄວາມໝາຍຊີ້ໄປຫາຂໍ້ມູນຂອງ $im. ການປະຕິບັດໃນການເຂົ້າເຖິງ pdls virtual ເຫຼົ່ານັ້ນເທົ່ານັ້ນ
ພາກສ່ວນເຫຼົ່ານັ້ນຂອງຂໍ້ມູນຕາມທີ່ລະບຸໄວ້ໂດຍການໂຕ້ຖຽງທີ່ຈະຕັດ. ດັ່ງນັ້ນພວກເຮົາສາມາດພິມໄດ້
ແຖວທີ 2:

pdl> p $line
[10 11 12 13 14]

ໃຫ້ສັງເກດຄວາມແຕກຕ່າງໃນ "Flow State" ຂອງ $area ຂ້າງເທິງ ແລະຂ້າງລຸ່ມນີ້:

pdl> p $ ພື້ນທີ່
pdl> ຊ່ວຍ $area
ຕົວແປນີ້ແມ່ນ Double D [2,3] VC 0.00Kb

ຕໍ່ໄປນີ້ສະແດງໃຫ້ເຫັນວ່າ $im ແລະ $line ປະຕິບັດຕົວຈິງຕາມທີ່ເຈົ້າຄາດຫວັງຈາກ a
ວັດຖຸຄ້າຍຄືຕົວຊີ້ (ຫຼືໃນຮູບ dataflow: ການປ່ຽນແປງໃນຂໍ້ມູນຂອງ $line ແມ່ນ
ຂະຫຍາຍພັນກັບ $im):

pdl> $im++
pdl> p $line
[11 12 13 14 15]
pdl> $line += 2
pdl> p $im

[
[ 1 2 3 4 5 ]
[ 6 7 8 9 10 ]
[13 14 15 16 17]
[16 17 18 19 20]
[21 22 23 24 25]
]

ໃຫ້ສັງເກດວິທີການປະຕິບັດການມອບຫມາຍໃນ pdls virtual ຂອງເດັກນ້ອຍປ່ຽນ pdl ທາງດ້ານຮ່າງກາຍຂອງພໍ່ແມ່
ແລະໃນທາງກັບກັນ (ຢ່າງໃດກໍ່ຕາມ, ພື້ນຖານ "=" ມອບຫມາຍບໍ່ໄດ້, ໃຊ້ ".=" ເພື່ອໃຫ້ໄດ້ຜົນກະທົບນັ້ນ.
ເບິ່ງຂ້າງລຸ່ມນີ້ສໍາລັບເຫດຜົນ). pdls ເດັກ virtual ແມ່ນບາງສິ່ງບາງຢ່າງເຊັ່ນ: "ການເຊື່ອມຕໍ່ສົດ" ກັບ
"ຕົ້ນສະບັບ" pdl ພໍ່ແມ່. ດັ່ງທີ່ໄດ້ກ່າວກ່ອນຫນ້ານີ້, ພວກເຂົາສາມາດຄິດວ່າຈະເຮັດວຽກຄ້າຍຄືກັນກັບ a
ຕົວຊີ້ C. ແຕ່ກົງກັນຂ້າມກັບຕົວຊີ້ C, ພວກເຂົາມີຂໍ້ມູນເພີ່ມເຕີມຫຼາຍ. ກ່ອນອື່ນ ໝົດ, ພວກເຂົາ
ລະບຸໂຄງສ້າງຂອງຂໍ້ມູນທີ່ພວກເຂົາເປັນຕົວແທນ (ຂະຫນາດຂອງ pdl ໃຫມ່) ແລະ
ອັນທີສອງ, ກໍານົດວິທີການສ້າງໂຄງສ້າງນີ້ຈາກຂໍ້ມູນພໍ່ແມ່ຂອງມັນ (ວິທີການນີ້ເຮັດວຽກ
ຖືກຝັງຢູ່ໃນພາຍໃນຂອງ PDL ແລະບໍ່ສໍາຄັນສໍາລັບທ່ານທີ່ຈະຮູ້ຢ່າງໃດກໍ່ຕາມ (ເວັ້ນເສຍແຕ່ວ່າທ່ານ
ຕ້ອງການ hack ຫຼັກໃນອະນາຄົດຫຼືຢາກກາຍເປັນ PDL guru ໂດຍທົ່ວໄປ (ສໍາລັບ a
ຄໍານິຍາມຂອງສັດແປກນີ້ເບິ່ງ PDL:: ພາຍໃນ)).

ຕົວຢ່າງທີ່ຜ່ານມາໄດ້ສະແດງໃຫ້ເຫັນເຖິງການນໍາໃຊ້ປົກກະຕິຂອງຟັງຊັນ slice. ນັບຕັ້ງແຕ່
ການທໍາງານຂອງ slicing ມີຄວາມສໍາຄັນຫຼາຍໃນທີ່ນີ້ແມ່ນຄໍາອະທິບາຍຂອງ syntax ສໍາລັບ string ໄດ້
argument ກັບ slice:

$vpdl = $a->slice('ind0,ind1...')

ບ່ອນທີ່ "ind0" ກໍານົດສິ່ງທີ່ຕ້ອງເຮັດກັບດັດຊະນີ No 0 ຂອງ pdl $a, ແລະອື່ນໆ. ແຕ່ລະອົງປະກອບຂອງ
ບັນຊີລາຍຊື່ທີ່ແຍກດ້ວຍເຄື່ອງໝາຍຈຸດສາມາດມີໜຶ່ງໃນຮູບແບບຕໍ່ໄປນີ້:

' : ' ໃຊ້ມິຕິທັງໝົດ

'n' ໃຊ້ພຽງແຕ່ດັດຊະນີ "n". ຂະຫນາດຂອງດັດຊະນີນີ້ໃນ pdl virtual ຜົນໄດ້ຮັບແມ່ນ 1.
ຕົວຢ່າງທີ່ກ່ຽວຂ້ອງກັບຮູບແບບດັດສະນີສອງອັນທໍາອິດ:

pdl> $column = $im->slice('2,:')
pdl> $row = $im->slice(':,0')
pdl> p $column

[
[ປີ 3]
[ປີ 8]
[15]
[18]
[23]
]

pdl> p $row

[
[1 2 3 4 5]
]

pdl> ຊ່ວຍ $column
ຕົວແປນີ້ແມ່ນ Double D [1,5] VC 0.00Kb

pdl> ຊ່ວຍ $row
ຕົວແປນີ້ແມ່ນ Double D [5,1] VC 0.00Kb

'(n)' ໃຊ້ພຽງແຕ່ດັດຊະນີ "n". ຂະຫນາດນີ້ຖືກໂຍກຍ້າຍອອກຈາກ pdl ຜົນໄດ້ຮັບ (ອີງໃສ່
ຄວາມຈິງທີ່ວ່າຂະຫນາດຂອງຂະຫນາດ 1 ສາມາດຖືກໂຍກຍ້າຍອອກສະເຫມີ). ຄວາມແຕກຕ່າງລະຫວ່າງນີ້
ກໍ​ລະ​ນີ​ແລະ​ທີ່​ຜ່ານ​ມາ​ກາຍ​ເປັນ​ສິ່ງ​ສໍາ​ຄັນ​ໃນ​ການ​ມອບ​ຫມາຍ​ທີ່​ມື​ຊ້າຍ​ແລະ​ຂວາ​
ດ້ານຂ້າງຕ້ອງມີຂະຫນາດທີ່ເຫມາະສົມ.

pdl> $line = $im->slice(':,(0)')
pdl> ຊ່ວຍ $line
ຕົວແປນີ້ແມ່ນ Double D [5] -C 0.00Kb

pdl> p $line
[1 2 3 4 5]

ສັງເກດເຫັນຄວາມແຕກຕ່າງກັບຕົວຢ່າງທີ່ຜ່ານມາບໍ?

'n1:n2' or 'n1:n2:n3'
ເອົາຂອບເຂດຂອງດັດຊະນີຈາກ "n1" ຫາ "n2" ຫຼື (ຮູບແບບທີສອງ) ເອົາຂອບເຂດຂອງ
ຕົວຊີ້ວັດຈາກ "n1" ຫາ "n2" ດ້ວຍຂັ້ນຕອນ "n3". ຕົວຢ່າງສໍາລັບການນໍາໃຊ້ຮູບແບບນີ້ແມ່ນ
ຄໍານິຍາມທີ່ຜ່ານມາຂອງຮູບພາບຍ່ອຍປະກອບດ້ວຍເສັ້ນຄູ່.

pdl> $even = $im->slice(':,1:-1:2')

ຕົວຢ່າງນີ້ຍັງສະແດງໃຫ້ເຫັນວ່າດັດຊະນີທາງລົບເຮັດວຽກຄືກັບພວກມັນປົກກະຕິ
ອາເຣແບບ Perl ໂດຍການນັບຖອຍຫຼັງຈາກຈຸດສິ້ນສຸດຂອງມິຕິ. ຖ້າ "n2" ແມ່ນ
ນ້ອຍກວ່າ "n1" (ໃນຕົວຢ່າງ -1 ແມ່ນເທົ່າກັບດັດຊະນີ 4) ອົງປະກອບໃນ
virtual pdl ຖືກກັບຄືນຢ່າງມີປະສິດທິພາບກ່ຽວກັບພໍ່ແມ່ຂອງມັນ.

'*[ນ]'
ເພີ່ມຂະຫນາດ dummy. ຂະໜາດຂອງຂະໜາດນີ້ຈະເປັນ 1 ໂດຍຄ່າເລີ່ມຕົ້ນ ຫຼືເທົ່າກັບ
"n" ຖ້າການໂຕ້ຖຽງຕົວເລກທາງເລືອກແມ່ນໃຫ້.

ດຽວນີ້, ນີ້ແມ່ນສິ່ງທີ່ແປກປະຫຼາດແທ້ໆເມື່ອເຫັນຄັ້ງ ທຳ ອິດ. dummy ແມ່ນຫຍັງ
ມິຕິ? ມິຕິ dummy ແຊກມິຕິທີ່ບໍ່ເຄີຍມີມາກ່ອນ. ແນວໃດ
ແມ່ນແລ້ວບໍ? ດີ, ໃນກໍລະນີຂອງຂະຫນາດໃຫມ່ທີ່ມີຂະຫນາດ 1 ມັນສາມາດເຮັດໄດ້ງ່າຍ
ອະທິບາຍໂດຍວິທີທີ່ທ່ານສາມາດກໍານົດ vector (ມີອົງປະກອບ "m") ກັບ an
"(1,m)" ຫຼື "(m,1)" matrix. ອັນດຽວກັນຖືແນ່ນອນສໍາລັບວັດຖຸມິຕິລະດັບທີ່ສູງກວ່າ.
ຫນ້າສົນໃຈຫຼາຍແມ່ນກໍລະນີຂອງຂະຫນາດ dummy ຂອງຂະຫນາດຫຼາຍກ່ວາຫນຶ່ງ (ຕົວຢ່າງ
"slice('*5, :')"). ນີ້ເຮັດວຽກໃນລັກສະນະດຽວກັນກັບການໂທຫາຫນ້າທີ່ dummy ສ້າງ
ຂະຫນາດ dummy ໃຫມ່. ສະນັ້ນອ່ານແລະກວດເບິ່ງຄໍາອະທິບາຍຂອງມັນຂ້າງລຸ່ມນີ້.

'([n1:n2[:n3]]=i)'
[ຍັງບໍ່ທັນໄດ້ປະຕິບັດ ??????] ດ້ວຍການໂຕ້ຖຽງແບບນີ້ ເຈົ້າເຮັດ ໂດຍທົ່ວໄປ
ເສັ້ນຂວາງ. ໄດ້ diagonal ຈະເປັນມິຕິ. "i" ຂອງ pdl ຜົນຜະລິດໃຫມ່ແລະ (ຖ້າ
ສ່ວນທາງເລືອກໃນວົງເລັບທີ່ລະບຸໄວ້) ຈະຂະຫຍາຍໄປຕາມຂອບເຂດຂອງດັດຊະນີ
ລະບຸຂະຫນາດຂອງ pdl ຂອງພໍ່ແມ່. ໂດຍທົ່ວໄປການໂຕ້ຖຽງເຊັ່ນນີ້
ພຽງແຕ່ເຮັດໃຫ້ຄວາມຮູ້ສຶກຖ້າຫາກວ່າມີການໂຕ້ຖຽງອື່ນໆເຊັ່ນນີ້ໃນການໂທດຽວກັນກັບ slice.
ພາກສ່ວນໃນວົງເລັບເປັນທາງເລືອກສໍາລັບການໂຕ້ຖຽງປະເພດນີ້. ການໂຕ້ຖຽງທັງຫມົດນີ້
ປະເພດທີ່ລະບຸຂະຫນາດເປົ້າຫມາຍດຽວກັນ "i" ຕ້ອງກ່ຽວຂ້ອງກັບຈໍານວນດຽວກັນຂອງ
ຕົວຊີ້ວັດໃນຂະຫນາດຂອງພໍ່ແມ່ຂອງພວກເຂົາ. ວິທີທີ່ດີທີ່ສຸດທີ່ຈະອະທິບາຍມັນອາດຈະເປັນການໃຫ້
ຕົວຢ່າງ, ໃນທີ່ນີ້ພວກເຮົາສ້າງ pdl ທີ່ຫມາຍເຖິງອົງປະກອບຕາມເສັ້ນຂວາງຂອງຊ່ອງ
pdl ພໍ່ແມ່ຂອງມັນ (ເປັນ cube):

$cube = zeroes(5,5,5);
$sdiag = $cube->slice('(=0),(=0),(=0)');

ຄໍາສັ່ງຂ້າງເທິງສ້າງ pdl virtual ທີ່ເປັນຕົວແທນຂອງເສັ້ນຂວາງຕາມ
ຂະໜາດຂອງພໍ່ແມ່. 0, 1 ແລະ 2 ແລະເຮັດໃຫ້ມິຕິຂອງມັນ 0 (ມິຕິເທົ່ານັ້ນ) ຂອງ
ມັນ. ທ່ານໃຊ້ syntax ຂະຫຍາຍຖ້າຫາກວ່າຂະຫນາດຂະຫນາດຂອງຂະຫນາດພໍ່ແມ່ຂອງທ່ານ
ຕ້ອງ​ການ​ທີ່​ຈະ​ສ້າງ​ເສັ້ນ​ຂວາງ​ຈາກ​ຂະ​ຫນາດ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຫຼື​ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ກັບ​ຄືນ​ໄປ​ບ່ອນ​
ລໍາດັບຂອງອົງປະກອບໃນເສັ້ນຂວາງ, e.g

$rect = zeroes(12,3,5,6,2);
$vpdl = $rect->slice('2:7,(0:1=1),(4),(5:4=1),(=1)');

ດັ່ງນັ້ນອົງປະກອບຂອງ $vpdl ຫຼັງຈາກນັ້ນຈະກ່ຽວຂ້ອງກັບພໍ່ແມ່ຂອງມັນໃນວິທີທີ່ພວກເຮົາສາມາດເຮັດໄດ້
ສະແດງອອກເປັນ:

vpdl(i,j) = rect(i+2,j,4,5-j,j) 0<=i<5, 0<=j<2

[ ເຮັດວຽກຢູ່ໃນຫນ້າທີ່ດັດສະນີໃຫມ່: "$b = $a->index($c);" ???? ]

ມີ ມີ ທີ່ແຕກຕ່າງກັນ ປະເພດ of ວຽກມອບ ໝາຍ in PDL
ຕົວຢ່າງທີ່ຜ່ານມາໄດ້ສະແດງໃຫ້ເຫັນແລ້ວວ່າ pdls virtual ສາມາດຖືກນໍາໃຊ້ເພື່ອດໍາເນີນການຫຼື
ເຂົ້າເຖິງບາງສ່ວນຂອງຂໍ້ມູນຂອງ pdl ພໍ່ແມ່. ພວກເຂົາຍັງສາມາດຖືກນໍາໃຊ້ເປັນມູນຄ່າໃນການມອບຫມາຍ
(ດັ່ງທີ່ການໃຊ້ "++" ໃນບາງຕົວຢ່າງຂ້າງເທິງໄດ້ສະແດງໃຫ້ເຫັນແລ້ວ). ສໍາລັບຢ່າງຈະແຈ້ງ
ການມອບຫມາຍໃຫ້ຂໍ້ມູນທີ່ສະແດງໂດຍ virtual pdl ທີ່ທ່ານຕ້ອງໃຊ້ ".=" ທີ່ overloaded.
operator (ເຊິ່ງໃນສະພາບການນີ້ພວກເຮົາໂທຫາ ຂະຫຍາຍພັນດ້ວຍ ການມອບຫມາຍ). ເປັນຫຍັງເຈົ້າບໍ່ສາມາດໃຊ້ໄດ້
ປະຕິບັດການມອບຫມາຍປົກກະຕິ "="?

ດີ, ແນ່ນອນທ່ານຍັງສາມາດໃຊ້ຕົວປະຕິບັດການ '=' ແຕ່ມັນຈະບໍ່ເຮັດສິ່ງທີ່ທ່ານຕ້ອງການ. ນີ້
ແມ່ນເນື່ອງມາຈາກຄວາມຈິງທີ່ວ່າຕົວປະຕິບັດການ '=' ບໍ່ສາມາດ overloaded ໃນທາງດຽວກັນກັບຄົນອື່ນ
ຜູ້ປະຕິບັດການມອບຫມາຍ. ຖ້າພວກເຮົາພະຍາຍາມໃຊ້ '=' ເພື່ອພະຍາຍາມມອບຫມາຍຂໍ້ມູນໃຫ້ກັບສ່ວນຫນຶ່ງຂອງ a
pdl ທາງດ້ານຮ່າງກາຍໂດຍຜ່ານ pdl virtual ພວກເຮົາຈະບໍ່ບັນລຸຜົນກະທົບທີ່ຕ້ອງການ (ແທນທີ່ຈະເປັນ
ຕົວແປທີ່ເປັນຕົວແທນຂອງ pdl virtual (ການອ້າງອີງເຖິງສິ່ງທີ່ເປັນພອນ) ຈະຫຼັງຈາກ
ການມອບໝາຍພຽງແຕ່ປະກອບດ້ວຍການອ້າງອີງເຖິງສິ່ງທີ່ເປັນພອນອີກອັນຫນຶ່ງທີ່ຈະປະຕິບັດ
ການມອບຫມາຍໃນອະນາຄົດເປັນສໍາເນົາ "ທາງດ້ານຮ່າງກາຍ" ຂອງ rvalue ຕົ້ນສະບັບ [ອັນນີ້ຕົວຈິງແລ້ວຍັງບໍ່ທັນໄດ້
ຈະແຈ້ງແລະເປັນຫົວຂໍ້ຂອງການສົນທະນາໃນບັນຊີລາຍຊື່ທາງໄປສະນີນັກພັດທະນາ PDL]. ໃນຄວາມຫມາຍນັ້ນ
ຈະທໍາລາຍການເຊື່ອມຕໍ່ຂອງ pdl ກັບພໍ່ແມ່ [ບໍ່ແມ່ນພຶດຕິກໍານີ້ໃນຄວາມຮູ້ສຶກ
ກົງກັນຂ້າມກັບສິ່ງທີ່ເກີດຂື້ນໃນກະແສຂໍ້ມູນ, ບ່ອນທີ່ ".=" ທໍາລາຍການເຊື່ອມຕໍ່ກັບພໍ່ແມ່? ].

ຕົວຢ່າງ

pdl> $line = $im->slice(':,(2)')
pdl> $line = ສູນ(5)
pdl> $line++;
pdl> p $im

[
[ 1 2 3 4 5 ]
[ 6 7 8 9 10 ]
[13 14 15 16 17]
[16 17 18 19 20]
[21 22 23 24 25]
]

pdl> p $line
[1 1 1 1 1]

ແຕ່ໃຊ້ ".="

pdl> $line = $im->slice(':,(2)')
pdl> $line .= ສູນ(5​)
pdl> $line++
pdl> p $im

[
[ 1 2 3 4 5 ]
[ 6 7 8 9 10 ]
[ 1 1 1 1 1 ]
[16 17 18 19 20]
[21 22 23 24 25]
]

pdl> ພິມ $line
[1 1 1 1 1]

ນອກຈາກນີ້, ທ່ານສາມາດທົດແທນໄດ້

pdl> $line .= 0;

ສໍາ​ລັບ​ການ​ມອບ​ຫມາຍ​ຂ້າງ​ເທິງ (ສູນ​ແມ່ນ​ປ່ຽນ​ເປັນ piddle scalar​, ບໍ່​ມີ​ຂະ​ຫນາດ​ດັ່ງ​ນັ້ນ​.
ມັນສາມາດໄດ້ຮັບການມອບຫມາຍໃຫ້ piddle ໃດ).

ຄຸນນະສົມບັດທີ່ດີໃນສະບັບ perl ທີ່ຜ່ານມາແມ່ນ lvalue subroutines (ເຊັ່ນ, ຮຸ່ນ 5.6.x ແລະ
ສູງຂຶ້ນລວມທັງ perls ທັງຫມົດທີ່ສະຫນັບສະຫນູນໂດຍ PDL). ທີ່ອະນຸຍາດໃຫ້ຫນຶ່ງທີ່ຈະນໍາໃຊ້
slicing syntax ທັງສອງດ້ານຂອງການມອບຫມາຍ:

pdl> $im->slice(':,(2)').= ສູນ(5)->xvals-> float

ກ່ຽວຂ້ອງກັບຄຸນສົມບັດການມອບຫມາຍຍ່ອຍຂອງ lvalue ເປັນຈັ່ນຈັບພຽງເລັກນ້ອຍສໍາລັບ unwary: perls ທີ່ຜ່ານມາ
ແນະນໍາ "ລັກສະນະ" ທີ່ທໍາລາຍການນໍາໃຊ້ຂອງ PDL ຂອງ lvalue subs ສໍາລັບການມອບຫມາຍ slice ໃນເວລາທີ່
ແລ່ນພາຍໃຕ້ perl debugger, "perl -d". ພາຍໃຕ້ debugger, ການນໍາໃຊ້ຂ້າງເທິງໃຫ້ an
error ເຊັ່ນ: "ບໍ່ສາມາດສົ່ງຄືນຄ່າຊົ່ວຄາວຈາກ lvalue subroutine..." ດັ່ງນັ້ນທ່ານຕ້ອງໃຊ້ syntax.
ເຊັ່ນນີ້:

pdl> ($pdl = $im->slice(':,(2)')).= ສູນ(5)->xvals-> float

ເຊິ່ງເຮັດວຽກໄດ້ທັງແບບມີ ແລະບໍ່ມີຕົວດີບັກ ແຕ່ເປັນການໂຕ້ແຍ້ງທີ່ສັບສົນ ແລະງຸ່ມງ່າມໃນການອ່ານ.

ໃຫ້ສັງເກດວ່າສາມາດມີບັນຫາກັບການມອບຫມາຍແບບນີ້ເມື່ອ lvalue ແລະ rvalue pdls
ອ້າງອີງເຖິງສ່ວນທີ່ທັບຊ້ອນກັນຂອງຂໍ້ມູນໃນ pdl ຫຼັກ:

# ກັບຄືນອົງປະກອບຂອງແຖວທໍາອິດຂອງ $a
($tmp = $a->slice(':,(1)')).= $a->slice('-1:0,(1)');

ໃນປັດຈຸບັນ, ຂໍ້ມູນພໍ່ແມ່ຢູ່ເບື້ອງຂວາຂອງການມອບຫມາຍບໍ່ໄດ້ຖືກຄັດລອກກ່ອນ
(ພາຍໃນ) ການມອບໝາຍ loop ດຳເນີນຕໍ່ໄປ. ດັ່ງນັ້ນ, ຜົນໄດ້ຮັບຂອງການມອບຫມາຍນີ້ຈະຂຶ້ນກັບ
ກ່ຽວກັບລໍາດັບທີ່ອົງປະກອບໄດ້ຖືກມອບຫມາຍແລະເກືອບແນ່ນອນ ບໍ່ ເຮັດໃນສິ່ງທີ່ທ່ານ
ຕ້ອງການ. ດັ່ງນັ້ນ, semantics ປະຈຸບັນ undefined ສໍາລັບໃນປັດຈຸບັນແລະຮັບຜິດຊອບທີ່ຈະປ່ຽນແປງໄດ້ທຸກເວລາ. ເຖິງ
ໄດ້​ຮັບ​ການ​ປະ​ຕິ​ບັດ​ທີ່​ຕ້ອງ​ການ​, ການ​ນໍາ​ໃຊ້​

($tmp = $a->slice(':,(1)')).= $a->slice('-1:0,(1)')->ສຳເນົາ;

ເຊິ່ງເຮັດໃຫ້ສໍາເນົາທາງດ້ານຮ່າງກາຍຂອງ slice ຫຼື

($tmp = $a->slice(':,(1)')).= $a->slice('-1:0,(1)')->sever;

ເຊິ່ງໃຫ້ຜົນເປັນຕ່ອນດຽວກັນແຕ່ແຍກການເຊື່ອມຕໍ່ຂອງຊອຍກັບພໍ່ແມ່ຂອງມັນ.

ອື່ນ ໆ ຫນ້າທີ່ ທີ່ manipulate ຂະຫນາດ
ໄດ້ເວົ້າຢ່າງກວ້າງຂວາງກ່ຽວກັບຫນ້າທີ່ຂອງ slice ມັນຄວນຈະສັງເກດວ່ານີ້ບໍ່ແມ່ນ
ຟັງຊັນດັດສະນີ PDL ເທົ່ານັ້ນ. ມີຫນ້າທີ່ດັດສະນີເພີ່ມເຕີມທີ່ມີປະໂຫຍດເຊັ່ນກັນ
(ໂດຍສະເພາະໃນສະພາບການຂອງກະທູ້ທີ່ພວກເຮົາຈະເວົ້າກ່ຽວກັບຕໍ່ມາ). ນີ້ແມ່ນບັນຊີລາຍຊື່
ແລະບາງຕົວຢ່າງວິທີການນໍາໃຊ້ພວກມັນ.

"dummy"
ໃສ່​ຂະ​ຫນາດ dummy ຂອງ​ຂະ​ຫນາດ​ທີ່​ທ່ານ​ລະ​ບຸ​ໄວ້ (ຄ່າ​ເລີ່ມ​ຕົ້ນ 1​) ໃນ​ສະ​ຖານ​ທີ່​ເລືອກ​.
ທ່ານ​ບໍ່​ສາ​ມາດ​ລໍ​ຖ້າ​ທີ່​ຈະ​ໄດ້​ຍິນ​ວິ​ທີ​ການ​ທີ່​ບັນ​ລຸ​ໄດ້​? ແລ້ວ, ອົງປະກອບທັງໝົດທີ່ມີດັດຊະນີ "(X,x,Y)"
("0<=x
pdl (ບ່ອນທີ່ "X" ແລະ "Y" ຫມາຍເຖິງກຸ່ມຂອງດັດຊະນີກ່ອນແລະຫຼັງຈາກສະຖານທີ່
ບ່ອນ​ທີ່​ຂະ​ຫນາດ dummy ໄດ້​ຖືກ​ໃສ່​.)

ຕົວຢ່າງນີ້ຄິດໄລ່ຈຸດປະສານງານ x ຂອງຈຸດສູນກາງຂອງຮູບພາບ (ຕໍ່ມາພວກເຮົາຈະ
ຮຽນຮູ້ວ່າຕົວຈິງແລ້ວພວກເຮົາບໍ່ຕ້ອງການຂະຫນາດ dummy ຂໍຂອບໃຈກັບ magic ຂອງ implicit ໄດ້
threading; ແຕ່ການນໍາໃຊ້ຂະຫນາດ dummy ລະຫັດຍັງຈະເຮັດວຽກຢູ່ໃນໂລກ thread-less;
ເຖິງແມ່ນວ່າເມື່ອທ່ານໄດ້ເຮັດວຽກກັບກະທູ້ PDL ທ່ານຈະບໍ່ຕ້ອງການດໍາລົງຊີວິດໂດຍບໍ່ມີພວກມັນ
ອີກເທື່ອຫນຶ່ງ).

# ສູນກາງ
($xd,$yd) = $im-> dims;
$xc = sum($im*xvals(zeroes($xd))->dummy(1,$yd))/sum($im);

ໃຫ້ອະທິບາຍວິທີການເຮັດວຽກໃນລາຍລະອຽດເພີ່ມເຕີມເລັກນ້ອຍ. ຫນ້າທໍາອິດ, ຜະລິດຕະພັນ:

$xvs = xvals(zeroes($xd));
ພິມ $xvs->dummy(1,$yd); # ຊ້ຳແຖວ $yd ເທື່ອ
$prod = $im*xvs->dummy(1,$yd); # ປະກອບເປັນຜະລິດຕະພັນທີ່ສະຫລາດກັບ pixels ລວງ
# ເສັ້ນຊ້ຳຂອງ x-values

ສ່ວນທີ່ເຫຼືອແມ່ນຫຼັງຈາກນັ້ນສະຫຼຸບຜົນໄດ້ຮັບຂອງຜະລິດຕະພັນ pixel-wise ຮ່ວມກັນແລະ
normalizing ກັບຜົນລວມຂອງຄ່າ pixels ລວງທັງຫມົດໃນຮູບຕົ້ນສະບັບດັ່ງນັ້ນການຄິດໄລ່
x-coordinate ຂອງ "ສູນກາງຂອງມະຫາຊົນ" ຂອງຮູບພາບ (ການແປຄ່າ pixels ເປັນ
ມວນ​ຊົນ​ທ້ອງ​ຖິ່ນ​) ຊຶ່ງ​ເປັນ​ທີ່​ຮູ້​ຈັກ​ເປັນ​ສູນ​ກາງ​ຂອງ​ຮູບ​ພາບ​.

ຕໍ່​ໄປ​ແມ່ນ​ເປັນ (ຈາກ​ຈຸດ​ຂອງ​ການ​ບໍ​ລິ​ໂພກ​ຄວາມ​ຊົງ​ຈໍາ​) ການ​ປ່ຽນ​ແປງ​ລາ​ຄາ​ຖືກ​ຫຼາຍ​ຈາກ​
ຂະຫນາດສີຂີ້ເຖົ່າເຖິງ RGB, ie ທຸກໆ pixels ປະຈຸບັນຖືເປັນສາມເທົ່າຂອງຄ່າແທນທີ່ຈະເປັນ scalar.
3 ຄ່າໃນ triple ແມ່ນ, ໂຊກດີ, ທັງຫມົດດຽວກັນສໍາລັບຮູບພາບສີຂີ້ເຖົ່າ, ດັ່ງນັ້ນ
ວ່າ trick ຂອງພວກເຮົາເຮັດວຽກໄດ້ດີໃນທີ່ມັນແຜນທີ່ທັງຫມົດສາມສະມາຊິກຂອງ triple ກັບ
ອົງ​ປະ​ກອບ​ແຫຼ່ງ​ດຽວ​ກັນ​:

# ການປ່ຽນຂະໜາດສີເທົາເປັນ RGB ລາຄາຖືກ
$rgb = $grey->dummy(0,3)

ຂໍອະໄພ, ເຄັດລັບນີ້ບໍ່ສາມາດຖືກໃຊ້ເພື່ອປ່ຽນຮູບ B/W ເກົ່າຂອງທ່ານໃຫ້ເປັນສີໄດ້
ໃນ​ວິ​ທີ​ທີ່​ທ່ານ​ຕ້ອງ​ການ​. :(

ໃຫ້ສັງເກດວ່າການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາຂອງ piddles ທີ່ມີຂະຫນາດ dummy ແມ່ນມີຄວາມອ່ອນໄຫວໂດຍສະເພາະກັບ
ການ​ເປັນ​ຕົວ​ແທນ​ພາຍ​ໃນ​. ຖ້າ piddle ສາມາດຖືກສະແດງເປັນ virtual affine
(``vaffine'') piddle, ມີພຽງແຕ່ໂຄງສ້າງການຄວບຄຸມທີ່ຖືກເກັບຮັກສາໄວ້. ແຕ່ຖ້າ $b ໃນ

$a = ສູນ(10000)
$b = $a->dummy(1,10000);

ໄດ້ຖືກເຮັດໃຫ້ທາງດ້ານຮ່າງກາຍໂດຍປົກກະຕິບາງ, ທ່ານຈະພົບເຫັນວ່າການນໍາໃຊ້ຫນ່ວຍຄວາມຈໍາຂອງໂຄງການຂອງທ່ານ
ໄດ້ເຕີບໂຕຢ່າງກະທັນຫັນໂດຍ 100Mb.

"ເສັ້ນຂວາງ"
ແທນ​ທີ່​ສອງ​ມິ​ຕິ (ທີ່​ຕ້ອງ​ມີ​ຂະ​ຫນາດ​ເທົ່າ​ທຽມ​ກັນ​) ໂດຍ​ຫນຶ່ງ​ມິ​ຕິ​ທີ່​
ອ້າງອີງເຖິງອົງປະກອບທັງໝົດຕາມ "ເສັ້ນຂວາງ" ຕາມສອງມິຕິດັ່ງກ່າວ. ນີ້, ພວກເຮົາ
ມີສອງຕົວຢ່າງທີ່ຄວນຈະຄຸ້ນເຄີຍກັບທຸກຄົນທີ່ເຄີຍເຮັດບາງເສັ້ນ
ພຶດຊະຄະນິດ. ກ່ອນອື່ນ ໝົດ, ສ້າງຕາຕະລາງຄວາມສາມັກຄີ:

# ມາຕຣິກເບື້ອງສາມັກຄີ
$e = zeroes(float, 3, 3); # ເຮັດໃຫ້ທຸກຢ່າງເປັນສູນ
($tmp = $e->ເສັ້ນຂວາງ(0,1)).= 1; # ຕັ້ງອົງປະກອບຕາມເສັ້ນຂວາງເປັນ 1
ພິມ $e;

ຫຼືເສັ້ນຂວາງອື່ນໆ:

($tmp = $e->slice(':-1:0')->ເສັ້ນຂວາງ(0,1)).= 2;
ພິມ $e;

(ທ່ານສັງເກດເຫັນບໍວ່າພວກເຮົາໃຊ້ຟັງຊັນຂອງ slice ເພື່ອກັບຄືນລໍາດັບຂອງແຖວກ່ອນ
ຕັ້ງເສັ້ນຂວາງຂອງເດັກໃຫມ່, ດັ່ງນັ້ນການກໍານົດເສັ້ນຂວາງຂອງ
parent ?) ຫຼືການສ້າງແຜນທີ່ຈາກຊ່ອງຂອງ matrices ເສັ້ນຂວາງໄປຫາພາກສະຫນາມໃນໄລຍະທີ່
matrices ໄດ້ຖືກກໍານົດ, ຕາມຮອຍຂອງ matrix ເປັນ:

# ຕິດຕາມມາຕຣິກເບື້ອງ
$trace = sum($mat->ເສັ້ນຂວາງ(0,1)); # ລວມທຸກອົງປະກອບທາງຂວາງ

"xchg" ແລະ "mv"
xchg ການແລກປ່ຽນຫຼື "transposes" ສອງຂະຫນາດທີ່ລະບຸໄວ້. ກົງໄປກົງມາ
ຍົກຕົວຢ່າງ:

# transpose matrix (ໂດຍບໍ່ມີການ reshuffling ຂໍ້ມູນຢ່າງຊັດເຈນແລະ
#ເຮັດສຳເນົາ)
$prod = $ax $a->xchg(0,1);

ໃນປັດຈຸບັນ $prod ຄວນຈະໃກ້ຊິດກັບ matrix ຄວາມສາມັກຄີ ຖ້າ $a ເປັນ matrix orthogonal.
ປົກກະຕິແລ້ວ "xchg" ຈະຖືກໃຊ້ໃນສະພາບການຂອງ threading ແຕ່ເພີ່ມເຕີມກ່ຽວກັບວ່າຕໍ່ມາ.

mv ເຮັດວຽກໃນແບບທີ່ຄ້າຍຄືກັນ. ມັນຍ້າຍມິຕິ (ລະບຸໂດຍຕົວເລກຂອງມັນຢູ່ໃນ
ພໍ່ແມ່) ກັບຕໍາແຫນ່ງໃຫມ່ໃນ pdl ເດັກໃຫມ່:

$b = $a->mv(4,0); # ເຮັດໃຫ້ມິຕິທີ 5 ຂອງ $a ເປັນອັນດັບທຳອິດໃນ
# ເດັກໃຫມ່ $b

ຄວາມແຕກຕ່າງລະຫວ່າງ "xchg" ແລະ "mv" ແມ່ນວ່າ "xchg" ພຽງແຕ່ປ່ຽນຕໍາແຫນ່ງຂອງສອງ
ມິຕິກັບກັນແລະກັນ, ໃນຂະນະທີ່ "mv" ແຊກມິຕິທໍາອິດໄປຫາສະຖານທີ່ຂອງ
ອັນທີສອງ, ການເຄື່ອນຍ້າຍຂອງຂະຫນາດອື່ນໆປະມານຕາມຄວາມເຫມາະສົມ.

"ຊໍ່"
ຫຍໍ້ຫຼາຍມິຕິເປັນອັນດຽວ. ການໂຕ້ຖຽງເທົ່ານັ້ນຂອງມັນລະບຸວ່າມີຂະຫນາດເທົ່າໃດ
ຂອງແຫຼ່ງ pdl ຄວນຈະຖືກຍຸບ (ເລີ່ມຕົ້ນຈາກທໍາອິດ). ເປັນ (ຍອມຮັບ
unrealistic) ຕົວຢ່າງແມ່ນ 3D pdl ທີ່ເກັບຂໍ້ມູນຈາກ stack ຂອງໄຟລ໌ຮູບພາບທີ່ທ່ານ
ພຽງແຕ່ໄດ້ອ່ານໃນ. ຢ່າງໃດກໍຕາມ, ຂໍ້ມູນຈາກແຕ່ລະຮູບພາບແມ່ນເປັນຕົວແທນຂອງເວລາ 1D
ຊຸດ ແລະໄດ້ຖືກຈັດລຽງແບບນັ້ນເທົ່ານັ້ນ ເພາະວ່າມັນຖືກສ້າງເປັນດິຈິຕອນດ້ວຍກອບ
grabber. ດັ່ງນັ້ນເພື່ອໃຫ້ມັນອີກເທື່ອຫນຶ່ງເປັນ array ຂອງລໍາດັບທີ່ໃຊ້ເວລາທີ່ທ່ານເວົ້າ

pdl> $seqs = $stack->ກຸ່ມ(2​)
pdl> ຊ່ວຍ vars
ຕົວແປ PDL ໃນຊຸດຫຼັກ::

ຊື່ປະເພດ Dimension Flow State Mem
-------------------------------------------------- --------------
$seqs Double D [8000,50] -C 0.00Kb
$stack Double D [100,80,50] P 3.05Mb

ບໍ່ສົມຈິງຍ້ອນວ່າມັນອາດຈະເບິ່ງຄືວ່າ, ຊອບແວກ້ອງຈຸລະທັດ confocal ຂອງພວກເຮົາຂຽນຂໍ້ມູນ (ບາງຄັ້ງ)
ທາງນີ້. ແຕ່ເລື້ອຍໆທ່ານໃຊ້ clump ເພື່ອບັນລຸຜົນກະທົບທີ່ແນ່ນອນໃນເວລາທີ່ໃຊ້ implicit
ຫຼືກະທູ້ທີ່ຈະແຈ້ງ.

ໂທຫາເຄືອຂ່າຍ to ດັດສະນີ ຫນ້າທີ່ ສາມາດເຮັດໄດ້ be ຕ່ອງໂສ້
ດັ່ງທີ່ທ່ານອາດຈະໄດ້ສັງເກດເຫັນໃນບາງຕົວຢ່າງຂ້າງເທິງນີ້ໂທຫາຫນ້າທີ່ດັດສະນີ
ສາມາດຖືກຕ່ອງໂສ້ຢ່າງດີນັບຕັ້ງແຕ່ຫນ້າທີ່ທັງຫມົດເຫຼົ່ານີ້ສົ່ງຄືນວັດຖຸເດັກນ້ອຍທີ່ສ້າງຂຶ້ນໃຫມ່.
ຢ່າງໃດກໍຕາມ, ໃນເວລາທີ່ເຮັດການຫມູນໃຊ້ດັດຊະນີຢ່າງກວ້າງຂວາງໃນລະບົບຕ່ອງໂສ້ໃຫ້ແນ່ໃຈວ່າຈະຕິດຕາມສິ່ງທີ່
ທ່ານກໍາລັງເຮັດ, eg

$a->xchg(0,1)->mv(0,4)

ຍ້າຍມິຕິ 1 ຂອງ $a ໄປຫາຕຳແໜ່ງ 4 ຕັ້ງແຕ່ເວລາທີ່ຄຳສັ່ງທີສອງຖືກປະຕິບັດ
ມິຕິເດີມ 1 ໄດ້ຖືກຍ້າຍໄປຕໍາແໜ່ງ 0 ຂອງລູກໃໝ່ທີ່ເອີ້ນ "mv"
ຫນ້າທີ່. ຂ້າພະເຈົ້າຄິດວ່າທ່ານໄດ້ຮັບຄວາມຄິດ (ເຖິງວ່າຈະມີຄໍາອະທິບາຍທີ່ສັບສົນຂອງຂ້ອຍ).

ຂະຫຍາຍພັນ ວຽກມອບ ໝາຍ ('.=') ແລະ dummy ຂະຫນາດ
sublety ທີ່ກ່ຽວຂ້ອງກັບການສ້າງດັດສະນີແມ່ນການມອບຫມາຍໃຫ້ pdls ທີ່ມີຂະຫນາດ dummy ຂອງ
ຂະໜາດໃຫຍ່ກວ່າ 1. ການມອບໝາຍເຫຼົ່ານີ້ (ໂດຍໃຊ້ ".=") ຖືກຫ້າມເນື່ອງຈາກອົງປະກອບຫຼາຍອັນ
ຂອງ lvalue pdl ຊີ້ໄປຫາອົງປະກອບດຽວກັນຂອງພໍ່ແມ່. ດັ່ງນັ້ນ, ມູນຄ່າຂອງ
ອົງ​ປະ​ກອບ​ຂອງ​ພໍ່​ແມ່​ເຫຼົ່າ​ນັ້ນ​ແມ່ນ​ອາດ​ຈະ​ມີ​ຄວາມ​ບໍ່​ຊັດ​ເຈນ​ແລະ​ຈະ​ຂຶ້ນ​ກັບ​ລໍາ​ດັບ​ທີ່​
ການປະຕິບັດເຮັດໃຫ້ການມອບຫມາຍໃຫ້ອົງປະກອບ. ດັ່ງນັ້ນ, ການມອບຫມາຍດັ່ງນີ້:

$a = pdl [1,2,3];
$b = $a->dummy(1,4);
$b .= yvals(zeroes(3,4));

ສາມາດຜະລິດຜົນໄດ້ຮັບທີ່ບໍ່ຄາດຄິດແລະຜົນໄດ້ຮັບຢ່າງຊັດເຈນ undefined ໂດຍ PDL ເນື່ອງຈາກວ່າ
ເມື່ອ PDL ໄດ້ຮັບຄຸນສົມບັດຄອມພິວເຕີ້ຂະຫນານ, ຜົນໄດ້ຮັບໃນປະຈຸບັນອາດຈະປ່ຽນແປງໄດ້ດີ.

ຈາກທັດສະນະຂອງ dataflow ການແນະນໍາຂອງ dummy ຂະຫນາດໃຫຍ່ກວ່າຫນຶ່ງ
ຂະ​ຫນາດ​ແມ່ນ​ຖື​ວ່າ​ເປັນ​ການ​ຫັນ​ປ່ຽນ irreversible (ຄ້າຍ​ຄື​ກັນ​ກັບ​ຄໍາ​ສັບ​ຕ່າງໆ​ໃນ
Thermodynamics) ເຊິ່ງກີດຂວາງການຂະຫຍາຍພັນທາງຫຼັງຂອງການມອບໝາຍໃຫ້ພໍ່ແມ່ (ເຈົ້າ
ໄດ້ຮ້ອງຂໍຢ່າງຈະແຈ້ງໂດຍໃຊ້ ".=" ການມອບໝາຍ). ບັນຫາທີ່ຄ້າຍຄືກັນທີ່ຕ້ອງລະວັງ
ເກີດຂຶ້ນໃນບໍລິບົດຂອງ threading ທີ່ບາງຄັ້ງຂະຫນາດ dummy ຖືກສ້າງຂື້ນ implicitly
ໃນລະຫວ່າງການ loop thread (ເບິ່ງຂ້າງລຸ່ມນີ້).

ເຫດຜົນ ສໍາລັບການ ໄດ້ ພໍ່ແມ່/ລູກ (ຫຼື "ຕົວຊີ້") ແນວຄິດ
[ອັນ​ນີ້​ຈະ​ຕ້ອງ​ລໍ​ຖ້າ​ເລັກ​ນ້ອຍ​]

XXX ມີຄວາມຊົງຈໍາທີ່ມີປະສິດທິພາບ
XXXX ໃນບໍລິບົດຂອງ threading
XXXXXX ເປັນວິທີທີ່ປ່ຽນແປງໄດ້ ແລະມີປະສິດທິພາບຫຼາຍໃນການເຂົ້າເຖິງບາງສ່ວນຂອງຂໍ້ມູນ pdl
(ໃນ​ວິ​ທີ​ການ​ທົ່ວ​ໄປ​ຫຼາຍ​ກ​່​ວາ sec​, ແລະ​ອື່ນໆ​ອະ​ນຸ​ຍາດ​ໃຫ້​)
XXX ການປະຕິບັດທີ່ມີປະສິດທິພາບ
XXXXX ຄວາມແຕກຕ່າງກັບພາກສ່ວນ / ຢູ່, ແລະອື່ນໆ.

ວິທີການ to ເຮັດໃຫ້ ສິ່ງທີ່ ທາງດ້ານຮ່າງກາຍ ອີກເທື່ອຫນຶ່ງ
[ XXXXX ຕື່ມຂໍ້ມູນໃສ່ໃນພາຍຫຼັງເມື່ອທຸກຢ່າງໄດ້ຕົກລົງຕື່ມອີກເລັກນ້ອຍ ]

** ໃນ​ເວ​ລາ​ທີ່​ຈໍາ​ເປັນ (xsub routine interfacing C lib function​)
** ບັນ​ລຸ​ໄດ້​ແນວ​ໃດ (-​> ທາງ​ດ້ານ​ຮ່າງ​ກາຍ​)
** ວິ​ທີ​ການ​ທົດ​ສອບ (isphysical (ອະ​ທິ​ບາຍ​ວິ​ທີ​ການ​ເຮັດ​ວຽກ​ໃນ​ປັດ​ຈຸ​ບັນ​)​)
** -> ສໍາເນົາແລະ -> sever

ກະທູ້

ໃນວັກທີ່ຜ່ານມາກ່ຽວກັບການດັດສະນີພວກເຮົາໄດ້ກ່າວເຖິງຄໍາສັບໃນບາງຄັ້ງຄາວແຕ່
ໃນປັດຈຸບັນມັນເປັນເວລາແທ້ໆທີ່ຈະເວົ້າຢ່າງຈະແຈ້ງກ່ຽວກັບ "threading" ກັບ pdls. ຄໍາວ່າ threading ມີ
ຄວາມ​ຫມາຍ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຫຼາຍ​ໃນ​ຂົງ​ເຂດ​ທີ່​ແຕກ​ຕ່າງ​ກັນ​ຂອງ​ຄອມ​ພິວ​ເຕີ​. ພາຍໃນຂອບຂອງ PDL ມັນ
ອາດ​ຈະ​ໄດ້​ຮັບ​ການ​ກໍາ​ນົດ​ວ່າງ​ເປັນ​ສະ​ຖານ​ທີ່ looping implicit​. ມັນ implicit ເນື່ອງຈາກວ່າ
ທ່ານບໍ່ໄດ້ລະບຸຫຍັງເຊັ່ນ: ການປິດບັງ for-loops ແຕ່ວ່າ loops ແມ່ນອັດຕະໂນມັດ
(ຫຼື 'magically') ສ້າງຂຶ້ນໂດຍ PDL ໂດຍອີງໃສ່ຂະຫນາດຂອງ pdls ທີ່ກ່ຽວຂ້ອງ. ນີ້
ຄວນໃຫ້ຄວາມຄິດທຳອິດແກ່ເຈົ້າວ່າ ເປັນຫຍັງໜ້າທີ່ການໝູນໃຊ້ດັດຊະນີ/ຂະໜາດທີ່ເຈົ້າໄດ້ພົບ
ໃນວັກທີ່ຜ່ານມາມີຄວາມສໍາຄັນໂດຍສະເພາະແລະເປັນປະໂຫຍດໃນສະພາບການຂອງ
ກະທູ້. ສ່ວນປະກອບອື່ນໆສໍາລັບການ threading (ນອກຈາກ pdls ທີ່ກ່ຽວຂ້ອງ) ແມ່ນ a
ຟັງຊັນທີ່ຮູ້ threading (ໂດຍທົ່ວໄປ, ເຫຼົ່ານີ້ແມ່ນ PDL:: PP ລວບລວມຫນ້າທີ່) ແລະ
ວ່າ pdls ແມ່ນ "ກະທູ້" ຫຼາຍກວ່າ. ຫຼາຍກ່ຽວກັບຄໍາສັບຕ່າງໆແລະຕອນນີ້ໃຫ້ພະຍາຍາມ
ໃຫ້ຄວາມສະຫວ່າງບາງຢ່າງກ່ຽວກັບສິ່ງທີ່ມັນຫມາຍຄວາມວ່າທັງຫມົດ.

ສົມບູນແບບ ກະທູ້ - a ຄັ້ງທໍາອິດ ຍົກຕົວຢ່າງ
ມີສອງຕົວແປທີ່ແຕກຕ່າງກັນເລັກນ້ອຍຂອງ threading. ພວກເຮົາເລີ່ມຕົ້ນດ້ວຍສິ່ງທີ່ພວກເຮົາໂທຫາ
"ກະທູ້ implicit". ໃຫ້ເລືອກເອົາຕົວຢ່າງການປະຕິບັດທີ່ກ່ຽວຂ້ອງກັບການ looping ຂອງຟັງຊັນ
ຫຼາຍກວ່າອົງປະກອບຂອງ pdl. ສົມມຸດວ່າພວກເຮົາມີຮູບພາບ RGB ທີ່ພວກເຮົາຕ້ອງການປ່ຽນເປັນສີຂີ້ເຖົ່າ.
ຂະໜາດ. ຮູບພາບ RGB ແມ່ນສະແດງໂດຍ 3-dim pdl "im(3,x,y)" ບ່ອນທີ່ມີມິຕິທໍາອິດ.
ມີສາມອົງປະກອບສີຂອງແຕ່ລະ pixels ແລະ "x" ແລະ "y" ແມ່ນ width ແລະຄວາມສູງຂອງ
ຮູບພາບ, ຕາມລໍາດັບ. ຕໍ່ໄປ, ພວກເຮົາຈໍາເປັນຕ້ອງໄດ້ກໍານົດວິທີການແປງເປັນສາມສີຕາມທີ່ກໍານົດໄວ້
pixels ເຂົ້າໄປໃນມູນຄ່າສີຂີ້ເຖົ່າ (ເພື່ອເປັນຕົວຢ່າງທີ່ແທ້ຈິງມັນຄວນຈະເປັນຕົວແທນຂອງພີ່ນ້ອງ
ຄວາມເຂັ້ມຂຸ້ນທີ່ເຊລຕາທີ່ບໍ່ມີສີຂອງພວກເຮົາຈະກວດພົບສີນັ້ນເພື່ອບັນລຸ
ສິ່ງ​ທີ່​ພວກ​ເຮົາ​ຈະ​ເອີ້ນ​ວ່າ​ການ​ປ່ຽນ​ແປງ​ທໍາ​ມະ​ຊາດ​ຈາກ​ສີ​ໄປ​ເປັນ​ສີ​ຂີ້​ເຖົ່າ​. ປະມານວ່າ
ເຮັດວຽກໄດ້ດີແມ່ນການຄິດໄລ່ຄວາມເຂັ້ມຂອງສີຂີ້ເຖົ່າຈາກແຕ່ລະ RGB triplet (r,g,b) ເປັນ.
ລວມນ້ຳໜັກ

grey-value = 77/256*r + 150/256*g + 29/256*b =
ພາຍໃນ([77,150,29]/256, [r,g,b])

ບ່ອນທີ່ແບບຟອມສຸດທ້າຍຊີ້ໃຫ້ເຫັນວ່າພວກເຮົາສາມາດຂຽນນີ້ເປັນຜະລິດຕະພັນພາຍໃນຂອງ 3-vector
ປະ​ກອບ​ດ້ວຍ​ນ​້​ໍາ​ຫນັກ​ສໍາ​ລັບ​ອົງ​ປະ​ກອບ​ສີ​ແດງ​, ສີ​ຂຽວ​ແລະ​ສີ​ຟ້າ​ທີ່​ມີ 3 vector ທີ່​ປະ​ກອບ​ດ້ວຍ​
ອົງປະກອບຂອງສີ. ຕາມປະເພນີ, ພວກເຮົາອາດຈະຂຽນຫນ້າທີ່ຄ້າຍຄືຕໍ່ໄປນີ້
ການ​ປຸງ​ແຕ່ງ​ຮູບ​ພາບ​ທັງ​ຫມົດ​:

@dims=$im-> dims ຂອງຂ້ອຍ;
# ທີ່ນີ້ປົກກະຕິກວດເບິ່ງວ່າ dim ທໍາອິດມີຂະຫນາດທີ່ຖືກຕ້ອງ (3), ແລະອື່ນໆ
$grey=zeroes(@dims[1,2]); # ເຮັດ pdl ສໍາລັບຮູບພາບສີຂີ້ເຖົ່າຜົນໄດ້ຮັບ
$w = pdl [77,150,29] / 256; # vector ຂອງນ້ຳໜັກ
ສໍາລັບ ($j=0;$j
ສໍາລັບ ($i=0;$i
# ຄິດໄລ່ຄ່າ pixels
$tmp = inner($w,$im->slice(':,(i),(j)'));
set($grey,$i,$j,$tmp); # ແລະຕັ້ງມັນເປັນຮູບສີເທົາ
}
}

ໃນປັດຈຸບັນພວກເຮົາຂຽນດຽວກັນໂດຍໃຊ້ threading (ສັງເກດວ່າ "ພາຍໃນ" ແມ່ນຫນ້າທີ່ຮັບຮູ້ threading
ກຳນົດໄວ້ໃນ PDL::Primitive package)

$grey = ພາຍໃນ($im,pdl([77,150,29]/256));

ພວກເຮົາໄດ້ສິ້ນສຸດດ້ວຍເສັ້ນດຽວທີ່ສ້າງ pdl $grey ໂດຍອັດຕະໂນມັດ
ຈໍານວນແລະຂະຫນາດຂອງຂະຫນາດແລະດໍາເນີນການ loops ອັດຕະໂນມັດ ( loops ເຫຼົ່ານີ້ແມ່ນ
ປະຕິບັດເປັນລະຫັດ C ໄວຢູ່ໃນພາຍໃນຂອງ PDL). ແລ້ວ, ພວກເຮົາຍັງຕິດໜີ້ເຈົ້າຢູ່
ຄໍາອະທິບາຍວິທີການ 'magic' ນີ້ແມ່ນບັນລຸໄດ້.

ວິທີການ ບໍ່ ໄດ້ ຍົກຕົວຢ່າງ ການເຮັດວຽກ ?
ສິ່ງທໍາອິດທີ່ຄວນສັງເກດແມ່ນວ່າທຸກໆຫນ້າທີ່ເປັນ threading ຮູ້ (ເຫຼົ່ານີ້ແມ່ນບໍ່ມີ
ຟັງຊັນການຍົກເວັ້ນທີ່ລວບລວມຈາກຄໍາອະທິບາຍຫຍໍ້ໂດຍ PDL::PP, ຕໍ່ມາເອີ້ນວ່າ PP-
functions) ຄາດວ່າຈະມີຈໍານວນຂະຫນາດ (ຕໍາ່ສຸດທີ່) ກໍານົດ (ພວກເຮົາເອີ້ນວ່າຂະຫນາດຫຼັກ)
ຈາກແຕ່ລະການໂຕ້ຖຽງ pdl ຂອງມັນ. ຟັງຊັນພາຍໃນຄາດວ່າຈະມີສອງມິຕິຫນຶ່ງ (ການປ້ອນຂໍ້ມູນ)
ຕົວກໍານົດການທີ່ມັນຄິດໄລ່ຄ່າສູນມິຕິມິຕິ (ຜົນຜະລິດ). ພວກເຮົາຂຽນວ່າ
ສັນຍາລັກເປັນ "ພາຍໃນ((n),(n),[o]())" ແລະເອີ້ນມັນວ່າ "ພາຍໃນ". ລາຍເຊັນ, ບ່ອນທີ່ n ເປັນຕົວແທນ
ຂະຫນາດຂອງຂະຫນາດນັ້ນ. n ຄວາມເທົ່າທຽມກັນໃນຕົວກໍານົດການທໍາອິດແລະທີສອງຫມາຍຄວາມວ່າ
ຂະ​ຫນາດ​ເຫຼົ່າ​ນັ້ນ​ຕ້ອງ​ມີ​ຂະ​ຫນາດ​ເທົ່າ​ທຽມ​ກັນ​ໃນ​ການ​ໂທ​ໃດ​ຫນຶ່ງ​. ເປັນຕົວຢ່າງທີ່ແຕກຕ່າງກັນ, ເອົາ
ຜະ​ລິດ​ຕະ​ພັນ​ພາຍ​ນອກ​ທີ່​ໃຊ້​ເວ​ລາ​ສອງ 1D vectors ເພື່ອ​ສ້າງ 2D matrix​, ຂຽນ​ສັນ​ຍາ​ລັກ​ເປັນ​
"ນອກ(ນ),(m),[o](n,m))". "[o]" ໃນທັງສອງຕົວຢ່າງຊີ້ໃຫ້ເຫັນວ່ານີ້ (ທີ່ນີ້ທີສາມ)
argument ແມ່ນການໂຕ້ຖຽງຜົນຜະລິດ. ໃນຕົວຢ່າງສຸດທ້າຍ, ຂະຫນາດຂອງທໍາອິດແລະທີສອງ
ການໂຕ້ຖຽງບໍ່ຈໍາເປັນຕ້ອງຕົກລົງ, ແຕ່ທ່ານເບິ່ງວ່າພວກເຂົາກໍານົດຂະຫນາດຂອງສອງຂະຫນາດແນວໃດ
ຂອງຜົນຜະລິດ pdl.

ນີ້ແມ່ນຈຸດໃນເວລາທີ່ threading ສຸດທ້າຍເຂົ້າໄປໃນເກມ. ຖ້າທ່ານໂທຫາ PP-functions ກັບ
pdls ທີ່ມີ ເພີ່ມເຕີມ ກ່ວາຂະຫນາດຫຼັກທີ່ຕ້ອງການ, ຂະຫນາດທໍາອິດຂອງ pdl
arguments ຖືກນໍາໃຊ້ເປັນຂະຫນາດຫຼັກແລະຂະຫນາດເພີ່ມເຕີມແມ່ນ threaded
ເກີນ. ຂໍ​ໃຫ້​ພວກ​ເຮົາ​ສະ​ແດງ​ໃຫ້​ເຫັນ​ນີ້​ທໍາ​ອິດ​ທີ່​ມີ​ຕົວ​ຢ່າງ​ຂອງ​ພວກ​ເຮົາ​ຂ້າງ​ເທິງ​ນີ້​

$grey = ພາຍໃນ($im,$w); # w ແມ່ນ vector ນ້ໍາຫນັກຈາກຂ້າງເທິງ

ໃນ​ກໍ​ລະ​ນີ​ນີ້ $w ແມ່ນ 1D ແລະ​ສະ​ຫນອງ​ໃຫ້​ພຽງ​ແຕ່​ຂະ​ຫນາດ​ຫຼັກ​, $im ແມ່ນ 3D​, ຫຼາຍ​
ໂດຍສະເພາະ "(3,x,y)". ມິຕິທໍາອິດ (ຂະຫນາດ 3) ແມ່ນຂະຫນາດຫຼັກທີ່ຕ້ອງການ
ທີ່ກົງກັບ (ຕາມຄວາມຕ້ອງການຂອງພາຍໃນ) ມິຕິທຳອິດ (ແລະດຽວ) ຂອງ $w. ທີ່​ສອງ
ຂະ​ຫນາດ​ແມ່ນ​ຂະ​ຫນາດ​ກະ​ທູ້​ທໍາ​ອິດ (ຂອງ​ຂະ​ຫນາດ "x​"​) ແລະ​ທີ​ສາມ​ແມ່ນ​ຢູ່​ທີ່​ນີ້​ຄັ້ງ​ທີ​ສອງ​
ຂະຫນາດກະທູ້ (ຂະຫນາດ "y"). pdl ຜົນ​ຜະ​ລິດ​ແມ່ນ​ການ​ສ້າງ​ຕັ້ງ​ອັດ​ຕະ​ໂນ​ມັດ (ຕາມ​ການ​ຮ້ອງ​ຂໍ​ໂດຍ
ຕັ້ງ $grey ເປັນ "null" ກ່ອນການເອີ້ນ). ຂະຫນາດຜົນຜະລິດແມ່ນໄດ້ຮັບໂດຍ
ຕໍ່ທ້າຍ loop ຂະຫນາດ (ທີ່ນີ້ "(x,y)") ກັບຂະຫນາດຜົນຜະລິດຫຼັກ (ທີ່ນີ້ 0D) ກັບ
ສົ່ງຜົນໃຫ້ຂະໜາດສຸດທ້າຍຂອງ pdl ທີ່ສ້າງອັດຕະໂນມັດ (ທີ່ນີ້ "0D+2D=2D" ເພື່ອໃຫ້ຜົນໄດ້ຮັບ 2D
ຂະຫນາດ "(x,y)").

ດັ່ງນັ້ນຄໍາສັ່ງຂ້າງເທິງນີ້ເອີ້ນວ່າການທໍາງານຫຼັກທີ່ຄິດໄລ່ຜະລິດຕະພັນພາຍໃນຂອງສອງ
1D vectors "x*y" ເວ​ລາ​ກັບ $w ແລະ​ສ່ວນ 1D ທັງ​ຫມົດ​ຂອງ​ຮູບ​ແບບ "(':,(i),(j)')" ຂອງ $im ແລະ
ກໍານົດອົງປະກອບຕາມລໍາດັບຂອງຜົນຜະລິດ pdl "$grey(i,j)" ກັບຜົນໄດ້ຮັບຂອງແຕ່ລະ
ການ​ຄິດ​ໄລ່​. ພວກເຮົາສາມາດຂຽນເປັນສັນຍາລັກ

$grey(0,0) = f($w,$im(:,(0),(0)))
$grey(1,0) = f($w,$im(:,(1),(0)))
.
.
.
$grey(x-2,y-1) = f($w,$im(:,(x-2),(y-1))))
$grey(x-1,y-1) = f($w,$im(:,(x-1),(y-1))))

ແຕ່ນີ້ແມ່ນເຮັດໂດຍອັດຕະໂນມັດໂດຍ PDL ໂດຍບໍ່ມີການຂຽນ Loop Perl ຢ່າງຊັດເຈນ. ພວກເຮົາເບິ່ງ
ວ່າຄໍາສັ່ງກໍ່ສ້າງ pdl ຜົນຜະລິດທີ່ມີຂະຫນາດທີ່ເຫມາະສົມແລະກໍານົດ
ອົງປະກອບທີ່ແທ້ຈິງແມ່ນຜົນຂອງການຄິດໄລ່ສໍາລັບແຕ່ລະ pixels ລວງຂອງຮູບພາບການປ້ອນຂໍ້ມູນ.

ໃນເວລາທີ່ pdls ແລະຂະຫນາດພິເສດແມ່ນມີສ່ວນຮ່ວມ, ສິ່ງຕ່າງໆກໍ່ສັບສົນຫຼາຍ.
ພວກເຮົາທໍາອິດຈະໃຫ້ກົດລະບຽບທົ່ວໄປວິທີການຂະຫນາດກະທູ້ຂຶ້ນກັບຂະຫນາດຂອງ
input pdls ຊ່ວຍໃຫ້ທ່ານສາມາດຄິດອອກຂະຫນາດຂອງ pdl ຜົນຜະລິດທີ່ສ້າງໂດຍອັດຕະໂນມັດ
(ສໍາລັບຊຸດການປ້ອນຂໍ້ມູນ pdls ແລະຂະຫນາດຫຼັກຂອງ PP-function ໃນຄໍາຖາມ). ໄດ້
ກົດລະບຽບທົ່ວໄປສ່ວນຫຼາຍອາດຈະສັບສົນເລັກນ້ອຍໃນສາຍຕາທໍາອິດດັ່ງນັ້ນພວກເຮົາຈະກໍານົດອອກ
ເພື່ອສະແດງໃຫ້ເຫັນເຖິງການນໍາໃຊ້ທີ່ມີຊຸດຂອງຕົວຢ່າງເພີ່ມເຕີມ (ເຊິ່ງຫວັງວ່າຈະ
ສະແດງໃຫ້ເຫັນວ່າມີຫຼາຍສະຖານະການປະຕິບັດຕົວຈິງທີ່ threading ເຂົ້າມາ
ມີປະໂຫຍດຫຼາຍ).

A ໂທ ສໍາລັບການ ລະຫັດ ລະບຽບວິໄນ
ກ່ອນທີ່ພວກເຮົາຈະຊີ້ໃຫ້ເຫັນລາຍລະອຽດດ້ານວິຊາການອື່ນໆຂອງ threading, ກະລຸນາສັງເກດການໂທນີ້ສໍາລັບ
ລະບຽບວິໄນການຂຽນໂປລແກລມໃນເວລາໃຊ້ threading:

ເພື່ອຮັກສາຄວາມສາມາດໃນການອ່ານຂອງມະນຸດ, ກະລຸນາ ຄໍາຄິດຄໍາເຫັນໃດໆການສະແດງອອກ nontrivial ໃນຂອງທ່ານ
ລະຫັດທີ່ກ່ຽວຂ້ອງກັບ threading. ສໍາຄັນທີ່ສຸດ, ສໍາລັບ subroutine ໃດ, ປະກອບມີຂໍ້ມູນຂ່າວສານທີ່
ການເລີ່ມຕົ້ນກ່ຽວກັບສິ່ງທີ່ທ່ານຄາດຫວັງວ່າຂະຫນາດຈະເປັນຕົວແທນ (ຫຼືຂອບເຂດຂອງຂະຫນາດ).

ໃນຖານະເປັນການເຕືອນ, ເບິ່ງຫນ້າທີ່ບໍ່ມີເອກະສານນີ້ແລະພະຍາຍາມເດົາສິ່ງທີ່ອາດຈະເກີດຂຶ້ນ:

ການຊອກຫາຍ່ອຍ {
my ($im,$palette) = @_;
$res ຂອງຂ້ອຍ;
index($palette->xchg(0,1),
$im->long->dummy(0,($palette->dim)[0]),
($res=null));
ກັບຄືນ $res;
}

ທ່ານຕົກລົງເຫັນດີວ່າມັນອາດຈະເປັນການຍາກທີ່ຈະຄິດອອກຂະຫນາດທີ່ຄາດໄວ້, ຈຸດປະສົງຂອງ
ປົກກະຕິ, ແລະອື່ນໆ? (ຖ້າທ່ານຕ້ອງການຊອກຫາສິ່ງທີ່ລະຫັດນີ້ເຮັດ, ເບິ່ງຂ້າງລຸ່ມນີ້)

ວິທີການ to ຮູບ ອອກ ໄດ້ loop ຂະຫນາດ
ມີ​ກົດ​ລະ​ບຽບ​ສອງ​ສາມ​ທີ່​ອະ​ນຸ​ຍາດ​ໃຫ້​ທ່ານ​ເພື່ອ​ຄິດ​ອອກ​ຈໍາ​ນວນ​ແລະ​ຂະ​ຫນາດ​ຂອງ loop ໄດ້​
ຂະຫນາດ (ແລະຖ້າຂະຫນາດຂອງ input pdls ຂອງທ່ານປະຕິບັດຕາມກົດລະບຽບ threading).
ຂະຫນາດຂອງການໂຕ້ຖຽງ pdl ໃດຖືກແບ່ງອອກເປັນສອງກຸ່ມດັ່ງຕໍ່ໄປນີ້: Core
ຂະຫນາດ (ຕາມທີ່ກໍານົດໂດຍ PP-function, ເບິ່ງ ເອກະສານຊ້ອນ B ສໍາລັບບັນຊີລາຍຊື່ຂອງ PDL primitives)
ແລະຂະຫນາດພິເສດທີ່ປະກອບດ້ວຍຂະຫນາດທີ່ຍັງເຫຼືອທັງຫມົດຂອງ pdl ນັ້ນ. ຍົກ​ຕົວ​ຢ່າງ
ເອີ້ນຟັງຊັນ "func" ທີ່ມີລາຍເຊັນ "func((n,m),[o](n))" ດ້ວຍ pdl.
"a(2,4,7,1,3)" ເປັນ "f($a,($o = null))" ສົ່ງຜົນໃຫ້ການແບ່ງຂະໜາດຂອງ a semantic.
ເຂົ້າໄປໃນ: ຂະຫນາດຫຼັກ "(2,4)" ແລະຂະຫນາດພິເສດ "(7,1,3)".

ຂະໜາດຫຼັກ R0 ຖືກລະບຸດ້ວຍຂະໜາດ N ທຳອິດຂອງ pdl ທີ່ກ່ຽວຂ້ອງ
ການໂຕ້ຖຽງ (ແລະຕ້ອງການ). ຂະຫນາດເພີ່ມເຕີມໃດໆແມ່ນຂະຫນາດພິເສດແລະໃຊ້ເພື່ອ
ກໍານົດຂະຫນາດຂອງ loop ໄດ້.

R1 ຈໍານວນຂອງ ( implicit ) ຂະຫນາດ loop ເທົ່າກັບຈໍານວນສູງສຸດຂອງພິເສດ
ຂະ​ຫນາດ​ທີ່​ນໍາ​ໃຊ້​ໃນ​ໄລ​ຍະ​ຊຸດ​ຂອງ​ການ​ໂຕ້​ຖຽງ pdl​.

R2 ຂະຫນາດຂອງແຕ່ລະຂະຫນາດຂອງ loop ແມ່ນມາຈາກຂະຫນາດຕາມລໍາດັບ
ຂະຫນາດຂອງການໂຕ້ຖຽງ pdl. ຂະຫນາດຂອງວົງແຫວນແມ່ນໃຫ້ໂດຍ
ຂະຫນາດສູງສຸດທີ່ພົບເຫັນຢູ່ໃນ pdls ໃດທີ່ມີຂະຫນາດພິເສດນີ້.

R3 ສໍາລັບ pdls ທັງຫມົດທີ່ມີຂະຫນາດພິເສດໃຫ້, ຂະຫນາດຈະຕ້ອງເທົ່າກັບຂະຫນາດຂອງ
ຂະຫນາດຂອງ loop (ຕາມການກໍານົດໂດຍກົດລະບຽບທີ່ຜ່ານມາ) ຫຼື 1; ຖ້າບໍ່ດັ່ງນັ້ນທ່ານຍົກ a
ຂໍ້ຍົກເວັ້ນ runtime. ຖ້າຂະຫນາດຂອງຂະຫນາດພິເສດໃນ pdl ແມ່ນຫນຶ່ງ
ປະຕິບັດໂດຍ implicitly ເປັນ dummy ຂະຫນາດຂອງຂະຫນາດເທົ່າກັບວ່າ loop dim ຂະຫນາດໃນເວລາທີ່
ປະຕິບັດການ loop thread.

R4 ຖ້າ pdl ບໍ່ມີຂະຫນາດຂອງ loop, ໃນ thread loop pdl ນີ້ຖືກປະຕິບັດຄືກັບວ່າ
ມີຂະຫນາດ dummy ຂອງຂະຫນາດເທົ່າກັບຂະຫນາດຂອງວົງ loop ນັ້ນ.

R5 ຖ້າ​ຫາກ​ວ່າ​ຜົນ​ຜະ​ລິດ​ການ​ສ້າງ​ອັດ​ຕະ​ໂນ​ມັດ​ໄດ້​ຖືກ​ນໍາ​ໃຊ້ (ໂດຍ​ການ​ຕັ້ງ pdl ທີ່​ກ່ຽວ​ຂ້ອງ​ເປັນ "PDL-​> null​" ກ່ອນ​.
invocation) ຈໍານວນຂະຫນາດຂອງ pdl ທີ່ສ້າງຂຶ້ນແມ່ນເທົ່າກັບຜົນລວມຂອງ
ຈໍາ​ນວນ​ຂະ​ຫນາດ​ຜະ​ລິດ​ຕະ​ພັນ​ຫຼັກ + ຈໍາ​ນວນ​ຂອງ​ຂະ​ຫນາດ loop​. ຂະຫນາດຂອງແກນ
ຂະຫນາດຜົນຜະລິດແມ່ນມາຈາກຂະຫນາດທີ່ກ່ຽວຂ້ອງຂອງ input pdls (ຕາມທີ່ລະບຸ
ໃນຄໍານິຍາມຟັງຊັນ) ແລະຂະຫນາດຂອງຂະຫນາດອື່ນໆແມ່ນເທົ່າກັບ
ຂະ​ຫນາດ​ຂອງ​ຂະ​ຫນາດ loop ມັນ​ແມ່ນ​ໄດ້​ມາ​ຈາກ​. pdl ສ້າງອັດຕະໂນມັດຈະເປັນ
ທາງກາຍະພາບ (ເວັ້ນເສຍແຕ່ dataflow ແມ່ນຢູ່ໃນການດໍາເນີນງານ).

ໃນສະພາບການນີ້, ໃຫ້ສັງເກດວ່າທ່ານສາມາດແລ່ນເຂົ້າໄປໃນບັນຫາທີ່ມີການມອບຫມາຍໃຫ້ກັບ pdls ທີ່ມີ
ຂະຫນາດ dummy ຫຼາຍກວ່າຫນຶ່ງ (ເບິ່ງຂ້າງເທິງ). ເຖິງແມ່ນວ່າ pdl ຜົນຜະລິດຂອງທ່ານບໍ່ມີ
ທຸກໆຂະຫນາດ dummy ໃນສະຖານທີ່ທໍາອິດທີ່ເຂົາເຈົ້າອາດຈະສິ້ນສຸດດ້ວຍ dummy ສ້າງ implicitly
ຂະຫນາດຕາມ R4.

ຕົວຢ່າງ, ສົມມຸດວ່າພວກເຮົາມີ PP-function (ທີ່ນີ້ບໍ່ໄດ້ລະບຸ) ທີ່ມີລາຍເຊັນ:

func((m,n),(m,n,o),(m),[o](m,o))

ແລະທ່ານເອີ້ນມັນດ້ວຍ 3 pdls "a(5,3,10,11)", "b(5,3,2,10,1,12)", ແລະ "c(5,1,11,12)" ເປັນ

func($a,$b,$c,($d=null))

ຫຼັງຈາກນັ້ນ, ຈໍານວນຂະຫນາດຂອງວົງແມ່ນ 3 (ໂດຍ "R0 + R1" ຈາກ $b ແລະ $c) ທີ່ມີຂະຫນາດ.
"(10,11,12)" (ໂດຍ R2); ສອງຂະຫນາດຫຼັກຜົນຜະລິດແມ່ນ "(5,2)" (ຈາກລາຍເຊັນຂອງ
func) ສົ່ງຜົນໃຫ້ຜົນຜະລິດ 5 ມິຕິ pdl $c ຂອງຂະຫນາດ "(5,2,10,11,12)" (ເບິ່ງ R5) ແລະ
(ທີ່ສ້າງຂຶ້ນໂດຍອັດຕະໂນມັດ) $d ແມ່ນມາຈາກ "($a,$b,$c)" ໃນຮູບແບບທີ່ສາມາດສະແດງອອກໄດ້.
ໃນ pdl pseudo-code as

$d(:,:,i,j,k).= func($a(:,:,i,j),$b(:,:,:,i,0,k),$c(:, 0,j,k))
ກັບ 0<=i<10, 0<=j<=11, 0<=k<12

ຖ້າພວກເຮົາວິເຄາະການປ່ຽນສີເປັນສີເທົາອີກຄັ້ງດ້ວຍກົດລະບຽບເຫຼົ່ານີ້ຢູ່ໃນໃຈພວກເຮົາສັງເກດເຫັນ
ອີກປະການຫນຶ່ງປະໂຫຍດທີ່ຍິ່ງໃຫຍ່ຂອງກະທູ້ implicit. ພວກເຮົາສາມາດໂທຫາການແປງດ້ວຍ pdl
ເປັນຕົວແທນ pixels (im(3)), ເສັ້ນຂອງ rgb pixels ("im(3,x)"), ຮູບພາບສີທີ່ເຫມາະສົມ
("im(3,x,y)") ຫຼືຮູບ RGB ທັງໝົດ ("im(3,x,y,z)"). ຕາບໃດທີ່ $im ແມ່ນຂອງ
ຮູບແບບ "(3, ...)" pdl ຜົນຜະລິດທີ່ສ້າງຂຶ້ນໂດຍອັດຕະໂນມັດຈະມີຈໍານວນທີ່ເຫມາະສົມ
ຂະ​ຫນາດ​ແລະ​ບັນ​ຈຸ​ຂໍ້​ມູນ​ຄວາມ​ເຂັ້ມ​ແຂງ​ດັ່ງ​ທີ່​ພວກ​ເຮົາ​ຄາດ​ຫວັງ​ວ່າ​ມັນ​ນັບ​ຕັ້ງ​ແຕ່ loops ໄດ້​
ປະຕິບັດ implicitly ຂອບໃຈ implicit ກະທູ້. ເຈົ້າສາມາດໂນ້ມນ້າວຕົວເອງໄດ້ງ່າຍໆວ່າ
ການໂທດ້ວຍສີ pixel $grey ແມ່ນ 0D, ມີສາຍມັນອອກເປັນ 1D grey(x), ມີຮູບ
ພວກເຮົາໄດ້ຮັບ "grey(x,y)" ແລະສຸດທ້າຍພວກເຮົາໄດ້ຮັບ stack ຮູບພາບ "grey(x,y,z)".

ຂໍໃຫ້ຕື່ມກົດລະບຽບທົ່ວໄປເຫຼົ່ານີ້ໃຫ້ກັບຊີວິດຕື່ມອີກໂດຍການຜ່ານສອງສາມອັນຕໍ່ໄປ
ຕົວຢ່າງ. ຜູ້​ອ່ານ​ອາດ​ຈະ​ພະ​ຍາ​ຍາມ​ທີ່​ຈະ​ຄິດ​ອອກ​ແບບ​ທີ່​ທຽບ​ເທົ່າ​ທີ່​ຈະ​ແຈ້ງ​ສໍາ​ລັບ​ການ
looping ແລະປຽບທຽບຄວາມຍືດຫຍຸ່ນຂອງປົກກະຕິເຫຼົ່ານັ້ນໂດຍໃຊ້ threading implicit ກັບ the
ການ​ສ້າງ​ຕັ້ງ​ຢ່າງ​ຊັດ​ເຈນ​. ນອກຈາກນັ້ນ, ໂດຍສະເພາະໃນເວລາທີ່ການນໍາໃຊ້ຂະຫນາດ thread ຫຼາຍມັນເປັນ a
ອອກ​ກໍາ​ລັງ​ກາຍ​ທີ່​ເປັນ​ປະ​ໂຫຍດ​ເພື່ອ​ກວດ​ສອບ​ຄວາມ​ໄວ​ຂອງ​ພີ່​ນ້ອງ​ໂດຍ​ການ​ເຮັດ​ການ​ທົດ​ສອບ benchmark ບາງ (ທີ່​ພວກ​ເຮົາ​ຍັງ​
ຕ້ອງ​ເຮັດ).

ຫນ້າທໍາອິດໃນແຖວແມ່ນຕົວຢ່າງ centroid ທີ່ເຮັດໃຫມ່ເລັກນ້ອຍ, ຕອນນີ້ຖືກລະຫັດດ້ວຍ threading
ຈິດໃຈ.

# threaded mult ເພື່ອຄິດໄລ່ centroid coords, ເຮັດວຽກສໍາລັບການ stacks ເຊັ່ນດຽວກັນ
$xc = sumover(($im*xvals(($im->dims)[0]))->ກຸ່ມ(2)) /
sumover($im->ກຸ່ມ(2));

ຂໍໃຫ້ວິເຄາະສິ່ງທີ່ເກີດຂຶ້ນເທື່ອລະກ້າວ. ຫນ້າທໍາອິດຜະລິດຕະພັນ:

$prod = $im*xvals(zeroes(($im->dims)[0]))

ນີ້ຕົວຈິງແລ້ວຈະເຮັດວຽກສໍາລັບການ $im ເປັນຫນຶ່ງ, ສອງ, ສາມ, ແລະມິຕິສູງກວ່າ. ຖ້າ $im ແມ່ນ
one-dimensional ມັນເປັນພຽງແຕ່ຜະລິດຕະພັນທໍາມະດາ (ໃນຄວາມຫມາຍວ່າທຸກໆອົງປະກອບຂອງ $im ແມ່ນ
ຄູນດ້ວຍອົງປະກອບຕາມລໍາດັບຂອງ "xvals(...)"), ຖ້າ $im ມີຂະຫນາດຫຼາຍ
ກະທູ້ເພີ່ມເຕີມແມ່ນເຮັດໄດ້ໂດຍການເພີ່ມຂະຫນາດ dummy ທີ່ເຫມາະສົມກັບ "xvals(...)"
ອີງຕາມ R4. ສິ່ງທີ່ສໍາຄັນກວ່ານັ້ນ, ການປະຕິບັດການ suover ສອງສະແດງໃຫ້ເຫັນຕົວຢ່າງທໍາອິດຂອງວິທີການ
ເພື່ອເຮັດໃຫ້ການນໍາໃຊ້ຄໍາສັ່ງ manipulating ຂະຫນາດ. ເບິ່ງລາຍເຊັນຂອງ sumover ຢ່າງໄວວາ
ຈະເຕືອນທ່ານວ່າມັນພຽງແຕ່ "gobble" ຂະຫນາດທໍາອິດຂອງ pdl ປ້ອນຂໍ້ມູນໃຫ້.
ແຕ່ຈະເປັນແນວໃດຖ້າພວກເຮົາຕ້ອງການຄິດໄລ່ຜົນລວມຫຼາຍກວ່າອົງປະກອບທັງຫມົດຂອງສອງທໍາອິດ
ຂະຫນາດ? ດີ, ບໍ່ມີຫຍັງເຮັດໃຫ້ພວກເຮົາຈາກການຖ່າຍທອດ pdl virtual ເຂົ້າໄປໃນ sumover ເຊິ່ງໃນນີ້
ກໍ​ລະ​ນີ​ແມ່ນ​ສ້າງ​ຕັ້ງ​ຂຶ້ນ​ໂດຍ clumping ສອງ​ມິ​ຕິ​ທໍາ​ອິດ​ຂອງ "parent pdl​" ເປັນ​ຫນຶ່ງ​. ຈາກ
ທັດສະນະຂອງ pdl ພໍ່ແມ່, ຜົນລວມໄດ້ຖືກຄິດໄລ່ໃນປັດຈຸບັນໃນໄລຍະສອງມິຕິທໍາອິດ,
ດັ່ງທີ່ພວກເຮົາຕ້ອງການ, ເຖິງແມ່ນວ່າ sumover ໄດ້ເຮັດວຽກຕາມທີ່ລະບຸໄວ້ໃນລາຍເຊັນຂອງມັນ. ໄດ້
ມັນ ?

ອີກອັນໜຶ່ງອັນເລັກນ້ອຍຂອງການຂຽນລະຫັດແບບນັ້ນ: ພວກເຮົາຕັ້ງໃຈໃຊ້
"sumover($pdl->ກຸ່ມ(2))" ແທນ "sum($pdl)" ເພື່ອໃຫ້ພວກເຮົາສາມາດຜ່ານພຽງແຕ່ຮູບພາບ
"(x,y)" ຫຼື stack ຂອງຮູບ "(x,y,t)" ເຂົ້າໄປໃນປົກກະຕິນີ້ແລະໄດ້ຮັບພຽງແຕ່ຫນຶ່ງ.
x-coordiante ຫຼື vector ຂອງ x-coordinates (ຂະຫນາດ t) ໃນການກັບຄືນ.

ຊຸດການດໍາເນີນງານທົ່ວໄປອີກອັນຫນຶ່ງແມ່ນສິ່ງທີ່ຄົນເຮົາສາມາດເອີ້ນວ່າ "ການດໍາເນີນງານການຄາດຄະເນ". ເຫຼົ່ານີ້
ການດໍາເນີນງານໃຊ້ເວລາ ND pdl ເປັນ input ແລະສົ່ງຄືນ a (N-1)-D "projected" pdl. ການດໍາເນີນງານເຫຼົ່ານີ້
ມັກຈະຖືກປະຕິບັດດ້ວຍຫນ້າທີ່ເຊັ່ນ: sumover, prodover, ຕໍາ່ສຸດທີ່ແລະສູງສຸດ. ການນໍາໃຊ້
ອີກເທື່ອຫນຶ່ງຮູບພາບເປັນຕົວຢ່າງທີ່ພວກເຮົາອາດຈະຕ້ອງການຄິດໄລ່ຄ່າ pixels ສູງສຸດສໍາລັບແຕ່ລະເສັ້ນ
ຂອງຮູບພາບຫຼື stack ຮູບພາບ. ພວກເຮົາຮູ້ວິທີເຮັດແນວນັ້ນ

# ສູງສຸດຂອງເສັ້ນ (ເປັນຫນ້າທີ່ຂອງຈໍານວນເສັ້ນແລະເວລາ)
ສູງສຸດ($stack,($ret=null));

ແຕ່ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະຄິດໄລ່ສູງສຸດຕໍ່ຖັນໃນເວລາທີ່ກະທູ້ implicit ສະເຫມີນໍາໃຊ້
ການທໍາງານຫຼັກຂອງມິຕິທໍາອິດແລະກະທູ້ໃນໄລຍະອື່ນໆທັງຫມົດ? ພວກເຮົາສາມາດເຮັດແນວໃດ
ບັນ​ລຸ​ໄດ້​ວ່າ​ແທນ​ທີ່​ຈະ​ເປັນ​ການ​ທໍາ​ງານ​ຫຼັກ​ໄດ້​ຖືກ​ນໍາ​ໃຊ້​ກັບ​ມິ​ຕິ​ທີ​ສອງ​ແລະ​
threading ແມ່ນເຮັດໃນໄລຍະອື່ນໆ. ເຈົ້າເດົາໄດ້ບໍ? ແມ່ນແລ້ວ, ພວກເຮົາສ້າງ pdl virtual ທີ່ມີ
ມິຕິທີສອງຂອງ "parent pdl" ເປັນມິຕິທໍາອິດຂອງມັນໂດຍໃຊ້ຄໍາສັ່ງ "mv".

# ຖັນສູງສຸດ (ເປັນໜ້າທີ່ຂອງຈຳນວນຖັນ ແລະເວລາ)
ສູງສຸດ($stack->mv(1,0),($ret=null));

ແລະການຄິດໄລ່ຜົນລວມທັງຫມົດຂອງຕ່ອນຍ່ອຍໃນໄລຍະສາມມິຕິໃນປັດຈຸບັນແມ່ນເກືອບງ່າຍເກີນໄປ

# ຜົນລວມຂອງ pixels ໃນເວລາ (ສົມມຸດວ່າເວລາແມ່ນຄວາມມືດທີສາມ)
sumover($stack->mv(2,0),($ret=null));

ສຸດທ້າຍ, ຖ້າຫາກວ່າທ່ານຕ້ອງການທີ່ຈະນໍາໃຊ້ການດໍາເນີນງານກັບອົງປະກອບທັງຫມົດ (ເຊັ່ນ: ສູງສຸດຂອງອົງປະກອບທັງຫມົດຫຼື
ຜົນບວກຫຼາຍກວ່າອົງປະກອບທັງຫມົດ) ໂດຍບໍ່ຄໍານຶງເຖິງຂະຫນາດຂອງ pdl ໃນຄໍາຖາມ "clump" ມາ
ໃນ handy. ເປັນຕົວຢ່າງເບິ່ງຄໍານິຍາມຂອງ "sum" (ຕາມກໍານົດໃນ "Ufunc.pm"):

ຜົນລວມຍ່ອຍ {
PDL::Ufunc::sumover($name->clump(-1),($tmp=null));
ກັບຄືນ $tmp->at(); # ສົ່ງຄືນຕົວເລກ Perl, ບໍ່ແມ່ນ 0D pdl
}

ພວກເຮົາໄດ້ກ່າວມາແລ້ວວ່າການດໍາເນີນງານພື້ນຖານທັງຫມົດສະຫນັບສະຫນູນ threading ແລະການມອບຫມາຍແມ່ນບໍ່ມີ
ຂໍ້​ຍົກ​ເວັ້ນ. ດັ່ງນັ້ນ, ນີ້ແມ່ນການມອບຫມາຍສອງສາມກະທູ້

pdl> $im = zeroes(byte, 10,20)
pdl> $line = exp(-rvals(10)**2/9)
# ການມອບໝາຍແບບກະທູ້
pdl> $im .= $line # ຕັ້ງທຸກເສັ້ນຂອງ $im ເປັນ $line
pdl> $im2 .= 5 # ຕັ້ງທຸກອົງປະກອບຂອງ $im2 ເປັນ 5

ຕອນນີ້ເຈົ້າຄົງຈະເຫັນວ່າມັນເຮັດວຽກແນວໃດ ແລະມັນເຮັດຫຍັງ, ບໍ່ແມ່ນບໍ?

ເພື່ອສໍາເລັດຮູບຕົວຢ່າງໃນວັກນີ້ແມ່ນຫນ້າທີ່ສ້າງຮູບພາບ RGB ຈາກ
ອັນທີ່ເອີ້ນວ່າຮູບ palette. ຮູບພາບ palette ປະກອບດ້ວຍສອງພາກສ່ວນ: ຮູບພາບຂອງ
ຕົວຊີ້ວັດເຂົ້າໃນຕາຕະລາງຊອກຫາສີແລະຕາຕະລາງຊອກຫາສີຂອງມັນເອງ. [ອະທິບາຍວິທີການ
ເຮັດວຽກ] ພວກເຮົາຈະໃຊ້ PP-function ທີ່ພວກເຮົາຍັງບໍ່ໄດ້ encoutered ເທື່ອໃນທີ່ຜ່ານມາ
ຕົວຢ່າງ. ມັນ​ເປັນ​ຫນ້າ​ທີ່​ດັດ​ຊະ​ນີ​ທີ່​ມີ​ຊື່​ທີ່​ເຫມາະ​ສົມ​, ລາຍ​ເຊັນ "((n​)​, (), [o​]())" (ເບິ່ງ ເອກະສານຊ້ອນ
B) ດ້ວຍການທໍາງານຫຼັກທີ່ "index(pdl (0,2,4,5),2,($ret=null))" ຈະສົ່ງຄືນຄ່າ.
ອົງປະກອບທີ່ມີດັດຊະນີ 2 ຂອງ input pdl ທໍາອິດ. ໃນກໍລະນີນີ້, $ret ຈະມີຄ່າ 4.
ດັ່ງນັ້ນນີ້ແມ່ນຕົວຢ່າງ:

# ການຊອກຫາດັດຊະນີແບບກະທູ້ເພື່ອສ້າງຮູບ RGB, ຫຼື RGBA ຫຼື YMCK
# ຈາກຮູບ palette (ສະແດງໂດຍຕາຕະລາງຊອກຫາ $palette ແລະ
# ຮູບພາບດັດສະນີສີ $im)
# ເຈົ້າສາມາດເວົ້າພຽງແຕ່ dummy(0) ນັບຕັ້ງແຕ່ກົດລະບຽບຂອງ threading ເຮັດໃຫ້ມັນເຫມາະ
pdl> index($palette->xchg(0,1),
$im->long->dummy(0,($palette->dim)[0]),
($res=null));

ໃຫ້ຜ່ານມັນແລະອະທິບາຍຂັ້ນຕອນທີ່ກ່ຽວຂ້ອງ. ສົມມຸດວ່າພວກເຮົາກໍາລັງຈັດການກັບ RGB
lookup-table $palette ມີຂະໜາດ "(3,x)". ທໍາອິດພວກເຮົາແລກປ່ຽນຂະຫນາດຂອງ palette ໄດ້
ດັ່ງນັ້ນການ looping ແມ່ນເຮັດໄດ້ຫຼາຍກວ່າມິຕິທໍາອິດຂອງ $palette (ຂະຫນາດ 3 ທີ່ເປັນຕົວແທນ r,
g, ແລະ b ອົງປະກອບ). ໃນປັດຈຸບັນເບິ່ງ $im, ພວກເຮົາເພີ່ມຂະຫນາດ dummy ຂອງຂະຫນາດເທົ່າກັບ
ຄວາມຍາວຂອງຈໍານວນຂອງອົງປະກອບ (ໃນກໍລະນີທີ່ພວກເຮົາກໍາລັງສົນທະນານີ້ພວກເຮົາສາມາດມີພຽງແຕ່
ໃຊ້ເລກ 3 ເນື່ອງຈາກພວກເຮົາມີ 3 ອົງປະກອບສີ). ພວກເຮົາສາມາດນໍາໃຊ້ຂະຫນາດ dummy ນັບຕັ້ງແຕ່
ສໍາລັບອົງປະກອບສີສີແດງ, ສີຂຽວແລະສີຟ້າ, ພວກເຮົາໃຊ້ດັດຊະນີດຽວກັນຈາກຮູບພາບຕົ້ນສະບັບ,
ຕົວຢ່າງ: ສົມມຸດວ່າ pixel ທີ່ແນ່ນອນຂອງ $im ມີມູນຄ່າ 4 ຫຼັງຈາກນັ້ນການຊອກຫາຄວນຈະຜະລິດ
triple

[palette(0,4),palette(1,4),palette(2,4)]

ສໍາລັບອົງປະກອບສີແດງ, ສີຂຽວແລະສີຟ້າໃຫມ່ຂອງຮູບພາບຜົນຜະລິດ. ຫວັງເປັນຢ່າງຍິ່ງວ່າໃນປັດຈຸບັນທ່ານມີ
ບາງປະເພດຂອງຄວາມຄິດສິ່ງທີ່ລະຫັດຂ້າງເທິງນີ້ຄວນຈະເຮັດ (ມັນມັກຈະເປັນ
ຂ້ອນຂ້າງສັບສົນເພື່ອອະທິບາຍລາຍລະອຽດວິທີການເຮັດວຽກຂອງລະຫັດ threading; ພຽງແຕ່ສືບຕໍ່ເດີນຫນ້າ
ແລະທົດລອງເລັກນ້ອຍເພື່ອໃຫ້ໄດ້ຄວາມຮູ້ສຶກທີ່ດີກວ່າສໍາລັບມັນ).

ຖ້າທ່ານໄດ້ອ່ານກົດລະບຽບກະທູ້ຢ່າງລະມັດລະວັງ, ທ່ານອາດຈະສັງເກດເຫັນວ່າພວກເຮົາບໍ່ໄດ້
ຕ້ອງບອກຢ່າງຈະແຈ້ງກ່ຽວກັບຂະຫນາດຂອງ dummy ທີ່ພວກເຮົາສ້າງສໍາລັບ $im; ໃນ​ເວ​ລາ​ທີ່​ພວກ​ເຮົາ
ສ້າງມັນດ້ວຍຂະຫນາດ 1 (ຄ່າເລີ່ມຕົ້ນ) ກົດລະບຽບຂອງ threading ເຮັດໃຫ້ມັນເຫມາະກັບອັດຕະໂນມັດ
ຂະຫນາດທີ່ຕ້ອງການ (ຕາມກົດລະບຽບ R3, ໃນຕົວຢ່າງຂອງພວກເຮົາຂະຫນາດຈະເປັນ 3 ສົມມຸດວ່າ palette ຂອງ
ຂະຫນາດ "(3,x)"). ເນື່ອງຈາກວ່າສະຖານະການເຊັ່ນນີ້ເກີດຂຶ້ນເລື້ອຍໆໃນການປະຕິບັດ, ນີ້ແມ່ນເຫດຜົນແທ້ໆ
ກົດລະບຽບ R3 ໄດ້ຖືກນໍາສະເຫນີ (ສ່ວນທີ່ເຮັດໃຫ້ຂະຫນາດຂອງຂະຫນາດ 1 ເຫມາະກັບກະທູ້
loop ຂະ​ຫນາດ dim). ດັ່ງນັ້ນພວກເຮົາພຽງແຕ່ສາມາດເວົ້າ

pdl> index($palette->xchg(0,1),$im->long->dummy(0),($res=null));

ອີກເທື່ອຫນຶ່ງ, ທ່ານສາມາດເຮັດໃຫ້ຕົວທ່ານເອງວ່າປົກກະຕິນີ້ຈະສ້າງຜົນຜະລິດທີ່ເຫມາະສົມຖ້າຖືກເອີ້ນ
ດ້ວຍ pixels ($im ແມ່ນ 0D), ເສັ້ນ ($im ແມ່ນ 1D), ຮູບພາບ ($im ແມ່ນ 2D), ..., ການຊອກຫາ RGB
ຕາຕະລາງ (palette ແມ່ນ "(3,x)") ແລະຕາຕະລາງຊອກຫາ RGBA (palette ແມ່ນ "(4,x)", ເບິ່ງຕົວຢ່າງ OpenGL).
ຄວາມຍືດຫຍຸ່ນນີ້ແມ່ນບັນລຸໄດ້ໂດຍກົດລະບຽບຂອງ threading ທີ່ເຮັດຢ່າງຖືກຕ້ອງ
ສິ່ງທີ່ຢູ່ໃນສະຖານະການສ່ວນໃຫຍ່.

ເພື່ອຫໍ່ມັນທັງຫມົດອີກເທື່ອຫນຶ່ງ, ແນວຄວາມຄິດທົ່ວໄປແມ່ນດັ່ງຕໍ່ໄປນີ້. ຖ້າທ່ານຕ້ອງການບັນລຸ
looping ໃນໄລຍະສະເພາະໃດຫນຶ່ງແລະມີ core functionality ນຳໃຊ້ກັບອັນອື່ນ
ທີ່ກໍານົດໄວ້ຂອງຂະຫນາດທີ່ທ່ານໃຊ້ຄໍາສັ່ງ manipulating ມິຕິເພື່ອສ້າງ (ຫຼື
ຫຼາຍ) virtual pdl(s) ດັ່ງນັ້ນຈາກຈຸດຂອງທັດສະນະຂອງ ພໍ່ແມ່ pdl(s) ທ່ານໄດ້ຮັບສິ່ງທີ່
ທ່ານຕ້ອງການ (ສະເຫມີມີລາຍເຊັນຂອງຫນ້າທີ່ຢູ່ໃນຄໍາຖາມແລະ R1-R5 ຢູ່ໃນໃຈ!).
ງ່າຍ, ບໍ່ແມ່ນບໍ?

ຜົນຜະລິດ ການສ້າງອັດຕະໂນມັດ ແລະ ຟັງຊັນ PP ໂທຫາ ອະນຸສັນຍາ
ໃນຈຸດນີ້, ພວກເຮົາຕ້ອງຫັນໄປຫາລາຍລະອຽດດ້ານວິຊາການບາງຢ່າງທີ່ກ່ຽວຂ້ອງກັບທົ່ວໄປ
ການເອີ້ນສົນທິສັນຍາຂອງ PP-functions ແລະການສ້າງອັດຕະໂນມັດຂອງການໂຕ້ຖຽງຜົນຜະລິດ.
ໂດຍພື້ນຖານແລ້ວ, ມີສອງວິທີຂອງການເອີ້ນ pdl routines, ຄື

$result = func($a,$b);

ແລະ

func($a,$b,$result);

ຖ້າທ່ານພຽງແຕ່ໃຊ້ threading implicit ຫຼັງຈາກນັ້ນຕົວແປຜົນຜະລິດສາມາດອັດຕະໂນມັດ
ສ້າງໂດຍ PDL. ທ່ານຕັ້ງທຸງນັ້ນໃສ່ PP-function ໂດຍກໍານົດການໂຕ້ຖຽງຜົນຜະລິດເປັນ a
pdl ປະເພດພິເສດທີ່ຖືກສົ່ງຄືນຈາກການໂທຫາຟັງຊັນ "PDL->null" ທີ່ກັບຄືນມາ
pdl ທີ່ຈໍາເປັນ "ຫວ່າງເປົ່າ" (ສໍາລັບຜູ້ທີ່ສົນໃຈໃນລາຍລະອຽດມີທຸງຢູ່ໃນ C pdl
ໂຄງປະກອບການນີ້). ຂະຫນາດຂອງ pdl ທີ່ສ້າງຂຶ້ນແມ່ນຖືກກໍານົດໂດຍກົດລະບຽບຂອງ
ກະທູ້ implicit: ຂະຫນາດທໍາອິດແມ່ນຂະຫນາດຜົນຜະລິດຫຼັກທີ່
ຂະ​ຫນາດ​ກະ​ທູ້​ແມ່ນ​ໄດ້​ຕໍ່​ທ້າຍ (ຊຶ່ງ​ໃນ​ນັ້ນ​ກໍາ​ນົດ​ໂດຍ​ຂະ​ຫນາດ​ຂອງ​
input pdls ດັ່ງທີ່ອະທິບາຍຂ້າງເທິງ). ດັ່ງນັ້ນເຈົ້າສາມາດເວົ້າໄດ້

func($a,$b,($result=PDL->null));

or

$result = func($a,$b)

ເຊິ່ງແມ່ນ ຢ່າງ​ແນ່​ນອນ ທຽບເທົ່າ.

ໄດ້ຮັບການເຕືອນວ່າທ່ານສາມາດເຮັດໄດ້ ບໍ່ ໃຊ້ການສ້າງຜົນຜະລິດອັດຕະໂນມັດໃນເວລາທີ່ໃຊ້ threading explicit (ສໍາລັບ
ເຫດຜົນອະທິບາຍໃນພາກຕໍ່ໄປນີ້ກ່ຽວກັບ ຢ່າງຊັດເຈນ ກະທູ້, variant ທີສອງຂອງ
threading).

ໃນ loops "ແຫນ້ນ" ທ່ານອາດຈະຕ້ອງການທີ່ຈະຫຼີກເວັ້ນການສ້າງ implicit ຂອງ pdl ຊົ່ວຄາວໃນ
ແຕ່ລະຂັ້ນຕອນຂອງ loop ທີ່ມາພ້ອມກັບຮູບແບບ "ຫນ້າທີ່" ແຕ່ແທນທີ່ຈະເວົ້າ

# ສ້າງ pdl ຜົນຜະລິດຂອງຂະຫນາດທີ່ເຫມາະສົມພຽງແຕ່ຢູ່ໃນການຮຽກຮ້ອງຄັ້ງທໍາອິດ
$result = null;
ສໍາລັບ (0...$n) {
func($a,$b,$result); # ທັງໝົດແຕ່ການຮຽກຮ້ອງທຳອິດ $result
func2($b); # ຖືກກໍານົດແລະມີຂະຫນາດທີ່ເຫມາະສົມກັບ
# ເອົາຜົນໄດ້ຮັບທີ່ສະຫນອງໃຫ້ $b's dims ບໍ່ປ່ຽນແປງ
twiddle($result,$a); # ເຮັດບາງຢ່າງຈາກ $result ຫາ $a ເພື່ອເຮັດຊ້ຳ
}

ຂໍ້ຄວາມທີ່ເອົາຢູ່ເຮືອນຂອງພາກນີ້ອີກເທື່ອຫນຶ່ງ: ຈົ່ງຮູ້ເຖິງຂໍ້ຈໍາກັດຂອງຜົນຜະລິດ
ການສ້າງໃນເວລາທີ່ການນໍາໃຊ້ ຢ່າງຊັດເຈນ ກະທູ້.

ໂດຍສະເພາະ ກະທູ້
ມາເຖິງຕອນນັ້ນພຽງແຕ່ເວົ້າເຖິງລົດຊາດທໍາອິດຂອງກະທູ້, ມັນເຖິງເວລາແລ້ວ
ແນະນໍາຕົວແປທີສອງ. ແທນທີ່ຈະ shuffling ປະມານຂະຫນາດຕະຫຼອດເວລາແລະ
ອີງໃສ່ກົດລະບຽບຂອງກະທູ້ implicit ເພື່ອໃຫ້ມັນຖືກຕ້ອງທັງຫມົດບາງເທື່ອເຈົ້າອາດຈະຕ້ອງການ
ລະບຸໃນວິທີການທີ່ຈະແຈ້ງກວ່າວິທີການປະຕິບັດການ loop thread. ມັນອາດຈະບໍ່ຄືກັນ
ແປກໃຈທີ່ variant ຂອງເກມນີ້ແມ່ນເອີ້ນວ່າ ຢ່າງຊັດເຈນ ກະທູ້. ໃນປັດຈຸບັນ, ກ່ອນທີ່ພວກເຮົາ
ສ້າງຄວາມປະທັບໃຈທີ່ບໍ່ຖືກຕ້ອງ: ມັນບໍ່ແມ່ນ implicit or ຢ່າງຊັດເຈນ; ສອງລົດຊາດເຮັດ
ປະສົມ. ແຕ່ເພີ່ມເຕີມກ່ຽວກັບວ່າຕໍ່ມາ.

ສອງຟັງຊັນທີ່ໃຊ້ຫຼາຍທີ່ສຸດທີ່ມີ threading ຢ່າງຊັດເຈນແມ່ນ thread ແລະ unthread. ພວກເຮົາເລີ່ມຕົ້ນ
ດ້ວຍຕົວຢ່າງທີ່ສະແດງໃຫ້ເຫັນເຖິງການນໍາໃຊ້ປົກກະຕິຂອງອະດີດ:

[ # ** ນີ້ແມ່ນຕົວຢ່າງທີ່ຮ້າຍແຮງທີ່ສຸດທີ່ຈະເລີ່ມຕົ້ນດ້ວຍ]
# ແຕ່ສາມາດໃຊ້ເພື່ອສະແດງໃຫ້ເຫັນວ່າ $mat += $line ແຕກຕ່າງຈາກ
# $mat->ກະ​ທູ້(0) += $line
# threading explicit ເພື່ອເພີ່ມ vector ໃສ່ແຕ່ລະຖັນຂອງ matrix
pdl> $mat = ສູນ(4,3)
pdl> $line = pdl (3.1416,2,-2)
pdl> ($tmp = $mat->ກະ​ທູ້(0)) += $line

ໃນຕົວຢ່າງນີ້, "$mat->ກະ​ທູ້(0)" ບອກ PDL ວ່າທ່ານຕ້ອງການມິຕິທີສອງຂອງສິ່ງນີ້
pdl ທີ່ຈະ threaded ທໍາອິດທີ່ນໍາໄປສູ່ loop thread ທີ່ສາມາດສະແດງອອກເປັນ

ສໍາລັບ (j=0; j<3; j++) {
ສໍາລັບ (i=0; i<4; i++) {
mat(i,j) += src(j);
}
}

"ກະທູ້" ເອົາບັນຊີລາຍຊື່ຂອງຕົວເລກເປັນ arguments ທີ່ລະບຸຢ່າງຊັດເຈນວ່າຂະຫນາດໃດ
ກະທູ້ກ່ອນ. ດ້ວຍການແນະນໍາຂອງກະທູ້ທີ່ຊັດເຈນ, ຂະຫນາດຂອງ pdl ແມ່ນ
ແນວຄວາມຄິດແບ່ງອອກເປັນສາມກຸ່ມທີ່ແຕກຕ່າງກັນ, ສອງອັນສຸດທ້າຍທີ່ພວກເຮົາມີຢູ່ແລ້ວ
ພົບ: ຂະໜາດກະທູ້, ຂະໜາດຫຼັກ ແລະ ຂະໜາດພິເສດ.

ແນວຄວາມຄິດ, ມັນດີທີ່ສຸດທີ່ຈະຄິດເຖິງຂະຫນາດຂອງ pdl ທີ່ໄດ້ລະບຸໄວ້ໃນ
ການໂທຫາ "ກະທູ້" ທີ່ຖືກເອົາໄປຈາກຂະຫນາດປົກກະຕິແລະໃສ່ a
stack ແຍກຕ່າງຫາກ. ດັ່ງນັ້ນສົມມຸດວ່າພວກເຮົາມີ pdl "a(4,7,2,8)" ເວົ້າ

$b = $a->ກະທູ້(2,1)

ສ້າງ pdl virtual ໃຫມ່ຂອງຂະຫນາດ "b(4,8)" (ທີ່ພວກເຮົາເອີ້ນວ່າ dims ທີ່ຍັງເຫຼືອ) ທີ່.
ຍັງມີຂະຫນາດ 2 thread ຂອງຂະຫນາດ "(2,7)". ສໍາລັບຈຸດປະສົງຂອງເອກະສານນີ້ພວກເຮົາຂຽນ
ທີ່ເປັນສັນຍາລັກເປັນ "b(4,8){2,7}". ຄວາມແຕກຕ່າງທີ່ສໍາຄັນກັບຕົວຢ່າງທີ່ຜ່ານມາບ່ອນທີ່
ພຽງແຕ່ໃຊ້ threading implicit ແມ່ນຄວາມຈິງທີ່ວ່າຂະຫນາດຫຼັກຖືກຈັບຄູ່ກັບ
ໄດ້ ຍັງເຫຼືອ ຂະຫນາດ ເຊິ່ງບໍ່ຈໍາເປັນຂະຫນາດທໍາອິດຂອງ pdl. ພວກເຮົາ
ຕອນນີ້ຈະລະບຸວ່າຂະໜາດຂອງກະທູ້ປ່ຽນແປງກົດລະບຽບ R1-R5 ແນວໃດສຳລັບກະທູ້
loops (ເຊິ່ງໃຊ້ກັບກໍລະນີພິເສດທີ່ບໍ່ມີການໂຕ້ຖຽງ pdl ໃດໆ
ຂະຫນາດ).

ຂະຫນາດ T0 Core ຖືກຈັບຄູ່ກັບ n ທໍາອິດ ຍັງເຫຼືອ ຂະຫນາດ ຂອງ pdl
ການໂຕ້ຖຽງ (ສັງເກດຄວາມແຕກຕ່າງກັບ R1). ຕື່ມອີກ ຍັງເຫຼືອ ຂະຫນາດ ມີ ພິເສດ
ຂະຫນາດ ແລະຖືກນໍາໃຊ້ເພື່ອກໍານົດ implicit loop ຂະຫນາດ.

T1a ຈໍານວນຂອງ implicit loop ຂະຫນາດ ເທົ່າກັບຈໍານວນສູງສຸດຂອງພິເສດ
ຂະ​ຫນາດ​ທີ່​ນໍາ​ໃຊ້​ໃນ​ໄລ​ຍະ​ຊຸດ​ຂອງ​ການ​ໂຕ້​ຖຽງ pdl​.

T1b ຈໍານວນຂອງ ຢ່າງຊັດເຈນ loop ຂະຫນາດ ເທົ່າກັບຈຳນວນສູງສຸດຂອງກະທູ້
ຂະ​ຫນາດ​ທີ່​ນໍາ​ໃຊ້​ໃນ​ໄລ​ຍະ​ຊຸດ​ຂອງ​ການ​ໂຕ້​ຖຽງ pdl​.

T1c ຈໍານວນທັງຫມົດຂອງ loop ຂະຫນາດ ແມ່ນເທົ່າກັບຜົນລວມຂອງ ຢ່າງຊັດເຈນ loop ຂະຫນາດ
ແລະ implicit loop ຂະຫນາດ. ໃນ loop thread, ຢ່າງຊັດເຈນ loop ຂະຫນາດ ມີ
threaded ທໍາອິດປະຕິບັດຕາມໂດຍ implicit loop ຂະຫນາດ.

T2 ຂະຫນາດຂອງແຕ່ລະຄົນ loop ຂະຫນາດ ແມ່ນໄດ້ມາຈາກຂະຫນາດຕາມລໍາດັບ
ຂະຫນາດຂອງການໂຕ້ຖຽງ pdl. ມັນໄດ້ຖືກມອບໃຫ້ໂດຍຂະຫນາດສູງສຸດທີ່ພົບໃນ pdls ໃດ
ມີຂະຫນາດກະທູ້ນີ້ (ສໍາລັບ ຢ່າງຊັດເຈນ loop ຂະຫນາດ) ຫຼືຂະຫນາດພິເສດ (ສໍາລັບ
implicit loop ຂະຫນາດ).

T3 ກົດລະບຽບນີ້ໃຊ້ກັບທຸກ ຢ່າງຊັດເຈນ loop dimension ເຊັ່ນດຽວກັນກັບໃດໆ implicit loop
dimension. ສໍາລັບ pdls ທັງຫມົດທີ່ໃຫ້ thread / ພິເສດ dimension ຂະຫນາດຕ້ອງເປັນ
ເທົ່າກັບຂະຫນາດຕາມລໍາດັບ ຊັດເຈນ / implicit loop dimension ຫຼື 1; ຖ້າບໍ່ດັ່ງນັ້ນ
ທ່ານຍົກຂໍ້ຍົກເວັ້ນ runtime. ຖ້າຂະຫນາດຂອງ ກ thread / ພິເສດ dimension ຂອງ pdl ແມ່ນຫນຶ່ງ
ມັນໄດ້ຖືກປະຕິບັດໂດຍ implicitly ເປັນຂະຫນາດ dummy ຂອງຂະຫນາດເທົ່າກັບ ຊັດເຈນ / implicit
loop dimension.

T4 ຖ້າ pdl ບໍ່ມີ a thread / ພິເສດ dimension ທີ່​ສອດ​ຄ້ອງ​ກັນ​ກັບ​
ຊັດເຈນ / implicit loop dimension, ໃນ loop thread pdl ນີ້ຖືກປະຕິບັດຄືກັບວ່າມີ
ຂະຫນາດ dummy ຂອງຂະຫນາດເທົ່າກັບຂະຫນາດຂອງວົງ loop ນັ້ນ.

T4a pdl ທັງໝົດທີ່ມີ ກະ​ທູ້ ຂະຫນາດ ຕ້ອງມີຈໍານວນກະທູ້ດຽວກັນ
ຂະ ໜາດ.

T5 Output auto-creation ບໍ່ສາມາດໃຊ້ໄດ້ຖ້າຫາກວ່າການໂຕ້ຖຽງ pdl ໃດໆ ກະ​ທູ້
ຂະຫນາດ. ຖ້າບໍ່ດັ່ງນັ້ນ R5 ນຳໃຊ້.

ຂໍ້​ຈໍາ​ກັດ​ດຽວ​ກັນ​ນໍາ​ໃຊ້​ກ່ຽວ​ກັບ​ຂະ​ຫນາດ dummy implicit (ສ້າງ​ໂດຍ
ຄໍາ​ຮ້ອງ​ສະ​ຫມັກ T4​) ດັ່ງ​ທີ່​ໄດ້​ກ່າວ​ມາ​ແລ້ວ​ໃນ​ພາກ​ສ່ວນ​ກ່ຽວ​ກັບ​ກະ​ທູ້ implicit​: ຖ້າ​ຫາກ​ວ່າ​ມີ​
pdls ຜົນ​ຜະ​ລິດ​ມີ (ຢ່າງ​ຊັດ​ເຈນ​ຫຼື​ການ​ສ້າງ​ໂດຍ implicitly) ຂະ​ຫນາດ dummy ຫຼາຍ​ກ​່​ວາ​ຫນຶ່ງ
ການຍົກເວັ້ນ runtime ຈະຖືກຍົກຂຶ້ນມາ.

ໃຫ້ພວກເຮົາສະແດງກົດລະບຽບເຫຼົ່ານີ້ຢູ່ໃນບ່ອນເຮັດວຽກໃນກໍລະນີທົ່ວໄປ. ສົມມຸດວ່າພວກເຮົາມີ (ທີ່ນີ້
unspecified) PP-function ທີ່ມີລາຍເຊັນ:

func((m,n),(m),(),[o](m))

ແລະທ່ານເອີ້ນມັນດ້ວຍ 3 pdls "a(5,3,10,11)", "b(3,5,10,1,12)", "c(10)" ແລະ pdl ຜົນຜະລິດ
"d(3,11,5,10,12)" (ເຊິ່ງສາມາດທີ່ນີ້ ບໍ່ ຈະຖືກສ້າງຂື້ນໂດຍອັດຕະໂນມັດ) ເປັນ

func($a->thread(1,3),$b->thread(0,3),$c,$d->thread(0,1))

ຈາກລາຍເຊັນຂອງ func ແລະຂ້າງເທິງໂທຫາ pdls ແບ່ງອອກເປັນກຸ່ມດັ່ງຕໍ່ໄປນີ້ຂອງ
ຂະຫນາດຫຼັກ, ພິເສດ ແລະ thread (ຂຽນໃນຮູບແບບ "pdl(core dims){thread dims}[extra
dims]"):

a(5,10){3,11}[] b(5){3,1}[10,12] c(){}[10] d(5){3,11}[10,12]

ດ້ວຍສິ່ງນີ້ເພື່ອຊ່ວຍພວກເຮົາ (ໂດຍທົ່ວໄປແລ້ວມັນເປັນປະໂຫຍດທີ່ຈະຂຽນການໂຕ້ຖຽງລົງແບບນີ້
ໃນເວລາທີ່ທ່ານເລີ່ມຕົ້ນມັກຫຼີ້ນກັບ threading ແລະຕ້ອງການທີ່ຈະຕິດຕາມສິ່ງທີ່ເກີດຂຶ້ນ) ພວກເຮົາ
ເພີ່ມເຕີມ deduce ວ່າຈໍານວນຂອງຂະຫນາດ loop explicit ແມ່ນ 2 (ໂດຍ T1b ຈາກ $a ແລະ $b)
with sizes "(3,11)" (ໂດຍ T2); 2 ຂະໜາດຂອງ loop implicit (ໂດຍ T1a ຈາກ $b ແລະ $d) ຂອງຂະຫນາດ
"(10,12)" (ໂດຍ T2) ແລະອົງປະກອບຂອງໄດ້ຖືກຄິດໄລ່ຈາກ input pdls ໃນທາງທີ່ສາມາດ
ສະແດງອອກໃນ pdl pseudo-code as

ສໍາລັບ (l=0;l<12;l++)
ສໍາລັບ (k=0;k<10;k++)
ສໍາລັບ (j=0;j<11;j++) ຜົນກະທົບຂອງການປິ່ນປົວມັນເປັນ dummy dim (ດັດຊະນີ j)
ສໍາລັບ (i=0;i<3;i++) |
d(i,j,:,k,l) ​​= func(a(:,i,:,j),b(i,:,k,0,l),c(k))

Ugh, ຕົວຢ່າງນີ້ກໍ່ບໍ່ງ່າຍໃນແງ່ຂອງການຮັກສາບັນຊີ. ມັນໃຫ້ບໍລິການສ່ວນໃຫຍ່ເປັນ
ຕົວຢ່າງວິທີການຄິດອອກວ່າມີຫຍັງເກີດຂຶ້ນໃນເວລາທີ່ທ່ານພົບກັບການເບິ່ງທີ່ສັບສົນ
ການສະແດງອອກ. ແຕ່ດຽວນີ້ເຖິງເວລາແທ້ໆທີ່ຈະສະແດງໃຫ້ເຫັນວ່າການໃສ່ກະທູ້ມີປະໂຫຍດໂດຍການໃຫ້ບາງສ່ວນຕື່ມອີກ
ຕົວຢ່າງທີ່ເອີ້ນວ່າ "ປະຕິບັດ" ຂອງພວກເຮົາ.

[ ຕົວຢ່າງຕໍ່ໄປນີ້ຈະຕ້ອງມີຄໍາອະທິບາຍເພີ່ມເຕີມໃນອະນາຄົດ. ສໍາ​ລັບ
ໃນປັດຈຸບັນກະລຸນາພະຍາຍາມດໍາລົງຊີວິດກັບຄໍາເຫັນໃນຊິ້ນລະຫັດ. ]

ຕົວຢ່າງ 1:

*** ປີ້ນກັບຂອງມາຕຣິກເບື້ອງສະແດງໂດຍ eigvecs ແລະ eigvals
** ໃຫ້ເມທຣິກສົມມາຕຣິກເບື້ອງ M = A^T x diag(lambda_i) x A
** => ປີ້ນ M^-1 = A^T x diag(1/lambda_i) x A
** ທຳອິດ $tmp = diag(1/lambda_i)*A
** ຫຼັງຈາກນັ້ນ A^T * $tmp ໂດຍຜະລິດຕະພັນພາຍໃນ threaded
# ການຈັດການດັດສະນີເພື່ອໃຫ້ matrices ພິມຖືກຕ້ອງພາຍໃຕ້ pdl
$inv .= $evecs*0; # ພຽງແຕ່ສໍາເນົາເພື່ອໃຫ້ໄດ້ຜົນຜະລິດຂະຫນາດທີ່ເຫມາະສົມ
$tmp .= $evecs; # ເບື້ອງຕົ້ນ, ບໍ່ມີການຂະຫຍາຍພັນຄືນ
($tmp2 = $tmp->ກະ​ທູ້(0)) // $evals; # ການແບ່ງກະທູ້
# ແລະດຽວນີ້ການຄູນມາຕຣິກເບື້ອງໃນການປອມຕົວ
PDL::Primitive::inner($evecs->xchg(0,1)->thread(-1,1),
$tmp->thread(0,-1),
$inv->thread(0,1));
# ທາງເລືອກສໍາລັບ matrix mult ໂດຍໃຊ້ threading implicit,
# xchg ທໍາອິດພຽງແຕ່ສໍາລັບການຖ່າຍທອດ
PDL::Primitive::inner($evecs->xchg(0,1)->dummy(1)
$tmp->xchg(0,1)->dummy(2)
($inv=null));

ຕົວຢ່າງ 2:

# ຜະລິດຕະພັນນອກໂດຍການຄູນ threaded
# ຄວາມກົດດັນທີ່ພວກເຮົາຕ້ອງເຮັດດ້ວຍການໂທຫາ my_biop1 ຢ່າງຈະແຈ້ງ
# ເມື່ອໃຊ້ກະທູ້ທີ່ຊັດເຈນ
$res=zeroes(($a->dims)[0],($b->dims)[0]);
my_biop1($a->thread(0,-1),$b->thread(-1,0),$res->(0,1),"*");
# ສິ່ງທີ່ຄ້າຍຄືກັນໂດຍການໃສ່ກະທູ້ implicit ກັບ pdl ສ້າງອັດຕະໂນມັດ
$res = $a->dummy(1) * $b->dummy(0)

ຕົວຢ່າງ 3:

# ການນໍາໃຊ້ທີ່ແຕກຕ່າງກັນຂອງ thread ແລະ unthread ເພື່ອ shuffle ຈໍານວນຂອງ
# ມິຕິໃນຄັ້ງດຽວໂດຍບໍ່ມີການໂທຫຼາຍໄປຫາ ->xchg ແລະ ->mv

# ໃຊ້ thread/unthread ເພື່ອສະຫຼັບຂະໜາດອ້ອມຮອບ
# ພຽງແຕ່ລອງມັນອອກແລະປຽບທຽບ pdl ຂອງເດັກກັບພໍ່ແມ່
$trans = $a->thread(4,1,0,3,2)->unthread;

ຕົວຢ່າງ 4:

# ຄິດໄລ່ສອງສາມກ່ອງ
# $bb ຈະຖື BB ເປັນ [xmin,xmax],[ymin,ymax],[zmin,zmax]
# ພວກເຮົາໃຊ້ thread ແລະ unthread ອີກເທື່ອ ໜຶ່ງ ເພື່ອສະຫຼັບຂະ ໜາດ ອ້ອມຮອບ
pdl> $bb = zeroes(double, 2,3 );
pdl> ຕໍາ່ສຸດທີ່($vertices->ກະ​ທູ້(0)-> clump->unthread(1), $bb->slice('(0), :'));
pdl> ສູງສຸດ ($vertices->ກະ​ທູ້(0)-> clump->unthread(1), $bb->slice('(1), :'));

ຕົວຢ່າງ 5:

# ຄິດ​ໄລ່​ການ​ແບ່ງ​ປັນ​ດ້ວຍ​ຕົນ​ເອງ (ເຊັ່ນ​: ການ​ປົກ​ກະ​ຕິ​ຂອງ​ຕົນ​ເອງ​) ລໍາ​ດັບ​ຂອງ​ຮູບ​ພາບ​
# ໃຊ້ threading explicit ແລະການແບ່ງ threaded implicitly
$stack = read_image_stack();
# ຄິດໄລ່ຄ່າສະເລ່ຍ (ຕໍ່ pixel ສະເລ່ຍ) ຂອງຮູບ $n+1 ທຳອິດ
$aver = zeroes([stack->dims]->[0,1]); # ເຮັດໃຫ້ຜົນຜະລິດ pdl
sumover($stack->slice(":,:,0:$n")->ກະທູ້(0,1),$aver);
$aver /= ($n+1);
$stack /= $aver; # ເຮັດໃຫ້ stack ເປັນປົກກະຕິໂດຍການເຮັດການແບ່ງ threaded
# implicit ກັບ explicit
# ທາງເລືອກໃນການຄິດໄລ່ $aver ດ້ວຍການໃສ່ກະທູ້ implicit ແລະການສ້າງອັດຕະໂນມັດ
sumover($stack->slice(":,:,0:$n")->mv(2,0),($aver=null));
$aver /= ($n+1);
#

ສົມບູນແບບ ເມື່ອທຽບກັບ ຢ່າງຊັດເຈນ ກະທູ້
ໃນວັກນີ້ພວກເຮົາຈະຍົກຕົວຢ່າງໃນເວລາທີ່ການໃສ່ກະທູ້ທີ່ຊັດເຈນແມ່ນດີກວ່າ
ກະທູ້ implicit ແລະໃນທາງກັບກັນ. ແຕ່ຫຼັງຈາກນັ້ນອີກເທື່ອຫນຶ່ງ, ນີ້ອາດຈະບໍ່ແມ່ນວິທີທີ່ດີທີ່ສຸດ
ເອົາກໍລະນີຕັ້ງແຕ່ເຈົ້າຮູ້ແລ້ວ: ທັງສອງລົດຊາດປະສົມກັນ. ດັ່ງນັ້ນ, ມັນເພີ່ມເຕີມກ່ຽວກັບວິທີການ
ເພື່ອໃຫ້ໄດ້ຮັບສິ່ງທີ່ດີທີ່ສຸດຂອງທັງສອງໂລກແລະ, ແນວໃດກໍ່ຕາມ, ໃນທີ່ດີທີ່ສຸດຂອງ Perl ປະເພນີ: TIMTOWTDI !

[ຂໍອະໄພ, ອັນນີ້ຍັງຕ້ອງໄດ້ຕື່ມໃສ່ໃນສະບັບຕໍ່ມາ; ອາດຈະອ້າງເຖິງຕົວຢ່າງຂ້າງເທິງ
ຫຼື​ເລືອກ​ເອົາ​ບາງ​ອັນ​ໃຫມ່​]

ສຸດທ້າຍ, ນີ້ອາດຈະເປັນບ່ອນທີ່ດີທີ່ຈະພຽງແຕ່ໃຫ້ລາຍລະອຽດດ້ານວິຊາການທັງຫມົດທີ່ພວກເຮົາໄດ້ໄປ
ຢູ່ໃນປະມານສອງສາມຫນ້າ: ເປັນຫຍັງກະທູ້?

ດີ, ລະຫັດທີ່ໃຊ້ threading ຄວນ (ຫຼາຍ) ໄວກວ່າລະຫັດທີ່ໃຊ້
explicit for-loops (ຫຼືການສ້າງ Perl ທີ່ຄ້າຍຄືກັນ) ເພື່ອບັນລຸຫນ້າທີ່ດຽວກັນ.
ໂດຍ​ສະ​ເພາະ​ແມ່ນ​ກ່ຽວ​ກັບ​ຄອມ​ພິວ​ເຕີ (ມີ​ອຸ​ປະ​ກອນ​ການ​ຄອມ​ພິວ​ເຕີ vector / ຂະ​ຫນານ​) PDL​
threading ຈະຖືກປະຕິບັດໃນວິທີທີ່ໃຊ້ປະໂຫຍດຈາກສິ່ງອໍານວຍຄວາມສະດວກເພີ່ມເຕີມ
ຂອງ​ເຄື່ອງ​ຈັກ​ເຫຼົ່າ​ນີ້​. ຍິ່ງໄປກວ່ານັ້ນ, ມັນເປັນການສ້າງແນວຄວາມຄິດພຽງແຕ່ (ເຖິງແມ່ນວ່າດ້ານວິຊາການ
ລາຍລະອຽດອາດຈະມີສ່ວນຮ່ວມໃນບາງຄັ້ງ) ແລະສາມາດ ຢ່າງຫຼວງຫຼາຍ ຫຼຸດ​ຜ່ອນ​ຄວາມ​ສັບ​ສົນ syntactical ຂອງ​
ລະຫັດ PDL (ແຕ່ຮັກສາຄໍາເຕືອນສໍາລັບເອກະສານຢູ່ໃນໃຈ). ເມື່ອເຈົ້າສະດວກສະບາຍ
ກັບ ກະທູ້ ວິທີການຄິດ (ແລະການຂຽນລະຫັດ) ມັນບໍ່ຄວນຈະຍາກເກີນໄປທີ່ຈະ
ເຂົ້າ​ໃຈ​ລະ​ຫັດ​ທີ່​ຜູ້​ອື່ນ​ໄດ້​ຂຽນ​ກ​່​ວາ (ສະ​ຫນອງ​ໃຫ້​ເຂົາ​ເຈົ້າ​ໃຫ້​ຄວາມ​ຄິດ​ວ່າ​ແນວ​ໃດ​
ຂະຫນາດວັດສະດຸປ້ອນທີ່ຄາດວ່າຈະມີ, ແລະອື່ນໆ). ເປັນຄໍາແນະນໍາທົ່ວໄປເພື່ອເພີ່ມການປະຕິບັດຂອງທ່ານ
ລະຫັດ: ຖ້າທ່ານຕ້ອງແນະນໍາ loop ເຂົ້າໄປໃນລະຫັດຂອງທ່ານ, ພະຍາຍາມປະຕິຮູບບັນຫາດັ່ງກ່າວ
ທີ່ທ່ານສາມາດນໍາໃຊ້ threading ເພື່ອປະຕິບັດ loop ໄດ້ (ເຊັ່ນດຽວກັນກັບສິ່ງທີ່ມີຂໍ້ຍົກເວັ້ນ
ກົດ​ລະ​ບຽບ​ນີ້​; ແຕ່ຜູ້ຂຽນຂອງເອກະສານນີ້ມັກຈະຄິດວ່າສິ່ງເຫຼົ່ານີ້ແມ່ນຫາຍາກ
ກໍລະນີ ;).

PDL::PP

An ງ່າຍ ວິທີການ to ກໍານົດ ຫນ້າທີ່ ທີ່ ມີ ຮູ້ of ດັດສະນີ ແລະ ກະທູ້ (ແລະ ໄດ້ ຈັກກະວານ ແລະ
ທຸກຢ່າງ)
PDL:PP ແມ່ນສ່ວນຫນຶ່ງຂອງການແຈກຢາຍ PDL. ມັນຖືກນໍາໃຊ້ເພື່ອສ້າງຫນ້າທີ່ຮັບຮູ້
indexing ແລະ threading ກົດລະບຽບຈາກຄໍາອະທິບາຍຫຍໍ້ຫຼາຍ. ມັນສາມາດເປັນປະໂຫຍດສໍາລັບທ່ານຖ້າຫາກວ່າ
ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ຂຽນ​ຫນ້າ​ທີ່​ຂອງ​ຕົນ​ເອງ​ຫຼື​ຖ້າ​ຫາກ​ວ່າ​ທ່ານ​ຕ້ອງ​ການ​ທີ່​ຈະ​ໂຕ້​ຕອບ​ຫນ້າ​ທີ່​ຈາກ​ການ​
ຫ້ອງສະຫມຸດພາຍນອກເພື່ອໃຫ້ພວກເຂົາສະຫນັບສະຫນູນການດັດສະນີແລະກະທູ້ (ແລະບາງທີການໄຫລຂອງຂໍ້ມູນເຊັ່ນດຽວກັນ,
ເບິ່ງ PDL::Dataflow). ສໍາລັບລາຍລະອຽດເພີ່ມເຕີມກວດເບິ່ງ PDL::PP.

ເອກະສານຊ້ອນ A

Affine ການຫັນເປັນ - a ພິເສດ ລະດັບ of ງ່າຍດາຍ ແລະ ປະສິດທິພາບ ການຫັນເປັນ
[ ອັນນີ້ຍັງເປັນສິ່ງທີ່ຈະເພີ່ມເຂົ້າໃນການປ່ອຍໃນອະນາຄົດ. ພວກເຮົາມີທົ່ວໄປແລ້ວບໍ
make_affine routine ໃນ PDL ? ມັນເປັນໄປໄດ້ທີ່ພວກເຮົາຈະອ້າງເຖິງຜູ້ຊາຍທີ່ເຫມາະສົມອື່ນ
ຫນ້າ​ຈາກ​ທີ່​ນີ້​]

ເອກະສານຊ້ອນ B

ລາຍເຊັນ of ມາດຕະຖານ PDL::PP ລວບລວມ ຫນ້າທີ່
ການຄັດເລືອກລາຍເຊັນຂອງ PDL primitives ເພື່ອສະແດງໃຫ້ເຫັນວ່າ PP ລວບລວມຂະຫນາດໃດ
ຫນ້າທີ່ gobble ເຖິງ (ແລະດັ່ງນັ້ນທ່ານສາມາດຄິດອອກສິ່ງທີ່ຈະໄດ້ຮັບການ threaded ໃນໄລຍະ). ສ່ວນໃຫຍ່
ຫນ້າທີ່ເຫຼົ່ານີ້ແມ່ນພື້ນຖານທີ່ກໍານົດໄວ້ໃນ "primitive.pd"

# ຟັງຊັນໃນ primitive.pd
#
sumover ((n),[o]())
prodover ((n),[o]())
axisvalues ​​((n)) ແທນ
ພາຍໃນ ((n),(n),[o]())
ນອກ ((n),(m),[o](n,m))
innerwt ((n),(n),(n),[o]())
inner2 ((m),(m,n),(n),[o]())
inner2t ((j,n),(n,m),(m,k),[o]())
ດັດຊະນີ (1D,0D,[o])
ຂັ້ນຕ່ຳ (1D,[o])
ສູງສຸດ (1D,[o])
wstat ((n),(n),(),[o],())
assgn (( ),())

# ການດໍາເນີນງານພື້ນຖານ
ການ​ດໍາ​ເນີນ​ງານ​ຄູ່ ((),(),[o]())
ການດໍາເນີນງານ unary ((),[o]())

ຜູ້ຂຽນ & COPYRIGHT

ລິຂະສິດ (C) 1997 Christian Soeller ([email protected]) & Tuomas J. Lukka
([email protected]). ສະຫງວນລິຂະສິດທັງໝົດ. ເຖິງແມ່ນວ່າ destined ສໍາລັບການປ່ອຍເປັນຫນ້າຜູ້ຊາຍ
ດ້ວຍການແຈກຢາຍ PDL ມາດຕະຖານ, ມັນບໍ່ແມ່ນໂດເມນສາທາລະນະ. ການ​ອະ​ນຸ​ຍາດ​ແມ່ນ​ອະ​ນຸ​ຍາດ​ໃຫ້​
ແຈກຢາຍເອກະສານສະບັບນີ້ຢ່າງເສລີໂດຍບໍ່ໃຫ້ມີການດັດແກ້ພາຍນອກ
ການຈັດຮູບແບບຈະຖືກເຮັດ, ແລະແຈ້ງການສະບັບນີ້ຍັງຄົງ intact. ເຈົ້າໄດ້ຮັບອະນຸຍາດແລະ
ຊຸກຍູ້ໃຫ້ໃຊ້ລະຫັດແລະຕົວອະນຸພັນຂອງມັນຢູ່ໃນລະຫັດແຫຼ່ງຂອງທ່ານເອງເພື່ອຄວາມມ່ວນຫຼືສໍາລັບ
ກຳໄລຕາມທີ່ເຈົ້າເຫັນພໍດີ.

ໃຊ້ PDL::Indexingp ອອນໄລນ໌ໂດຍໃຊ້ບໍລິການ onworks.net