PDL::MATLABp - Online nel cloud

PROGRAMMA:

NOME

PDL::MATLAB - Una guida per gli utenti di MATLAB.

INTRODUZIONE

Se sei un utente MATLAB, questa pagina è per te. Spiega le principali differenze tra
MATLAB e PDL per aiutarti a partire il più rapidamente possibile.

Si documento is non è un a lezione. Per questo, vai su PDL::QuickStart. Questo documento
complementi la guida di avvio rapido, in quanto evidenzia le principali differenze tra MATLAB e
Pdl.

Perl

La differenza chiave tra MATLAB e PDL è Perl.

Perl è un linguaggio di programmazione generico con migliaia di moduli disponibili gratuitamente
In rete. PDL è un'estensione di Perl. Ciò consente ai programmi PDL di accedere a più funzioni
di quanto la maggior parte degli strumenti numerici possa sognare. Allo stesso tempo, la maggior parte delle differenze di sintassi tra
MATLAB e PDL sono il risultato della sua fondazione Perl.

sentirti do non è un avere a Imparando molti Perl a be efficace con PDL. Ma se vuoi imparare
Perl, è disponibile in linea un'eccellente documentazione (http://perldoc.perl.org>) o
tramite il comando "perldoc perl". C'è anche un portale per principianti
(<http://perl-begin.org>).

Il repository dei moduli di Perl si chiama CPAN (http://www.cpan.org>) e ha una vasta gamma di
moduli. Esegui "perldoc cpan" per ulteriori informazioni.

TERMINOLOGIA: PIZZA

MATLAB si riferisce in genere a vettori, matrici e array. Perl ha già degli array e il
i termini "vettore" e "matrice" si riferiscono tipicamente a raccolte mono e bidimensionali di
dati. Non avendo un buon termine per descrivere il loro oggetto, gli sviluppatori PDL hanno coniato il termine
"pisciare" per dare un nome al loro tipo di dati.

A pisciare consiste in una serie di numeri organizzati come un insieme di dati N-dimensionali. piddles
fornire un'archiviazione efficiente e un calcolo veloce di grandi matrici N-dimensionali. Loro sono
altamente ottimizzato per il lavoro numerico.

Per ulteriori informazioni, vedere "piddles vs Perl Array" più avanti in questo documento.

COMANDO FINESTRA E IDE

A differenza di MATLAB, PDL non viene fornito con un IDE dedicato. Tuttavia viene fornito con un
shell interattiva ed è possibile utilizzare un IDE Perl per sviluppare programmi PDL.

PDL interattivo conchiglia
Per avviare la shell interattiva, apri un terminale ed esegui "perldl" o "pdl2". Come in MATLAB,
la shell interattiva è il modo migliore per imparare la lingua. Per uscire dalla shell, digita
"uscita", proprio come MATLAB.

scrittura PDL programmi
Un popolare IDE per Perl si chiama Padre (http://padre.perlide.org>). è croce
piattaforma e facile da usare.

Ogni volta che si scrive un programma PDL autonomo (cioè al di fuori della shell "perldl" o "pdl2")
è necessario avviare il programma con "use PDL;". Questo comando importa il modulo PDL in
Perla. Ecco un esempio di programma PDL:

utilizzare PDL; # Importa il modulo PDL principale.
usa PDL::NiceSlice; # Importa modulo PDL aggiuntivo.
usa PDL::AutoLoader; # Importa modulo PDL aggiuntivo.

$b = pdl [2,3,4]; # Le istruzioni terminano con un punto e virgola.
$A = pdl [[1,2,3],[4,5,6] ]; # matrice bidimensionale.

print $A x $b->trasponi;

Salva questo file come "mioprogramma.pl" ed eseguilo con:

perl mioprogramma.pl

Novità: Flessibile sintassi
Nelle versioni correnti di PDL (versione 2.4.7 o successive) esiste una sintassi a matrice flessibile che
può sembrare estremamente simile a MATLAB:

1) Usa un ';' per delimitare le righe:

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

2) Usa gli spazi per separare gli elementi:

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

Fondamentalmente, fintanto che metti una "q" davanti alla parentesi di apertura, PDL dovrebbe "fare cosa
vuoi dire". Quindi puoi scrivere in una sintassi che ti è più comoda.

MODULI PER MATLAB UTENTI

Ci sono due moduli che gli utenti MATLAB vorranno usare:

PDL::NiceSlice
Fornisce a PDL una sintassi per le sezioni (sottomatrici) più breve e più familiare
Utenti MATLAB.

%MATLAB
b(1:5) --> Seleziona i primi 5 elementi da b.

# PDL senza NiceSlice
$b->slice("0:4") --> Seleziona i primi 5 elementi da $b.

# PDL con NiceSlice
$b(0:4) --> Seleziona i primi 5 elementi da $b.

PDL::Caricatore automatico
Fornisce un caricatore automatico in stile MATLAB per PDL. Se viene chiamata una funzione sconosciuta "pippo()",
PDL cerca un file chiamato "foo.pdl". Se ne trova uno, lo legge.

BASIC CARATTERISTICHE

Questa sezione spiega come la sintassi di PDL differisce da MATLAB. La maggior parte degli utenti MATLAB vorrà
Comincia qui.

Generale "trabocchetti"
Indici
In PDL, gli indici iniziano da "0" (come C e Java), non da 1 (come MATLAB o FORTRAN). Per
esempio, se $b è un array con 5 elementi, gli elementi verrebbero numerati da 0 a
4.

Visualizzazione di un oggetto
MATLAB normalmente visualizza automaticamente il contenuto degli oggetti. Nelle conchiglie PDL che visualizzi
oggetti in modo esplicito con il comando "stampa" o la scorciatoia "p":

MATLAB:

>> a = 12
a = 12
>> b = 23; % Sopprimi output.
>>

PDL Shell (perldl o pdl2):

pdl> $a = 12 # Nessun output.
pdl> print $a # Stampa oggetto.
12
pdl> p $a # "p" è una scorciatoia per "print" nella shell.
12
pdl>

Creazione piddles
Variabili in PDL
Le variabili iniziano sempre con il segno '$'.

MATLAB: valore = 42
PerlDL: $valore = 42

Sintassi di base
Usa il costruttore "pdl" per creare un nuovo pisciare.

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

matrici semplici
MATLAB PDL
------ ------
Matrice di quelli quelli(5) quelli 5,5
Matrice di zeri zeri(5) zeri 5,5
Matrice casuale rand(5) casuale 5,5
Vettore lineare 1:5 sequenza 5

Si noti che in PDL le parentesi in una chiamata di funzione sono spesso facoltative. è
importante tenere d'occhio eventuali ambiguità. Per esempio:

pdl> p zeri 2, 2 + 2

Dovrebbe essere interpretato come "zeri (2,2) + 2" o come "zeri 2, (2+2)"? Entrambi sono
dichiarazioni valide:

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

Piuttosto che cercare di memorizzare l'ordine di precedenza di Perl, è meglio usare
parentesi per rendere il codice non ambiguo.

Sequenze a spaziatura lineare
MATLAB: >> linspace(2,10,5)
risposta = 2 4 6 8 10

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

Spiegazione: Inizia con un piddle unidimensionale di 1 elementi e assegnalo ugualmente
valori distanziati da 2 a 10.

MATLAB ha una singola chiamata di funzione per questo. D'altronde il metodo del PDL è più
flessibile:

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

Affettatura e indici
L'estrazione di un sottoinsieme da una raccolta di dati è nota come affettare. PDL e MATLAB
hanno una sintassi simile per lo slicing, ma ci sono due importanti differenze:

1) Gli indici PDL iniziano da 0, come in C e Java. MATLAB avvia gli indici da 1.

