PDL::QuickStartp - Online sa Cloud

PROGRAMA:

NAME

PDL::QuickStart - Mabilis na pagpapakilala sa mga feature ng PDL.

SINOPSIS

Isang maikling buod ng mga pangunahing tampok ng PDL at kung paano gamitin ang mga ito.

DESCRIPTION

pagpapakilala
Ang Perl ay isang napakahusay at versatile na scripting language, na angkop sa mga nagsisimula at
nagbibigay-daan sa mabilis na prototyping. Gayunpaman hanggang kamakailan ay hindi nito sinusuportahan ang mga istruktura ng data na
pinapayagan itong gumawa ng mabilis na pag-crunch ng numero.

Gayunpaman sa pagbuo ng Perl v5, nakuha ni Perl ang 'Mga Bagay'. Upang ilagay ito sa simpleng mga gumagamit
maaaring tukuyin ang kanilang sariling mga espesyal na uri ng data, at magsulat ng mga custom na gawain upang manipulahin ang mga ito
alinman sa mababang antas ng mga wika (C at Fortran) o sa Perl mismo.

Ito ay ganap na pinagsamantalahan ng mga developer ng PerlDL. Kumpleto na ang 'PDL' module
Object-Oriented na extension sa Perl (bagaman hindi mo kailangang malaman kung para saan ang isang bagay
gamitin ito) na nagbibigay-daan sa malalaking N-dimensional na set ng data, tulad ng malalaking larawan, spectra, oras
serye, atbp na iimbak mahusay at manipulahin en masa. Halimbawa sa PDL
module maaari nating isulat ang Perl code na "$a = $b + $c", kung saan ang $b at $c ay malalaking dataset (hal.
2048x2048 na mga larawan), at makuha ang resulta sa loob lamang ng isang bahagi ng isang segundo.

Ang mga variable ng PDL (o 'piddles' ayon sa pagkakakilala sa mga ito) ay sumusuporta sa isang malawak na hanay ng
pangunahing mga uri ng data - ang mga array ay maaaring mga byte, maikling integer (nalagdaan o hindi nalagdaan), mahaba
integers, floats o double precision floats. At dahil sa Object-Oriented na kalikasan ng
Ang mga bagong customized na datatype ng PDL ay maaaring makuha mula sa kanila.

Pati na rin ang mga module ng PDL, na maaaring gamitin ng mga normal na programa ng Perl, ang PerlDL ay may kasamang a
command line Perl shell, na tinatawag na 'perldl', na sumusuporta sa pag-edit ng command line. Sa
kumbinasyon sa iba't ibang mga PDL graphics module na nagbibigay-daan sa data na madaling maglaro
kasama at nakikita.

Tulong
Ang PDL ay naglalaman ng malawak na dokumentasyon, na magagamit pareho sa loob ng perldl or pdl2 mga shell at
mula sa command line, gamit ang "pdldoc" program. Para sa karagdagang impormasyon subukan ang alinman sa:

pdl> tulong tulong
$ pdldoc

Dapat ding available ang mga HTML na kopya ng dokumentasyon. Upang mahanap ang kanilang lokasyon, subukan
ang mga sumusunod:

pdl> foreach ( mapa{"$_/PDL/HtmlDocs"}@INC ) { p "$_\n" kung -d $_ }

Perl Uri ng data at paano PDL nagpapalawak sila
Ang mga pangunahing istruktura ng data ng Perl ay mga scalar variable, hal $x, na maaaring maglaman ng mga numero
o mga string, listahan o array ng mga scalar, hal @x, at mga nauugnay na array/hashes ng mga scalar,
hal %x.

Ipinapakilala ng Perl v5 ang mga istruktura at bagay ng data ng Perl. Isang simpleng scalar variable na $x na ngayon
isang uri ng data na tinukoy ng gumagamit o ganap na bagay (ito ay talagang may hawak na sanggunian (isang matalinong
"pointer") dito ngunit hindi iyon nauugnay para sa ordinaryong paggamit ng perlDL)

