PDL::QuickStartp - Online in de cloud

PROGRAMMA:

NAAM

PDL::QuickStart - Snelle introductie tot PDL-functies.

KORTE INHOUD

Een korte samenvatting van de belangrijkste PDL-functies en hoe u deze kunt gebruiken.

PRODUCTBESCHRIJVING

Introductie
Perl is een buitengewoon goede en veelzijdige scripttaal, zeer geschikt voor beginners en gevorderden
maakt snelle prototypering mogelijk. Tot voor kort ondersteunde het echter geen datastructuren die
liet het toe om snel cijfers te kraken.

Met de ontwikkeling van Perl v5 verwierf Perl echter 'Objects'. Om het simpel te zeggen: gebruikers
kunnen hun eigen speciale gegevenstypen definiëren en aangepaste routines schrijven om deze te manipuleren
hetzij in talen op een laag niveau (C en Fortran) of in Perl zelf.

Dit is volledig uitgebuit door de PerlDL-ontwikkelaars. De module 'PDL' is een complete
Objectgeoriënteerde uitbreiding op Perl (hoewel u niet hoeft te weten wat een object betekent
gebruik het) waarmee grote N-dimensionale datasets mogelijk zijn, zoals grote afbeeldingen, spectra, tijd
series, enz. die moeten worden opgeslagen efficiënt en gemanipuleerd en massa. Bijvoorbeeld met de PDL
module kunnen we de Perl-code "$a = $b + $c" schrijven, waarbij $b en $c grote datasets zijn (bijv.
2048 x 2048 afbeeldingen) en ontvang het resultaat in slechts een fractie van een seconde.

PDL-variabelen (of 'piddles' zoals ze bekend zijn geworden) ondersteunen een breed scala aan
fundamentele gegevenstypen - arrays kunnen bytes, korte gehele getallen (met of zonder teken) en lang zijn
gehele getallen, drijvers of dubbele precisie drijvers. En vanwege het objectgeoriënteerde karakter van
Er kunnen nieuwe aangepaste PDL-gegevenstypen van worden afgeleid.

Naast de PDL-modules, die door normale Perl-programma's kunnen worden gebruikt, wordt PerlDL geleverd met een
opdrachtregel Perl-shell, genaamd 'perldl', die bewerking op de opdrachtregel ondersteunt. In
in combinatie met de verschillende PDL grafische modules kunnen gegevens eenvoudig worden afgespeeld
mee en gevisualiseerd.

Help
PDL bevat uitgebreide documentatie, zowel beschikbaar binnen de parel or pdl2 schelpen en
vanaf de opdrachtregel, met behulp van het programma "pdldoc". Voor meer informatie kunt u een van de volgende proberen:

pdl> help help
$ pdldoc

HTML-kopieën van de documentatie moeten ook beschikbaar zijn. Probeer het om hun locatie te vinden
het volgende:

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

Perl Datatypen en hoe PDL strekt aan hen
De fundamentele Perl-datastructuren zijn scalaire variabelen, bijvoorbeeld $x, die getallen kunnen bevatten
of tekenreeksen, lijsten of arrays van scalairen, bijvoorbeeld @x, en associatieve arrays/hashes van scalaires,
bijv. %x.

Perl v5 maakt kennis met Perl-datastructuren en -objecten. Er is nu een eenvoudige scalaire variabele $x
een door de gebruiker gedefinieerd gegevenstype of een volledig object (het bevat feitelijk een referentie (een smart
"pointer") hiernaar toe, maar dat is niet relevant voor normaal gebruik van perlDL)

Het fundamentele idee achter perlDL is om $x een heel 1D-spectrum of een 2D-spectrum te laten bevatten
afbeelding, een 3D-datakubus, enzovoort, tot aan grote N-dimensionale datasets. Dit kunnen zijn
in één keer gemanipuleerd, bijvoorbeeld "$a = $b + 2" voert een vectorbewerking uit op elke waarde in de
spectrum/beeld/etc.

