PDL :: QuickStartp - Online en la nube

PROGRAMA:

NOMBRE

PDL :: QuickStart: introducción rápida a las funciones de PDL.

SINOPSIS

Un breve resumen de las principales funciones de PDL y cómo utilizarlas.

DESCRIPCIÓN

Introducción
Perl es un lenguaje de scripting extremadamente bueno y versátil, muy adecuado para principiantes y
permite la creación rápida de prototipos. Sin embargo, hasta hace poco tiempo, no admitía estructuras de datos que
le permitió hacer un procesamiento rápido de números.

Sin embargo, con el desarrollo de Perl v5, Perl adquirió 'Objetos'. En pocas palabras, los usuarios
puede definir sus propios tipos de datos especiales y escribir rutinas personalizadas para manipularlos
ya sea en lenguajes de bajo nivel (C y Fortran) o en Perl mismo.

Esto ha sido completamente aprovechado por los desarrolladores de PerlDL. El módulo 'PDL' es un completo
Extensión orientada a objetos para Perl (aunque no es necesario saber qué es un objeto para
usarlo) que permite grandes conjuntos de datos N-dimensionales, como imágenes grandes, espectros, tiempo
serie, etc. para ser almacenado efficiently y manipulado en masa. Por ejemplo con la PDL
módulo podemos escribir el código Perl "$ a = $ b + $ c", donde $ by $ c son grandes conjuntos de datos (p. ej.
2048x2048 imágenes) y obtenga el resultado en solo una fracción de segundo.

Las variables PDL (o 'piddles' como se las conoce) admiten una amplia gama de
tipos de datos fundamentales: las matrices pueden ser bytes, enteros cortos (con o sin signo), largos
enteros, flotantes o flotantes de doble precisión. Y debido a la naturaleza orientada a objetos de
A partir de ellos se pueden derivar nuevos tipos de datos personalizados PDL.

Además de los módulos PDL, que pueden ser utilizados por programas Perl normales, PerlDL viene con un
línea de comandos Shell de Perl, llamado 'perldl', que admite la edición de la línea de comandos. En
combinación con los diversos módulos gráficos PDL esto permite que los datos se reproduzcan fácilmente
con y visualizado.

Ayuda
PDL contiene una amplia documentación, disponible tanto en el perdl or pdl2 conchas y
desde la línea de comando, usando el programa "pdldoc". Para obtener más información, pruebe cualquiera de los siguientes:

pdl> ayuda ayuda
$ pdldoc

También deberían estar disponibles copias HTML de la documentación. Para encontrar su ubicación, intente
el seguimiento:

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

Perl Tipos de datos e how PDL Se extiende them
Las estructuras de datos fundamentales de Perl son variables escalares, por ejemplo, $ x, que pueden contener números
o cadenas, listas o matrices de escalares, por ejemplo, @x, y matrices asociativas / hashes de escalares,
por ejemplo,% x.

Perl v5 presenta las estructuras de datos y los objetos de Perl. Una variable escalar simple $ x ahora es
un tipo de datos definido por el usuario o un objeto completo (en realidad contiene una referencia (una
"puntero") a esto, pero eso no es relevante para el uso normal de perlDL)

La idea fundamental detrás de perlDL es permitir que $ x contenga un espectro 1D completo, o un espectro 2D.
imagen, un cubo de datos 3D, y así sucesivamente hasta grandes conjuntos de datos N-dimensionales. Estos pueden ser
manipulado todo a la vez, por ejemplo, "$ a = $ b + 2" hace una operación vectorial en cada valor en el
espectro / imagen / etc.

