PDL::QuickStartp - Online nel cloud

PROGRAMMA:

NOME

PDL::QuickStart: rapida introduzione alle funzionalità PDL.

SINOSSI

Un breve riepilogo delle principali funzionalità PDL e come utilizzarle.

DESCRIZIONE

Introduzione
Perl è un linguaggio di scripting estremamente valido e versatile, adatto sia ai principianti che ai principianti
consente la prototipazione rapida. Tuttavia fino a poco tempo fa non supportava strutture di dati quali
gli ha permesso di elaborare velocemente i numeri.

Tuttavia con lo sviluppo di Perl v5, Perl ha acquisito "Objects". Per dirla semplicemente, utenti
possono definire i propri tipi di dati speciali e scrivere routine personalizzate per manipolarli
sia nei linguaggi di basso livello (C e Fortran) che nello stesso Perl.

Questo è stato pienamente sfruttato dagli sviluppatori PerlDL. Il modulo 'PDL' è completo
Estensione orientata agli oggetti di Perl (anche se non è necessario sapere a cosa serve un oggetto
usarlo) che consente grandi insiemi di dati N-dimensionali, come immagini di grandi dimensioni, spettri, tempo
serie, ecc. da memorizzare in modo efficiente e manipolato en di massa. Ad esempio con il Pdl
modulo possiamo scrivere il codice Perl "$a = $b + $c", dove $b e $c sono insiemi di dati di grandi dimensioni (es.
2048x2048) e ottieni il risultato in solo una frazione di secondo.

Le variabili PDL (o "piddles", come sono diventate note) supportano un'ampia gamma di
tipi di dati fondamentali: gli array possono essere byte, interi brevi (con o senza segno), lunghi
numeri interi, float o float a doppia precisione. E a causa della natura orientata agli oggetti di
Da essi possono essere derivati ​​nuovi tipi di dati personalizzati PDL.

Oltre ai moduli PDL, che possono essere utilizzati dai normali programmi Perl, PerlDL viene fornito con un file
shell Perl da riga di comando, chiamata "perldl", che supporta la modifica della riga di comando. In
in combinazione con i vari moduli grafici PDL ciò consente di riprodurre facilmente i dati
con e visualizzato.

Aiuto
PDL contiene un'ampia documentazione, disponibile sia all'interno del file perl or pdl2 conchiglie e
dalla riga di comando, utilizzando il programma "pdldoc". Per ulteriori informazioni provare uno dei seguenti:

pdl> aiuto aiuto
$ pdldoc

Dovrebbero essere disponibili anche copie HTML della documentazione. Per trovare la loro posizione, prova
il seguente:

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

Perl Tipi di dati e come PDL si estende loro
Le strutture dati fondamentali di Perl sono variabili scalari, ad esempio $x, che possono contenere numeri
o stringhe, elenchi o array di scalari, ad esempio @x, e array/hash associativi di scalari,
ad esempio %x.

Perl v5 introduce le strutture dati e gli oggetti Perl. Ora esiste una semplice variabile scalare $x
un tipo di dati definito dall'utente o un oggetto completo (in realtà contiene un riferimento (uno smart
"pointer") a questo ma questo non è rilevante per l'uso normale di perlDL)

L'idea fondamentale alla base di perlDL è consentire a $x di contenere un intero spettro 1D o 2D
immagine, un cubo di dati 3D e così via fino a grandi set di dati N-dimensionali. Questi possono essere
manipolato tutto in una volta, ad esempio "$a = $b + 2" esegue un'operazione vettoriale su ciascun valore in
spettro/immagine/ecc.

