PDL::MATLABp - Online in de cloud

PROGRAMMA:

NAAM

PDL::MATLAB - Een gids voor MATLAB-gebruikers.

INLEIDING

Als u een MATLAB-gebruiker bent, is deze pagina iets voor u. Het legt de belangrijkste verschillen tussen
MATLAB en PDL om u te helpen zo snel mogelijk aan de slag te gaan.

Deze document is niet a zelfstudie. Ga daarvoor naar PDL::QuickStart. Dit document
complementen de Snelstartgids, omdat deze de belangrijkste verschillen tussen MATLAB en
PDL.

Perl

Het belangrijkste verschil tussen MATLAB en PDL is Perl.

Perl is een programmeertaal voor algemene doeleinden met duizenden gratis beschikbare modules
op internet. PDL is een uitbreiding van Perl. Dit geeft PDL-programma's toegang tot meer functies
dan de meeste numerieke tools kunnen dromen. Tegelijkertijd zijn de meeste syntaxisverschillen tussen
MATLAB en PDL zijn het resultaat van de Perl-stichting.

Je do niet hebben naar U leert veel Perl naar be effectief met PDL. Maar als je wilt leren
Perl, er is uitstekende documentatie online beschikbaar (http://perldoc.perl.org>) of
via het commando "perldoc perl". Er is ook een beginnersportaal
(<http://perl-begin.org>).

De modulerepository van Perl heet CPAN (http://www.cpan.org>) en het heeft een enorm scala aan
modulen. Voer "perldoc cpan" uit voor meer informatie.

TERMINOLOGIE: PLASJE

MATLAB verwijst doorgaans naar vectoren, matrices en arrays. Perl heeft al arrays, en de
termen "vector" en "matrix" verwijzen doorgaans naar een- en tweedimensionale verzamelingen van
gegevens. Omdat ze geen goede term hadden om hun object te beschrijven, bedachten PDL-ontwikkelaars de term
"plasje" om een ​​naam te geven aan hun gegevenstype.

A plasje bestaat uit een reeks getallen georganiseerd als een N-dimensionale dataset. Piddles
zorgen voor efficiënte opslag en snelle berekening van grote N-dimensionale matrices. Zij zijn
sterk geoptimaliseerd voor numeriek werk.

Voor meer informatie, zie "Piddles vs Perl arrays" verderop in dit document.

COMMAND VENSTER EN IDE

In tegenstelling tot MATLAB wordt PDL niet geleverd met een speciale IDE. Het komt echter met een
interactieve shell en u kunt een Perl IDE gebruiken om PDL-programma's te ontwikkelen.

PDL interactieve schelp
Om de interactieve shell te starten, opent u een terminal en voert u "perldl" of "pdl2" uit. Net als in MATLAB,
de interactieve shell is de beste manier om de taal te leren. Typ . om de shell te verlaten
"exit", net als MATLAB.

schrijf- PDL programma's
Een populaire IDE voor Perl heet Padre (http://padre.perlide.org>). Het is dwars
platform en gemakkelijk te gebruiken.

Telkens wanneer u een zelfstandig PDL-programma schrijft (dwz buiten de "perldl"- of "pdl2"-shell)
u moet het programma starten met "use PDL;". Met deze opdracht wordt de PDL-module geïmporteerd in:
Perl. Hier is een voorbeeld van een PDL-programma:

gebruik PDL; # Importeer de belangrijkste PDL-module.
gebruik PDL::NiceSlice; # Importeer extra PDL-module.
gebruik PDL::AutoLoader; # Importeer extra PDL-module.

$b = pdl [2,3,4]; # Verklaringen eindigen op een puntkomma.
$A = pdl [ [1,2,3],[4,5,6] ]; # Tweedimensionale matrix.

print $A x $b->transponeren;

Sla dit bestand op als "myprogram.pl" en voer het uit met:

perl mijnprogramma.pl

Nieuw: Flexibel syntaxis
In de huidige versies van PDL (versie 2.4.7 of hoger) is er een flexibele matrixsyntaxis
kan erg op MATLAB lijken:

1) Gebruik een ';' om rijen af ​​te bakenen:

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

2) Gebruik spaties om elementen te scheiden:

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

Kortom, zolang u een "q" voor de openingshaak plaatst, moet PDL "doen wat"
u bedoelt". U kunt dus in een syntaxis schrijven die voor u comfortabeler is.

MODULES VOOR MATLAB GEBRUIKERS

Er zijn twee modules die MATLAB-gebruikers willen gebruiken:

PDL::Mooi stukje
Geeft PDL een syntaxis voor segmenten (submatrices) die korter en vertrouwder is
MATLAB-gebruikers.

% MATLAB
b(1:5) --> Selecteert de eerste 5 elementen van b.

# PDL zonder NiceSlice
$b->slice("0:4") --> Selecteert de eerste 5 elementen van $b.

# PDL met NiceSlice
$b(0:4) --> Selecteert de eerste 5 elementen van $b.

PDL::Autolader
Biedt een autoloader in MATLAB-stijl voor PDL. Als een onbekende functie "foo()" wordt aangeroepen,
PDL zoekt naar een bestand met de naam "foo.pdl". Als het er een vindt, leest het het.

BASIC KENMERKEN

In deze sectie wordt uitgelegd hoe de syntaxis van PDL verschilt van die van MATLAB. De meeste MATLAB-gebruikers zullen dat willen
begin hier.

Snel naar "gekkies"
Index
In PDL beginnen indices bij '0' (zoals C en Java), niet bij 1 (zoals MATLAB of FORTRAN). Voor
Als $b bijvoorbeeld een array met 5 elementen is, worden de elementen genummerd van 0 tot
4.

Een object weergeven
MATLAB geeft normaal gesproken de inhoud van objecten automatisch weer. In de PDL-shells die u weergeeft
objecten expliciet met het commando "print" of de sneltoets "p":

MATLAB:

>> een = 12
a = 12
>> b = 23; % Uitvoer onderdrukken.
>>

PDL-shell (perldl of pdl2):

pdl> $a = 12 # Geen uitvoer.
pdl> print $a # Print object.
12
pdl> p $a # "p" is een afkorting voor "print" in de shell.
12
pdl>

Wij creëren Piddles
Variabelen in PDL
Variabelen beginnen altijd met het '$'-teken.

MATLAB: waarde = 42
PerlDL: $waarde = 42

Basissyntaxis
Gebruik de "pdl"-constructor om een ​​nieuwe . te maken plasje.

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

Eenvoudige matrices
MATLAB PDL
------ ------
Matrix van degenen degenen(5) degenen 5,5
Matrix van nullen nullen(5) nullen 5,5
Willekeurige matrix rand(5) willekeurig 5,5
Lineaire vector 1:5 reeks 5

Merk op dat in PDL de haakjes in een functieaanroep vaak optioneel zijn. Het is
belangrijk om eventuele onduidelijkheden in de gaten te houden. Bijvoorbeeld:

pdl> p nullen 2, 2 + 2

Moet dit worden geïnterpreteerd als "nullen(2,2) + 2" of als "nullen 2, (2+2)"? Beide zijn
geldige verklaringen:

pdl> p nullen (2,2, 2) + XNUMX
[
[2 2]
[2 2]
]
pdl> p nullen 2, (2+2)
[
[0 0]
[0 0]
[0 0]
[0 0]
]

In plaats van te proberen de volgorde van Perl te onthouden, is het het beste om te gebruiken
haakjes om uw code eenduidig ​​te maken.

Lineair gespreide reeksen
MATLAB: >> linspace(2,10,5)
ans = 2 4 6 8 10

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

Uitleg: Begin met een 1-dimensionale piddle van 5 elementen en geef het gelijk
gespreide waarden van 2 tot 10.

MATLAB heeft hiervoor een enkele functieaanroep. Aan de andere kant is de methode van PDL meer
flexibel:

pdl> p nullen(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 nullen(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 nullen(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]
]
]

Snijden en indexen
Het extraheren van een subset uit een verzameling gegevens staat bekend als: snijden. PDL en MATLAB
hebben een vergelijkbare syntaxis voor segmenteren, maar er zijn twee belangrijke verschillen:

1) PDL-indexen beginnen bij 0, zoals in C en Java. MATLAB begint indexen op 1.

2) In MATLAB denk je "rijen en kolommen". Denk bij PDL aan "x en y".

