PDL::MATLABp - Online sa Cloud

PROGRAMA:

NAME

PDL::MATLAB - Isang gabay para sa mga gumagamit ng MATLAB.

PANIMULA

Kung ikaw ay gumagamit ng MATLAB, ang pahinang ito ay para sa iyo. Ipinapaliwanag nito ang mga pangunahing pagkakaiba sa pagitan
MATLAB at PDL upang matulungan kang magpatuloy sa lalong madaling panahon.

ito dokumento is hindi a sangguni. Para diyan, pumunta sa PDL::QuickStart. Ang dokumentong ito
mga pandagdag ang Quick Start guide, dahil itinatampok nito ang mga pangunahing pagkakaiba sa pagitan ng MATLAB at
PDL.

Perl

Ang pangunahing pagkakaiba sa pagitan ng MATLAB at PDL ay Perl.

Ang Perl ay isang pangkalahatang layunin na programming language na may libu-libong mga module na malayang magagamit
sa web. Ang PDL ay isang extension ng Perl. Nagbibigay ito ng access sa mga PDL program sa mas maraming feature
kaysa sa maaaring pangarapin ng karamihan sa mga numerical na tool. Kasabay nito, karamihan sa mga pagkakaiba sa syntax sa pagitan
Ang MATLAB at PDL ay resulta ng pundasyon ng Perl nito.

