PDL::QuickStartp - En ligne dans le Cloud

PROGRAMME:

Nom

PDL::QuickStart - Présentation rapide des fonctionnalités PDL.

SYNOPSIS

Un bref résumé des principales fonctionnalités de PDL et comment les utiliser.

DESCRIPTION

Introduction
Perl est un langage de script extrêmement bon et polyvalent, bien adapté aux débutants et
permet un prototypage rapide. Cependant, jusqu'à récemment, il ne supportait pas les structures de données qui
lui a permis de faire des calculs rapides.

Cependant, avec le développement de Perl v5, Perl a acquis 'Objects'. Pour faire simple, les utilisateurs
peuvent définir leurs propres types de données spéciaux et écrire des routines personnalisées pour les manipuler
soit dans les langages de bas niveau (C et Fortran) soit en Perl lui-même.

Cela a été pleinement exploité par les développeurs PerlDL. Le module 'PDL' est un
Extension orientée objet vers Perl (bien que vous n'ayez pas besoin de savoir ce qu'est un objet
l'utiliser) qui permet de grands ensembles de données à N dimensions, tels que de grandes images, spectres, temps
série, etc à stocker efficacement et manipulé en massa. Par exemple avec le PDL
module, nous pouvons écrire le code Perl "$a = $b + $c", où $b et $c sont de grands ensembles de données (par exemple
2048x2048 images) et obtenez le résultat en une fraction de seconde seulement.

Les variables PDL (ou « piddles » comme on les appelle) prennent en charge un large éventail de
types de données fondamentaux - les tableaux peuvent être des octets, des entiers courts (signés ou non signés), longs
entiers, flottants ou flottants double précision. Et en raison de la nature orientée objet de
De nouveaux types de données personnalisés PDL peuvent en être dérivés.

En plus des modules PDL, qui peuvent être utilisés par des programmes Perl normaux, PerlDL est livré avec un
shell Perl en ligne de commande, appelé 'perldl', qui prend en charge l'édition en ligne de commande. Dans
combinaison avec les différents modules graphiques PDL permet de lire facilement les données
avec et visualisé.

Aide
PDL contient une documentation complète, disponible à la fois dans le perl or pdl2 coquilles et
depuis la ligne de commande, en utilisant le programme "pdldoc". Pour plus d'informations, essayez l'une des options suivantes :

pdf> aide aide
$ pdldoc

Des copies HTML de la documentation devraient également être disponibles. Pour trouver leur emplacement, essayez
ce qui suit:

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

Perl Types de données et how PDL S'étend le point de vue de
Les structures de données fondamentales de Perl sont des variables scalaires, par exemple $x, qui peuvent contenir des nombres
ou des chaînes, des listes ou des tableaux de scalaires, par exemple @x, et des tableaux/hachages associatifs de scalaires,
par exemple %x.

Perl v5 introduit les structures de données et les objets Perl. Une simple variable scalaire $x soit maintenant
un type de données défini par l'utilisateur ou un objet complet (il contient en fait une référence (un
"pointeur") à ceci mais qui n'est pas pertinent pour l'utilisation ordinaire de perlDL)

L'idée fondamentale derrière perlDL est de permettre à $x de contenir tout un spectre 1D, ou un 2D
image, un cube de données 3D, et ainsi de suite jusqu'à de grands ensembles de données à N dimensions. Ceux-ci peuvent être
manipulé en une seule fois, par exemple "$a = $b + 2" effectue une opération vectorielle sur chaque valeur dans le
spectre/image/etc.

Vous pouvez très bien demander : "Pourquoi ne pas simplement stocker un spectre sous la forme d'une simple liste de style Perl @x avec chaque
pixel étant un élément de liste ?" Les deux réponses clés à cela sont Mémoire et vitesse. Parce que nous
savons que notre spectre est constitué de nombres purs, nous pouvons les stocker de manière compacte dans un seul bloc
de mémoire correspondant à un tableau numérique de style C. Cela prend BEAUCOUP moins de mémoire que
la liste Perl équivalente. Il est alors facile de passer ce bloc de mémoire à un ajout rapide
routine, ou à toute autre fonction C qui traite des tableaux. Par conséquent, perlDL est très
rapide --- par exemple on peut multiplier une image 2048*2048 exactement en même temps qu'elle
prendrait en C ou FORTRAN (0.1 seconde sur mon SPARC). Un autre avantage de ceci est que pour
opérations simples (par exemple "$x += 2") on peut manipuler l'ensemble du tableau sans se soucier
sa dimensionnalité.