Potresti chiedere: "Perché non memorizzare semplicemente uno spettro come un semplice elenco di stile Perl @x con ciascuno
pixel è un elemento dell'elenco?" Le due risposte chiave a questa domanda sono memoria e velocità. Perché noi
sappiamo che il nostro spettro è costituito da numeri puri, possiamo memorizzarli in modo compatto in un unico blocco
di memoria corrispondente a un array numerico in stile C. Questo occupa MOLTA meno memoria di
l'elenco Perl equivalente. È quindi facile passare questo blocco di memoria a un'aggiunta rapida
routine o a qualsiasi altra funzione C che si occupi degli array. Di conseguenza perlDL è molto
veloce --- ad esempio è possibile moltiplicare un'immagine 2048*2048 esattamente nello stesso tempo
richiederebbe C o FORTRAN (0.1 secondi sul mio SPARC). Un ulteriore vantaggio di questo è che per
operazioni semplici (ad esempio "$x += 2") si possono manipolare l'intero array senza preoccuparsi
la sua dimensionalità.

Trovo che quando si usa perlDL sia molto utile pensare alle variabili Perl @x standard come
"elenchi" di "cose" generiche e variabili PDL come $x come "array" che possono essere contenuti
in elenchi o hash. Molto spesso nei miei script perlDL ho @x che contiene un elenco di spettri,
o un elenco di immagini (o anche un mix!). O forse si potrebbe avere un hash (ad esempio %x) di
immagini... l'unico limite è la memoria!

Le variabili perlDL supportano una gamma di tipi di dati: gli array possono essere byte o numeri interi brevi
(con segno o senza segno), interi lunghi, float o float a doppia precisione.

Impiego
PerlDL viene caricato nel tuo script Perl utilizzando questo comando:

utilizzare il PDL; # negli script Perl: utilizza i moduli perlDL standard

Ci sono anche molti moduli di estensione, ad esempio PDL::Graphics::TriD. La maggior parte di questi (ma
non tutti perché a volte non è opportuno) seguono una convenzione standard. Se dici:

usa PDL::Graphics::TriD;

Importi tutto in un elenco standard dal modulo. A volte potresti volerlo
non importare nulla (ad esempio se si desidera utilizzare sempre la sintassi OO e risparmiare la tassa di importazione).
Per questi dici:

utilizzare PDL::Grafica::TriD qw();

E le virgolette vuote "qw()" vengono riconosciute come significanti "niente". Puoi anche specificare a
elenco di funzioni da importare nel normale modo Perl.

C'è anche una shell interattiva, "perldl" o "pdl2", vedi perl o pdl2 per i dettagli.

A creare a nuovi PDL variabile
Ecco alcuni modi per creare una variabile PDL:

$a = pdl [1..10]; # matrice 1D
$a = pdl (1,2,3,4); #Idem
$a = pdl '[1 2 3 4]'; #Idem
$b = pdl [[1,2,3],[4,5,6]]; # Array 2D 3x2
$b = pdl '[1 2 3; 4 5 6]'; #Idem
$b = pdlq[1,2,3; 4,5,6]; #Idem
$b = pdl <
[1 2 3]
[4 5 6]
NUOVOPDL
$c = pdlq[1 -2]; # Piddle a 2 elementi contenente 1 e -2
$c = pdlq[1 - 2]; # Piddle a 2 elementi contenente 1 e -2
$b = pdl 42 # Scalare 0-dimensionale
$c = pdl $a; # Crea una nuova copia

$d = byte [1..10]; # Vedi "Conversione del tipo"
$e = zeri(3,2,4); # Array 3x2x4 riempito con zeri

$c = rfits $file; # Leggi il file FITS

@x = ( pdl(42), zeri(3,2,4), rfits($file) ); # È un ELENCO di variabili PDL!

La pdl() la funzione viene utilizzata per inizializzare una variabile PDL da uno scalare, lista, lista
riferimento, un'altra variabile PDL o una stringa formattata correttamente.

Inoltre tutte le funzioni PDL convertono automaticamente i normali scalari Perl in variabili PDL
al volo.

(vedi anche le sezioni "Conversione tipo" e "Input/Output" di seguito)

Aritmetica (E booleano espressioni)
$a = $b + 2; $a++; $a = $b / $c; # Eccetera.

$c=quadrato($a); $d = log10($b+100); # Eccetera

$e = $a>42; # Condizionale vettoriale