Ikaw do hindi mayroon sa matuto magkano Perl sa be mabisa sa PDL. Pero kung gusto mong matuto
Perl, mayroong mahusay na dokumentasyong magagamit on-line (http://perldoc.perl.org>) o
sa pamamagitan ng command na "perldoc perl". Mayroon ding beginner's portal
(<http://perl-begin.org>).

Ang imbakan ng module ng Perl ay tinatawag na CPAN (http://www.cpan.org>) at mayroon itong malawak na hanay ng
mga module. Patakbuhin ang "perldoc cpan" para sa higit pang impormasyon.

TERMINOLOHIYA: PIDDLE

Ang MATLAB ay karaniwang tumutukoy sa mga vector, matrice, at array. Ang Perl ay mayroon nang mga array, at ang
Ang mga terminong "vector" at "matrix" ay karaniwang tumutukoy sa isa at dalawang-dimensional na koleksyon ng
datos. Dahil walang magandang termino para ilarawan ang kanilang bagay, nabuo ng mga developer ng PDL ang termino
"piddle" para bigyan ng pangalan ang kanilang data type.

A piddle ay binubuo ng isang serye ng mga numero na nakaayos bilang isang N-dimensional na set ng data. Piddles
magbigay ng mahusay na pag-iimbak at mabilis na pag-compute ng malalaking N-dimensional na matrice. Sila ay
lubos na na-optimize para sa numerical na gawain.

Para sa karagdagang impormasyon, tingnan ang "Piddles vs Perl Mga Arrays" mamaya sa dokumentong ito.

COMMAND WINDOW AT IDE

Hindi tulad ng MATLAB, ang PDL ay hindi kasama ng nakalaang IDE. Gayunpaman, ito ay may kasamang isang
interactive na shell at maaari kang gumamit ng Perl IDE upang bumuo ng mga programang PDL.

PDL interactive talukap ng alimango
Upang simulan ang interactive na shell, magbukas ng terminal at patakbuhin ang "perldl" o "pdl2". Tulad ng sa MATLAB,
ang interactive na shell ay ang pinakamahusay na paraan upang matutunan ang wika. Upang lumabas sa shell, i-type
"lumabas", tulad ng MATLAB.

Pagsulat PDL mga programa
Isang sikat na IDE para sa Perl ay tinatawag na Padre (http://padre.perlide.org>). Ito ay krus
platform at madaling gamitin.

Sa tuwing magsusulat ka ng stand-alone na PDL program (ibig sabihin sa labas ng "perldl" o "pdl2" shell)
dapat mong simulan ang programa sa "use PDL;". Ini-import ng command na ito ang PDL module sa
Perl. Narito ang isang sample na PDL program:

gumamit ng PDL; # Mag-import ng pangunahing PDL module.
gumamit ng PDL::NiceSlice; # Mag-import ng karagdagang PDL module.
gumamit ng PDL::AutoLoader; # Mag-import ng karagdagang PDL module.

$b = pdl [2,3,4]; # Ang mga pahayag ay nagtatapos sa semicolon.
$A = pdl [ [1,2,3],[4,5,6] ]; # 2-dimensional na matrix.

i-print ang $A x $b->transpose;

I-save ang file na ito bilang "myprogram.pl" at patakbuhin ito gamit ang:

perl myprogram.pl

Bago: Nababaluktot palaugnayan
Sa kasalukuyang mga bersyon ng PDL (bersyon 2.4.7 o mas bago) mayroong isang flexible matrix syntax na
maaaring magmukhang lubos na katulad sa MATLAB:

1) Gumamit ng ';' upang limitahan ang mga hilera:

$b = pdl q[ 2,3,4 ];
$A = pdl q[ 1,2,3 ; 4,5,6 ];

2) Gumamit ng mga puwang upang paghiwalayin ang mga elemento:

$b = pdl q[ 2 3 4 ];
$A = pdl q[ 1 2 3 ; 4 5 6 ];

Karaniwan, hangga't naglalagay ka ng "q" sa harap ng pambungad na bracket, ang PDL ay dapat "gawin kung ano
ibig mong sabihin". Kaya maaari kang sumulat sa isang syntax na mas komportable para sa iyo.

MGA MODULO PARA SA MATLAB USERS

Mayroong dalawang mga module na gustong gamitin ng mga user ng MATLAB:

PDL::NiceSlice
Nagbibigay sa PDL ng syntax para sa mga hiwa (sub-matrice) na mas maikli at mas pamilyar
mga gumagamit ng MATLAB.

% MATLAB
b(1:5) -> Pinipili ang unang 5 elemento mula sa b.

# PDL na walang NiceSlice
$b->slice("0:4") --> Pinipili ang unang 5 elemento mula sa $b.

# PDL na may NiceSlice
$b(0:4) --> Pinipili ang unang 5 elemento mula sa $b.

PDL::AutoLoader
Nagbibigay ng MATLAB-style na autoloader para sa PDL. Kung ang isang hindi kilalang function na "foo()" ay tinatawag,
Hinahanap ng PDL ang isang file na tinatawag na "foo.pdl". Kung nakahanap ito ng isa, babasahin ito.

BATAYANG TAMPOK

Ipinapaliwanag ng seksyong ito kung paano naiiba ang syntax ng PDL sa MATLAB. Karamihan sa mga gumagamit ng MATLAB ay gugustuhin
magsimula dito.

Pangkalahatan "gotchas"
Index
Sa PDL, ang mga indeks ay nagsisimula sa '0' (tulad ng C at Java), hindi 1 (tulad ng MATLAB o FORTRAN). Para sa
halimbawa, kung ang $b ay isang array na may 5 elemento, ang mga elemento ay bibigyan ng bilang mula 0 hanggang
4.

Pagpapakita ng isang bagay
Karaniwang awtomatikong ipinapakita ng MATLAB ang mga nilalaman ng object. Sa mga PDL shell na iyong ipinapakita
mga bagay na tahasang may "print" na utos o ang shortcut na "p":

MATLAB:

>> a = 12
a = 12
>> b = 23; % Pigilan ang output.
>>

PDL Shell (perldl o pdl2):

pdl> $a = 12 # Walang output.
pdl> print $a # Print object.
12
pdl> p $a # "p" ay isang shorthand para sa "print" sa shell.
12
pdl>

Paglikha Piddles
Mga variable sa PDL
Palaging nagsisimula ang mga variable sa tanda na '$'.

MATLAB: halaga = 42
PerlDL: $value = 42

Pangunahing syntax
Gamitin ang "pdl" constructor para gumawa ng bago piddle.

MATLAB: v = [1,2,3,4]
PerlDL: $v = pdl [1,2,3,4]

MATLAB: A = [ 1,2,3 ; 3,4,5 ]
PerlDL: $A = pdl [ [1,2,3] , [3,4,5] ]

Mga simpleng matrice
MATLAB PDL
------ ------
Matrix ng mga mga(5) isa 5,5
Matrix ng mga zero mga zero(5) mga zero 5,5
Random na matrix Rand(5) random 5,5
Linear vector 1:5 sequence 5

Pansinin na sa PDL ang panaklong sa isang function na tawag ay kadalasang opsyonal. Ito ay
mahalagang bantayan ang mga posibleng ambiguities. Halimbawa:

pdl> p zero 2, 2 + 2

Dapat ba itong bigyang kahulugan bilang "zero(2,2) + 2" o bilang "zero 2, (2+2)"? Parehong
wastong mga pahayag:

pdl> p zero(2,2) + 2
[
[2 2]
[2 2]
]
pdl> p zero 2, (2+2)
[
[0 0]
[0 0]
[0 0]
[0 0]
]

Sa halip na subukang kabisaduhin ang pagkakasunud-sunod ng pangunguna ni Perl, ito ay pinakamahusay na gamitin
panaklong upang gawing hindi malabo ang iyong code.

Mga linearly spaced sequence
MATLAB: >> linspace(2,10,5)
ans = 2 4 6 8 10

PerlDL: pdl> p mga zero(5)->xlinvals(2,10)
[2 4 6 8 10]

Paliwanag: Magsimula sa isang 1-dimensional na piddle ng 5 elemento at ibigay ito nang pantay-pantay
may pagitan na mga halaga mula 2 hanggang 10.

Ang MATLAB ay may isang function na tawag para dito. Sa kabilang banda, ang pamamaraan ng PDL ay higit pa
nababaluktot:

pdl> p zero(5,5)->xlinvals(2,10)
[
[ 2 4 6 8 10]
[ 2 4 6 8 10]
[ 2 4 6 8 10]
[ 2 4 6 8 10]
[ 2 4 6 8 10]
]
pdl> p zero(5,5)->ylinvals(2,10)
[
[ 2 2 2 2 2]
[ 4 4 4 4 4]
[ 6 6 6 6 6]
[ 8 8 8 8 8]
[10 10 10 10 10]
]
pdl> p zero(3,3,3)->zlinvals(2,6)
[
[
[2 2 2]
[2 2 2]
[2 2 2]
]
[
[4 4 4]
[4 4 4]
[4 4 4]
]
[
[6 6 6]
[6 6 6]
[6 6 6]
]
]

Paghiwa at mga indeks
Ang pagkuha ng isang subset mula sa isang koleksyon ng data ay kilala bilang pagpipiraso. PDL at MATLAB
ay may katulad na syntax para sa paghiwa, ngunit may dalawang mahalagang pagkakaiba:

1) Ang mga indeks ng PDL ay nagsisimula sa 0, tulad ng sa C at Java. Nagsisimula ang MATLAB ng mga indeks sa 1.

2) Sa MATLAB sa tingin mo ay "mga hilera at haligi". Sa PDL, isipin ang "x at y".