Je trouve qu'en utilisant perlDL, il est plus utile de penser aux variables Perl @x standard comme
« listes » de « choses » génériques et de variables PDL comme $x en tant que « tableaux » qui peuvent être contenus
dans des listes ou des hachages. Assez souvent dans mes scripts perlDL j'ai @x contient une liste de spectres,
ou une liste d'images (ou même un mix !). Ou peut-être que l'on pourrait avoir un hachage (par exemple %x) de
images... la seule limite est la mémoire !

Les variables perlDL prennent en charge une gamme de types de données - les tableaux peuvent être des octets, des entiers courts
(signés ou non signés), entiers longs, flottants ou flottants double précision.

Utilisation
PerlDL est chargé dans votre script Perl à l'aide de cette commande :

utiliser PDL ; # dans les scripts Perl : utilisez les modules perlDL standard

Il existe également de nombreux modules d'extension, par exemple PDL::Graphics::TriD. La plupart d'entre eux (mais
pas tous car parfois ce n'est pas approprié) suivent une convention standard. Si tu le dis:

utiliser PDL::Graphics::TriD;

Vous importez tout dans une liste standard à partir du module. Parfois, vous voudrez peut-être
ne rien importer (par exemple si vous souhaitez utiliser la syntaxe OO tout le temps et économiser la taxe d'importation).
Pour ceux-ci, vous dites :

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

Et les guillemets vides "qw()" sont reconnus comme signifiant "rien". Vous pouvez également spécifier un
liste des fonctions à importer de la manière normale de Perl.

Il existe également un shell interactif, "perldl" ou "pdl2", voir perl ou pdl2 pour plus de détails.

À engendrent a nouvelle PDL variable
Voici quelques façons de créer une variable PDL :

$a = pdl [1..10]; # 1D tableau
$a = pdl (1,2,3,4); # Idem
$a = pdl '[1 2 3 4]'; # Idem
$b = pdl [[1,2,3],[4,5,6]] ; # 2D 3x2 tableau
$b = pdl '[1 2 3; 4 5 6]'; # Idem
$b = pdl q[1,2,3; 4,5,6] ; # Idem
$b = pdl <
[1 2 3]
[4 5 6]
NOUVEAUPDL
$c = pdl q[1 -2] ; # Piddle à 2 éléments contenant 1 et -2
$c = pdl q[1 - 2] ; # Piddle à 2 éléments contenant 1 et -2
$b = pdl 42 # scalaire à 0 dimension
$c = pdl $a; # Faire une nouvelle copie

$d = octet [1..10] ; # Voir "Conversion de type"
$e = zéros(3,2,4) ; # 3x2x4 tableau rempli de zéros

$c = rfits $file; # Lire le fichier FITS

@x = ( M(42), zéros(3,2,4), rfits($file) ); # Est-ce une LISTE de variables PDL !

La pdl() la fonction est utilisée pour initialiser une variable PDL à partir d'un scalaire, liste, liste
référence, une autre variable PDL ou une chaîne correctement formatée.

De plus, toutes les fonctions PDL convertissent automatiquement les scalaires Perl normaux en variables PDL
à la volée.

(voir également les sections « Conversion de type » et « Entrée/Sortie » ci-dessous)

Arithmétique (Et booléen expressions)
$a = $b + 2 ; $a++ ; $a = $b / $c ; # Etc.

$c=carré($a); $d = log10($b+100); # Etc

$e = $a>42 ; # Vecteur conditionnel

$e = 42*($a>42) + $a*($a<=42); # Haut de la casquette

$b = $a->log10 sauf si tout ($a <= 0); # éviter les erreurs en virgule flottante

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

$f = où($a, $a > 10); # où renvoie un groupe d'éléments pour
# dont la condition est vraie

imprimer $a ; # $a dans un contexte de chaîne l'imprime dans un format N-dimensionnel

(et autres opérateurs/fonctions Perl)

Lors de l'utilisation de piddles dans des expressions conditionnelles (c'est-à-dire les constructions "if", "à moins que" et "while")
seuls les piddles avec exactement un élément sont autorisés, par exemple

$a = pdl (1,0,0,1) ;
print "est défini" si $a->indice(2);

Notez que les opérateurs booléens renvoient en général des piddles multi-éléments. Par conséquent, la
suivant va générer une erreur

affiche "est ok" si $a > 3 ;

puisque "$a > 3" est un piddle avec 4 éléments. Utilisez plutôt tout ou tout pour tester si tout ou partie des
les éléments remplissent la condition :

affiche "certains sont > 3" s'il y en a $a>3 ;
print "ne peut pas prendre de logarithme" à moins que tous les $a>0 ;

Il existe également de nombreuses fonctions prédéfinies, qui sont décrites sur d'autres pages de manuel. Vérifier
PDL :: Index.

Matrice fonctions
'x' est détourné en tant qu'opérateur de multiplication matricielle. par exemple "$c = $ax $b" ;

perlDL est une ligne majeure et non une colonne majeure, c'est donc en fait "c(i,j) = sum_k a(k,j) b(i,k)" -
mais lorsque les matrices sont imprimées, les résultats seront corrects. N'oubliez pas que les indices sont
renversé. par exemple:

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

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

Remarque : transposer() fait ce qu'il dit et est un moyen pratique de transformer les vecteurs de ligne en
vecteurs colonnes.

Comment à écrire a simple fonction
sous-produit de point {
mon ($a,$b) = @_;
retour somme($a*$b) ;
}
1;

Si mis dans le fichier dotproduct.pdl serait chargé automatiquement si vous utilisez PDL::AutoLoader (voir
ci-dessous).

Bien sûr, cette fonction est déjà disponible en tant que fonction interne, voir PDL::Primitive.

Type Conversion
Par défaut pour pdl() est double. Les conversions sont :

$a = flottant($b);
$c = long($d); # "long" est généralement un entier de 4 octets
$d = octet($a);

Aussi double(), court(), ushort(), index().

REMARQUE : la routine indx() est un type entier spécial qui
est la taille correcte pour une valeur d'index PDL (taille de dimension,
index, ou offest) qui peut être un 32bit (long) ou
Quantité 64 bits (longlong) selon que le perl
est construit avec un support 32 bits ou 64 bits.