2) In MATLAB pensi a "righe e colonne". In PDL, pensa "x e y".

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

Avvertenza
Quando scrivi un programma PDL autonomo devi includere il PDL::NiceSlice
modulo. Vedi la sezione precedente "MODULI PER MATLAB UTENTI" per più
informazioni.

utilizzare PDL; # Importa il modulo PDL principale.
usa PDL::NiceSlice; # Bella sintassi per affettare.
usa PDL::AutoLoader; # Caricatore automatico simile a MATLAB.

$A = casuale 4,4;
stampa $A(0,1);

Matrice Operazioni
Moltiplicazione della matrice
MATLAB: LA * SI
PerlDL: $A x $B

Moltiplicazione per elemento
MATLAB: LA .* SI
PerlDL: $A * $B

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

funzioni che aggregato dati
Alcune funzioni (come "sum", "max" e "min") aggregano dati per un set di dati N-dimensionale.
Questo è un luogo in cui MATLAB e PDL adottano un approccio diverso:

In MATLAB, queste funzioni lavorano tutte lungo una dimensione.
>> A = [ 1,5,4 ; 4,2,1 ]
LA = 1 5 4
4 2 1
>> massimo(A)
es = 4 5 4
>> massimo(A')
as = 5 4

Se vuoi il massimo per l'intero set di dati, puoi usare la speciale A(:)
notazione che sostanzialmente trasforma l'intero set di dati in un singolo 1-dimensionale
vettore.

>> massimo(A(:))
anni = 5
>> A = unità (2,2,2,2)
>> massimo(A(:))
anni = 1

PDL offre due funzioni per ogni caratteristica.
somma contro somma
media vs media
massimo vs massimo
minimo vs minimo

Le lungo Nome lavora su una dimensione, mentre il corto Nome funziona sull'intero
piscio.

pdl> p $A = pdl [ [1,5,4] , [4,2,1] ]
[
[1 5 4]
[4 2 1]
]
pdl> p $A->massimo
[5 4]
pdl> p $A->transpose->massimo
[4 5 4]
pdl> p $A-> max
5
pdl> p unità(2,2,2)->max
1
pdl> p unità(2,2,2,2)->max
1

Note: Nota che PDL si aggrega orizzontalmente mentre MATLAB si aggrega verticalmente. In altro
parole:

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

Consiglio: In MATLAB pensi a "righe e colonne". In PDL, pensa "x e y".

Maggiore dimensionale dati set
Un problema correlato è il modo in cui MATLAB e PDL comprendono set di dati di dimensioni maggiori. MATLAB era
progettato per vettori 1D e matrici 2D. Gli oggetti di dimensioni superiori ("array ND") erano
aggiunto sopra. Al contrario, il PDL è stato progettato fin dall'inizio per piselli N-dimensionali. Questo
porta ad alcune sorprese in MATLAB che non si verificano in PDL:

MATLAB vede un vettore come una matrice 2D.
MATLAB PerlDL
------ ------
>> vettore = [1,2,3,4]; pdl> $vettore = pdl [1,2,3,4]
>> size(vettore) pdl> p $vector->dims
es = 1 4 4

MATLAB vede "[1,2,3,4]" come una matrice 2D (matrice 1x4). PDL lo vede come un vettore 1D: A
dimensione unica di taglia 4.

Ma MATLAB ignora l'ultima dimensione di una matrice 4x1x1.
MATLAB PerlDL
------ ------
>> A = uni(4,1,1); pdl> $A = unità 4,1,1
>> size(A) pdl> p $A->dims
risposta = 4 1 4 1 1

E MATLAB tratta una matrice 4x1x1 in modo diverso da una matrice 1x1x4.
MATLAB PerlDL
------ ------
>> A = uni(1,1,4); pdl> $A = unità 1,1,4
>> size(A) pdl> p $A->dims
risposta = 1 1 4 1 1 4

MATLAB non ha una sintassi diretta per gli array ND.
pdl> $A = pdl [ [[1,2,3],[4,5,6]], [[2,3,4],[5,6,7]] ]
pdl> p $A->dims
3 2 2

Supporto delle funzionalità.
In MATLAB, diverse funzionalità come il supporto per matrici sparse non sono disponibili per ND
matrici. In PDL, quasi tutte le funzionalità supportate da piddle 1D e 2D sono ugualmente
supportato da piddles N-dimensionali. Di solito non c'è distinzione.

Ciclo continuo Strutture
Perl ha molte strutture di loop, ma mostreremo solo quella che ci è più familiare
Utenti MATLAB:

MATLAB PerlDL
------ ------
per i = 1:10 per $i (1..10) {
disp(i) stampa $i
fine per }

Note: Non utilizzare mai i cicli for per il lavoro numerico. I cicli for di Perl sono più veloci di quelli di MATLAB,
ma entrambi impallidiscono contro un'operazione "vettorizzata". PDL ha molti strumenti che
facilitare la scrittura di programmi vettorizzati. Questi vanno oltre lo scopo di questa guida. Per
per saperne di più, vedere: PDL::Indicizzazione, PDL::Filettatura e PDL::PP.

Allo stesso modo, non usare mai 1..10 per il lavoro numerico, anche al di fuori di un ciclo for. 1..10 è un
matrice perla. Gli array Perl sono progettati per la flessibilità, non per la velocità. Utilizzo piselli anziché.
Per saperne di più, vedere la sezione successiva.

piddles vs Perl Array
È importante notare la differenza tra a piddle e un array Perl. Perl ha un
oggetto array di uso generale che può contenere qualsiasi tipo di elemento:

@perl_array = 1..10;
@perl_array = ( 12, "Ciao" );
@perl_array = ( 1, 2, 3, \@altro_perl_array, sequenza(5));

Gli array Perl ti permettono di creare potenti strutture dati (vedi Dati strutture sotto), ma
di sono non è un progettato per numerico lavoro. Per questo, usa piselli:

$pdl = pdl [ 1, 2, 3, 4 ];
$pdl = sequenza 10_000_000;
$pdl = unità 600, 600;

Per esempio:

$punti = pdl 1..10_000_000 # 4.7 secondi
$punti = sequenza 10_000_000 # millisecondi

Consiglio: è possibile utilizzare i caratteri di sottolineatura nei numeri ("10_000_000" è migliore di 10000000).

Condizionali
Perl ha molti condizionali, ma mostreremo solo quello che è più familiare a MATLAB
gli utenti:

MATLAB PerlDL
------ ------
if valore > MAX if ($valore > $MAX) {
disp("Troppo grande") print "Troppo grande\n";
elseif valore < MIN } elsif ($valore < $MIN) {
disp("Troppo piccolo") print "Troppo piccolo\n";
altro } altro {
disp("Perfetto!") print "Perfetto!\n";
fine }

Note: Ecco una "presa":

MATLAB: altrimenti
PerlDL: elsif

Se il tuo condizionale fornisce un errore di sintassi, controlla di aver scritto i tuoi "elsif"
correttamente.

TIMTOWDI (Là Is Più Di Uno Modo A Do Esso)
Una delle differenze più interessanti tra PDL e altri strumenti è l'espressività
del linguaggio Perl. TIMTOWDI, o "C'è più di un modo per farlo", è il motto di Perl.

Perl è stato scritto da un linguista e una delle sue proprietà distintive è che le istruzioni possono
essere formulato in modi diversi per dare alla lingua un aspetto più naturale. Ad esempio, tu
è improbabile che dicano a un amico:

"Fino a quando non ho finito, continuerò a lavorare".

Il linguaggio umano è più flessibile di così. Invece, è più probabile che tu dica:

"Continuerò a lavorare finché non avrò finito".

A causa delle sue radici linguistiche, Perl è l'unico linguaggio di programmazione con questo tipo di
flessibilità. Ad esempio, Perl ha tradizionali cicli while e istruzioni if:

mentre (! finito() ) {
continuare a lavorare();
}

if (! moglie_arrabbiata() ) {
bacio_moglie();
}

Ma offre anche l'alternativa fino a quando che a salvo che dichiarazioni:

fino a (finito() ) {
continuare a lavorare();
}

a meno che ( moglie_arrabbiata() ) {
bacio_moglie();
}

E Perl ti permette di scrivere loop e condizionali in forma "postfix":

keep_working() fino al termine();

kiss_wife() a meno che wife_angry();

In questo modo, Perl spesso consente di scrivere codice più naturale e facile da capire di quanto non sia
possibile in linguaggi di programmazione più restrittivi.

funzioni
La sintassi di PDL per dichiarare le funzioni differisce significativamente da quella di MATLAB.

MATLAB PerlDL
------ ------
funzione retval = foo(x,y) sub foo {
valoreret = x.**2 + x.*y mio ($x, $y) = @_;
funzione finale return $x**2 + $x*$y;
}

Non lasciarti intimidire da tutta la nuova sintassi. Ecco una rapida analisi di una funzione
dichiarazione nel PDL:

1) "sotto" sta per "subroutine".