MATLAB PerlDL
------ ------
>> Isang pdl> p $A
A = [
1 2 3 [1 2 3]
4 5 6 [4 5 6]
7 8 9 [7 8 9]
]
-------------------------------------------------- -----
(row = 2, col = 1) (x = 0, y = 1)
>> A(2,1) pdl> p $A(0,1)
ans = [
4 [4]
]
-------------------------------------------------- -----
(row = 2 hanggang 3, col = 1 hanggang 2) (x = 0 hanggang 1, y = 1 hanggang 2)
>> A(2:3,1:2) pdl> p $A(0:1,1:2)
ans = [
4 5 [4 5]
7 8 [7 8]
]

babala
Kapag sumulat ka ng isang stand-alone na PDL program kailangan mong isama ang PDL::NiceSlice
modyul. Tingnan ang nakaraang seksyon "MGA MODULO PARA SA MATLAB USERS" para sa karagdagang
impormasyon.

gumamit ng PDL; # Mag-import ng pangunahing PDL module.
gumamit ng PDL::NiceSlice; # Magandang syntax para sa paghiwa.
gumamit ng PDL::AutoLoader; # MATLAB-like na autoloader.

$A = random 4,4;
i-print ang $A(0,1);

Matris Mga Operasyon
Pagpaparami ng matris
MATLAB: A * B
PerlDL: $A x $B

