funcalc - Online en la nube

PROGRAMA:

NOMBRE

funcalc - Calculadora de Funtools (para tablas binarias)

SINOPSIS

funcalc [-n] [-a argstr] [-e expr] [-f archivo] [-l enlace] [-p prog] [oname [columnas]]

CAMPUS

-a argstr # argumentos de usuario para pasar al programa compilado
-e expr # expresión funcalc
-f archivo # archivo que contiene la expresión funcalc
-l libs # libs para agregar al comando de enlace
-n # código generado de salida en lugar de compilar y ejecutar
-p prog # genera un programa con nombre, sin ejecución
-u # muere si alguna variable no está declarada (no la declare automáticamente)

DESCRIPCIÓN

funcalc es un programa de calculadora que permite construir expresiones arbitrarias,
compilado y ejecutado en columnas en una tabla Funtools (FITS tabla binaria o evento sin formato
expediente). Funciona integrando expresiones proporcionadas por el usuario en un programa de plantilla C, luego
compilar y ejecutar el programa. funcalc Las expresiones son declaraciones de C, aunque algunas
Se admiten simplificaciones importantes (como la declaración automática de variables).

funcalc Las expresiones se pueden especificar de tres formas: en la línea de -e
[expresión] cambiar, en un archivo usando el -f [expediente] cambiar, o de stdin (si ninguno -e
ni -f está especificado). Por supuesto, un archivo que contiene funcalc las expresiones se pueden leer desde
entrada estándar

Cada invocación de funcalc requiere que se especifique un archivo de tabla Funtools de entrada como
primer argumento de la línea de comando. El archivo de la tabla Funtools de salida es el segundo opcional
argumento. Solo es necesario si se está creando un archivo FITS de salida (es decir, en los casos en que
las funcalc expresión solo imprime valores, no se necesita ningún archivo de salida). Si entrada y salida
ambos archivos están especificados, un tercer argumento opcional puede especificar la lista de columnas para
activar (usando FunColumnActivate ()) Tenga en cuenta que funcalc determina si se debe o no
generar código para escribir un archivo de salida basado en la presencia o ausencia de una salida
argumento de archivo.

A funcalc expresión se ejecuta en cada fila de una tabla y consta de uno o más C
declaraciones que operan en las columnas de esa fila (posiblemente usando variables temporales).
Dentro de una expresión, se hace referencia a una columna del corriente fila usando la estructura C
sintaxis canalla-[colname]>, por ejemplo, cur-> x, cur-> pha, etc. Se pueden definir variables escalares locales
usando declaraciones C al principio de la expresión, o de lo contrario se pueden definir
automáticamente por funcalc (ser de tipo doble). Así, por ejemplo, un intercambio de columnas x
yy en una tabla se puede realizar utilizando cualquiera de los siguientes equivalentes funcalc
expresiones:

doble temperatura;
temp = cur-> x;
cur-> x = cur-> y;
cur-> y = temp;

o bien:

temp = cur-> x;
cur-> x = cur-> y;
cur-> y = temp;

Cuando esta expresión se ejecuta usando un comando como:

funcalc -f swap.expr itest.ev otest.ev

el archivo resultante tendrá los valores de las columnas xey intercambiadas.

De forma predeterminada, el tipo de datos de la variable para una columna es el mismo que el tipo de datos del
columna almacenada en el archivo. Esto se puede cambiar agregando ": [dtype]" al primer
referencia a esa columna. En el ejemplo anterior, para forzar que xey se generen como dobles,
especificar el tipo 'D' explícitamente:

temp = cur-> x: D;
cur-> x = cur-> y: D;
cur-> y = temp;

Los especificadores de tipo de datos siguen la sintaxis de la tabla FITS estándar para definir columnas usando TFORM:

· A: caracteres ASCII

· B: carácter de 8 bits sin firmar

· I: int firmado de 16 bits

· U: int de 16 bits sin firmar (no FITS estándar)

· J: int de 32 bits con signo

· V: int de 32 bits sin firmar (no FITS estándar)

· E: flotante de 32 bits

· D: flotante de 64 bits

· X: bits (tratados como una matriz de caracteres)

Tenga en cuenta que solo la primera referencia a una columna debe contener el tipo de datos explícito
especificador.

Por supuesto, es importante manejar correctamente el tipo de datos de las columnas. Uno de los
causa más frecuente de error en funcalc La programación es el uso implícito de datos incorrectos.
escriba para una columna en expresión. Por ejemplo, el cálculo:

dx = (cur-> x - cur-> y) / (cur-> x + cur-> y);

por lo general, debe realizarse utilizando aritmética de punto flotante. En los casos en que xey
las columnas son números enteros, esto se puede hacer leyendo las columnas como dobles usando un explícito
especificación de tipo:

dx = (cur-> x: D - cur-> y: D) / (cur-> x + cur-> y);

Alternativamente, se puede hacer usando la conversión de tipo C en la expresión:

dx = ((doble) cur-> x - (doble) cur-> y) / ((doble) cur-> x + (doble) cur-> y);

Además de acceder a las columnas de la fila actual, también se puede hacer referencia al
anterior fila usando anterior[colname]>, y al Next fila usando Siguiente-[colname]>. Tenga en cuenta que
if anterior[colname]> se especifica en el funcalc expresión, la primera fila no es
procesado. Si Siguiente-[colname]> se especifica en el funcalc expresión, la última fila
no se procesa. De este modo, prev y Next están garantizados para apuntar siempre a filas válidas.
Por ejemplo, para imprimir los valores de la columna x actual y la columna y anterior,
utilizar la función C fprintf en un funcalc expresión:

fprintf (salida estándar, "% d% d \ n", cur-> x, anterior-> y);

Se pueden especificar nuevas columnas usando el mismo canalla-[colname]> sintaxis agregando la columna
type (y especificadores opcionales tlmin / tlmax / binsiz), separados por dos puntos. Por ejemplo,
cur-> avg: D definirá una nueva columna de tipo double. Los especificadores de tipo son los mismos que los
utilizado anteriormente para especificar nuevos tipos de datos para las columnas existentes.

Por ejemplo, para crear y generar una nueva columna que sea el valor promedio de x e y
columnas, se puede definir una nueva columna "promedio":

cur-> avg: D = (cur-> x + cur-> y) /2.0

Tenga en cuenta que el ';' final no es necesario para expresiones de una sola línea.

Al igual que con la especificación del tipo de datos FITS TFORM, el especificador del tipo de datos de la columna puede ir precedido
por un recuento numérico para definir una matriz, por ejemplo, "10I" significa un vector de 10 entradas cortas, "2E"
significa dos flotadores de precisión simple, etc. Una nueva columna solo necesita ser definida una vez en un
funcalc expresión, después de lo cual se puede utilizar sin volver a especificar el tipo. Esta
incluye referencia a elementos de una matriz de columnas:

cur-> avg [0]: 2D = (cur-> x + cur-> y) /2.0;
cur-> avg [1] = (cur-> x - cur-> y) /2.0;

El tipo de datos 'X' (bits) se trata como una matriz de caracteres de dimensión (numeric_count / 8), es decir,
16X se procesa como una matriz de caracteres de 2 bytes. Se accede a cada elemento de matriz de 8 bits por separado:

cur-> stat [0]: 16X = 1;
cur-> stat [1] = 2;

Aquí, se crea una columna de 16 bits con el MSB establecido en 1 y el LSB establecido en 2.

De forma predeterminada, todas las filas procesadas se escriben en el archivo de salida especificado. Si quieres
omitir la escritura de ciertas filas, simplemente ejecute la instrucción C "continuar" al final de la
funcalc expresión, ya que la escritura de la fila se realiza inmediatamente después de la
se ejecuta la expresión. Por ejemplo, para omitir la escritura de filas cuyo promedio es el mismo que el
valor x actual:

cur-> avg [0]: 2D = (cur-> x + cur-> y) /2.0;
cur-> avg [1] = (cur-> x - cur-> y) /2.0;
si (cur-> avg [0] == cur-> x)
continuar

Si no se especifica ningún argumento de archivo de salida en el funcalc línea de comando, no hay archivo de salida
abierto y no se escriben filas. Esto es útil en expresiones que simplemente imprimen resultados
resultados en lugar de generar un nuevo archivo:

fpv = (cur->av3:D-cur->av1:D)/(cur->av1+cur->av2:D+cur->av3);
fbv = cur-> av2 / (cur-> av1 + cur-> av2 + cur-> av3);
fpu = ((double)cur->au3-cur->au1)/((double)cur->au1+cur->au2+cur->au3);
fbu = cur-> au2 / (doble) (cur-> au1 + cur-> au2 + cur-> au3);
fprintf (salida estándar, "% f \ t% f \ t% f \ t% f \ n", fpv, fbv, fpu, fbu);

En el ejemplo anterior, usamos tanto la especificación de tipo explícita (para columnas "av") como el tipo
casting (para columnas "au") para garantizar que todas las operaciones se realicen en doble
precisión.

Cuando se especifica un archivo de salida, la tabla de entrada seleccionada se procesa y las filas de salida
se copian en el archivo de salida. Tenga en cuenta que el archivo de salida se puede especificar como "stdout" en
para escribir las filas de salida en la salida estándar. Si el argumento del archivo de salida es
pasado, también se puede pasar un tercer argumento opcional para especificar qué columnas procesar.