MATLAB PerlDL
------ ------
>> A pdl> p $A
een = [
1 2 3 [1 2 3]
4 5 6 [4 5 6]
7 8 9 [7 8 9]
]
-------------------------------------------------- -----
(rij = 2, col = 1) (x = 0, y = 1)
>> A(2,1) pdl> p $A(0,1)
antw = [
4 [4]
]
-------------------------------------------------- -----
(rij = 2 tot 3, col = 1 tot 2) (x = 0 tot 1, y = 1 tot 2)
>> A(2:3,1:2) pdl> p $A(0:1,1:2)
antw = [
4 5 [4 5]
7 8 [7 8]
]

waarschuwing
Wanneer u een zelfstandig PDL-programma schrijft, moet u de PDL::NiceSlice . opnemen
module. Zie de vorige paragraaf "MODULES VOOR MATLAB GEBRUIKERS" voor meer
informatie.

gebruik PDL; # Importeer de belangrijkste PDL-module.
gebruik PDL::NiceSlice; # Leuke syntaxis voor het snijden.
gebruik PDL::AutoLoader; # MATLAB-achtige autoloader.

$A = willekeurig 4,4;
druk $A(0,1) af;

Matrix Operations
Matrix vermenigvuldiging
MATLAB: A*B
PerlDL: $A x $B

