PDL::QuickStartp - Online in de cloud

PROGRAMMA:

NAAM

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

KORTE INHOUD

Een kort overzicht van de belangrijkste PDL-functies en hoe u ze kunt gebruiken.

PRODUCTBESCHRIJVING

Introductie
Perl is een uiterst goede en veelzijdige scripttaal, die zeer geschikt is voor beginners en
maakt rapid prototyping mogelijk. Tot voor kort ondersteunde het echter geen datastructuren die
waardoor het snel rekenwerk kon uitvoeren.

Met de ontwikkeling van Perl v5 kreeg Perl echter 'Objects'. Simpel gezegd, gebruikers
kunnen hun eigen speciale gegevenstypen definiëren en aangepaste routines schrijven om deze te manipuleren
hetzij in laagniveau-talen (C en Fortran) of in Perl zelf.

De PerlDL-ontwikkelaars hebben hier volledig gebruik van gemaakt. De 'PDL'-module is een complete
Objectgeoriënteerde uitbreiding van Perl (hoewel je niet hoeft te weten wat een object is om
(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 massaBijvoorbeeld met de PDL
module kunnen we de Perl-code "$a = $b + $c" schrijven, waarbij $b en $c grote datasets zijn (bijv.
2048x2048 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), lange getallen zijn
integers, floats of floats met dubbele precisie. En vanwege de objectgeoriënteerde aard van
Er kunnen nieuwe, aangepaste PDL-gegevenstypen uit worden afgeleid.

Naast de PDL-modules, die door normale Perl-programma's kunnen worden gebruikt, wordt PerlDL geleverd met een
Perl-shell voor de opdrachtregel, genaamd 'perldl', die bewerking via de opdrachtregel ondersteunt. In
in combinatie met de verschillende PDL grafische modules kan dit ervoor zorgen dat data eenvoudig afgespeeld kan worden
met en gevisualiseerd.

Help
PDL bevat uitgebreide documentatie, beschikbaar zowel 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 opties proberen:

pdl> help help
$ pdldoc

HTML-kopieën van de documentatie zouden ook beschikbaar moeten zijn. Om de locatie te vinden, kunt u het volgende proberen:
het volgende:

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

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

Perl v5 introduceert Perl-datastructuren en -objecten. Een eenvoudige scalaire variabele $x is nu beschikbaar.
een door de gebruiker gedefinieerd gegevenstype of een volledig object (het bevat feitelijk een referentie (een slimme
('pointer') hiernaar, maar dat is niet relevant voor het normale gebruik van perlDL)

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

U vraagt ​​zich wellicht af: "Waarom slaat u een spectrum niet gewoon op als een eenvoudige Perl @x-stijllijst met elk
"Is de pixel een lijstitem?" De twee belangrijkste antwoorden hierop zijn: geheugen en snelheid. Omdat wij
Omdat ons spectrum uit zuivere 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 eenvoudig om dit geheugenblok door te geven aan een snelle toevoeging.
routine, of aan een andere C-functie die met arrays werkt. Als gevolg hiervan is perlDL erg
snel --- men kan bijvoorbeeld een 2048*2048-afbeelding in exact dezelfde tijd vermenigvuldigen als
zou duren in C of FORTRAN (0.1 sec op mijn SPARC). Een ander voordeel hiervan is dat voor
Met eenvoudige bewerkingen (bijvoorbeeld "$x += 2") kan men de hele array manipuleren zonder dat men zich daar druk om hoeft te maken.
de dimensionaliteit ervan.

Ik vind dat het bij het gebruik van perlDL het meest nuttig 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. In mijn PerlDL-scripts bevat @x vaak een lijst met spectra.
of een lijst met afbeeldingen (of zelfs een mix!). Of misschien zou je een hash (bijv. %x) kunnen hebben van
afbeeldingen... de enige beperking is het geheugen!

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

Gebruik
PerlDL wordt in uw Perl-script geladen met behulp van de volgende opdracht:

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) volgen een standaardconventie. Als je zegt:

gebruik PDL::Graphics::TriD;

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

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

En de lege "qw()"-aanhalingstekens worden herkend als 'niets'. U kunt ook een
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 zijn 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]; # 2-elementen piddle met 1 en -2
$c = pdl q[1 - 2]; # 2-elementen piddle met 1 en -2
$b = pdl 42 # 0-dimensionale scalair
$c = pdl $a; # Maak een nieuwe kopie

$d = byte [1..10]; # Zie "Typeconversie"
$e = zeroes(3,2,4); # 3x2x4 met nul gevulde array

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

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

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

Bovendien converteren alle PDL-functies automatisch normale Perl-scalarwaarden 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); # Enzovoort