Element-wise multiplication
MATLAB: A .* B
PerlDL: $A * $B

I-transpose
MATLAB: A'
PerlDL: $A->transpose

Pag-andar na pinagsama-sama data
Ang ilang mga function (tulad ng "sum", "max" at "min") ay pinagsama-samang data para sa isang N-dimensional na set ng data.
Ito ay isang lugar kung saan ang MATLAB at PDL ay gumagamit ng ibang paraan:

Sa MATLAB, gumagana ang lahat ng mga function na ito sa isang dimensyon.
>> A = [ 1,5,4 ; 4,2,1 ]
A = 1 5 4
+4 2 1
>> max(A)
ans = 4 5 4
>> max(A')
ans = 5

Kung gusto mo ng maximum para sa buong set ng data, maaari mong gamitin ang espesyal na A(:)
notation na karaniwang ginagawang iisang 1-dimensional ang buong set ng data
vector

>> max(A(:))
ans = 5
>> A = mga (2,2,2,2)
>> max(A(:))
ans = 1

Nag-aalok ang PDL ng dalawang function para sa bawat feature.
sum vs sumover
avg vs average
max vs maximum
min vs minimum

Ang mahaba pangalan gumagana sa isang dimensyon, habang ang maikli pangalan gumagana sa kabuuan
piddle.

pdl> p $A = pdl [ [1,5,4] , [4,2,1] ]
[
[1 5 4]
[4 2 1]
]
pdl> p $A->maximum
[5 4]
pdl> p $A->transpose->maximum
[4 5 4]
pdl> p $A->max
5
pdl> p ones(2,2,2)->max
1
pdl> p ones(2,2,2,2)->max
1

nota Pansinin na ang PDL ay nagsasama-sama nang pahalang habang ang MATLAB ay nagsasama-sama nang patayo. Sa iba
mga salita:

MATLAB PerlDL
max(A) == $A->transpose->maximum
max(A') == $A->maximum

TIP: Sa MATLAB sa tingin mo ay "mga hilera at haligi". Sa PDL, isipin ang "x at y".

Mas mataas dimensional data set
Ang isang nauugnay na isyu ay kung paano nauunawaan ng MATLAB at PDL ang mga set ng data ng mas mataas na dimensyon. MATLAB noon
idinisenyo para sa mga 1D na vector at 2D na matrice. Ang mga mas matataas na dimensyon na bagay ("ND arrays") ay
idinagdag sa itaas. Sa kabaligtaran, ang PDL ay idinisenyo para sa mga N-dimensional na piddle mula sa simula. Ito
humahantong sa ilang mga sorpresa sa MATLAB na hindi nangyayari sa PDL:

Nakikita ng MATLAB ang isang vector bilang isang 2D matrix.
MATLAB PerlDL
------ ------
>> vector = [1,2,3,4]; pdl> $vector = pdl [1,2,3,4]
>> size(vector) pdl> p $vector->dims
ans = 1 4 4

Nakikita ng MATLAB ang "[1,2,3,4]" bilang isang 2D matrix (1x4 matrix). Nakikita ito ng PDL bilang isang 1D vector: A
solong dimensyon ng laki 4.

Ngunit hindi pinapansin ng MATLAB ang huling dimensyon ng isang 4x1x1 matrix.
MATLAB PerlDL
------ ------
>> A = ones(4,1,1); pdl> $A = mga 4,1,1
>> size(A) pdl> p $A->dims
ans = 4 1 4 1 1

At iba ang pagtrato ng MATLAB sa isang 4x1x1 matrix mula sa isang 1x1x4 matrix.
MATLAB PerlDL
------ ------
>> A = ones(1,1,4); pdl> $A = mga 1,1,4
>> size(A) pdl> p $A->dims
ans = 1 1 4 1 1 4

Ang MATLAB ay walang direktang syntax para sa mga array ng ND.
pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
pdl> p $A->dim
+3 2 2

Suporta sa tampok.
Sa MATLAB, maraming mga tampok tulad ng kalat-kalat na suporta sa matrix ay hindi magagamit para sa ND
mga array. Sa PDL, halos anumang feature na sinusuportahan ng 1D at 2D piddles, ay pantay
suportado ng N-dimensional piddles. Karaniwang walang pagkakaiba.

Silo Kaayusan
Ang Perl ay may maraming mga istraktura ng loop, ngunit ipapakita lamang namin ang isa na pinaka-pamilyar sa
Mga gumagamit ng MATLAB:

MATLAB PerlDL
------ ------
para sa i = 1:10 para sa $i (1..10) {
disp(i) print $i
endfor }

nota Huwag kailanman gumamit ng mga for-loop para sa numerical na gawain. Ang mga for-loop ng Perl ay mas mabilis kaysa sa MATLAB,
ngunit pareho silang namumutla laban sa isang "vectorized" na operasyon. Ang PDL ay may maraming mga tool na
mapadali ang pagsusulat ng mga vectorized na programa. Ang mga ito ay lampas sa saklaw ng gabay na ito. Upang
matuto pa, tingnan ang: PDL::Indexing, PDL::Threading, at PDL::PP.

Gayundin, huwag gumamit ng 1..10 para sa numerical na gawain, kahit sa labas ng for-loop. 1..10 ay a
Perl array. Ang mga array ng Perl ay idinisenyo para sa flexibility, hindi sa bilis. Gamitin mga piddles sa halip.
Para matuto pa, tingnan ang susunod na seksyon.

Piddles vs Perl Mga Arrays
Mahalagang tandaan ang pagkakaiba sa pagitan ng a Piddle at isang Perl array. Si Perl ay may isang
general-purpose array object na maaaring maglaman ng anumang uri ng elemento:

@perl_array = 1..10;
@perl_array = ( 12, "Hello" );
@perl_array = ( 1, 2, 3, \@another_perl_array, pagkakasunud-sunod(5) );

Binibigyang-daan ka ng mga array ng Perl na lumikha ng makapangyarihang mga istruktura ng data (tingnan ang data kaayusan sa ibaba), pero
sila ay hindi dinisenyo para numerical trabaho. Para diyan, gamitin mga piddles:

$pdl = pdl [ 1, 2, 3, 4 ];
$pdl = sequence 10_000_000;
$pdl = mga 600, 600;

Halimbawa:

$points = pdl 1..10_000_000 # 4.7 segundo
$points = sequence 10_000_000 # milliseconds

TIP: Maaari kang gumamit ng mga salungguhit sa mga numero ("10_000_000" ay mas mahusay kaysa sa 10000000).

Mga kalagayan
Maraming kondisyon ang Perl, ngunit ipapakita lamang namin ang isa na pinakapamilyar sa MATLAB
mga gumagamit:

MATLAB PerlDL
------ ------
if value > MAX if ($value > $MAX) {
disp("Masyadong malaki") i-print ang "Masyadong malaki\n";
elseif value < MIN } elsif ($value < $MIN) {
disp("Masyadong maliit") i-print ang "Masyadong maliit\n";
iba } iba {
disp("Perpekto!") i-print ang "Perpekto!\n";
wakas}

nota Narito ang isang "gotcha":

MATLAB: elseif
PerlDL: elsif

Kung nagbibigay ng syntax error ang iyong conditional, tingnan kung isinulat mo ang iyong "elsif."
tama.

TIMTOWDI (Ayan Is pa kaysa Isa Paraan Upang Do ito)
Ang isa sa mga pinaka-kagiliw-giliw na pagkakaiba sa pagitan ng PDL at iba pang mga tool ay ang pagpapahayag
ng wikang Perl. TIMTOWDI, o "There Is More than One Way To Do It", ang motto ni Perl.

Ang Perl ay isinulat ng isang linguist, at ang isa sa mga katangian nito sa pagtukoy ay ang mga pahayag na maaari
mabuo sa iba't ibang paraan upang bigyan ang wika ng mas natural na pakiramdam. Halimbawa, ikaw
malamang na hindi sasabihin sa isang kaibigan:

"Habang hindi pa ako tapos, patuloy akong magtatrabaho."

Ang wika ng tao ay mas nababaluktot kaysa doon. Sa halip, mas malamang na sabihin mo:

"Magtatrabaho ako hanggang sa matapos ako."

Dahil sa mga ugat ng lingguwistika nito, ang Perl ay ang tanging programming language na may ganitong uri ng
kakayahang umangkop. Halimbawa, ang Perl ay may tradisyonal na mga while-loop at if-statement:

habang ( ! tapos() ) {
keep_working();
}

kung ( ! wife_galit() ) {
kiss_wife();
}

Ngunit nag-aalok din ito ng alternatibo hanggang at maliban na lamang kung mga pahayag:

hanggang sa ( tapos() ) {
keep_working();
}

maliban kung ( wife_angry() ) {
kiss_wife();
}

At pinapayagan ka ng Perl na magsulat ng mga loop at conditional sa form na "postfix":

keep_working() until finished();

kiss_wife() maliban kung wife_angry();

Sa ganitong paraan, madalas kang binibigyang-daan ng Perl na magsulat ng mas natural, madaling maunawaan na code kaysa sa dati
posible sa mas mahigpit na mga programming language.

Pag-andar
Ang syntax ng PDL para sa pagdedeklara ng mga function ay malaki ang pagkakaiba sa MATLAB's.

MATLAB PerlDL
------ ------
function retval = foo(x,y) sub foo {
retval = x.**2 + x.*y my ($x, $y) = @_;
endfunction return $x**2 + $x**y;
}

Huwag matakot sa lahat ng bagong syntax. Narito ang isang mabilis na pagtakbo sa isang function
deklarasyon sa PDL:

1) "subAng ibig sabihin ay "subroutine".

2) "my" nagdedeklara ng mga variable na lokal sa function.