Elementgewijze vermenigvuldiging
MATLAB: A .* B
PerlDL: $A * $B

transponeren
MATLAB: Een'
PerlDL: $A->transponeren

Functies uit die aggregaat gegevens
Sommige functies (zoals 'som', 'max' en 'min') aggregeren gegevens voor een N-dimensionale gegevensset.
Dit is een plek waar MATLAB en PDL een andere aanpak hanteren:

In MATLAB werken deze functies allemaal langs één dimensie.
>> EEN = [ 1,5,4 ; 4,2,1 ]
EEN = 1 5 4
4 2 1
>> maximaal(A)
ans = 4 5 4
>> maximaal(A')
ans = 5 4

Als u het maximum voor de gehele dataset wilt, kunt u de speciale A(:)
notatie die in feite de gehele dataset in één enkele 1-dimensionale vorm verandert
vector.

>> maximaal(A(:))
ans = 5
>> A = enen(2,2,2,2)
>> maximaal(A(:))
ans = 1

PDL biedt voor elke functie twee functies.
som versus sumover
gemiddelde vs gemiddelde
max versus maximum
min versus minimum

De lang naam werkt over een dimensie, terwijl de kort naam werkt over het hele
plasje.

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->transponeren->maximum
[4 5 4]
pdl> p $A->max
5
pdl> p degenen(2,2,2)->max
1
pdl> p degenen(2,2,2,2)->max
1

Note Merk op dat PDL horizontaal aggregeert, terwijl MATLAB verticaal aggregeert. In andere
woorden:

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

TIP: In MATLAB denk je "rijen en kolommen". Denk bij PDL aan "x en y".

Hoger dimensionale gegevens sets
Een verwante kwestie is hoe MATLAB en PDL datasets met een hogere dimensie begrijpen. MATLAB was
ontworpen voor 1D-vectoren en 2D-matrices. Hogerdimensionale objecten ("ND-arrays") waren dat wel
bovenaan toegevoegd. PDL is daarentegen vanaf het begin ontworpen voor N-dimensionale piddles. Dit
leidt tot een paar verrassingen in MATLAB die niet voorkomen in PDL:

MATLAB beschouwt een vector als een 2D-matrix.
MATLAB PerlDL
------ ------
>> vector = [1,2,3,4]; pdl> $vector = pdl [1,2,3,4]
>> grootte(vector) pdl> p $vector->dimmen
ans = 1 4 4

MATLAB beschouwt "[1,2,3,4]" als een 2D-matrix (1x4-matrix). PDL ziet het als een 1D-vector: A
enkele afmeting van maat 4.

Maar MATLAB negeert de laatste dimensie van een 4x1x1-matrix.
MATLAB PerlDL
------ ------
>> A = eenheden(4,1,1); pdl> $A = degenen 4,1,1
>> maat(A) pdl> p $A->afm
ans = 4 1 4 1 1

En MATLAB behandelt een 4x1x1-matrix anders dan een 1x1x4-matrix.
MATLAB PerlDL
------ ------
>> A = eenheden(1,1,4); pdl> $A = degenen 1,1,4
>> maat(A) pdl> p $A->afm
ans = 1 1 4 1 1 4

MATLAB heeft geen directe syntaxis voor ND-arrays.
pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
pdl> p $A->dims
3 2 2

Functie ondersteuning.
In MATLAB zijn verschillende functies, zoals ondersteuning voor sparse matrix, niet beschikbaar voor ND
arrays. In PDL is vrijwel elke functie die wordt ondersteund door 1D- en 2D-piddles gelijk
ondersteund door N-dimensionale piddles. Er is meestal geen onderscheid.

Ringleiding Structuren
Perl heeft veel lusstructuren, maar we zullen alleen degene laten zien die het meest bekend is bij
MATLAB-gebruikers:

MATLAB PerlDL
------ ------
voor i = 1:10 voor $i (1..10) {
disp(i) print $i
eindevoor }

Note Gebruik nooit for-loops voor numeriek werk. De for-loops van Perl zijn sneller dan die van MATLAB,
maar ze verbleken allebei tegen een "gevectoriseerde" operatie. PDL heeft veel tools die:
vergemakkelijken het schrijven van gevectoriseerde programma's. Deze vallen buiten het bestek van deze handleiding. Tot
meer informatie, zie: PDL::Indexing, PDL::Threading en PDL::PP.

Gebruik ook nooit 1..10 voor numeriek werk, zelfs niet buiten een for-lus. 1..10 is een
Perl-array. Perl-arrays zijn ontworpen voor flexibiliteit, niet voor snelheid. Gebruik maken van plassen gebruiken.
Zie het volgende gedeelte voor meer informatie.

Piddles vs Perl arrays
Het is belangrijk om het verschil tussen a Plasje en een Perl-array. Perl heeft een
universeel array-object dat elk type element kan bevatten:

@perl_array = 1..10;
@perl_array = ( 12, "Hallo" );
@perl_array = ( 1, 2, 3, \@een andere_perl_array, volgorde(5));

Met Perl-arrays kunt u krachtige gegevensstructuren maken (zie Data structuren onderstaand), maar
ze zijn niet ontworpen voor numeriek werk. Gebruik daarvoor plassen:

$pdl = pdl [ 1, 2, 3, 4 ];
$pdl = reeks 10_000_000;
$pdl = enen 600, 600;

Bijvoorbeeld:

$punten = pdl 1..10_000_000 # 4.7 seconden
$punten = reeks 10_000_000 # milliseconden

TIP: U kunt onderstrepingstekens gebruiken in cijfers ("10_000_000" leest beter dan 10000000).

Voorwaardelijke
Perl heeft veel conditionals, maar we laten alleen degene zien die het meest bekend is bij MATLAB
gebruikers:

MATLAB PerlDL
------ ------
als waarde > MAX als ($ waarde > $ MAX) {
disp("Te groot") print "Te groot\n";
elseif waarde < MIN } elsif ($ waarde < $MIN) {
disp("Te klein") print "Te klein\n";
anders } anders {
disp("Perfect!") print "Perfect!\n";
einde }

Note Hier is een "gok":

MATLAB: andersif
PerlDL: anders

Als uw voorwaardelijke een syntaxisfout geeft, controleer dan of u uw "elsif"'s hebt geschreven
correct.

TIJDDI (Daar Is Meer Dan One Wijze waarop Naar Do Het)
Een van de meest interessante verschillen tussen PDL en andere tools is de expressiviteit
van de Perl-taal. TIMTOWDI, of "Er is meer dan één manier om het te doen", is het motto van Perl.

Perl is geschreven door een taalkundige, en een van de bepalende eigenschappen ervan is dat uitspraken kunnen
op verschillende manieren worden geformuleerd om de taal een natuurlijker gevoel te geven. Bijvoorbeeld, jij
zullen waarschijnlijk niet tegen een vriend zeggen:

"Zolang ik nog niet klaar ben, blijf ik werken."

Menselijke taal is flexibeler dan dat. In plaats daarvan zeg je eerder:

"Ik zal blijven werken tot ik klaar ben."

Vanwege zijn taalkundige wortels is Perl de enige programmeertaal met dit soort
flexibiliteit. Perl heeft bijvoorbeeld traditionele while-loops en if-statements:

while ( ! klaar() ) {
blijf werken();
}

if (! wife_angry()) {
kus_vrouw();
}

Maar het biedt ook het alternatief tot en tenzij verklaringen:

tot ( klaar() ) {
blijf werken();
}

tenzij ( wife_angry() ) {
kus_vrouw();
}

En met Perl kun je loops en conditionals in "postfix"-vorm schrijven:

keep_working() tot klaar();

kiss_wife() tenzij wife_angry();

Op deze manier stelt Perl u vaak in staat om natuurlijkere, gemakkelijk te begrijpen code te schrijven dan is
mogelijk in meer beperkende programmeertalen.

Functies
De syntaxis van PDL voor het declareren van functies verschilt aanzienlijk van die van MATLAB.

MATLAB PerlDL
------ ------
functie retval = foo(x,y) sub foo {
retval = x.**2 + x.*y mijn ($x, $y) = @_;
eindfunctie retour $x**2 + $x*$y;
}

Laat je niet intimideren door alle nieuwe syntaxis. Hier is een snelle doorloop van een functie
aangifte in PDL:

1) "beneden" staat voor "subroutine".