Je zou je kunnen afvragen: "Waarom slaan we niet gewoon een spectrum op als een eenvoudige Perl @x-stijllijst bij elk spectrum
pixel een lijstitem is?" De twee belangrijkste antwoorden hierop zijn geheugen en snelheid. Omdat we
Omdat we weten dat ons spectrum uit pure getallen bestaat, kunnen we ze compact in één blok opslaan
geheugen dat overeenkomt met een numerieke array in C-stijl. Dit neemt VEEL minder geheugen in beslag dan
de equivalente Perl-lijst. Het is dan gemakkelijk om dit geheugenblok door te geven aan een snelle toevoeging
routine, of naar een andere C-functie die zich bezighoudt met arrays. Als gevolg hiervan is perlDL erg
snel --- je kunt bijvoorbeeld een afbeelding van 2048*2048 in precies dezelfde tijd vermenigvuldigen
zou C of FORTRAN opnemen (0.1 sec op mijn SPARC). Een bijkomend voordeel hiervan is dat voor
Met eenvoudige handelingen (bijvoorbeeld "$x += 2") kan men de hele array manipuleren zonder zich er zorgen over te maken
zijn dimensionaliteit.

Ik vind dat het bij het gebruik van perlDL het nuttigst is om standaard Perl @x-variabelen te beschouwen als
"lijsten" met generieke "dingen" en PDL-variabelen zoals $x als "arrays" die kunnen worden opgenomen
in lijsten of hashes. Heel vaak heb ik in mijn perlDL-scripts @x een lijst met spectra,
of een lijst met afbeeldingen (of zelfs een mix!). Of misschien kan er een hash (bijvoorbeeld %x) van zijn
afbeeldingen... de enige limiet is geheugen!

perlDL-variabelen ondersteunen een reeks gegevenstypen - arrays kunnen bytes zijn, korte gehele getallen
(met of zonder teken), lange gehele getallen, floats of floats met dubbele precisie.

Gebruik
PerlDL wordt met deze opdracht in uw Perl-script geladen:

gebruik PDL; # in Perl-scripts: gebruik de standaard perlDL-modules

Er zijn ook veel uitbreidingsmodules, bijvoorbeeld PDL::Graphics::TriD. De meeste hiervan (maar
niet allemaal omdat het soms niet gepast is) een standaardconventie volgen. Als je zegt:

gebruik PDL::Graphics::TriD;

Je importeert alles in een standaardlijst uit de module. Soms wil je dat misschien wel
importeer niets (bijvoorbeeld als u de hele tijd de OO-syntaxis wilt gebruiken en de importbelasting wilt opslaan).
Hiervoor zeg je:

gebruik PDL::Graphics::TriD qw();

En de lege "qw()"-aanhalingstekens worden herkend als 'niets'. U kunt ook een opgeven
lijst met functies die op de normale Perl-manier moeten worden geïmporteerd.

Er is ook een interactieve shell, "perldl" of "pdl2", zie parel of pdl2 voor details.

Naar en je merk te creëren a nieuwe PDL variabele
Hier volgen enkele manieren om een ​​PDL-variabele te maken:

$a = pdl [1..10]; # 1D-array
$a = pdl (1,2,3,4); # Idem dito
$a = pdl '[1 2 3 4]'; # Idem dito
$b = pdl [[1,2,3],[4,5,6]]; # 2D 3x2-array
$b = pdl '[1 2 3; 4 5 6]'; # Idem dito
$b = pdl q[1,2,3; 4,5,6]; # Idem dito
$b = pdl <
[1 2 3]
[4 5 6]
NIEUWPDL
$c = pdl q[1 -2]; # Piddle met 2 elementen met 1 en -2
$c = pdl q[1 - 2]; # Piddle met 2 elementen met 1 en -2
$b = pdl 42 # 0-dimensionaal scalair
$c = pdl$a; # Maak een nieuwe kopie

$d = byte [1..10]; # Zie "Typeconversie"
$e = nullen(3,2,4); # 3x2x4 nulgevulde array

$c = rfits $bestand; # Lees het FITS-bestand

@ x = ( pdl(42), nullen(3,2,4), rfits($file) ); # Is een LIJST met PDL-variabelen!

Dé pdl() functie wordt gebruikt om een ​​PDL-variabele te initialiseren vanuit een scalaire lijst, lijst
referentie, een andere PDL-variabele of een correct opgemaakte tekenreeks.

Bovendien converteren alle PDL-functies automatisch normale Perl-scalaire waarden naar PDL-variabelen
onderweg.

(zie ook de secties "Typeconversie" en "Invoer/uitvoer" hieronder)