3) "@_" ay isang espesyal na array ng Perl na nagtataglay ng lahat ng mga parameter ng function. Mukhang ito
tulad ng isang kakaibang paraan upang gawin ang mga function, ngunit ito ay nagbibigay-daan sa iyo upang gumawa ng mga function na tumatagal ng isang
variable na bilang ng mga parameter. Halimbawa, ang sumusunod na function ay tumatagal ng anumang bilang ng
mga parameter at idinagdag ang mga ito nang sama-sama:

sub mysum {
my ($i, $total) = (0, 0);
para sa $i (@_) {
$kabuuan += $i;
}
ibalik ang $kabuuan;
}

4) Maaari kang magtalaga ng mga halaga sa ilang mga variable nang sabay-sabay gamit ang syntax:

($a, $b, $c) = (1, 2, 3);

Kaya, sa mga nakaraang halimbawa:

# Idineklara nito ang dalawang lokal na variable at inisimulan ang mga ito sa 0.
my ($i, $total) = (0, 0);

# Kinukuha nito ang unang dalawang elemento ng @_ at inilalagay ang mga ito sa $x at $y.
aking ($x, $y) = @_;

5) Ang "pagbabalikAng " statement ay nagbibigay ng return value ng function, kung mayroon man.

KARAGDAGANG TAMPOK