2) "my" declareert variabelen als lokaal voor de functie.

3) "@_" is een speciale Perl-array die alle functieparameters bevat. Dit lijkt misschien
als een vreemde manier om functies uit te voeren, maar het stelt je in staat om functies te maken die een
variabel aantal parameters. De volgende functie heeft bijvoorbeeld een willekeurig aantal
parameters en voegt ze samen:

sub mijnsom {
mijn ($i, $totaal) = (0, 0);
voor $i (@_) {
$totaal += $i;
}
retourneer $totaal;
}

4) U kunt waarden aan meerdere variabelen tegelijk toewijzen met behulp van de syntaxis:

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

Dus in de vorige voorbeelden:

# Dit declareert twee lokale variabelen en initialiseert ze naar 0.
mijn ($i, $totaal) = (0, 0);

# Dit neemt de eerste twee elementen van @_ en zet ze in $x en $y.
mijn ($x, $y) = @_;

5) De "terugkeer" statement geeft de geretourneerde waarde van de functie, indien aanwezig.

EXTRA KENMERKEN

ASCII Dien in IO
Om gegevensbestanden te lezen die door witruimte gescheiden kolommen met getallen bevatten (zoals gelezen zou worden
met behulp van MATLAB laden commando) gebruikt men de PDL rcols in PDL::IO::Divers. Voor een generaal
overzicht van de IO-functionaliteit die beschikbaar is in PDL, zie de documentatie voor PDL::IO, bijv.
"help PDL::IO" in het pdl2 shell of "pdldoc PDL::IO" vanaf de shell-opdrachtregel.