Ces routines convertissent également automatiquement les listes Perl pour permettre le raccourci pratique :

$a = octet [[1..10],[1..10]] ; # Créer un tableau d'octets 2D
$a = flottant [1..1000] ; # Créer un tableau flottant 1D

et ainsi de suite

Impression
Développe automatiquement le tableau au format N-dimensionnel :

imprimer $a ;

$b = "La réponse est = $a " ;

sections
PDL dispose d'opérateurs de tranchage et de sectionnement multidimensionnels très puissants ; voir le
LPD ::Tranches(3) page de manuel pour plus de détails ; nous allons décrire le plus important ici.

PDL montre son héritage Perl/C en ce sens que les tableaux sont à décalage nul. Ainsi une image 100x100 a
indices "0..99,0..99". (La convention est que le centre du pixel (0,0) est à la coordonnée
(0.0,0.0). Toutes les fonctions graphiques PDL sont conformes à cette définition et masquent l'unité
offsets, par exemple, de la bibliothèque PGPLOT FORTRAN.

Suivant la convention habituelle, la coordonnée (0,0) est affichée en bas à gauche lorsque
afficher une image. Il apparaît en haut à gauche lors de l'utilisation de ""print $a"" etc.

Le sectionnement simple utilise une extension de syntaxe à Perl, PDL::NiceSlice, qui vous permet de
spécifier des sous-plages via un modificateur de méthode nulle à un PDL :

$b = $a->($x1:$x2,$y1:$y2,($z1)); # Prendre la sous-section

Ici, $a est une variable tridimensionnelle et $b obtient une découpe plane définie par le
limites $x1, $x2, $y1, $y2, à l'emplacement $z1. La parenthèse autour de $z1 provoque le
indice trivial à omettre -- sinon $b serait en trois dimensions avec un troisième
dimension de l'ordre 1.

Vous pouvez placer des tranches PDL de chaque côté de l'opérateur d'affectation par élément ".=", comme
Sun:

# Définir une partie de $bigimage sur les valeurs de $smallimage
$bigimage->($xa:$xb,$ya:$yb) .= $smallimage;

Quelques autres mélanges :

$c = nelem($a); # Nombre de pixels

$val = at($object, $x,$y,$z...) # Valeur de pixel à la position, sous forme de scalaire Perl
$val = $object->at($x,$y,$z...) # équivalent (syntaxe de la méthode OK)

$b = xvals($a); # Remplir le tableau avec les valeurs X-coord (également yvals(), zvals(),
# axisvals($x,$axis) et rvals() pour la distance radiale
# du centre).

Entrée / Sortie
Les modules "PDL::IO" implémentent plusieurs fonctions de formatage IO utiles. ce serait trop
pour donner des exemples de chacun, mais vous pouvez trouver un bon aperçu sur PDL::IO. Voici un échantillon de
certains des formats d'E/S pris en charge dans PDL.

PDL::IO::Divers
Routines Ascii, FITS et FIGARO/NDF IO.

PDL :: IO :: FastRaw
En utilisant les types de données brutes de votre machine, une E/S non portable mais incroyablement rapide
format. Prend également en charge le mappage de la mémoire pour conserver la mémoire et obtenir plus de vitesse.

PDL :: IO :: FlexRaw
Formats de données brutes générales. Comme FastRaw, mais en mieux.

PDL::IO::Navigateur
Un navigateur Curses pour les tableaux.

PDL :: IO :: Pnm
Prise en charge des bitmaps et pixmaps de Portaple.

PDL::IO::Photo
En utilisant le module précédent et netpbm, permet d'écrire facilement des GIF, jpeg
et quoi que ce soit avec des commandes simples.

Graphiques
La philosophie derrière perlDL est de le faire fonctionner avec une variété de graphiques existants
bibliothèques car aucun package unique ne satisfera tous les besoins et toutes les personnes et cela permet
un pour travailler avec des packages que l'on connaît déjà et qu'on aime. Il y aura évidemment des
des chevauchements de fonctionnalités et un certain manque de cohérence et d'uniformité. Cependant cela permet
PDL pour suivre un domaine en développement rapide - les derniers modules PDL fournissent des interfaces
aux graphiques OpenGL et VRML !

PDL::Graphiques::PGPLOT
PGPLOT fournit une bibliothèque simple pour les graphiques linéaires et l'affichage d'images.

Il existe une interface simple pour cela dans le module interne PDL::Graphics::PGPLOT, qui
appelle des routines dans le module de niveau supérieur PGPLOT disponible séparément.

PDL::Graphiques::PLplot
PLplot fournit une bibliothèque simple pour créer des graphiques avec plusieurs pilotes de sortie,
y compris un pilote direct à piddle.

Ce module fournit à la fois des fonctionnalités de haut niveau et de bas niveau basées sur PLplot. Les
les commandes de bas niveau sont à peu près des liaisons directes avec l'interface C de PLplot. Lire la suite
à PDL::Graphics::PLplot.

PDL::Graphiques::IIS
De nombreux astronomes aiment utiliser SAOimage et Ximtool (ou là des dérivations/clones). Ces
sont des widgets gratuits utiles pour l'inspection et la visualisation des images. (Ils ne sont pas
fourni avec perlDL mais peut facilement être obtenu à partir de leurs sites officiels hors du
Rapporter.)