Puede preguntar: "¿Por qué no almacenar simplemente un espectro como una lista de estilo Perl @x simple con cada
¿Pixel es un elemento de la lista? "Las dos respuestas clave a esto son memoria e velocidad. Porque nosotros
sabemos que nuestro espectro consta de números puros, podemos almacenarlos de forma compacta en un solo bloque
de memoria correspondiente a una matriz numérica de estilo C. Esto ocupa MUCHA menos memoria que
la lista de Perl equivalente. Entonces es fácil pasar este bloque de memoria a una adición rápida
rutina, o cualquier otra función de C que se ocupa de matrices. Como resultado, perlDL es muy
rápido --- por ejemplo, se puede multiplicar una imagen de 2048 * 2048 exactamente al mismo tiempo que
tomaría C o FORTRAN (0.1 seg en mi SPARC). Otra ventaja de esto es que para
operaciones simples (por ejemplo, "$ x + = 2") uno puede manipular toda la matriz sin preocuparse por
su dimensionalidad.

Encuentro que cuando uso perlDL es más útil pensar en las variables estándar de Perl @x como
"listas" de "cosas" genéricas y variables PDL como $ x como "matrices" que se pueden contener
en listas o hashes. Muy a menudo en mis scripts de perlDL tengo @x contiene una lista de espectros,
o una lista de imágenes (¡o incluso una combinación!). O tal vez uno podría tener un hash (por ejemplo,% x) de
imágenes ... ¡el único límite es la memoria!

Las variables perlDL admiten una variedad de tipos de datos: las matrices pueden ser bytes, enteros cortos
(con o sin signo), enteros largos, flotantes o flotantes de doble precisión.

Uso
PerlDL se carga en su script Perl usando este comando:

utilizar PDL; # en scripts de Perl: use los módulos estándar de perlDL

También hay muchos módulos de extensión, por ejemplo, PDL :: Graphics :: TriD. La mayoría de estos (pero
no todos, ya que a veces no es apropiado) siguen una convención estándar. Si usted dice:

use PDL :: Graphics :: TriD;

Importa todo en una lista estándar desde el módulo. A veces es posible que desee
no importe nada (por ejemplo, si desea utilizar la sintaxis OO todo el tiempo y guardar el impuesto de importación).
Por estos dices:

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

Y las comillas "qw ()" vacías se reconocen como "nada". También puede especificar un
lista de funciones para importar de la forma normal de Perl.

También hay un shell interactivo, "perldl" o "pdl2", consulte perdl o pdl2 para más detalles.

A Para crear a new PDL variable
A continuación, se muestran algunas formas de crear una variable PDL:

$ a = pdl [1..10]; Matriz # 1D
$ a = pdl (1,2,3,4, XNUMX, XNUMX, XNUMX); # Ídem
$ a = pdl '[1 2 3 4]'; # Ídem
$ b = pdl [[1,2,3], [4,5,6]]; # Matriz 2D 3x2
$ b = pdl '[1 2 3; 4 5 6] '; # Ídem
$ b = pdl q [1,2,3, 4,5,6, XNUMX; XNUMX]; # Ídem
$ b = pdl <
[1 2 3]
[4 5 6]
NUEVOPDL
$ c = pdl q [1-2]; # Piddle de 2 elementos que contiene 1 y -2
$ c = pdl q [1 - 2]; # Piddle de 2 elementos que contiene 1 y -2
$ b = pdl 42 # escalar de dimensión 0
$ c = pdl $ a; # Hacer una nueva copia

$ d = byte [1..10]; # Ver "Conversión de tipos"
$ e = ceros (3,2,4); # 3x2x4 matriz llena de ceros

$ c = archivo $ adecuado; # Leer archivo FITS

@x = ( pdl(42), ceros (3,2,4), rfits ($ archivo)); # ¡Es una LISTA de variables PDL!

El pdl () La función se usa para inicializar una variable PDL desde un escalar, lista, lista
referencia, otra variable PDL o una cadena con el formato adecuado.

Además, todas las funciones de PDL convierten automáticamente los escalares normales de Perl en variables de PDL
sobre la marcha.

(consulte también las secciones "Conversión de tipo" y "Entrada / salida" a continuación)

Aritmética (y booleano expresiones)
$ a = $ b + 2; $ a ++; $ a = $ b / $ c; # Etc.

$ c = raíz cuadrada ($ a); $ d = log10 ($ b + 100); # Etc