$e = $a>42; # Vectorvoorwaardelijk

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

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

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

$f = where($a, $a > 10); # where retourneert een klein aantal elementen voor
# waarbij de voorwaarde waar is

print $a; # $a in string-context drukt het af in een N-dimensionaal formaat

(en andere Perl-operatoren/functies)

Bij het gebruik van piddles in voorwaardelijke expressies (bijvoorbeeld "als", "tenzij" en "terwijl" constructies)
alleen piddles met precies één element zijn toegestaan, bijvoorbeeld

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

Merk op dat de Booleaanse operatoren in algemene multi-element piddles retourneren. Daarom is de
het volgende zal een foutmelding geven

print "is ok" als $a > 3;

Omdat "$a > 3" een piddle is met 4 elementen. Gebruik liever all of any om te testen of alle of een deel van de
de elementen voldoen aan de voorwaarde:

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

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

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

perlDL is rij-major, niet kolom-major, dus dit is eigenlijk "c(i,j) = sum_k a(k,j) b(i,k)" -
maar wanneer matrices worden afgedrukt, zien de resultaten er goed uit. Onthoud alleen dat de indices
omgekeerd. bijv.:

$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
kolomvectoren.

Hoe naar schrijven a simpel functie
sub-dotproduct {
mijn ($a,$b) = @_;
retourneer som ($a*$b);
}
1;

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

Deze functie is uiteraard al beschikbaar als interne functie, zie PDL::Primitive.

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

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

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