Ang pangunahing ideya sa likod ng perlDL ay payagan ang $x na humawak ng isang buong 1D spectrum, o isang 2D
larawan, isang 3D data cube, at iba pa hanggang sa malalaking N-dimensional na set ng data. Ang mga ito ay maaaring
manipulahin nang sabay-sabay, hal. "$a = $b + 2" ay gumagawa ng vector operation sa bawat value sa
spectrum/imahe/atbp.

Maaari mong itanong: "Bakit hindi na lang mag-imbak ng spectrum bilang isang simpleng listahan ng istilo ng Perl @x sa bawat isa
pixel na isang listahan ng item?" Ang dalawang pangunahing sagot dito ay memorya at pabilisin. Dahil tayo
alam na ang aming spectrum ay binubuo ng mga purong numero na maaari naming siksik na iimbak ang mga ito sa isang bloke
ng memorya na naaayon sa isang C style numeric array. Ito ay tumatagal ng mas kaunting memorya kaysa
ang katumbas na listahan ng Perl. Pagkatapos ay madaling ipasa ang bloke ng memorya na ito sa isang mabilis na karagdagan
routine, o sa anumang iba pang C function na tumatalakay sa mga array. Bilang isang resulta perlDL ay napaka
mabilis --- halimbawa ay maaaring i-multiply ng isa ang isang 2048*2048 na imahe sa eksaktong kaparehong oras nito
ay kukuha ng C o FORTRAN (0.1 segundo sa aking SPARC). Ang isang karagdagang bentahe nito ay para sa
mga simpleng operasyon (hal. "$x += 2") ay maaaring manipulahin ng isa ang buong hanay nang walang pakialam
dimensionality nito.

Nalaman ko kapag gumagamit ng perlDL ito ay pinaka-kapaki-pakinabang na isipin ang karaniwang Perl @x variable bilang
"mga listahan" ng mga generic na "bagay" at mga variable ng PDL tulad ng $x bilang "mga array" na maaaring maglaman
sa mga listahan o hash. Madalas sa aking mga script ng perlDL mayroon akong @x na naglalaman ng isang listahan ng spectra,
o isang listahan ng mga larawan (o kahit isang halo!). O marahil ang isa ay maaaring magkaroon ng hash (hal %x) ng
mga larawan... ang tanging limitasyon ay memorya!

Ang mga variable ng perlDL ay sumusuporta sa isang hanay ng mga uri ng data - ang mga array ay maaaring mga byte, maikling integer
(signed o unsigned), long integers, floats o double precision floats.

Paggamit
Ang PerlDL ay na-load sa iyong Perl script gamit ang command na ito:

gumamit ng PDL; # sa Perl script: gamitin ang karaniwang perlDL modules

Marami ring extension module, hal. PDL::Graphics::TriD. Karamihan sa mga ito (ngunit
hindi lahat kung minsan ay hindi angkop) sumunod sa isang karaniwang kumbensyon. Kung sasabihin mo:

gumamit ng PDL::Graphics::TriD;

Ini-import mo ang lahat sa isang karaniwang listahan mula sa module. Minsan baka gusto mo
walang import (hal. kung gusto mong gumamit ng OO syntax sa lahat ng oras at i-save ang import tax).
Para sa mga ito sinasabi mo:

gumamit ng PDL::Graphics::TriD qw();

At ang walang laman na "qw()" quotes ay kinikilala bilang ibig sabihin ay 'wala'. Maaari mo ring tukuyin ang a
listahan ng mga function na i-import sa normal na paraan ng Perl.

Mayroon ding interactive na shell, "perldl" o "pdl2", tingnan perldl o pdl2 para sa mga detalye.

Upang lumikha a bago PDL nagbabago
Narito ang ilang paraan ng paggawa ng variable ng PDL:

$a = pdl [1..10]; # 1D array
$a = pdl (1,2,3,4); # Ditto
$a = pdl '[1 2 3 4]'; # Ditto
$b = pdl [[1,2,3],[4,5,6]]; # 2D 3x2 array
$b = pdl '[1 2 3; 4 5 6]'; # Ditto
$b = pdl q[1,2,3; 4,5,6]; # Ditto
$b = pdl <
[1 2 3]
[4 5 6]
NEWPDL
$c = pdl q[1 -2]; # 2-element piddle na naglalaman ng 1 at -2
$c = pdl q[1 - 2]; # 2-element piddle na naglalaman ng 1 at -2
$b = pdl 42 # 0-dimensional na scalar
$c = pdl $a; # Gumawa ng bagong kopya