$e = 42*($a>42) + $a*($a<=42); # Tappo superiore

$b = $a->log10 a meno che non ci sia ($a <= 0); # evita errori in virgola mobile

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

$f = dove($a, $a > 10); # dove restituisce una manciata di elementi per
# quale condizione è vera

stampa $a; # $a nel contesto di una stringa lo stampa in un formato N-dimensionale

(e altri operatori/funzioni Perl)

Quando si utilizzano piddles nelle espressioni condizionali (ad esempio, i costrutti "if", "unless" e "mentre")
sono ammessi solo piddle con esattamente un elemento, ad es

$a = pdl (1,0,0,1);
print "è impostato" se $a->Index(2);

Si noti che gli operatori booleani restituiscono in generale piddle multielemento. quindi, il
seguente genererà un errore

print "va bene" se $a > 3;

poiché "$a > 3" è un piddle con 4 elementi. Utilizzare piuttosto all or any per verificare se all or any of
gli elementi soddisfano la condizione:

print "alcuni sono > 3" se ce ne sono $a>3;
print "impossibile calcolare il logaritmo" a meno che tutti $a>0;

Ci sono anche molte funzioni predefinite, descritte in altre pagine man. Controllo
PDL::Indice.

Matrice funzioni
'x' viene dirottato come operatore di moltiplicazione della matrice. ad esempio "$c = $ax $b";

perlDL è principale di riga e non di colonna, quindi in realtà è "c(i,j) = sum_k a(k,j) b(i,k)" -
ma quando le matrici verranno stampate i risultati appariranno corretti. Ricorda solo che gli indici lo sono
invertito. per esempio:

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

dà $c = [
[ 1 11]
[ 8 10]
[ 2 2]
]

Nota: trasporre() fa quello che dice ed è un modo conveniente per trasformare i vettori di riga in
vettori colonna.

Come a scrivere a semplice function
sottoprodotto {
mio ($a,$b) = @_;
restituzione somma($a*$b) ;
}
1;

Se inserito nel file dotproduct.pdl verrebbe caricato automaticamente se si utilizza PDL::AutoLoader (vedere
sotto).

Naturalmente questa funzione è già disponibile come funzione interna, vedere PDL::Primitive.

Tipologia Conversione
Predefinito per pdl() è doppio. Le conversioni sono:

$a = float($b);
$c = lungo($d); # "lungo" è generalmente un int di 4 byte
$d = byte($a);

Leggi anche Doppio(), corto(), ucorto(), indice().

NOTA: La routine indx() è un tipo intero speciale che
è la dimensione corretta per un valore di indice PDL (dimensione dimensione,
index o offest) che può essere a 32 bit (lungo) o
Quantità a 64 bit (longlong) a seconda che il file perl
è costruito con il supporto a 32 bit o 64 bit.

Queste routine convertono automaticamente anche gli elenchi Perl per consentire la comoda abbreviazione:

$a = byte [[1..10],[1..10]]; # Crea un array di byte 2D
$a = virgola mobile [1..1000]; # Crea un array float 1D

ecc.

Stampa
Espande automaticamente l'array in formato N-dimensionale:

stampa $a;

$b = "La risposta è = $a ";

sezioni
PDL dispone di operatori di slicing e sezionamento multidimensionali molto potenti; vedere il
PDL::Slices(3) pagina man per i dettagli; descriveremo qui quello più importante.