OPMERKING: De indx()-routine is een speciaal geheel getaltype dat
is de juiste grootte voor een PDL-indexwaarde (dimensiegrootte,
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, zodat de volgende handige afkorting mogelijk is:

$a = byte [[1..10],[1..10]]; # Maak een 2D byte-array
$a = float [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 sectie-operatoren; zie de
PDL::Slices(3) manpagina voor details; we zullen hier de belangrijkste beschrijven.

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

Volgens de gebruikelijke conventie wordt de coördinaat (0,0) linksonder weergegeven wanneer
Een afbeelding weergeven. Deze verschijnt linksboven bij gebruik van ""print $a"" etc.

Voor eenvoudige secties wordt een syntaxisuitbreiding van Perl gebruikt, PDL::NiceSlice, waarmee u:
Geef subbereiken op via een nulmethode-modifier voor een PDL:

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

Hier is $a een driedimensionale variabele en krijgt $b een vlakke uitsparing die wordt gedefinieerd door de
limieten $x1, $x2, $y1, $y2, op de locatie $z1. De haakjes rond $z1 zorgen ervoor dat de
triviale index moet worden weggelaten -- anders zou $b driedimensionaal zijn met een derde
dimensie van orde 1.

Je kunt PDL-slices aan beide kanten 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 = xvals($a); # Vul de array met X-coördinatenwaarden (ook yvals(), zvals(),
# axisvals($x,$axis) en rvals() voor radiale afstand
# vanaf het midden).

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

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

PDL::IO::FastRaw
Met behulp van de ruwe gegevenstypen van uw machine, een niet-overdraagbare maar razendsnelle I/O
formaat. Ondersteunt ook geheugentoewijzing om geheugen te besparen en de snelheid te verhogen.

PDL::IO::FlexRaw
Algemene formaten voor ruwe data. Net als FastRaw, maar dan beter.

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

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

PDL::IO::Pic
Met behulp van de vorige module en netpbm is het mogelijk om eenvoudig GIF, jpeg te schrijven
en wat dan ook met simpele commando's.

grafiek
De filosofie achter perlDL is om het te laten werken met een verscheidenheid aan bestaande grafische
bibliotheken, omdat geen enkel pakket aan alle behoeften en alle mensen kan voldoen en dit maakt het mogelijk
iemand die met pakketten werkt die hij al kent en leuk vindt. Uiteraard zullen er enkele
overlappingen in functionaliteit en een gebrek aan consistentie en uniformiteit. Dit maakt het echter mogelijk
PDL houdt gelijke tred met een snel ontwikkelend vakgebied - de nieuwste PDL-modules bieden interfaces
naar OpenGL en VRML graphics!

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

Er is een eenvoudige interface hiervoor in de interne module PDL::Graphics::PGPLOT, die
roept routines aan in de afzonderlijk beschikbare PGPLOT-module op het hoogste niveau.

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

Deze module biedt zowel functionaliteit op hoog als laag niveau, gebaseerd op PLplot.
Low-level commando's zijn vrijwel directe verbindingen met de C-interface van PLplot. Lees meer
bij PDL::Graphics::PLplot.

PDL::Afbeeldingen::IIS
Veel astronomen gebruiken graag SAOimage en Ximtool (of hun afleidingen/klonen). Deze
zijn handige gratis widgets voor het inspecteren en visualiseren van afbeeldingen. (Ze zijn niet
geleverd met perlDL, maar kan gemakkelijk worden verkregen via hun officiële sites.
Netto.)

Met het PDL::Graphics::IIS-pakket kunt u afbeeldingen in deze ("IIS"-bestanden) weergeven
is de naam van een oud stuk hardware voor beeldweergave waarvan de protocollen deze hulpmiddelen
(conformeren aan.)

PDL::Afbeeldingen::TriD
Zie PDL::Graphics::TriD, dit is een verzameling 3D-routines voor OpenGL en (binnenkort)
VRML en andere 3D-formaten waarmee u driedimensionale punt-, lijn- en oppervlaktediagrammen kunt maken vanuit PDL.

Automatisch laden
Zie PDL::AutoLoader. Hiermee kun je functies op aanvraag automatisch laden, op een manier die misschien...
bekend bij gebruikers van MatLab.

Je 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 in
Opdrachtregel terughalen 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...
Gevonden documentatie database /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
Typ 'help' voor online hulp
Typ 'demo' voor online demo's
PDL v2.4.9_003 geladen (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 met een resolutie van 384 x 384, van 40 tot 761, met 84 kleuren (16-99)...

U kunt het ook uitvoeren vanuit de Perl-debugger ("perl -MPDL -d -e 1") als u dat wilt.

Diverse shell-functies:

p De shell gebruikt een alias voor "p" om een ​​handige korte vorm van "print" te zijn, bijvoorbeeld

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 directory) worden gesourced als
gevonden. Hierdoor kan de gebruiker globale en lokale PDL-code voor het opstarten hebben.

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

Ontsnappen
Elke regel die begint met het teken "#" wordt behandeld als een shell-escape. Dit teken
is configureerbaar door de Perl-variabele $PERLDL_ESCAPE in te stellen. Dit kan bijvoorbeeld:
worden ingesteld in "~/.perldlrc".

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

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

[Alle unitaire functies (sin etc.) kunnen worden gebruikt met inplace() - zie "Geheugen" hieronder.]

Objectoriëntatie en perlDL
PDL-bewerkingen zijn beschikbaar als functies en methoden. Zo kunnen nieuwe typen
object, om aangepaste gegevensklassen te vertegenwoordigen.

Door overbelasting te gebruiken, kun je wiskundige operatoren laten doen wat je wilt, en PDL
heeft een aantal ingebouwde trucs waardoor bestaande PDL-functies ongewijzigd kunnen blijven werken, zelfs als de
De onderliggende datarepresentatie is enorm veranderd! Zie PDL::Objects

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

OPMERKING: Op de meeste systemen is het beter om Perl te configureren (tijdens de bouwopties) om
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 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 neemt), dan is het commando

$a = $a + 1;

verbruikt nog eens 10 MB geheugen. Dit komt doordat de expressie "$a+1" een
tijdelijke kopie van $a om het resultaat vast te houden, dan wordt aan $a een referentie daaraan toegekend.
Hierna wordt de originele $a vernietigd, zodat er geen blijvend geheugenverspilling. Maar verder
een kleine machine, de groei van het geheugengebruik kan aanzienlijk zijn. Het is
duidelijk op deze manier gedaan zodat "$c=$a+1" werkt zoals verwacht.

Ook als men zegt:

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

Dan blijken $b en $a verschillend te zijn, zoals men naïef zou verwachten, omdat er een nieuwe referentie is
wordt aangemaakt en $a wordt eraan toegewezen.

Als $a echter een enorme geheugenvreter was (bijvoorbeeld een 3D-volume), is het misschien niet mogelijk om er een kopie van te maken.
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; # Echte kopie

of, 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 is een goede programmeerpraktijk. Hoeveel bewerkingen er ook kunnen worden uitgevoerd,
"ter plaatse" gedaan en dit kan nodig zijn wanneer grote arrays in gebruik zijn en het geheugen vol is.
een premie. Voor deze omstandigheden is de exploitant inplace() is voorzien die voorkomt
de extra kopie en maakt het mogelijk om het argument te wijzigen. Bijvoorbeeld:

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

WAARSCHUWING:

1. De gebruikelijke waarschuwingen met betrekking tot dubbele verwijzingen zijn van toepassing.

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

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

Zorgen kleinigheid
Als je een eenvoudige functie hebt geschreven en je wilt niet dat deze in je gezicht ontploft als je
Geef er een eenvoudig getal aan in plaats van een PDL-variabele. Roep de functie gewoon aan. topdl() eerste
om het veilig te maken. Bijvoorbeeld:

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

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

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