$ e = $ a> 42; # Vector condicional

$ e = 42 * ($ a> 42) + $ a * ($ a <= 42); # Tapa superior

$ b = $ a-> log10 a menos que alguna ($ a <= 0); # evitar el error de punto flotante

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

$ f = donde ($ a, $ a> 10); # donde devuelve una pizca de elementos para
# cuya condición es verdadera

imprimir $ a; # $ a en contexto de cadena lo imprime en un formato N-dimensional

(y otros operadores / funciones de Perl)

Cuando se usan piddles en expresiones condicionales (es decir, construcciones "si", "a menos que" y "while")
solo se permiten piddles con exactamente un elemento, p. ej.

$ a = pdl (1,0,0,1);
print "está configurado" si $ a->índice(2);

Tenga en cuenta que los operadores booleanos devuelven en general piddles de varios elementos. Por lo tanto, la
lo siguiente generará un error

imprimir "está bien" si $ a> 3;

ya que "$ a> 3" es un piddle con 4 elementos. Más bien use all o any para probar si todos o algunos de
los elementos cumplen la condición:

imprimir "algunos son> 3" si alguno $ a> 3;
print "no puede tomar logaritmos" a menos que todos $ a> 0;

También hay muchas funciones predefinidas, que se describen en otras páginas de manual. Cheque
PDL :: Índice.

Matrix funciones
'x' es secuestrado como el operador de multiplicación de matrices. por ejemplo, "$ c = $ ax $ b";

perlDL es una fila principal, no una columna principal, por lo que en realidad es "c (i, j) = sum_k a (k, j) b (i, k)" -
pero cuando se imprimen las matrices, los resultados se verán bien. Solo recuerda que los índices son
invertido. p.ej:

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

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

Nota: transponer() hace lo que dice y es una forma conveniente de convertir los vectores de fila en
vectores de columna.

Cómo a escribir a simples función
subproducto punto {
mi ($ a, $ b) = @_;
devolver suma ($ a * $ b);
}
1;

Si se coloca en el archivo dotproduct.pdl se cargará automáticamente si está utilizando PDL :: AutoLoader (consulte
abajo).

Por supuesto, esta función ya está disponible como función interna, consulte PDL :: Primitive.

Tipo Conversión
Predeterminado para pdl () es doble. Las conversiones son:

$ a = flotar ($ b);
$ c = largo ($ d); # "largo" es generalmente un int de 4 bytes
$ d = byte ($ a);

También doble(), corto(), ushort (), indx ().

NOTA: La rutina indx () es un tipo de entero especial que
es el tamaño correcto para un valor de índice PDL (tamaño de dimensión,
índice, u offest) que puede ser de 32 bits (largo) o
Cantidad de 64 bits (larga) dependiendo de si el perl
está construido con soporte de 32 bits o 64 bits.

Estas rutinas también convierten automáticamente las listas de Perl para permitir la práctica abreviatura:

$ a = byte [[1..10], [1..10]]; # Crear matriz de bytes 2D
$ a = flotante [1..1000]; # Crear matriz flotante 1D

etc.

Impresión
Expande automáticamente la matriz en formato N-dimensional:

imprimir $ a;

$ b = "La respuesta es = $ a";

secciones
PDL tiene operadores de corte y corte multidimensionales muy poderosos; ver el
PDL ::rebanadas(3) página de manual para obtener más detalles; describiremos el más importante aquí.