PDL mostra la sua eredità Perl/C in quanto gli array hanno un offset pari a zero. Quindi ha un'immagine 100x100
indici "0..99,0..99". (La convenzione è che il centro di pixel (0,0) è alla coordinata
(0.0,0.0). Tutte le funzioni grafiche PDL sono conformi a questa definizione e nascondono l'unità
offset, ad esempio, della libreria PGPLOT FORTRAN.

Secondo la consueta convenzione la coordinata (0,0) viene visualizzata in basso a sinistra quando
visualizzazione di un'immagine. Appare in alto a sinistra quando si utilizza ""print $a"" ecc.

Il sezionamento semplice utilizza un'estensione della sintassi di Perl, PDL::NiceSlice, che ti consente di farlo
specificare i sottointervalli tramite un modificatore del metodo null su un PDL:

$b = $a->($x1:$x2,$y1:$y2,($z1)); # Prendi la sottosezione

Qui, $a è una variabile tridimensionale e $b ottiene un ritaglio planare definito da
limiti $x1, $x2, $y1, $y2, nella posizione $z1. La parentesi attorno a $z1 causa il
indice banale da omettere, altrimenti $b sarebbe tridimensionale con una terza
dimensione dell'ordine 1.

Puoi inserire le sezioni PDL su entrambi i lati dell'operatore di assegnazione per elemento ".=", come
Sun:

# Imposta parte di $bigimage sui valori di $smallimage
$bigimage->($xa:$xb,$ya:$yb) .= $smallimage;

Qualche altra miscellanea:

$c = nelem($a); # Numero di pixel

$val = at($oggetto, $x,$y,$z...) # Valore del pixel in posizione, come scalare Perl
$val = $oggetto->at($x,$y,$z...) # equivalente (sintassi del metodo OK)

$b = xvals($a); # Riempie l'array con i valori della coordinata X (anche yvals(), zvals(),
# axisvals($x,$axis) e rvals() per la distanza radiale
# dal centro).

Input Output
I moduli "PDL::IO" implementano diverse utili funzioni del formato IO. Sarebbe troppo
per fornire esempi di ciascuno, ma puoi trovare una bella panoramica su PDL::IO. Ecco un esempio di
alcuni dei formati IO supportati in PDL.

PDL::IO::Varie
Routine IO Ascii, FITS e FIGARO/NDF.

PDL::IO::FastRaw
Utilizzando i tipi di dati grezzi della tua macchina, un IO non portatile ma incredibilmente veloce
formato. Supporta anche la mappatura della memoria per risparmiare memoria e ottenere maggiore velocità.

PDL::IO::FlexRaw
Formati generali dei dati grezzi. Come FastRaw, solo meglio.

PDL::IO::Browser
Un browser Curses per gli array.

PDL::IO::Pnm
Supporto per bitmap e pixmap Portaple.

PDL::IO::Fig
Utilizzando il modulo precedente e netpbm, è possibile scrivere facilmente GIF, jpeg
e quant'altro con semplici comandi.

Grafica
La filosofia alla base di perlDL è di farlo funzionare con una varietà di grafica esistente
librerie poiché nessun singolo pacchetto soddisferà tutte le esigenze e tutte le persone e questo lo consente
uno per lavorare con pacchetti che già conosci e che ti piacciono. Ovviamente ce ne saranno alcuni
sovrapposizioni di funzionalità e qualche mancanza di coerenza e uniformità. Tuttavia questo lo consente
PDL per stare al passo con un settore in rapido sviluppo: i più recenti moduli PDL forniscono interfacce
alla grafica OpenGL e VRML!

PDL::Grafica::PGPLOT
PGPLOT fornisce una semplice libreria per la grafica a linee e la visualizzazione di immagini.

C'è una semplice interfaccia a questo nel modulo interno PDL::Graphics::PGPLOT, che
chiama le routine nel modulo di livello superiore PGPLOT disponibile separatamente.

PDL::Grafica::PLplot
PLplot fornisce una semplice libreria per la creazione di grafica con più driver di output,
incluso un driver diretto al piddle.

Questo modulo fornisce funzionalità sia di alto che di basso livello basate su PLplot. IL
i comandi di basso livello sono praticamente collegamenti diretti all'interfaccia C di PLplot. Per saperne di più
in PDL::Grafica::PLplot.

PDL::Grafica::IIS
A molti astronomi piace usare SAOimage e Ximtool (o loro derivazioni/cloni). Questi
sono utili widget gratuiti per l'ispezione e la visualizzazione delle immagini. (Non sono
fornito con perlDL ma può essere facilmente ottenuto dai loro siti ufficiali fuori dal file
Netto.)