2) "my" dichiara le variabili come locali alla funzione.

3) "@_" è uno speciale array Perl che contiene tutti i parametri della funzione. Potrebbe sembrare
come uno strano modo di eseguire funzioni, ma ti consente di creare funzioni che richiedono un
numero variabile di parametri. Ad esempio, la seguente funzione richiede un numero qualsiasi di
parametri e li somma:

sub miosum {
mio ($i, $totale) = (0, 0);
per $i (@_) {
$totale += $i;
}
restituire $totale;
}

4) È possibile assegnare valori a più variabili contemporaneamente utilizzando la sintassi:

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

Quindi, negli esempi precedenti:

# Questo dichiara due variabili locali e le inizializza a 0.
mio ($i, $totale) = (0, 0);

# Questo prende i primi due elementi di @_ e li mette in $x e $y.
mio ($x, $y) = @_;

5) Il "ritorno" L'istruzione fornisce il valore di ritorno della funzione, se presente.

SUPPLEMENTARI CARATTERISTICHE

ASCII Compila il IO
Per leggere file di dati contenenti colonne di numeri separate da spazi (come verrebbe letto
utilizzando MATLAB caricare comando) si usa il PDL rcol in PDL::IO::Misc. Per un generale
revisione della funzionalità IO disponibile in PDL, vedere la documentazione per PDL::IO, ad es.
"aiuto PDL::IO" nel pdl2 shell o " pdldoc PDL::IO " dalla riga di comando della shell.