PDL muestra su herencia Perl / C en que las matrices son de compensación cero. Por tanto, una imagen de 100x100 tiene
índices "0..99,0..99". (La convención es que el centro del píxel (0,0) está en las coordenadas
(0.0,0.0). Todas las funciones gráficas de PDL se ajustan a esta definición y ocultan la unidad
compensaciones de, por ejemplo, la biblioteca PGPLOT FORTRAN.

Siguiendo la convención habitual, se muestra la coordenada (0,0) en la parte inferior izquierda cuando
mostrando una imagen. Aparece en la parte superior izquierda cuando se usa "" imprimir $ a "", etc.

El seccionamiento simple usa una extensión de sintaxis para Perl, PDL :: NiceSlice, que le permite
especificar subrangos a través de un modificador de método nulo a un PDL:

$ b = $ a -> ($ x1: $ x2, $ y1: $ y2, ($ z1)); # Tomar subsección

Aquí, $ a es una variable tridimensional, y $ b obtiene un corte plano que está definido por el
limita $ x1, $ x2, $ y1, $ y2, en la ubicación $ z1. El paréntesis alrededor de $ z1 hace que el
índice trivial que debe omitirse; de ​​lo contrario, $ b sería tridimensional con un tercer
dimensión de orden 1.

Puede colocar segmentos de PDL a ambos lados del operador de asignación de elementos ". =", Como
Sun:

# Establecer parte de $ bigimage a valores de $ smallimage
$ imagen grande -> ($ xa: $ xb, $ ya: $ yb). = $ imagen pequeña;

Alguna otra miscelánea:

$ c = nelem ($ a); # Número de píxeles

$ val = at ($ object, $ x, $ y, $ z ...) # Valor de píxel en la posición, como escalar de Perl
$ val = $ objeto-> en ($ x, $ y, $ z ...) # equivalente (sintaxis del método OK)

$ b = xvals ($ a); # Rellenar la matriz con valores de coordenadas X (también yvals (), zvals (),
# axisvals ($ x, $ axis) y rvals () para distancia radial
# desde el centro).

Entrada / Salida
Los módulos "PDL :: IO" implementan varias funciones útiles de formato IO. Seria demasiado
para dar ejemplos de cada uno, pero puede encontrar una buena descripción general en PDL :: IO. Aquí hay una muestra de
algunos de los formatos de E / S admitidos en PDL.

PDL :: IO :: Varios
Rutinas Ascii, FITS y FIGARO / NDF IO.

PDL :: IO :: FastRaw
Usando los tipos de datos sin procesar de su máquina, una IO inportable pero increíblemente rápida
formato. También es compatible con la asignación de memoria para conservar la memoria y obtener más velocidad.

PDL :: IO :: FlexRaw
Formatos generales de datos brutos. Como FastRaw, solo que mejor.

PDL :: IO :: Navegador
Un navegador de Curses para matrices.

PDL :: IO :: Pnm
Soporte de mapa de bits y mapa de píxeles de Portaple.

PDL :: IO :: Imagen
Usando el módulo anterior y netpbm, es posible escribir fácilmente GIF, jpeg
y lo que sea con simples comandos.

Gráficos
La filosofía detrás de perlDL es hacer que funcione con una variedad de gráficos existentes.
bibliotecas, ya que ningún paquete satisfará todas las necesidades y todas las personas y esto permite
uno para trabajar con paquetes que ya conoce y le gusta. Obviamente habrá algunos
superposiciones en funcionalidad y cierta falta de consistencia y uniformidad. Sin embargo esto permite
PDL para mantenerse al día con un campo en rápido desarrollo: los últimos módulos de PDL proporcionan interfaces
a gráficos OpenGL y VRML!

PDL :: Gráficos :: PGPLOT
PGPLOT proporciona una biblioteca simple para gráficos de líneas y visualización de imágenes.

Hay una interfaz fácil para esto en el módulo interno PDL :: Graphics :: PGPLOT, que
rutinas de llamadas en el módulo de nivel superior PGPLOT disponible por separado.

PDL :: Gráficos :: PLplot
PLplot proporciona una biblioteca simple para crear gráficos con múltiples controladores de salida,
incluido un controlador directo a piddle.

Este módulo proporciona funciones de alto y bajo nivel integradas en PLplot. El
Los comandos de bajo nivel son enlaces directos a la interfaz C de PLplot. Lee mas
en PDL :: Graphics :: PLplot.

PDL :: Gráficos :: IIS
A muchos astrónomos les gusta usar SAOimage y Ximtool (o sus derivaciones / clones). Estos
son widgets gratuitos útiles para la inspección y visualización de imágenes. (No son
proporcionado con perlDL pero se puede obtener fácilmente de sus sitios oficiales fuera de la
Red.)

El paquete PDL :: Graphics :: IIS proporciona permite mostrar imágenes en estos ("IIS"
es el nombre de un elemento antiguo de hardware de visualización de imágenes cuyos protocolos estas herramientas
se ajustan a.)

PDL :: Gráficos :: TriD
Vea PDL :: Graphics :: TriD, esta es una colección de rutinas 3D para OpenGL y (pronto)
VRML y otros formatos 3D que permiten trazados 3D de puntos, líneas y superficies desde PDL.

Autocarga
Consulte PDL :: Autocargador. Esto permite que uno cargue automáticamente funciones bajo demanda, de una manera tal vez
familiar para los usuarios de MatLab.

También se pueden escribir extensiones PDL como módulos Perl normales.

PDL conchas
El script de Perl "pdl2" (o "perldl") proporciona una interfaz de línea de comandos simple para PDL. Si
Se han instalado los últimos módulos Readlines / ReadKey "pdl2" detecta esto y habilita
recuperación y edición de la línea de comandos. Consulte la página de manual para obtener más detalles.

p.ej:

% perla
shell perlDL v1.354
PDL viene SIN ABSOLUTAMENTE NINGUNA GARANTÍA. Para obtener más detalles, consulte el archivo
'COPIA' en la distribución PDL. Este es un software gratuito y usted
son bienvenidos a redistribuirlo bajo ciertas condiciones, ver
el mismo archivo para más detalles.
ReadLines, NiceSlice, MultiLines habilitado
Leyendo PDL / default.perldlrc ...
Base de datos de documentos encontrados /home/pdl/dev/lib/perl5/site_perl/PDL/pdldoc.db
Escriba 'ayuda' para obtener ayuda en línea
Escriba 'demo' para demostraciones en línea
PDL cargado v2.4.9_003 (admite valores incorrectos)
pdl> $ x = rfits 'm51.fits'
Leyendo datos IMAGE ...
BITPIX = 32 tamaño = 147456 píxeles
Leyendo 589824 bytes
BSCALE = && BZERO =

pdl> use PDL :: Graphics :: PGPLOT;
pdl> imag $ x
Visualización de imágenes de 384 x 384 de 40 a 761, usando 84 colores (16-99) ...

También puede ejecutarlo desde el depurador de Perl ("perl -MPDL -d -e 1") si lo desea.

Características misceláneas de la carcasa:

p El alias de shell "p" es una forma corta y conveniente de "print", p. ej.

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

Inicialización
Los archivos "~ / .perldlrc"y" local.perldlrc "(en el directorio actual) se obtienen si
fundar. Esto permite al usuario tener un código PDL local y global para el inicio.

Ayuda
Escriba 'ayuda'! Uno puede buscar la documentación PDL y buscar documentación en cualquier
función.

Escapar
Cualquier línea que comience con el carácter "#" se trata como un escape de shell. Este personaje
se puede configurar estableciendo la variable de Perl $ PERLDL_ESCAPE. Esto podría, por ejemplo,
ajustarse en "~ / .perldlrc".

Sobrecarga operadores
Los siguientes operadores y funciones de Perl integrados se han sobrecargado para trabajar en PDL
variables:

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

[Todas las funciones unarias (sin, etc.) pueden usarse con en su lugar() - ver "Memoria" a continuación.]

Orientación a objetos e PerlDL
Las operaciones PDL están disponibles como funciones y métodos. Por tanto, se pueden derivar nuevos tipos de
objeto, para representar clases de datos personalizadas.

Al utilizar la sobrecarga, uno puede hacer que los operadores matemáticos hagan lo que les plazca, y PDL
tiene algunos trucos incorporados que permiten que las funciones PDL existentes funcionen sin cambios, incluso si el
La representación de los datos subyacentes ha cambiado enormemente. Ver PDL :: Objetos

Salud Cerebral personal e referencias
Jugar con matrices de datos realmente enormes puede requerir cierto cuidado. perlDL proporciona muchos
instalaciones que le permiten realizar operaciones en grandes arreglos sin generar copias adicionales
aunque esto requiere un poco más de reflexión y cuidado por parte del programador.

NOTA: En la mayoría de los sistemas, es mejor configurar Perl (durante las opciones de compilación) para
utilice la función del sistema "malloc ()" en lugar de la función incorporada de Perl. Esto se debe a que Perl
uno está optimizado para la velocidad en lugar del consumo de memoria virtual; esto puede resultar en
un factor de dos de mejora en la cantidad de almacenamiento de memoria que puede utilizar. El malloc de Perl
en 5.004 y posteriores tiene una serie de opciones de tiempo de compilación que puede utilizar para ajustar el
comportamiento.

Aritmética simple
Si $ a es una imagen grande (por ejemplo, ocupa 10 MB), entonces el comando

$ a = $ a + 1;

consume otros 10 MB de memoria. Esto se debe a que la expresión "$ a + 1" crea una
copia temporal de $ a para guardar el resultado, luego se asigna una referencia a $ a.
Después de esto, el $ a original se destruye, por lo que no hay permanente pérdida de memoria. Pero en
una máquina pequeña, el crecimiento de la huella de memoria puede ser considerable. Está
obviamente hecho de esta manera, por lo que "$ c = $ a + 1" funciona como se esperaba.

También si uno dice:

$ b = $ a; # $ by $ a ahora apuntan a los mismos datos
$ a = $ a + 1;

Entonces $ by $ a terminan siendo diferentes, como se espera ingenuamente, porque una nueva referencia
se crea y se le asigna $ a.

Sin embargo, si $ a era un gran acaparador de memoria (por ejemplo, un volumen 3D), es posible que crear una copia no
ser algo bueno. Uno puede evitar esta sobrecarga de memoria en el ejemplo anterior diciendo:

$ a ++;

Las operaciones "++, + =, -, - =", etc. todas llaman a una versión especial "in situ" del
subrutina aritmética. Esto significa que no se necesita más memoria; la desventaja de esto es
que si "$ b = $ a" entonces $ b también se incrementa. Para forzar una copia explícitamente:

$ b = pdl $ a; # Copia real

o, alternativamente, quizás mejor estilo:

$ b = $ a-> copiar;

Funciones
La mayoría de las funciones, por ejemplo, "log ()", devuelven un resultado que es una transformación de su
argumento. Esto lo convierte en una buena práctica de programación. Sin embargo, muchas operaciones pueden
hecho "en el lugar" y esto puede ser necesario cuando se utilizan matrices grandes y la memoria está en
un premio. Por estas circunstancias, el operador en su lugar() se proporciona lo que previene
la copia extra y permite modificar el argumento. p.ej:

$ x = log ($ matriz); # $ array no afectado
log (en lugar ($ bigarray)); # $ bigarray cambiado in situ

ADVERTENCIAS:

1. Se aplican las advertencias habituales sobre referencias duplicadas.

2. Obviamente, cuando se utiliza con algunas funciones que no se pueden aplicar in situ (p. Ej.
"convolve ()") ¡pueden ocurrir efectos inesperados! Intentamos indicar "inplace ()" - seguro
funciones en la documentación.

3. Las conversiones de tipos, como "float ()", pueden provocar copias ocultas.

Garantizar mendicidad
Si ha escrito una función simple y no quiere que estalle en su cara si
pasarle un número simple en lugar de una variable PDL. Simplemente llame a la función topdl () first
para que sea seguro. p.ej:

sub myfiddle {my $ pdl = topdl (turno); $ pdl-> fiddle_foo (...); ...}

"topdl ()" NO realiza una copia si se pasa una variable pdl - simplemente falla -
que es obviamente el comportamiento deseado. La rutina, por supuesto, no es necesaria en condiciones normales.
funciones definidas por el usuario que no se preocupan por los componentes internos.

Use PDL :: QuickStartp en línea usando los servicios de onworks.net