Le package PDL::Graphics::IIS permet d'afficher des images dans ces derniers ("IIS"
est le nom d'un ancien matériel d'affichage d'images dont les protocoles ces outils
conforme à.)

PDL::Graphiques::TriD
Voir PDL::Graphics::TriD, c'est une collection de routines 3D pour OpenGL et (bientôt)
VRML et autres formats 3D qui permettent des tracés 3D de points, de lignes et de surfaces à partir de PDL.

Chargement automatique
Voir PDL::AutoLoader. Cela permet de charger automatiquement des fonctions à la demande, d'une manière peut-être
familier aux utilisateurs de MatLab.

On peut aussi écrire des extensions PDL comme des modules Perl normaux.

PDL coquilles
Le script Perl "pdl2" (ou "perldl") fournit une interface de ligne de commande simple à PDL. Si
les derniers modules Readlines/ReadKey ont été installés "pdl2" le détecte et active
rappel et édition de la ligne de commande. Voir la page de manuel pour plus de détails.

par exemple:

% perldl
shell perlDL v1.354
PDL est livré avec ABSOLUMENT AUCUNE GARANTIE. Pour plus de détails, consultez le fichier
'COPYING' dans la distribution PDL. C'est un logiciel gratuit et vous
sont invités à le redistribuer sous certaines conditions, voir
le même fichier pour plus de détails.
ReadLines, NiceSlice, MultiLines activés
Lecture de PDL/default.perldlrc...
Base de données docs trouvée /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
Tapez 'help' pour l'aide en ligne
Tapez « demo » pour les démos en ligne
PDL chargé v2.4.9_003 (prend en charge les mauvaises valeurs)
pdl> $x = rfits 'm51.fits'
Lecture des données IMAGE...
BITPIX = 32 taille = 147456 pixels
Lecture 589824 octets
ÉCHELLE B = && BZÉRO =