Data structuren
Om complexe datastructuren te creëren, gebruikt MATLAB "cel arrays"En"structuur arrays".
De arrays en hashes van Perl bieden vergelijkbare functionaliteit, maar zijn krachtiger en flexibeler.
Deze sectie is slechts een kort overzicht van wat Perl te bieden heeft. Om hier meer over te weten te komen,
Ga aub naarhttp://perldoc.perl.org/perldata.html> of voer het commando "perldoc
perldata".

arrays
Perl-arrays zijn vergelijkbaar met de celarrays van MATLAB, maar flexibeler. Bijvoorbeeld binnen
MATLAB, een celarray is nog steeds fundamenteel een matrix. Het is gemaakt van rijen en rijen
moet dezelfde lengte hebben.

MATLAB
------
array = {1, 12, 'hallo'; rand(3, 2), degenen(3), 'rommel'}
=> Oké
array = {1, 12, 'hallo'; rand(3, 2), degenen(3) }
=> FOUT

Een Perl-array is een sequentiële gegevensstructuur voor algemene doeleinden. Het kan alle gegevens bevatten
type.

PerlDL
------
@array = ( [1, 12, 'hallo'] , [ willekeurig(3,2), degenen(3,3), 'rommel' ] )
=> Oké
@array = ( [1, 12, 'hallo'] , [ willekeurig(3,2), eenheden(3,3) ] )
=> Oké
@array = ( 5 , {'naam' => 'Mike'} , [1, 12, 'hallo'] )
=> Oké