En una tabla binaria FITS, a veces es conveniente copiar todas las demás extensiones FITS
al archivo de salida también. Esto se puede hacer agregando un signo '+' al nombre del
extensión en el nombre del archivo de entrada. Ver divertido para un ejemplo relacionado.

funcalc funciona integrando la expresión especificada por el usuario en un programa de plantilla C
llamado tabcalc.c. A continuación, se compila y ejecuta el programa completo. Variable
declaraciones que comienzan el funcalc las expresiones se colocan en la sección de declaración local
del programa principal de la plantilla. Todas las demás líneas se colocan en el programa principal de la plantilla.
bucle de procesamiento interno. Otros detalles de la generación de programas se manejan automáticamente. Para
ejemplo, los especificadores de columna se analizan para construir una estructura C para procesar filas, que es
pasó a FunColumnSelect () y usado en FunTableRowGet (). Si se usa una variable desconocida
en la expresión, lo que da como resultado un error de compilación, la compilación del programa se reintenta después
definiendo que la variable desconocida sea de tipo double.

Normalmente, funcalc el código de expresión se agrega a funcalc bucle de procesamiento de filas. Es posible
para agregar código a otras partes del programa colocando este código dentro de directivas especiales
de la forma:

[nombre de la directiva]
... el código va aquí ...
final

Las directivas son:

· global agregue código y declaraciones en el espacio global, antes de la rutina principal.

· local agregue declaraciones (y código) justo después de las declaraciones locales en main

· antes agregue el código justo antes de ingresar al ciclo de procesamiento de la fila principal

· después de agregue código justo después de salir del ciclo de procesamiento de la fila principal

Por lo tanto, lo siguiente funcalc expresión declarará variables globales y hará subrutina
llamadas justo antes y después del ciclo de procesamiento principal:

global
doble v1, v2;
doble inicio (vacío);
doble acabado (doble v);
final
antes
v1 = init ();
final
... procesar filas, con cálculos usando v1 ...
después de
v2 = terminar (v1);
si (v2 <0.0) {
fprintf (stderr, "el procesamiento falló% g ->% g \ n", v1, v2);
salida(1);
}
final

Rutinas como en eso() y terminar() anteriores se pasan al programa generado para vincular
usando el -l [Enlace directivas ...] cambiar. La cadena especificada por este conmutador será
agregado a la línea de enlace utilizada para construir el programa (antes de la biblioteca funtools). Para
ejemplo, asumiendo que en eso() y terminar() están en la biblioteca libmysubs.a en el
/ opt / special / lib directorio, use:

funcalc -l "-L / opt / special / lib -lmysubs" ...

Los argumentos de usuario se pueden pasar a un programa funcalc compilado usando un argumento de cadena al
"-Un interruptor. La cadena debe contener todos los argumentos del usuario. Por ejemplo, para pasar
los enteros 1 y 2, use:

funcalc -a "1 2" ...

Los argumentos se almacenan en una matriz interna y se accede a ellos como cadenas a través de ARGV (n)
macro. Por ejemplo, considere la siguiente expresión:

local
int pmín, pmáx;
final

antes
pmin = atoi (ARGV(0));
pmax = atoi (ARGV(1));
final

si ((cur-> pha> = pmin) && (cur-> pha <= pmax))
fprintf (stderr, "% d% d% d \ n", cur-> x, cur-> y, cur-> pha);

Esta expresión imprimirá los valores x, y y pha para todas las filas en las que el valor pha es
entre los dos valores de entrada del usuario:

funcalc -a '1 12' -f foo snr.ev '[cir 512 512 .1]'
512 512 6
512 512 8
512 512 5
512 512 5
512 512 8

funcalc -a '5 6' -f foo snr.ev '[cir 512 512 .1]'
512 512 6
512 512 5
512 512 5

Tenga en cuenta que es responsabilidad del usuario asegurarse de que el número correcto de argumentos
se pasan. La macro ARGV (n) devuelve un NULL si un argumento solicitado está fuera de los límites
del número real de argumentos, lo que generalmente da como resultado una SEGV si se procesa a ciegas. Verificar
el recuento de argumentos, use la macro ARGC:

local
long int semilla = 1;
doble límite = 0.8;
final

antes
si (ARGC> = 1) semilla = atol (ARGV(0));
si (ARGC> = 2) límite = atof (ARGV(1));
srand48 (semilla);
final

si (drand48 ()> límite) continuar;

La macro WRITE_ROW se expande al FunTableRowPut () llamada que escribe la fila actual. Eso
se puede utilizar para escribir la fila más de una vez. Además, la macro NROW se expande al
número de fila que se está procesando actualmente. El uso de estas dos macros se muestra a continuación.
ejemplo:

if (cur-> pha: I == cur-> pi: I) continuar;
a = cur-> pha;
cur-> pha = cur-> pi;
cur-> pi = a;
cur-> AVG: E = (cur-> pha + cur-> pi) /2.0;
cur-> NR: I = NROW;
si (NROW <10) WRITE_ROW;

Si -p [progreso] se especifica el modificador, la expresión no se ejecuta. Más bien, el
El ejecutable generado se guarda con el nombre del programa especificado para su uso posterior.

Si -n se especifica el modificador, la expresión no se ejecuta. Más bien, el código generado
se escribe en stdout. Esto es especialmente útil si desea generar un archivo de esqueleto
y agregue su propio código, o si necesita verificar errores de compilación. Tenga en cuenta que el comentario
al comienzo de la salida da el comando del compilador necesario para construir el programa en ese
plataforma. (El comando puede cambiar de una plataforma a otra debido al uso de
diferentes bibliotecas, conmutadores de compilador, etc.)

Como se mencionó previamente, funcalc declarará una variable escalar automáticamente (como
double) si esa variable se ha utilizado pero no se ha declarado. Esta facilidad está implementada
usando un script sed llamado funcalc.sed, que procesa la salida del compilador para detectar un
error de variable no declarado. Esta secuencia de comandos se ha sembrado con el error correspondiente.
información para gcc y cc en las plataformas Solaris, DecAlpha y SGI. Si encuentras eso
la declaración automática de escalares no funciona en su plataforma, consulte este script sed;
puede ser necesario agregar o editar algunos de los mensajes de error que detecta.

Para mantener el análisis léxico de funcalc expresiones (razonablemente) simples, elegimos
Aceptar algunas limitaciones sobre la precisión con la que se colocan los comentarios, espacios y líneas nuevas en C
en el programa generado. En particular, los comentarios asociados con las variables locales declaradas
al comienzo de una expresión (es decir, no en una local ... final bloque) generalmente terminará
en el bucle interno, no con las declaraciones locales:

/ * este comentario terminará en el lugar equivocado (es decir, bucle interno) * /
doble a; / * también en el lugar equivocado * /
/ * esto estará en el lugar correcto (bucle interno) * /
si (cur-> x: D == cur-> y: D) continuar; / * también en el lugar correcto * /
a = cur-> x;
cur-> x = cur-> y;
cur-> y = a;
cur-> avg: E = (cur-> x + cur-> y) /2.0;

De manera similar, los espacios y las nuevas líneas a veces se omiten o se agregan de una manera aparentemente arbitraria.
conducta. Por supuesto, ninguna de estas imperfecciones estilísticas afecta la corrección de la
código generado.

Gracias funcalc debe analizar la expresión del usuario utilizando los archivos de datos pasados ​​en el
línea de comando, los archivos de entrada deben abrirse y leerse dos veces: una vez durante el programa
generación y una vez durante la ejecución. Como resultado, no es posible utilizar stdin para el
fichero de entrada: funcalc no se puede utilizar como filtro. Consideraremos eliminar esta restricción
en otro momento.

Junto con los comentarios de C, funcalc Las expresiones pueden tener comentarios internos de una línea que son
no se pasa al programa C generado. Estos comentarios internos comienzan con el #
carácter y continúe hasta la nueva línea:

doble a; # esto no se pasa al archivo C generado
# ni es esto
a = cur-> x;
cur-> x = cur-> y;
cur-> y = a;
/ * este comentario se pasa al archivo C * /
cur-> avg: E = (cur-> x + cur-> y) /2.0;

Como se mencionó anteriormente, las columnas de entrada normalmente se identifican por su uso dentro
el bucle de eventos interno. Hay casos raros en los que es posible que desee leer una columna y
procesarlo fuera del bucle principal. Por ejemplo, qsort podría usar una columna en su orden
rutina de comparación que no se procesa dentro del bucle interno (y por lo tanto no
implícitamente especificado como una columna a leer). Para asegurarse de que dicha columna sea leída por el
bucle de eventos, use el explícito palabra clave. Los argumentos de esta palabra clave especifican columnas que
deben leerse en la estructura del registro de entrada aunque no se mencionen en la
bucle interior. Por ejemplo:

pi pha explícito

se asegurará de que las columnas pi y pha se lean para cada fila, incluso si no son
procesado en el bucle de eventos interno. los explícito La declaración se puede colocar en cualquier lugar.

Finalmente, tenga en cuenta que funcalc actualmente trabaja en expresiones que involucran tablas binarias FITS y
archivos de eventos sin procesar. Consideraremos agregar soporte para expresiones de imagen en un momento posterior,
si existe demanda de dicho apoyo por parte de la comunidad.

Use funcalc en línea usando los servicios de onworks.net