Dati strutture
Per creare strutture dati complesse, MATLAB utilizza "cella array" e "La struttura array".
Gli array e gli hash di Perl offrono funzionalità simili ma sono più potenti e flessibili.
Questa sezione è solo una rapida panoramica di ciò che Perl ha da offrire. Per saperne di più su questo,
per favore vai ahttp://perldoc.perl.org/perldata.html> oppure esegui il comando "perldoc
perldata".

Array
Gli array Perl sono simili agli array di celle di MATLAB, ma più flessibili. Ad esempio, in
MATLAB, un array di celle è ancora fondamentalmente una matrice. È fatto di righe e righe
devono avere la stessa lunghezza.

MATLAB
------
array = {1, 12, 'ciao'; rand(3, 2), quelli(3), 'spazzatura'}
=> OK
array = {1, 12, 'ciao'; rand(3, 2), quelli(3) }
=> ERRORE

Un array Perl è una struttura dati sequenziale di uso generale. Può contenere qualsiasi dato
tipo.

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

Nota che l'array Perl inizia con il prefisso "@" invece del "$" usato da
piselli.

A Imparando circa Perl matrici, per favore go a <http://perldoc.perl.org/perldata.html> or
eseguire il , il command "perldoc" perldata".

hash
Gli hash Perl sono simili agli array di strutture di MATLAB:

MATLAB
------
>> drink = struct('type', 'coke', 'size', 'large', 'myarray', {1,2,3})
>> drink.type = 'sprite'
>> drink.price = 12 % Aggiungi un nuovo campo all'array della struttura.

PerlDL
------
pdl> %drink = ( type => 'coca' , size => 'large', mypiddle => one(3,3,3) )
pdl> $drink{tipo} = 'sprite'
pdl> $drink{prezzo} = 12 # Aggiunge un nuovo campo all'hash.

Nota che gli hash Perl iniziano con il prefisso "%" invece del "@" per gli array e
"$" usato da piddles.

A Imparando circa Perl hash, per favore go a <http://perldoc.perl.org/perldata.html> or
eseguire il , il command "perldoc" perldata".

Performance
PDL ha potenti funzionalità di prestazioni, alcune delle quali non sono normalmente disponibili in
strumenti di calcolo numerico. Le pagine seguenti ti guideranno attraverso queste funzionalità:

PDL::Indicizzazione
Livello: Principiante

Questo tutorial per principianti copre la funzione di "vettorizzazione" standard che hai già
sapere da MATLAB. Usa questa pagina per imparare come evitare i cicli for per realizzare il tuo programma
più efficiente.

PDL::Filettatura
Livello: Intermedio

La funzione di "vettorizzazione" di PDL va oltre ciò che la maggior parte dei software numerici può fare. In
questo tutorial imparerai come "infilare" su dimensioni superiori, permettendoti di
vettorializzare il tuo programma più di quanto sia possibile in MATLAB.

Parametri di riferimento
Livello: Intermedio