Merk op dat Perl-arrays beginnen met het voorvoegsel "@" in plaats van de "$" die wordt gebruikt door
plassen.

Naar U leert over Perl reeksen, dan go naar <http://perldoc.perl.org/perldata.html> or
lopen the commando "perldoc perldata".

hashes
Perl-hashes zijn vergelijkbaar met de structuurarrays van MATLAB:

MATLAB
------
>> drankje = struct('type', 'cola', 'grootte', 'groot', 'myarray', {1,2,3})
>> drankje.type = 'sprite'
>> drink.price = 12 % Voeg een nieuw veld toe aan de structuurarray.

PerlDL
------
pdl> %drink = ( type => 'cola' , size => 'large', mypiddle => ones(3,3,3) )
pdl> $drink{type} = 'sprite'
pdl> $drink{price} = 12 # Nieuw veld toevoegen aan hash.

Merk op dat Perl-hashes beginnen met het voorvoegsel "%" in plaats van de "@" voor arrays en
"$" gebruikt door piddles.

Naar U leert over Perl hasj, dan go naar <http://perldoc.perl.org/perldata.html> or
lopen the commando "perldoc perldata".

Prestatie
PDL heeft krachtige prestatiefuncties, waarvan sommige normaal niet beschikbaar zijn in
numerieke rekentools. De volgende pagina's leiden u door deze functies:

PDL::Indexeren
Niveau: Beginners

Deze tutorial voor beginners behandelt de standaard "vectorisatie"-functie die je al hebt
ken van MATLAB. Gebruik deze pagina om te leren hoe u for-loops kunt vermijden bij het maken van uw programma
efficiënter.

PDL::Inrijgen
Niveau: Gemiddeld

De "vectorisatie"-functie van PDL gaat verder dan wat de meeste numerieke software kan doen. In
deze tutorial leert u hoe u over hogere dimensies kunt "rijgen", zodat u:
vectoriseer uw programma verder dan mogelijk is in MATLAB.

benchmarks
Niveau: Gemiddeld