Rekenkunde (En boolean uitdrukkingen)
$a = $b + 2; $a++; $a = $b / $c; # Enz.

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

$e = $a>42; # Vector voorwaardelijk

$e = 42*($a>42) + $a*($a<=42); # Dop bovenaan

$b = $a->log10 tenzij ($a <= 0); # vermijd drijvende-kommafout

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

$f = waar($a, $a > 10); # waar een aantal elementen voor wordt geretourneerd
# waarvan de voorwaarde waar is

druk $a af; # $a in stringcontext drukt het af in een N-dimensionaal formaat

(en andere Perl-operatoren/functies)

Bij gebruik van piddles in voorwaardelijke expressies (dat wil zeggen "if", "unless" en "while" constructies)
alleen piddles met precies één element zijn toegestaan, bijv

$a = pdl (1,0,0,1);
print "is ingesteld" als $a->index(2);

Merk op dat de Booleaanse operatoren retourneren in algemene piddles met meerdere elementen. Daarom, de
het volgende zal een fout opleveren

print "is oké" als $a > 3;

aangezien "$a > 3" een piddle is met 4 elementen. Gebruik liever alles of wat om te testen of alles of een deel ervan is
de elementen voldoen aan de voorwaarde:

print "sommige zijn > 3" indien aanwezig $a>3;
print "kan geen logaritme aannemen" tenzij alle $a>0;

Er zijn ook veel vooraf gedefinieerde functies, die op andere manpagina's worden beschreven. Rekening
PDL::Index.

Matrix functies
'x' wordt gekaapt als de matrixvermenigvuldigingsoperator. bijv. "$c = $ax $b";

perlDL is rij-major en geen kolom-major, dus dit is eigenlijk "c(i,j) = sum_k a(k,j) b(i,k)" -
maar wanneer matrices worden afgedrukt, zullen de resultaten er goed uitzien. Vergeet niet dat de indices dat wel zijn
teruggedraaid. bijvoorbeeld:

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

geeft $c = [
[ 1 11]
[ 8 10]
[ 2 2]
]

Opmerking: transponeren() doet wat het zegt en is een handige manier om rijvectoren om te zetten in
kolom vectoren.

Hoe naar schrijven a simpel functie
sub puntproduct {
mijn ($a,$b) = @_;
retoursom($a*$b) ;
}
1;

Als u het bestand dotproduct.pdl invoert, wordt het automatisch geladen als u PDL::AutoLoader gebruikt (zie
hieronder).

Uiteraard is deze functie al beschikbaar als de interne functie, zie PDL::Primitive.

Type Camper ombouw
Standaard voor pdl() is dubbel. Conversies zijn:

$a = zweven($b);
$c = lang($d); # "lang" is over het algemeen een int van 4 bytes
$d = byte($a);

ook dubbele(), kort(), ukort(), index().

OPMERKING: De indx()-routine is van een speciaal geheel getaltype
is de juiste maat voor een PDL-indexwaarde (afmetingsgrootte,
index of offest) die een 32-bits (lang) of
64bit (longlong) hoeveelheid, afhankelijk van of de perl
is gebouwd met 32bit- of 64bit-ondersteuning.

Deze routines converteren ook automatisch Perl-lijsten om de handige afkorting mogelijk te maken:

$a = byte [[1..10],[1..10]]; # Maak een 2D-bytearray
$a = zwevend [1..1000]; # Maak een 1D float-array

enz.

Print
Breidt de array automatisch uit in N-dimensionaal formaat:

druk $a af;

$b = "Antwoord is = $a ";

Secties
PDL beschikt over zeer krachtige multidimensionale snij- en snijoperatoren; zie de
PDL::Slices(3) manpagina voor details; de belangrijkste beschrijven we hier.