Perl viene fornito con un modulo di benchmark facile da usare per aiutarti a trovare quanto tempo ci vuole
per eseguire diverse parti del codice. È un ottimo strumento per aiutarti a concentrarti
sforzi di ottimizzazione. Puoi leggerlo online
(<http://perldoc.perl.org/Benchmark.html>) o tramite il comando "perldoc
Prova delle prestazioni".

PDL::PP
Livello: Avanzate

Il pre-processore di PDL è una delle funzionalità più potenti di PDL. Scrivi una funzione
definizione in markup speciale e il pre-processore genera codice C reale che può essere
compilato. Con PDL:PP ottieni la piena velocità del codice C nativo senza doverci occupare
con tutta la complessità del linguaggio C.

Tracciare
PDL ha capacità di trama complete. A differenza di MATLAB, PDL si affida maggiormente a terze parti
librerie (pgplot e PLplot) per le sue funzionalità di stampa 2D. Il suo plottaggio e grafica 3D
utilizza OpenGL per prestazioni e portabilità. PDL ha tre moduli principali di plottaggio:

PDL::Grafica::PGPLOT
I migliori per: Rappresentazione di funzioni 2D e set di dati.

Questa è un'interfaccia per la venerabile libreria PGPLOT. PGPLOT è stato ampiamente utilizzato in
le comunità accademiche e scientifiche per molti anni. In parte a causa della sua età,
PGPLOT ha alcune limitazioni rispetto ai pacchetti più recenti come PLplot (es no RGB
grafica). Ma ha molte caratteristiche che lo rendono ancora popolare in ambito scientifico
comunità.

PDL::Grafica::PLplot
I migliori per: Rappresentazione di funzioni 2D e set di dati 2D e 3D.

Questa è un'interfaccia per la libreria di plottaggio PLplot. PLplot è un moderno open source
biblioteca per la realizzazione di trame scientifiche. Supporta grafici di set di dati 2D e 3D.
PLplot è meglio supportato per piattaforme unix/linux/macosx. Ha uno sviluppatore attivo
la community e il supporto per le piattaforme win32 stanno migliorando.

PDL::Grafica::TriD
I migliori per: Rappresentazione delle funzioni 3D.

La libreria grafica 3D PDL nativa che utilizza OpenGL come backend per grafici e dati 3D
visualizzazione. Con OpenGL, è facile manipolare gli oggetti 3D risultanti con
il mouse in tempo reale.

scrittura GUI
Tramite Perl, PDL ha accesso a tutti i principali toolkit per creare una piattaforma multipiattaforma
Interfaccia grafica utente. Un'opzione popolare è wxPerl (http://wxperl.sourceforge.net>).
Questi sono i collegamenti Perl per wxWidgets, un potente toolkit GUI per la scrittura cross-
applicazioni della piattaforma.

wxWidgets è progettato per far sembrare la tua applicazione come un'applicazione nativa in
ogni piattaforma. Ad esempio, l'IDE Perl Padre spirituale è scritto con wxPerl.

Simlink
Simulink è un modellatore e simulatore grafico di sistemi dinamici. Può essere acquistato
separatamente come componente aggiuntivo di MATLAB. PDL e Perl non hanno un equivalente diretto a
Simulink di MATLAB. Se questa funzione è importante per te, dai un'occhiata a scilab:

<http://www.scilab.org>

Scilab è un altro software di analisi numerica. Come PDL, è gratuito e open source. Esso
non ha le caratteristiche uniche di PDL, ma è molto simile a MATLAB. Scilab viene fornito con
Xcos (precedentemente Scicos), un modellatore e simulatore di sistemi grafici simile a Simulink.

COPYRIGHT

Copyright 2010 Daniele Carrera ([email protected]). Puoi distribuirlo e/o modificarlo
documento alle stesse condizioni dell'attuale licenza Perl.

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

Ringraziamenti
Vorrei ringraziare David Mertens, Chris Marshall e Sigrid Carrera per il loro immenso
aiutare a rivedere le bozze precedenti di questa guida. Senza le loro ore di lavoro, questo
documento non sarebbe nemmeno lontanamente utile per gli utenti MATLAB come lo è oggi.

Usa PDL::MATLABp online utilizzando i servizi onworks.net