Perl wordt geleverd met een eenvoudig te gebruiken benchmarks-module om u te helpen bepalen hoe lang het duurt
om verschillende delen van uw code uit te voeren. Het is een geweldig hulpmiddel om u te helpen focussen op uw
optimalisatie inspanningen. Je leest er online over
(<http://perldoc.perl.org/Benchmark.html>) of via het commando "perldoc
Benchmark".

PDL::PP
Niveau: Geavanceerd

De Pre-Processor van PDL is een van de krachtigste functies van PDL. Je schrijft een functie
definitie in speciale opmaak en de pre-processor genereert echte C-code die kan worden
gecompileerd. Met PDL:PP krijgt u de volledige snelheid van native C-code zonder dat u hoeft te dealen
met de volledige complexiteit van de C-taal.

Plotten
PDL beschikt over volledige plotmogelijkheden. In tegenstelling tot MATLAB vertrouwt PDL meer op derden
bibliotheken (pgplot en PLplot) voor zijn 2D-plotfuncties. Zijn 3D plotten en graphics
gebruikt OpenGL voor prestaties en draagbaarheid. PDL heeft drie hoofdplotmodules:

PDL::Grafiek::PGPLOT
Beste voor: Het plotten van 2D-functies en datasets.

Dit is een interface naar de eerbiedwaardige PGPLOT-bibliotheek. PGPLOT is op grote schaal gebruikt in
de academische en wetenschappelijke gemeenschappen gedurende vele jaren. Mede door zijn leeftijd,
PGPLOT heeft enkele beperkingen in vergelijking met nieuwere pakketten zoals PLplot (bijv. geen RGB
grafiek). Maar het heeft veel functies die het nog steeds populair maken in de wetenschappelijke
gemeenschap.

PDL::Afbeeldingen::PLplot
Beste voor: Het plotten van 2D-functies en 2D- en 3D-gegevenssets.

Dit is een interface naar de PLplot-plotbibliotheek. PLplot is een moderne, open source
bibliotheek voor het maken van wetenschappelijke plots. Het ondersteunt plots van zowel 2D- als 3D-gegevenssets.
PLplot wordt het best ondersteund voor unix/linux/macosx-platforms. Het heeft een actieve ontwikkelaar
community en ondersteuning voor win32-platforms verbetert.

PDL::Afbeeldingen::TriD
Beste voor: 3D-functies plotten.

De native PDL 3D grafische bibliotheek die OpenGL gebruikt als backend voor 3D-plots en gegevens
visualisatie. Met OpenGL is het gemakkelijk om de resulterende 3D-objecten te manipuleren met
de muis in realtime.

schrijf- GUI's
Via Perl heeft PDL toegang tot alle belangrijke toolkits voor het creëren van een platformoverschrijdend platform
grafische gebruikersinterface. Een populaire optie is wxPerl (http://wxperl.sourceforge.net>).
Dit zijn de Perl-bindingen voor wxWidgets, een krachtige GUI-toolkit voor het schrijven van cross-
platform toepassingen.

wxWidgets is ontworpen om uw applicatie eruit te laten zien en aanvoelen als een native applicatie in
elk podium. Bijvoorbeeld de Perl IDE Vader is geschreven met wxPerl.

simulink
Simulink is een grafisch dynamisch systeemmodelbouwer en simulator. Het kan worden gekocht
afzonderlijk als add-on voor MATLAB. PDL en Perl hebben geen direct equivalent van
MATLAB's Simulink. Als deze functie belangrijk voor je is, kijk dan eens naar scilab:

<http://www.scilab.org>

Scilab is een andere numerieke analysesoftware. Net als PDL is het gratis en open source. Het
heeft niet de unieke kenmerken van PDL, maar lijkt sterk op MATLAB. Scilab wordt meegeleverd
Xco's (voorheen Scicos), een grafische systeemmodelmaker en simulator vergelijkbaar met Simulink.

COPYRIGHT

Copyright 2010 Daniel Carrera ([e-mail beveiligd]). U kunt dit verspreiden en/of wijzigen
document onder dezelfde voorwaarden als de huidige Perl-licentie.

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

Danksagung
Ik wil David Mertens, Chris Marshall en Sigrid Carrera bedanken voor hun immense werk
helpen bij het beoordelen van eerdere versies van deze handleiding. Zonder hun uren werk, dit
document zou in de verste verte niet zo nuttig zijn voor MATLAB-gebruikers als het nu is.

Gebruik PDL::MATLABp online met behulp van onworks.net-services