pdl> utiliser PDL::Graphics::PGPLOT;
pdl> image $x
Affichage d'une image 384 x 384 de 40 à 761, en utilisant 84 couleurs (16-99)...

Vous pouvez également l'exécuter depuis le débogueur Perl ("perl -MPDL -d -e 1") si vous le souhaitez.

Caractéristiques diverses de la coque :

p Le shell alias "p" pour être une forme courte pratique de "print", par exemple

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

Initialisation
Les fichiers "~/.perldlrc" et "local.perldlrc" (dans le répertoire courant) sont sourcés si
trouvé. Cela permet à l'utilisateur d'avoir un code PDL global et local pour le démarrage.

Aide
Tapez « aide » ! On peut rechercher la documentation PDL, et rechercher la documentation sur n'importe quel
la fonction.

Échapper
Toute ligne commençant par le caractère "#" est traitée comme un échappement du shell. Ce personnage
est configurable en définissant la variable Perl $PERLDL_ESCAPE. Cela pourrait, par exemple,
être mis en "~/.perldlrc".

Surcharge opérateurs
Les opérateurs et fonctions Perl intégrés suivants ont été surchargés pour fonctionner sur PDL
variables:

+ - * / > < >= <= << >> & | ^ == != <=> ** % ! ~
péché journal abs atan2 sqrt cos exp

[Toutes les fonctions unaires (sin etc.) peuvent être utilisées avec en place() - voir "Mémoire" ci-dessous.]

Objet-Orientation et perlDL
Les opérations PDL sont disponibles sous forme de fonctions et de méthodes. On peut ainsi dériver de nouveaux types de
objet, pour représenter des classes de données personnalisées.

En utilisant la surcharge, on peut faire en sorte que les opérateurs mathématiques fassent ce qu'on veut, et PDL
a quelques astuces intégrées qui permettent aux fonctions PDL existantes de fonctionner sans changement, même si le
la représentation des données sous-jacentes est considérablement modifiée ! Voir PDL::Objets