$d = byte [1..10]; # Tingnan ang "Uri ng conversion"
$e = zeroes(3,2,4); # 3x2x4 zero-filled na array

$c = rfits $file; # Basahin ang FITS file

@x = ( pdl(42), zeroes(3,2,4), rfits($file) ); # Ay isang LISTAHAN ng mga PDL variable!

Ang pdl() Ang function ay ginagamit upang simulan ang isang PDL variable mula sa isang scalar, listahan, listahan
reference, isa pang PDL variable, o isang maayos na na-format na string.

Bilang karagdagan, ang lahat ng mga function ng PDL ay awtomatikong nagko-convert ng mga normal na Perl scalar sa mga variable na PDL
on-the-fly.

(tingnan din ang mga seksyong "Uri ng Conversion" at "Input/Output" sa ibaba)

Pang-aritmetika (At boolean mga ekspresyon)
$a = $b + 2; $a++; $a = $b / $c; # Atbp.

$c=sqrt($a); $d = log10($b+100); # Atbp

$e = $a>42; # Vector na may kondisyon

$e = 42*($a>42) + $a*($a<=42); # Takip sa itaas

$b = $a->log10 maliban kung mayroon man ($a <= 0); # maiwasan ang floating point error

$a = $a / ( max($a) - min($a) );

$f = where($a, $a > 10); # kung saan nagbabalik ng piddle ng mga elemento para sa
# na ang kundisyon ay totoo

i-print ang $a; Ang # $a sa kontekstong string ay nagpi-print nito sa isang N-dimensional na format

(at iba pang Perl operator/function)

Kapag gumagamit ng mga piddle sa mga conditional na expression (ibig sabihin, "kung", "maliban na lang kung" at "habang" constructs)
tanging piddles na may eksaktong isang elemento ang pinapayagan, hal

$a = pdl (1,0,0,1);
print "ay nakatakda" kung $a->index(2);

Tandaan na ang mga boolean operator ay bumabalik sa pangkalahatang mga multi-element na piddle. Samakatuwid, ang
ang sumusunod ay magtataas ng error

i-print ang "ay ok" kung $a > 3;

dahil ang "$a > 3" ay isang piddle na may 4 na elemento. Sa halip gamitin ang lahat o anuman upang subukan kung lahat o alinman sa
tinutupad ng mga elemento ang kondisyon:

i-print ang "some are > 3" kung mayroon man $a>3;
print "can't take logarithm" maliban kung lahat ng $a>0;

Marami ring mga paunang natukoy na function, na inilalarawan sa ibang mga man page. Suriin
PDL::Indeks.

Matris function
Ang 'x' ay na-hijack bilang matrix multiplication operator. hal. "$c = $ax $b";

perlDL ay row-major hindi column major kaya ito ay talagang "c(i,j) = sum_k a(k,j) b(i,k)" -
ngunit kapag ang mga matrice ay nai-print ang mga resulta ay magiging tama. Tandaan lamang ang mga indeks
baligtad. hal:

$a = [ $b = [
[ 1 2 3 0] [1 1]
[ 1 -1 2 7] [0 2]
[ 1 0 0 1] [0 2]
] [1 1]
]

nagbibigay ng $c = [
[ 1 11]
[ 8 10]
[ 2 2]
]

tandaan: transpose() ginagawa kung ano ang sinasabi nito at ito ay isang maginhawang paraan upang gawing row vectors
mga vector ng haligi.

Gaano sa magsulat a simple tungkulin
sub dotproduct {
aking ($a,$b) = @_;
return sum($a*$b) ;
}
1;

Kung ilalagay sa file ang dotproduct.pdl ay maa-autoload kung gumagamit ka ng PDL::AutoLoader (tingnan ang
sa ibaba).

Siyempre, available na ang function na ito bilang panloob na function, tingnan ang PDL::Primitive.