Il pacchetto PDL::Graphics::IIS consente di visualizzare le immagini in questi ("IIS"
è il nome di un antico componente hardware per la visualizzazione di immagini il cui protocollo protegge questi strumenti
conforme alle.)

PDL::Grafica::TriD
Vedi PDL::Graphics::TriD, questa è una raccolta di routine 3D per OpenGL e (presto)
VRML e altri formati 3D che consentono grafici 3D di punti, linee e superfici da PDL.

Caricamento automatico
Vedere PDL::Caricatore automatico. Ciò consente forse di caricare automaticamente le funzioni su richiesta
familiare agli utenti di MatLab.

Si possono anche scrivere estensioni PDL come normali moduli Perl.

PDL conchiglie
Lo script Perl "pdl2" (o "perldl") fornisce una semplice interfaccia a riga di comando a PDL. Se
sono stati installati gli ultimi moduli Readlines/ReadKey, "pdl2" rileva questo e lo abilita
richiamo e modifica della riga di comando. Vedi la pagina man per i dettagli.

per esempio:

% perldl
shell perlDL v1.354
PDL viene fornito con ASSOLUTAMENTE NESSUNA GARANZIA. Per i dettagli, vedere il file
'COPIA' nella distribuzione PDL. Questo è un software gratuito e tu
sono invitati a ridistribuirlo a determinate condizioni, vedi
lo stesso file per i dettagli.
ReadLines, NiceSlice, MultiLines abilitati
Lettura PDL/default.perldlrc...
Database dei documenti trovati /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
Digitare "aiuto" per la guida in linea
Digita "demo" per le demo online
PDL caricato v2.4.9_003 (supporta valori errati)
pdl> $x = rfits 'm51.fits'
Lettura dei dati IMMAGINE...
BITPIX = dimensione 32 = 147456 pixel
Lettura 589824 byte
SCALA B = && ZERO B =

pdl> usa PDL::Grafica::PGPLOT;
pdl> immagine $x
Visualizzazione di immagini 384 x 384 da 40 a 761, utilizzando 84 colori (16-99)...

Se lo desideri, puoi anche eseguirlo dal debugger Perl ("perl -MPDL -d -e 1").

Caratteristiche varie della shell:

p La shell utilizza l'alias "p" per essere una comoda forma abbreviata di "print", ad es

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

Inizializzazione
I file "~/.perldlrc" e "local.perldlrc" (nella directory corrente) vengono originati se
trovato. Ciò consente all'utente di disporre di codice PDL globale e locale per l'avvio.

Aiuto
Scrivi "aiuto"! È possibile effettuare una ricerca nella documentazione PDL e cercare la documentazione su qualsiasi
funzione.

Fuga
Qualsiasi riga che inizia con il carattere "#" viene trattata come un escape di shell. Questo personaggio
è configurabile impostando la variabile Perl $PERLDL_ESCAPE. Ciò potrebbe, ad esempio,
essere impostato in "~/.perldlrc".

Sovraccarico Operatori
I seguenti operatori e funzioni Perl incorporati sono stati sovraccaricati per funzionare su PDL
variabili:

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

[Tutte le funzioni unarie (sin ecc.) possono essere utilizzate con a posto() - vedere "Memoria" di seguito.]

Orientamento agli oggetti e perlDL
Le operazioni PDL sono disponibili come funzioni e metodi. Quindi si possono ricavare nuovi tipi di
oggetto, per rappresentare classi di dati personalizzate.

Usando l'overloading puoi fare in modo che gli operatori matematici facciano quello che vuoi e PDL
ha alcuni trucchi incorporati che consentono alle funzioni PDL esistenti di funzionare invariate, anche se il file
la rappresentazione dei dati sottostanti è notevolmente cambiata! Vedere PDL::Oggetti