ASCII talaksan IO
Upang basahin ang mga file ng data na naglalaman ng mga whitespace na pinaghihiwalay ng mga column ng mga numero (tulad ng mababasa
gamit ang MATLAB magkarga command) ang isa ay gumagamit ng PDL rcols sa PDL::IO::Misc. Para sa isang heneral
pagsusuri ng functionality ng IO na available sa PDL, tingnan ang dokumentasyon para sa PDL::IO, hal,
"tulong PDL::IO" sa pdl2 shell o " pdldoc PDL::IO " mula sa shell command line.

data kaayusan
Upang lumikha ng mga kumplikadong istruktura ng data, ginagamit ng MATLAB ang "selda mga dumadating"At"kaayusan mga dumadating".
Ang mga array at hash ng Perl ay nag-aalok ng katulad na pagpapagana ngunit mas malakas at nababaluktot.
Ang seksyong ito ay isang mabilis na pangkalahatang-ideya lamang ng kung ano ang iniaalok ng Perl. Upang matuto nang higit pa tungkol dito,
mangyaring pumunta sahttp://perldoc.perl.org/perldata.html> o patakbuhin ang command na "perldoc
perldata".

Mga Arrays
Ang mga array ng Perl ay katulad ng mga array ng cell ng MATLAB, ngunit mas nababaluktot. Halimbawa, sa
MATLAB, isang cell array ay pa rin sa panimula isang matrix. Ito ay gawa sa mga hilera, at mga hilera
dapat may parehong haba.