uri Conversion
Default para sa pdl() ay doble. Ang mga conversion ay:

$a = float($b);
$c = mahaba($d); # "mahaba" ay karaniwang isang 4 byte int
$d = byte($a);

Kaya doble(), maikli(), ushort(), indx().

TANDAAN: Ang indx() routine ay isang espesyal na uri ng integer na
ay ang tamang sukat para sa isang PDL index value (laki ng dimensyon,
index, o offest) na maaaring 32bit (mahaba) o
64bit (longlong) dami depende sa kung ang perl
ay binuo na may 32bit o 64bit na suporta.

Awtomatikong kino-convert din ng mga gawaing ito ang mga listahan ng Perl upang payagan ang maginhawang shorthand:

$a = byte [[1..10],[1..10]]; # Lumikha ng 2D byte array
$a = float [1..1000]; # Lumikha ng 1D float array

at iba pa

imprenta
Awtomatikong pinapalawak ang array sa N-dimensional na format:

i-print ang $a;

$b = "Ang sagot ay = $a ";

Seksyon
Ang PDL ay may napakalakas na multidimensional slicing at sectioning operator; tingnan ang
PDL::Mga hiwa(3) man page para sa mga detalye; ilalarawan namin ang pinakamahalaga dito.

Ang PDL ay nagpapakita ng kanyang pamana ng Perl/C na ang mga array ay zero-offset. Kaya may 100x100 na imahe
mga indeks na "0..99,0..99". (Ang kombensiyon ay ang sentro ng pixel (0,0) ay nasa coordinate
(0.0,0.0). Ang lahat ng mga PDL graphics function ay umaayon sa kahulugan na ito at itago ang unit
mga offset ng, halimbawa, ang PGPLOT FORTRAN library.

Ang pagsunod sa karaniwang convention coordinate (0,0) ay ipinapakita sa kaliwang ibaba kapag
pagpapakita ng larawan. Lumilitaw ito sa kaliwang itaas kapag gumagamit ng ""print $a"" atbp.

Gumagamit ang simpleng sectioning ng extension ng syntax sa Perl, PDL::NiceSlice, na nagpapahintulot sa iyo na
tukuyin ang mga subrange sa pamamagitan ng isang null-method modifier sa isang PDL:

$b = $a->($x1:$x2,$y1:$y2,($z1)); # Kunin ang subsection

Dito, ang $a ay isang 3-dimensional na variable, at ang $b ay nakakakuha ng planar cutout na tinukoy ng
nililimitahan ang $x1, $x2, $y1, $y2, sa lokasyong $z1. Ang panaklong sa paligid ng $z1 ay sanhi ng
aalisin ang trivial index -- kung hindi, ang $b ay magiging three-dimensional na may pangatlo
sukat ng order 1.

Maaari kang maglagay ng mga hiwa ng PDL sa magkabilang gilid ng element-wise assignment operator ".=", tulad ng
Sun:

# Itakda ang bahagi ng $bigimage sa mga halaga mula sa $smallimage
$bigimage->($xa:$xb,$ya:$yb) .= $smallimage;

Ilang iba pang miscellany:

$c = nelem($a); # Bilang ng mga pixel

$val = at($object, $x,$y,$z...) # Pixel value sa posisyon, bilang Perl scalar
$val = $object->at($x,$y,$z...) # katumbas (method syntax OK)

$b = xvals($a); # Punan ang array ng mga halaga ng X-coord (din yvals(), zvals(),
# axisvals($x,$axis) at rvals() para sa radial distance
# mula sa gitna).

Input / Output
Ang "PDL::IO" na mga module ay nagpapatupad ng ilang kapaki-pakinabang na IO format function. Sobra na sana
upang magbigay ng mga halimbawa ng bawat isa, ngunit makakahanap ka ng magandang pangkalahatang-ideya sa PDL::IO. Narito ang isang sample ng
ilan sa mga sinusuportahang format ng IO sa PDL.

PDL::IO::Misc
Ascii, FITS at FIGARO/NDF IO routines.

PDL::IO::FastRaw
Gamit ang mga hilaw na uri ng data ng iyong makina, isang hindi madadala ngunit napakabilis na IO
pormat. Sinusuportahan din ang pagmamapa ng memorya upang makatipid ng memorya pati na rin makakuha ng higit na bilis.

PDL::IO::FlexRaw
Mga pangkalahatang format ng raw data. Tulad ng FastRaw, mas mahusay lamang.

PDL::IO::Browser
Isang Curses browser para sa mga array.

PDL::IO::Pnm
Portaple bitmap at suporta sa pixmap.

PDL::IO::Pic
Gamit ang nakaraang module at netpbm, ginagawang posible na madaling magsulat ng GIF, jpeg
at anuman na may simpleng utos.

Graphics
Ang pilosopiya sa likod ng perlDL ay gawin itong gumana sa iba't ibang umiiral na mga graphics
mga aklatan dahil walang iisang pakete ang makakatugon sa lahat ng pangangailangan at sa lahat ng tao at nagbibigay-daan ito
isa na magtrabaho sa mga pakete na alam at gusto na ng isa. Malinaw na magkakaroon ng ilan
overlaps sa functionality at ilang kakulangan ng consistency at pagkakapareho. Gayunpaman, pinapayagan nito
PDL upang makasabay sa isang mabilis na umuunlad na larangan - ang pinakabagong mga module ng PDL ay nagbibigay ng mga interface
sa OpenGL at VRML graphics!

PDL::Graphics::PGPLOT
Nagbibigay ang PGPLOT ng isang simpleng library para sa mga line graphics at pagpapakita ng imahe.

Mayroong madaling interface dito sa panloob na module na PDL::Graphics::PGPLOT, na
tumatawag sa mga gawain sa hiwalay na magagamit na PGPLOT na top-level na module.

PDL::Graphics::PLplot
Nagbibigay ang PLplot ng isang simpleng library para sa paglikha ng mga graphics na may maraming mga driver ng output,
kabilang ang isang direct-to-piddle driver.

Ang module na ito ay nagbibigay ng parehong mataas na antas at mababang antas ng pagpapaandar na binuo sa PLplot. Ang
Ang mga low-level na utos ay halos direktang nagbubuklod sa C interface ng PLplot. Magbasa pa
sa PDL::Graphics::PLplot.

PDL::Graphics::IIS
Maraming astronomer ang gustong gumamit ng SAOimage at Ximtool (o may mga derivasyon/clone). Ang mga ito
ay kapaki-pakinabang na mga libreng widget para sa inspeksyon at visualization ng mga imahe. (Hindi sila
ibinigay ng perlDL ngunit madaling makuha mula sa kanilang mga opisyal na site sa labas ng
Net.)

Ang PDL::Graphics::IIS package ay nagbibigay-daan sa isa na magpakita ng mga larawan sa mga ito ("IIS"
ay ang pangalan ng isang sinaunang item ng image display hardware na ang mga protocol ay ang mga tool na ito
umayon sa.)

PDL::Graphics::TriD
Tingnan ang PDL::Graphics::TriD, ito ay isang koleksyon ng mga 3D na gawain para sa OpenGL at (sa lalong madaling panahon)
VRML at iba pang 3D na format na nagbibigay-daan sa 3D point, line, at surface plots mula sa PDL.

Autoloading
Tingnan ang PDL::AutoLoader. Nagbibigay-daan ito sa isa na mag-autoload ng mga function on demand, sa paraang marahil
pamilyar sa mga gumagamit ng MatLab.

Maaari ding magsulat ng mga extension ng PDL bilang normal na mga module ng Perl.

PDL shell
Ang Perl script na "pdl2" (o "perldl") ay nagbibigay ng simpleng command line interface sa PDL. Kung
ang pinakabagong Readlines/ReadKey modules ay na-install na "pdl2" ay nakita ito at pinapagana
pag-recall at pag-edit ng command line. Tingnan ang man page para sa mga detalye.

halimbawa:

% perldl
perlDL shell v1.354
Ang PDL ay may WALANG WARRANTY. Para sa mga detalye, tingnan ang file
'KOPYA' sa pamamahagi ng PDL. Ito ay libreng software at ikaw
ay malugod na ipamahagi muli ito sa ilalim ng ilang mga kundisyon, tingnan
ang parehong file para sa mga detalye.
ReadLines, NiceSlice, MultiLines pinagana
Binabasa ang PDL/default.perldlrc...
Natagpuan ang database ng docs /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
I-type ang 'help' para sa online na tulong
I-type ang 'demo' para sa mga online na demo
Nag-load ng PDL v2.4.9_003 (sumusuporta sa masasamang halaga)
pdl> $x = rfits 'm51.fits'
Binabasa ang data ng IMAGE...
BITPIX = 32 laki = 147456 pixels
Binabasa ang 589824 bytes
BSCALE = && BZERO =

pdl> gumamit ng PDL::Graphics::PGPLOT;
pdl> imag $x
Ipinapakita ang 384 x 384 na imahe mula 40 hanggang 761, gamit ang 84 na kulay (16-99)...

Maaari mo ring patakbuhin ito mula sa Perl debugger ("perl -MPDL -d -e 1") kung gusto mo.

Iba't ibang mga tampok ng shell:

p Ang shell aliases na "p" ay isang maginhawang maikling anyo ng "print", hal

pdl> p mga 5,3
[
[1 1 1 1 1]
[1 1 1 1 1]
[1 1 1 1 1]
]

Pinasimulan
Ang mga papeles "~/.perldlrc" at "local.perldlrc" (sa kasalukuyang direktoryo) ay pinanggalingan kung
natagpuan. Nagbibigay-daan ito sa user na magkaroon ng global at lokal na PDL code para sa startup.

Tulong
I-type ang 'tulong'! Maaaring hanapin ng isa ang dokumentasyon ng PDL, at maghanap ng dokumentasyon sa anuman
function.

Makatakas
Ang anumang linya na nagsisimula sa "#" na character ay itinuturing bilang isang shell escape. Ang karakter na ito
ay maaaring i-configure sa pamamagitan ng pagtatakda ng Perl variable na $PERLDL_ESCAPE. Ito ay maaaring, halimbawa,
itakda sa "~/.perldlrc".

labis na karga operator
Ang mga sumusunod na builtin na operator at function ng Perl ay na-overload upang gumana sa PDL
variable

+ - * / > < >= <= << >> & | ^ == != <=> ** % ! ~
sin log abs atan2 sqrt cos exp

[Lahat ng unary function (kasalanan atbp.) ay maaaring gamitin sa sa lugar() - tingnan ang "Memory" sa ibaba.]

Object-Orientation at perlDL
Ang mga operasyon ng PDL ay magagamit bilang mga function at pamamaraan. Kaya ang isa ay maaaring makakuha ng mga bagong uri ng
object, upang kumatawan sa mga custom na klase ng data.

Sa pamamagitan ng paggamit ng labis na karga, maaaring gawin ng isang mathematical operator ang anumang gusto mo, at PDL
ay may ilang built-in na trick na nagpapahintulot sa mga umiiral nang PDL function na gumana nang hindi nagbabago, kahit na ang
ang pinagbabatayan na representasyon ng data ay malaki ang nabago! Tingnan ang PDL::Objects

Memorya paggamit at sanggunian
Maaaring mangailangan ng kaunting pag-iingat ang pakikialam sa napakalaking array ng data. PerlDL ay nagbibigay ng marami
mga pasilidad upang hayaan kang magsagawa ng mga operasyon sa malalaking array nang hindi bumubuo ng mga karagdagang kopya
kahit na ito ay nangangailangan ng kaunti pang pag-iisip at pangangalaga mula sa programmer.

TANDAAN: Sa ilang karamihan sa mga system, mas mainam na i-configure ang Perl (sa panahon ng mga pagpipilian sa pagbuo).
gamitin ang function na "malloc()" sa halip na ang built-in na Perl. Ito ay dahil kay Perl
ang isa ay na-optimize para sa bilis sa halip na pagkonsumo ng virtual memory - ito ay maaaring magresulta sa
isang kadahilanan ng dalawang pagpapabuti sa dami ng memory storage na magagamit mo. Ang Perl malloc
sa 5.004 at mas bago ay mayroong ilang mga pagpipilian sa oras ng pag-compile na magagamit mo upang ibagay ang
pag-uugali.

Simpleng aritmetika
Kung ang $a ay isang malaking imahe (hal. sumasakop sa 10MB) pagkatapos ay ang command

$a = $a + 1;

kumakain ng isa pang 10MB ng memorya. Ito ay dahil ang expression na "$a+1" ay lumilikha ng a
pansamantalang kopya ng $a para hawakan ang resulta, pagkatapos ay itatalaga si $a ng reference doon.
Pagkatapos nito, ang orihinal na $a ay nawasak kaya wala permanente basura ng memorya. Ngunit sa
isang maliit na makina, ang paglago sa memory footprint ay maaaring malaki. Ito ay
malinaw na ginawa sa ganitong paraan kaya ang "$c=$a+1" ay gumagana tulad ng inaasahan.

Gayundin kung may nagsabi:

$b = $a; # $b at $a ngayon ay tumuturo sa parehong data
$a = $a + 1;

Pagkatapos ang $b at $a ay magiging magkaiba, gaya ng inaasahan ng isang walang muwang, dahil isang bagong sanggunian
ay nilikha at $a ay itinalaga dito.

Gayunpaman, kung ang $a ay isang malaking memory hog (eg isang 3D volume) ang paggawa ng kopya nito ay maaaring hindi
maging isang magandang bagay. Maiiwasan ng isa ang memorya sa itaas sa halimbawa sa itaas sa pamamagitan ng pagsasabi:

$a++;

Ang mga operasyong "+++=,--,-=", atbp. lahat ay tinatawag na isang espesyal na "in-place" na bersyon ng
subroutine ng aritmetika. Nangangahulugan ito na wala nang memorya ang kailangan - ang downside nito ay
na kung ang "$b=$a" ay dinadagdagan din ang $b. Para tahasang puwersahin ang isang kopya:

$b = pdl $a; # Tunay na kopya

o, bilang kahalili, marahil mas mahusay na istilo:

$b = $a->kopya;

Pag-andar
Karamihan sa mga function, hal. "log()", ay nagbabalik ng resulta na isang pagbabago ng kanilang
argumento. Ito ay gumagawa para sa mahusay na kasanayan sa programming. Gayunpaman maraming mga operasyon ang maaaring gawin
tapos na "in-place" at ito ay maaaring kailanganin kapag ang malalaking array ay ginagamit at ang memory ay nasa
isang premium. Para sa mga pangyayaring ito ang operator sa lugar() ay ibinigay na pumipigil
ang dagdag na kopya at pinapayagan ang argumento na mabago. hal:

$x = log($array); # $array ang hindi naapektuhan
log(inplace($bigarray) ); # $bigarray ay nagbago sa situ

BABALA:

1. Nalalapat ang mga karaniwang caveat tungkol sa mga duplicate na sanggunian.

2. Malinaw na kapag ginamit sa ilang mga function na hindi maaaring ilapat sa lugar (hal
"convolve()") ang mga hindi inaasahang epekto ay maaaring mangyari! Sinusubukan naming ipahiwatig ang "inplace()"-safe
mga function sa dokumentasyon.

3. Ang mga uri ng conversion, gaya ng "float()", ay maaaring magdulot ng nakatagong pagkopya.

pagtiyak pagiging piddleness
Kung nagsulat ka ng isang simpleng function at hindi mo nais na ito ay sumabog sa iyong mukha kung ikaw
ipasa ito ng isang simpleng numero sa halip na isang PDL variable. Tawagan lang ang function topdl() una
para maging ligtas ito. hal:

sub myfiddle { my $pdl = topdl(shift); $pdl->fiddle_foo(...); ... }

Ang "topdl()" ay HINDI gumaganap ng isang kopya kung ang isang pdl variable ay naipasa - ito ay nahuhulog lamang -
na malinaw na ang nais na pag-uugali. Ang gawain ay hindi siyempre kailangan sa normal
mga function na tinukoy ng gumagamit na walang pakialam sa mga panloob.

Gamitin ang PDL::QuickStartp online gamit ang mga serbisyo ng onworks.net