Mémoire usage et
S'amuser avec des tableaux de données vraiment énormes peut nécessiter quelques précautions. perlDL fournit de nombreux
des fonctionnalités pour vous permettre d'effectuer des opérations sur de grandes baies sans générer de copies supplémentaires
bien que cela nécessite un peu plus de réflexion et d'attention de la part du programmeur.

REMARQUE : sur certains systèmes, il est préférable de configurer Perl (pendant les options de construction) pour
utilisez la fonction système "malloc()" plutôt que celle intégrée à Perl. C'est parce que Perl
l'un est optimisé pour la vitesse plutôt que pour la consommation de mémoire virtuelle - cela peut entraîner
un facteur de deux amélioration de la quantité de stockage de mémoire que vous pouvez utiliser. Le malloc Perl
dans 5.004 et versions ultérieures a un certain nombre d'options de compilation que vous pouvez utiliser pour régler le
comportement.

arithmétique simple
Si $a est une grande image (par exemple occupant 10 Mo) alors la commande

$a = $a + 1 ;

consomme encore 10 Mo de mémoire. C'est parce que l'expression "$a+1" crée un
copie temporaire de $a pour contenir le résultat, alors $a se voit attribuer une référence à cela.
Après cela, le $a d'origine est détruit, il n'y a donc plus de permanent perte de mémoire. Mais sur
une petite machine, la croissance de l'empreinte mémoire peut être considérable. Il est
évidemment fait de cette façon, donc "$c=$a+1" fonctionne comme prévu.

Aussi si l'on dit :

$b = $a ; # $b et $a pointent maintenant vers les mêmes données
$a = $a + 1 ;

Alors $b et $a finissent par être différents, comme on s'y attend naïvement, car une nouvelle référence
est créé et $a lui est affecté.

Cependant, si $a était un énorme rongeur de mémoire (par exemple un volume 3D), créer une copie de celui-ci peut ne pas
être une bonne chose. On peut éviter cette surcharge de mémoire dans l'exemple ci-dessus en disant :

$a++ ;

Les opérations "++,+=,--,-=", etc. appellent toutes une version spéciale "sur place" du
sous-programme arithmétique. Cela signifie qu'aucune mémoire supplémentaire n'est nécessaire - l'inconvénient est que
que si "$b=$a" alors $b est également incrémenté. Pour forcer une copie explicitement :

$b = pdl $a; # Copie réelle

ou, alternativement, peut-être un meilleur style :

$b = $a->copie ;

Les fonctions
La plupart des fonctions, par exemple "log()", renvoient un résultat qui est une transformation de leur
argument. Cela permet de bonnes pratiques de programmation. Cependant de nombreuses opérations peuvent être
fait "sur place" et cela peut être nécessaire lorsque de grands tableaux sont utilisés et que la mémoire est à
un premium. Dans ces circonstances, l'opérateur en place() est fourni, ce qui empêche
la copie supplémentaire et permet de modifier l'argument. par exemple:

$x = log($tableau); # $array non affecté
log( inplace($bigarray) ); # $bigarray changé in situ

AVERTISSEMENTS:

1. Les mises en garde habituelles concernant les références en double s'appliquent.

2. Évidemment lorsqu'il est utilisé avec certaines fonctions qui ne peuvent pas être appliquées in situ (par exemple
"convolve()") des effets inattendus peuvent se produire ! Nous essayons d'indiquer "inplace()"-safe
fonctions dans la documentation.

3. Les conversions de type, telles que "float()", peuvent provoquer une copie masquée.

Assurer désinvolture
Si vous avez écrit une fonction simple et que vous ne voulez pas qu'elle vous explose à la figure si vous
transmettez-lui un simple nombre plutôt qu'une variable PDL. Appelez simplement la fonction topdl() premier
pour le rendre sûr. par exemple:

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

"topdl()" n'effectue PAS de copie si une variable pdl est passée - elle tombe juste -
ce qui est évidemment le comportement souhaité. La routine n'est bien sûr pas nécessaire en temps normal
des fonctions définies par l'utilisateur qui ne se soucient pas des internes.

Utilisez PDL::QuickStartp en ligne à l'aide des services onworks.net