MATLAB
------
array = {1, 12, 'hello'; rand(3, 2), mga(3), 'basura'}
=> OK
array = {1, 12, 'hello'; rand(3, 2), mga(3) }
=> ERROR

Ang Perl array ay isang pangkalahatang layunin, sequential na istraktura ng data. Maaari itong maglaman ng anumang data
uri.

PerlDL
------
@array = ( [1, 12, 'hello'] , [ random(3,2), ones(3,3), 'junk' ] )
=> OK
@array = ( [1, 12, 'hello'] , [ random(3,2), ones(3,3) ] )
=> OK
@array = ( 5 , {'name' => 'Mike'} , [1, 12, 'hello'] )
=> OK

Pansinin na ang Perl array ay nagsisimula sa prefix na "@" sa halip na "$" na ginamit ni
mga piddles.

Upang matuto tungkol sa Perl array, pakiusap go sa <http://perldoc.perl.org/perldata.html> or
tumakbo ang utos "perldoc perldata".

Hashes
Ang mga hash ng Perl ay katulad ng mga arrays ng istraktura ng MATLAB:

MATLAB
------
>> inumin = struct('type', 'coke', 'size', 'malaki', 'myarray', {1,2,3})
>> drink.type = 'sprite'
>> drink.price = 12 % Magdagdag ng bagong field sa structure array.

PerlDL
------
pdl> %drink = ( type => 'coke' , size => 'malaki', mypiddle => ones(3,3,3) )
pdl> $drink{type} = 'sprite'
pdl> $drink{price} = 12 # Magdagdag ng bagong field sa hash.

Pansinin na ang Perl hash ay nagsisimula sa prefix na "%" sa halip na "@" para sa mga arrays at
"$" na ginagamit ng piddles.

Upang matuto tungkol sa Perl hash, pakiusap go sa <http://perldoc.perl.org/perldata.html> or
tumakbo ang utos "perldoc perldata".

pagganap
Ang PDL ay may mga mahuhusay na feature ng performance, ang ilan sa mga ito ay hindi karaniwang available sa
numerical computation tools. Gagabayan ka ng mga sumusunod na pahina sa mga tampok na ito:

PDL::Pag-i-index
Antas: Nagsisimula

Sinasaklaw ng beginner tutorial na ito ang karaniwang feature na "vectorization" na mayroon ka na
alam mula sa MATLAB. Gamitin ang page na ito upang matutunan kung paano maiwasan ang mga for-loop para gawin ang iyong program
mas mabisa.

PDL::Threading
Antas: Nasa pagitan

Ang tampok na "vectorization" ng PDL ay higit pa sa magagawa ng karamihan sa mga numerical software. Sa
sa tutorial na ito matututunan mo kung paano "mag-thread" sa mas matataas na dimensyon, na nagbibigay-daan sa iyo
gawing vector ang iyong programa nang higit pa kaysa sa posible sa MATLAB.

benchmarks
Antas: Nasa pagitan