Memorie uso e Riferimenti
Giocare con array di dati davvero enormi può richiedere una certa attenzione. perlDL ne fornisce molti
funzionalità che consentono di eseguire operazioni su array di grandi dimensioni senza generare copie aggiuntive
anche se questo richiede un po' più di riflessione e attenzione da parte del programmatore.

NOTA: Sulla maggior parte dei sistemi è meglio configurare Perl (durante le opzioni di compilazione) su
utilizzare la funzione di sistema "malloc()" anziché quella integrata in Perl. Questo perché Perl's
uno è ottimizzato per la velocità anziché per il consumo di memoria virtuale: ciò può comportare
un miglioramento di un fattore due nella quantità di memoria che è possibile utilizzare. Il malloc Perl
nella versione 5.004 e successive dispone di una serie di opzioni in fase di compilazione che è possibile utilizzare per ottimizzare il file
comportamento.

Aritmetica semplice
Se $a è un'immagine grande (ad esempio occupa 10 MB), allora il comando

$a = $a + 1;

consuma altri 10 MB di memoria. Questo perché l'espressione "$a+1" crea a
copia temporanea di $a per contenere il risultato, a $a viene assegnato un riferimento a quella.
Successivamente, l'originale $a viene distrutto, quindi non esiste più permanente spreco di memoria. Ma avanti
una macchina piccola, la crescita della memoria occupata può essere considerevole. È
ovviamente fatto in questo modo quindi "$c=$a+1" funziona come previsto.

Anche se uno dice:

$b = $a; # $b e $a ora puntano agli stessi dati
$a = $a + 1;

Quindi $b e $a finiscono per essere diversi, come ci si aspetta ingenuamente, perché un nuovo riferimento
viene creato e gli viene assegnato $a.

Tuttavia, se $a fosse un enorme divoratore di memoria (ad esempio un volume 3D), la creazione di una sua copia potrebbe non essere possibile
essere una buona cosa. Si può evitare questo sovraccarico di memoria nell'esempio precedente dicendo:

$a++;

Le operazioni "++,+=,--,-=", ecc. chiamano tutte una speciale versione "sul posto" del
subroutine aritmetica. Ciò significa che non è necessaria più memoria: lo svantaggio è questo
che se "$b=$a" allora anche $b viene incrementato. Per forzare una copia in modo esplicito:

$b = pdl $a; # Copia reale

o, in alternativa, forse uno stile migliore:

$b = $a->copia;

funzioni
La maggior parte delle funzioni, ad esempio "log()", restituiscono un risultato che è una loro trasformazione
discussione. Ciò costituisce una buona pratica di programmazione. Per quanto numerose possano essere le operazioni
fatto "sul posto" e questo potrebbe essere necessario quando sono in uso array di grandi dimensioni e la memoria è esaurita
un premio. Per queste circostanze l'operatore a posto() è fornito che impedisce
la copia extra e consente di modificare l'argomento. per esempio:

$x = log($array); # $array inalterato
log(inplace($bigray)); # $bigarray cambiato sul posto

AVVERTENZE:

1. Si applicano le solite avvertenze sui riferimenti duplicati.

2. Ovviamente se utilizzato con alcune funzioni che non possono essere applicate in situ (es
"convolve()") potrebbero verificarsi effetti inaspettati! Cerchiamo di indicare "inplace()"-safe
funzioni nella documentazione.

3. Le conversioni di tipo, come "float()", possono causare copie nascoste.

assicurare pigrizia
Se hai scritto una funzione semplice e non vuoi che ti esploda in faccia se tu
passargli un numero semplice anziché una variabile PDL. Chiama semplicemente la funzione topdl() prima di tutto
per renderlo sicuro. per esempio:

sub miofiddle { mio $pdl = topdl(shift); $pdl->fiddle_foo(...); ... }

"topdl()" NON esegue una copia se viene passata una variabile pdl - semplicemente fallisce -
che è ovviamente il comportamento desiderato. La routine ovviamente non è necessaria nella normalità
funzioni definite dall'utente che non si preoccupano degli interni.

Utilizzare PDL::QuickStartp in linea utilizzando i servizi onworks.net