PDL toont zijn Perl/C-erfgoed doordat arrays nul-offset zijn. Een afbeelding van 100x100 heeft dus
indexcijfers "0..99,0..99". (De afspraak is dat de centrum van pixel (0,0) bevindt zich op coördinaat
(0.0,0.0). Alle grafische PDL-functies voldoen aan deze definitie en verbergen het apparaat
offsets van bijvoorbeeld de PGPLOT FORTRAN-bibliotheek.

Volgens de gebruikelijke conventie wordt de coördinaat (0,0) linksonder weergegeven wanneer
een afbeelding weergeven. Het verschijnt linksboven als u "print $a" enz. gebruikt.

Eenvoudige secties maken gebruik van een syntaxisextensie voor Perl, PDL::NiceSlice, waarmee u dit kunt doen
specificeer subbereiken via een null-methode modifier naar een PDL:

$b = $a->($x1:$x2,$y1:$y2,($z1)); # Neem onderafdeling

Hier is $a een driedimensionale variabele en krijgt $b een vlakke uitsnijding die wordt gedefinieerd door de
beperkt $x1, $x2, $y1, $y2, op de locatie $z1. De haakjes rond $z1 veroorzaken de
triviale index moet worden weggelaten - anders zou $b driedimensionaal zijn met een derde
afmeting van bestelling 1.

U kunt PDL-plakken aan weerszijden van de elementgewijze toewijzingsoperator ".=" plaatsen, zoals
zon:

# Stel een deel van $bigimage in op waarden uit $smallimage
$bigimage->($xa:$xb,$ya:$yb) .= $smallimage;

Nog wat overige zaken:

$c = nelem($a); # Aantal pixels

$val = at($object, $x,$y,$z...) # Pixelwaarde op positie, als een Perl-scalair
$val = $object->at($x,$y,$z...) # equivalent (methodesyntaxis OK)

$b = xwaarden($a); # Vul array met X-coord-waarden (ook yvals(), zvals(),
# axisvals($x,$axis) en rvals() voor radiale afstand
# vanaf het midden).

Input / Output
De "PDL::IO"-modules implementeren verschillende nuttige IO-formaatfuncties. Het zou te veel zijn
om voorbeelden van elk te geven, maar een mooi overzicht kun je vinden op PDL::IO. Hier is een voorbeeld van
enkele van de ondersteunde IO-formaten in PDL.

PDL::IO::Divers
Ascii-, FITS- en FIGARO/NDF IO-routines.

PDL::IO::FastRaw
Met behulp van de onbewerkte gegevenstypen van uw machine, een niet-draagbare maar verblindend snelle IO
formaat. Ondersteunt ook geheugentoewijzing om geheugen te besparen en meer snelheid te krijgen.

PDL::IO::FlexRaw
Algemene formaten voor onbewerkte gegevens. Net als FastRaw, maar dan beter.

PDL::IO::Browser
Een Curses-browser voor arrays.

PDL::IO::Pnm
Portaple bitmap- en pixmap-ondersteuning.

PDL::IO::Afb
Door de vorige module en netpbm te gebruiken, is het mogelijk om eenvoudig GIF, jpeg te schrijven
en wat dan ook met eenvoudige commando's.

grafiek
De filosofie achter perlDL is om het te laten werken met een verscheidenheid aan bestaande afbeeldingen
bibliotheken, aangezien geen enkel pakket aan alle behoeften en alle mensen zal voldoen en dit mogelijk maakt
één om te werken met pakketten die je al kent en leuk vindt. Het zal duidelijk zijn dat er een aantal zullen zijn
overlap in functionaliteit en enig gebrek aan consistentie en uniformiteit. Dit laat echter toe
PDL om gelijke tred te houden met een zich snel ontwikkelend vakgebied: de nieuwste PDL-modules bieden interfaces
naar OpenGL- en VRML-afbeeldingen!

PDL::Grafiek::PGPLOT
PGPLOT biedt een eenvoudige bibliotheek voor lijngrafieken en beeldweergave.

Er is hiervoor een eenvoudige interface in de interne module PDL::Graphics::PGPLOT, die
roept routines aan in de afzonderlijk verkrijgbare PGPLOT-topniveaumodule.

PDL::Afbeeldingen::PLplot
PLplot biedt een eenvoudige bibliotheek voor het maken van afbeeldingen met meerdere uitvoerstuurprogramma's,
inclusief een direct-to-piddle-driver.

Deze module biedt functionaliteit op zowel hoog als laag niveau, gebouwd op PLplot. De
opdrachten op laag niveau zijn vrijwel directe bindingen met de C-interface van PLplot. Lees verder
bij PDL::Graphics::PLplot.

PDL::Afbeeldingen::IIS
Veel astronomen gebruiken graag SAOimage en Ximtool (of hun afleidingen/klonen). Deze
zijn handige gratis widgets voor inspectie en visualisatie van afbeeldingen. (Zij zijn niet
voorzien van perlDL maar kan eenvoudig worden verkregen via hun officiële sites buiten de
Netto.)

Met het PDL::Graphics::IIS-pakket kunt u afbeeldingen weergeven in deze ("IIS"
is de naam van een oud stuk hardware voor beeldweergave waarvan de protocollen deze tools bevatten
overeenstemmen met.)

PDL::Afbeeldingen::TriD
Zie PDL::Graphics::TriD, dit is een verzameling 3D-routines voor OpenGL en (binnenkort)
VRML en andere 3D-formaten die 3D-punt-, lijn- en oppervlakteplots van PDL mogelijk maken.

Automatisch laden
Zie PDL::AutoLoader. Hierdoor kan men functies op verzoek automatisch laden, misschien op een bepaalde manier
bekend bij gebruikers van MatLab.

U kunt PDL-extensies ook schrijven als normale Perl-modules.

PDL schelpen
Het Perl-script "pdl2" (of "perldl") biedt een eenvoudige opdrachtregelinterface voor PDL. Als
de nieuwste Readlines/ReadKey-modules zijn geïnstalleerd. "pdl2" detecteert dit en schakelt dit in
opdrachtregel oproepen en bewerken. Zie de manpagina voor details.

bijvoorbeeld:

% perldl
perlDL-shell v1.354
PDL wordt geleverd met ABSOLUUT GEEN GARANTIE. Zie het bestand voor meer informatie
'KOPIËREN' in de PDL-distributie. Dit is vrije software en jij
zijn welkom om het onder bepaalde voorwaarden opnieuw te distribueren, zie
hetzelfde bestand voor details.
ReadLines, NiceSlice, MultiLines ingeschakeld
PDL/default.perldlrc lezen...
Documentendatabase /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db gevonden
Typ 'help' voor online hulp
Typ 'demo' voor online demo's
Geladen PDL v2.4.9_003 (ondersteunt slechte waarden)
pdl> $x = rfits 'm51.fits'
IMAGE-gegevens lezen...
BITPIX = 32 grootte = 147456 pixels
589824 bytes lezen
BSCHAAL = && BZERO =

pdl> gebruik PDL::Graphics::PGPLOT;
pdl> afbeelding $x
Weergave van een afbeelding van 384 x 384 van 40 tot 761, met gebruik van 84 kleuren (16-99)...

Je kunt het ook uitvoeren vanuit de Perl-foutopsporing ("perl -MPDL -d -e 1") als je wilt.

Diverse shell-eigenschappen:

p De shell-alias "p" is een handige korte vorm van "print", bijv

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

initialisatie
De bestanden "~/.perldlrc" en "local.perldlrc" (in de huidige map) zijn afkomstig van if
gevonden. Hierdoor beschikt de gebruiker over globale en lokale PDL-code voor het opstarten.

Help
Typ 'help'! U kunt de PDL-documentatie doorzoeken en documentatie over elk document opzoeken
functie.

Ontsnappen
Elke regel die begint met het teken "#" wordt behandeld als een shell-escape. Dit karakter
kan worden geconfigureerd door de Perl-variabele $PERLDL_ESCAPE in te stellen. Dit zou bijvoorbeeld kunnen
wordt geplaatst in "~/.perldlrc".

Overbelasten exploitanten
De volgende ingebouwde Perl-operatoren en -functies zijn overbelast om op PDL te werken
variabelen:

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

[Alle unaire functies (sin etc.) kunnen worden gebruikt in situ() - zie "Geheugen" hieronder.]

Object-oriëntatie en perlDL
PDL-bewerkingen zijn beschikbaar als functies en methoden. Zo kan men nieuwe soorten afleiden
object, om aangepaste gegevensklassen weer te geven.

Door gebruik te maken van overbelasting kun je wiskundige operatoren laten doen wat je wilt, en PDL
heeft een aantal ingebouwde trucs waardoor bestaande PDL-functies ongewijzigd kunnen werken, zelfs als de
de onderliggende gegevensrepresentatie is enorm veranderd! Zie PDL::Objecten

Geheugen gebruik en referenties
Het rommelen met echt enorme data-arrays kan enige zorg vereisen. perlDL biedt er veel
faciliteiten waarmee u bewerkingen op grote arrays kunt uitvoeren zonder extra kopieën te genereren
hoewel dit wel wat meer aandacht en zorg van de programmeur vereist.

OPMERKING: Op sommige systemen is het beter om Perl te configureren (tijdens de build-opties).
gebruik de systeemfunctie "malloc()" in plaats van de ingebouwde functie van Perl. Dit komt omdat Perl's
de ene is geoptimaliseerd voor snelheid in plaats van voor het verbruik van virtueel geheugen - dit kan resulteren in
een factor twee verbetering in de hoeveelheid geheugenopslag die u kunt gebruiken. De Perl malloc
in 5.004 en later heeft een aantal compile-time-opties die u kunt gebruiken om de
gedrag.

Eenvoudige rekenkunde
Als $a een grote afbeelding is (bijvoorbeeld 10 MB in beslag nemend), dan wordt het commando

$a = $a + 1;

kost nog eens 10 MB geheugen. Dit komt omdat de uitdrukking "$a+1" een
tijdelijke kopie van $a om het resultaat vast te houden, waarna aan $a een verwijzing daarnaar wordt toegewezen.
Hierna wordt de originele $a vernietigd, dus er is geen blijvend geheugenverspilling. Maar op
een kleine machine kan de groei van de geheugenvoetafdruk aanzienlijk zijn. Het is
uiteraard op deze manier gedaan, dus "$c=$a+1" werkt zoals verwacht.

Ook als iemand zegt:

$b = $a; # $b en $a verwijzen nu naar dezelfde gegevens
$a = $a + 1;

Dan worden $b en $a uiteindelijk anders, zoals je naïef zou verwachten, omdat er een nieuwe referentie is
wordt gemaakt en $a wordt eraan toegewezen.

Maar als $a een enorm geheugenzwijn is (bijvoorbeeld een 3D-volume), is het maken van een kopie ervan misschien niet mogelijk
wees een goede zaak. Je kunt deze geheugenoverhead in het bovenstaande voorbeeld vermijden door te zeggen:

$a++;

De bewerkingen "++,+=,--,-=", enz. roepen allemaal een speciale "in-place" versie van de
rekenkundige subroutine. Dit betekent dat er geen geheugen meer nodig is - het nadeel hiervan is
dat als "$b=$a" $b ook wordt verhoogd. Om een ​​kopie expliciet te forceren:

$b = pdl$a; # Echt exemplaar

of, als alternatief, misschien een betere stijl:

$b = $a->kopie;

Functies
De meeste functies, bijvoorbeeld "log()", retourneren een resultaat dat een transformatie is van hun
argument. Dit zorgt voor een goede programmeerpraktijk. Hoe veel operaties er ook zijn
gedaan "in-place" en dit kan nodig zijn wanneer grote arrays in gebruik zijn en er geheugen beschikbaar is
een premie. Voor deze omstandigheden de exploitant in situ() is voorzien wat dit verhindert
de extra kopie en maakt het mogelijk dat het argument wordt gewijzigd. bijvoorbeeld:

$x = logboek($array); # $array wordt niet beïnvloed
log( inplace($bigarray) ); # $bigarray is ter plaatse veranderd

WAARSCHUWING:

1. De gebruikelijke kanttekeningen bij dubbele referenties zijn van toepassing.

2. Uiteraard bij gebruik met bepaalde functies die niet ter plaatse kunnen worden toegepast (bijv
"convolve()") onverwachte effecten kunnen optreden! We proberen "inplace()"-safe aan te geven
functies in de documentatie.

3. Typeconversies, zoals "float()", kunnen verborgen kopiëren veroorzaken.

Zorgen plasheid
Als je een eenvoudige functie hebt geschreven en je wilt niet dat deze in je gezicht ontploft
geef het een eenvoudig getal door in plaats van een PDL-variabele. Roep eenvoudigweg de functie aan topdl() eerste
om het veilig te maken. bijvoorbeeld:

sub mijnfiddle { mijn $pdl = topdl(shift); $pdl->fiddle_foo(...); ... }

"topdl()" voert GEEN kopie uit als een pdl-variabele wordt doorgegeven - deze valt er gewoon doorheen -
wat uiteraard het gewenste gedrag is. De routine is natuurlijk niet nodig in het normale leven
door de gebruiker gedefinieerde functies die zich niets aantrekken van de interne onderdelen.

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