Ang Perl ay may kasamang madaling gamitin na benchmarks module upang matulungan kang malaman kung gaano katagal ito
upang maisagawa ang iba't ibang bahagi ng iyong code. Ito ay isang mahusay na tool upang matulungan kang ituon ang iyong
pagsisikap sa pag-optimize. Maaari mong basahin ang tungkol dito online
(<http://perldoc.perl.org/Benchmark.html>) o sa pamamagitan ng command na "perldoc
Benchmark".

PDL::PP
Antas: Masulong

Ang Pre-Processor ng PDL ay isa sa pinakamakapangyarihang feature ng PDL. Sumulat ka ng isang function
kahulugan sa espesyal na markup at ang pre-processor ay bumubuo ng totoong C code na maaaring
pinagsama-sama. Sa PDL:PP makukuha mo ang buong bilis ng native C code nang hindi na kailangang harapin
na may ganap na kumplikado ng wikang C.

Pagpaplano
Ang PDL ay may ganap na tampok na kakayahan sa pag-plot. Hindi tulad ng MATLAB, higit na umaasa ang PDL sa third-party
mga aklatan (pgplot at PLplot) para sa mga tampok nitong 2D plotting. Ang 3D plotting at graphics nito
gumagamit ng OpenGL para sa performance at portability. Ang PDL ay may tatlong pangunahing mga module ng pag-plot:

PDL::Graphics::PGPLOT
Pinakamagaling para: Pag-plot ng mga 2D function at data set.

Ito ay isang interface sa kagalang-galang na PGPLOT library. Ang PGPLOT ay malawakang ginagamit sa
ang akademiko at siyentipikong komunidad sa loob ng maraming taon. Sa bahagi dahil sa edad nito,
Ang PGPLOT ay may ilang mga limitasyon kumpara sa mas bagong mga pakete tulad ng PLplot (hal. walang RGB
graphics). Ngunit mayroon itong maraming mga tampok na ginagawa pa rin itong popular sa siyentipiko
komunidad.

PDL::Graphics::PLplot
Pinakamagaling para: Pag-plot ng mga 2D function pati na rin ang 2D at 3D data set.

Ito ay isang interface sa PLplot plotting library. Ang PLplot ay isang moderno, open source
aklatan para sa paggawa ng mga siyentipikong plot. Sinusuportahan nito ang mga plot ng parehong 2D at 3D data set.
Pinakamahusay na sinusuportahan ang PLplot para sa mga platform ng unix/linux/macosx. Mayroon itong aktibong mga developer
ang komunidad at suporta para sa mga platform ng win32 ay bumubuti.

PDL::Graphics::TriD
Pinakamagaling para: Pag-plot ng mga 3D function.

Ang katutubong PDL 3D graphics library gamit ang OpenGL bilang backend para sa mga 3D plot at data
visualization. Sa OpenGL, madaling manipulahin ang mga nagresultang 3D na bagay gamit ang
ang mouse sa real time.

Pagsulat Mga GUI
Sa pamamagitan ng Perl, may access ang PDL sa lahat ng pangunahing toolkit para sa paglikha ng cross platform
graphical na interface ng gumagamit. Ang isang tanyag na opsyon ay wxPerl (http://wxperl.sourceforge.net>).
Ito ang Perl bindings para sa wxWidgets, isang malakas na toolkit ng GUI para sa pagsulat ng cross-
mga aplikasyon sa platform.

Ang wxWidgets ay idinisenyo upang gawing hitsura at pakiramdam ang iyong application bilang isang katutubong application sa
bawat plataporma. Halimbawa, ang Perl IDE Ama ay nakasulat gamit ang wxPerl.

simulink
Ang Simulink ay isang graphical dynamical system modeler at simulator. Maaari itong bilhin
hiwalay bilang isang add-on sa MATLAB. Ang PDL at Perl ay walang direktang katumbas sa
Simulink ng MATLAB. Kung mahalaga sa iyo ang feature na ito, tingnan mo scilab:

<http://www.scilab.org>

Ang Scilab ay isa pang numerical analysis software. Tulad ng PDL, ito ay libre at open source. Ito
ay walang mga natatanging tampok ng PDL, ngunit ito ay halos kapareho sa MATLAB. Kasama ang Scilab
Xcos (dating Scicos), isang graphical system modeler at simulator na katulad ng Simulink.

COPYRIGHT

Copyright 2010 Daniel Carrera ([protektado ng email]). Maaari mong ipamahagi at/o baguhin ito
dokumento sa ilalim ng parehong mga tuntunin ng kasalukuyang lisensya ng Perl.

Tingnan ang: http://dev.perl.org/licenses/

Pagkilala
Gusto kong pasalamatan sina David Mertens, Chris Marshall at Sigrid Carrera para sa kanilang napakalawak
tumulong sa pagrepaso sa mga naunang draft ng gabay na ito. Kung wala ang kanilang mga oras ng trabaho, ito
Ang dokumento ay hindi magiging kasing pakinabang ng mga gumagamit ng MATLAB gaya ng ngayon.

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