funcalc - En ligne dans le Cloud

PROGRAMME:

Nom

funcalc - Calculatrice Funtools (pour les tables binaires)

SYNOPSIS

funcalc [-n] [-a strarg] [-e expr] [-f fichier] [-l lien] [-p prog] [oname [colonnes]]

OPTIONS

-a argstr # arguments utilisateur à passer au programme compilé
-e expr # expression funcalc
-f fichier # fichier contenant l'expression funcalc
-l libs # libs à ajouter à la commande de lien
-n # produit le code généré au lieu de le compiler et de l'exécuter
-p prog # génère un programme nommé, pas d'exécution
-u # die si une variable n'est pas déclarée (ne pas déclarer automatiquement)

DESCRIPTION

funcalc est un programme de calculatrice qui permet de construire des expressions arbitraires,
compilé et exécuté sur les colonnes d'une table Funtools (table binaire FITS ou événement brut
déposer). Cela fonctionne en intégrant des expressions fournies par l'utilisateur dans un programme C modèle, puis
compiler et exécuter le programme. funcalc expressions sont des instructions C, bien que certaines
des simplifications importantes (telles que la déclaration automatique de variables) sont prises en charge.

funcalc les expressions peuvent être spécifiées de trois manières : sur la ligne de commande en utilisant le -e
[expression] switch, dans un fichier utilisant le -f [fichier] switch, ou de stdin (si ni l'un ni l'autre -e
ni -f est spécifié). Bien entendu un fichier contenant funcalc les expressions peuvent être lues à partir de
stdin.

Chaque invocation de funcalc nécessite qu'un fichier de table Funtools d'entrée soit spécifié comme
premier argument de la ligne de commande. Le fichier de sortie de la table Funtools est le deuxième facultatif
argument. Il n'est nécessaire que si un fichier FITS de sortie est en cours de création (c'est-à-dire dans les cas où
le funcalc expression n'imprime que les valeurs, aucun fichier de sortie n'est nécessaire). Si entrée et sortie
fichier sont tous deux spécifiés, un troisième argument facultatif peut spécifier la liste des colonnes à
activer (à l'aide FunColumnActivate()). Notez que funcalc détermine s'il faut ou non
générer du code pour écrire un fichier de sortie basé sur la présence ou l'absence d'une sortie
argument de fichier.

A funcalc expression s'exécute sur chaque ligne d'une table et se compose d'un ou plusieurs C
instructions qui opèrent sur les colonnes de cette ligne (éventuellement en utilisant des variables temporaires).
Dans une expression, il est fait référence à une colonne du actuel ligne en utilisant la structure C
syntaxe cur-[colname]>, par exemple cur->x, cur->pha, etc. Des variables scalaires locales peuvent être définies
en utilisant des déclarations C au tout début de l'expression, ou bien elles peuvent être définies
automatiquement par funcalc (être de type double). Ainsi, par exemple, un échange de colonnes x
et y dans un tableau peut être effectué en utilisant l'un des équivalents suivants funcalc
expressions:

double température ;
temp = cur->x;
cur->x = cur->y;
cur->y = temp;

ou:

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

Lorsque cette expression est exécutée à l'aide d'une commande telle que :

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

le fichier résultant aura les valeurs des colonnes x et y échangées.

Par défaut, le type de données de la variable pour une colonne est le même que le type de données de la
colonne telle qu'elle est stockée dans le fichier. Cela peut être modifié en ajoutant ":[dtype]" au premier
référence à cette colonne. Dans l'exemple ci-dessus, pour forcer x et y à être affichés en double,
spécifiez explicitement le type 'D' :

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

Les spécificateurs de type de données suivent la syntaxe de table FITS standard pour définir les colonnes à l'aide de TFORM :

· A : caractères ASCII

· B : caractère 8 bits non signé

· I : int 16 bits signé

· U : int 16 bits non signé (pas FITS standard)

· J : int 32 bits signé

· V : int 32 bits non signé (pas FITS standard)

· E : flottant 32 bits

· D : flottant 64 bits

· X : bits (traités comme un tableau de caractères)

Notez que seule la première référence à une colonne doit contenir le type de données explicite
spécificateur.

Bien entendu, il est important de gérer correctement le type de données des colonnes. Un de
cause d'erreur la plus fréquente dans funcalc la programmation est l'utilisation implicite de données erronées
type pour une colonne dans l'expression. Par exemple, le calcul :

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

doit généralement être effectué à l'aide de l'arithmétique à virgule flottante. Dans les cas où x et y
les colonnes sont des entiers, cela peut être fait en lisant les colonnes comme des doubles à l'aide d'un
spécification de type :

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

Alternativement, cela peut être fait en utilisant le transtypage C dans l'expression :

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

En plus d'accéder aux colonnes de la ligne actuelle, il est également possible de faire référence à la
précédent ligne à l'aide préc-[colname]>, et au next ligne à l'aide Suivant-[nom de la colonne]>. Noter que
if préc-[colname]> est spécifié dans le funcalc expression, la toute première ligne n'est pas
traité. Si Suivant-[colname]> est spécifié dans le funcalc expression, la toute dernière ligne
n'est pas traité. De cette façon, actu ainsi que next sont garantis de toujours pointer vers des lignes valides.
Par exemple, pour imprimer les valeurs de la colonne x actuelle et de la colonne y précédente,
utiliser la fonction C fprintf dans un funcalc expression:

fprintf(stdout, "%d %d\n", cur->x, prev->y);

De nouvelles colonnes peuvent être spécifiées en utilisant le même cur-[colname]> syntaxe en ajoutant la colonne
type (et les spécificateurs facultatifs tlmin/tlmax/binsiz), séparés par des deux-points. Par exemple,
cur->avg:D définira une nouvelle colonne de type double. Les spécificateurs de type sont les mêmes que ceux
utilisé ci-dessus pour spécifier de nouveaux types de données pour les colonnes existantes.

Par exemple, pour créer et sortir une nouvelle colonne qui est la valeur moyenne de x et y
colonnes, une nouvelle colonne "avg" peut être définie :

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

Notez que le ';' final n'est pas requis pour les expressions sur une seule ligne.

Comme avec la spécification de type de données FITS TFORM, le spécificateur de type de données de colonne peut être précédé
par un nombre numérique pour définir un tableau, par exemple, "10I" signifie un vecteur de 10 ints courts, "2E"
signifie deux flottants simple précision, etc. Une nouvelle colonne n'a besoin d'être définie qu'une seule fois dans un
funcalc expression, après quoi elle peut être utilisée sans re-spécifier le type. Cette
inclut une référence aux éléments d'un tableau de colonnes :

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

Le type de données 'X' (bits) est traité comme un tableau de caractères de dimension (numeric_count/8), c'est-à-dire
16X est traité comme un tableau de caractères de 2 octets. Chaque élément du tableau 8 bits est accessible séparément :

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

Ici, une colonne de 16 bits est créée avec le MSB défini sur 1 et le LSB défini sur 2.

Par défaut, toutes les lignes traitées sont écrites dans le fichier de sortie spécifié. Si tu veux
sauter l'écriture de certaines lignes, exécutez simplement l'instruction C "continue" à la fin de la
funcalc expression, puisque l'écriture de la ligne est effectuée immédiatement après la
expression est exécutée. Par exemple, pour ignorer l'écriture de lignes dont la moyenne est la même que la
valeur x actuelle :

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

Si aucun argument de fichier de sortie n'est spécifié sur le funcalc ligne de commande, aucun fichier de sortie n'est
ouvert et aucune ligne n'est écrite. Ceci est utile dans les expressions qui impriment simplement la sortie
résultats au lieu de générer un nouveau fichier :

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/(double)(cur->au1+cur->au2+cur->au3) ;
fprintf(stdout, "%f\t%f\t%f\t%f\n", fpv, fbv, fpu, fbu);

Dans l'exemple ci-dessus, nous utilisons à la fois une spécification de type explicite (pour les colonnes "av") et un type
casting (pour les colonnes "au") pour s'assurer que toutes les opérations sont effectuées en double
précision.

Lorsqu'un fichier de sortie est spécifié, la table d'entrée sélectionnée est traitée et les lignes de sortie
sont copiés dans le fichier de sortie. Notez que le fichier de sortie peut être spécifié comme "stdout" dans
afin d'écrire les lignes de sortie sur la sortie standard. Si l'argument du fichier de sortie est
passé, un troisième argument facultatif peut également être passé pour spécifier les colonnes à traiter.

Dans une table binaire FITS, il est parfois souhaitable de copier toutes les autres extensions FITS
également dans le fichier de sortie. Cela peut être fait en ajoutant un signe '+' au nom du
extension dans le nom du fichier d'entrée. Voir table amusante pour un exemple connexe.

funcalc fonctionne en intégrant l'expression spécifiée par l'utilisateur dans un modèle de programme C
appelé tabcalc.c. Le programme terminé est ensuite compilé et exécuté. Variable
déclarations qui commencent le funcalc expression sont placés dans la section de déclaration locale
du programme principal modèle. Toutes les autres lignes sont placées dans le programme principal du modèle
boucle de traitement interne. Les autres détails de la génération du programme sont gérés automatiquement. Pour
exemple, les spécificateurs de colonne sont analysés pour créer une structure C pour le traitement des lignes, qui est
transmis à FunColumnSelect() et utilisé dans FunTableRowGet(). Si une variable inconnue est utilisée
dans l'expression, entraînant une erreur de compilation, la construction du programme est réessayée après
définissant la variable inconnue comme étant de type double.

Normalement, funcalc le code d'expression est ajouté à funcalc boucle de traitement des lignes. C'est possible
pour ajouter du code à d'autres parties du programme en plaçant ce code dans des directives spéciales
de la forme:

[nom de la directive]
... le code va ici ...
fin

Les directives sont :

· de défis ajouter du code et des déclarations dans l'espace global, avant la routine principale.

· locales ajouter des déclarations (et du code) juste après les déclarations locales dans main

· before ajouter du code juste avant d'entrer dans la boucle de traitement de la ligne principale

· après ajouter du code juste après avoir quitté la boucle de traitement de la ligne principale

Ainsi, ce qui suit funcalc expression déclarera des variables globales et créera un sous-programme
appelle juste avant et juste après la boucle de traitement principale :

de défis
double v1, v2 ;
double init (void);
double finition (double v);
fin
before
v1 = init();
fin
... traiter les lignes, avec des calculs utilisant v1 ...
après
v2 = terminer(v1) ;
si( v2 < 0.0 ){
fprintf(stderr, "échec du traitement %g -> %g\n", v1, v2) ;
sortie(1);
}
fin

Des routines telles que init () ainsi que terminer() ci-dessus sont passés au programme généré pour la liaison
utilisant l' -l [relier directives ...] changer. La chaîne spécifiée par ce commutateur sera
ajouté à la ligne de lien utilisée pour construire le programme (avant la bibliothèque funtools). Pour
exemple, en supposant que init () ainsi que terminer() sont dans la bibliothèque libmysubs.a dans le
répertoire /opt/special/lib, utilisez :

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

Les arguments utilisateur peuvent être passés à un programme funcalc compilé en utilisant un argument de chaîne au
"-un interrupteur. La chaîne doit contenir tous les arguments utilisateur. Par exemple, pour passer
les entiers 1 et 2, utilisez :

funcalc -a "1 2" ...

Les arguments sont stockés dans un tableau interne et sont accessibles sous forme de chaînes via l'ARGV(n)
macro. Par exemple, considérons l'expression suivante :

locales
entier pmin, pmax ;
fin

before
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
fin

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

Cette expression imprimera les valeurs x, y et pha pour toutes les lignes dans lesquelles la valeur pha est
entre les deux valeurs saisies par l'utilisateur :

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

Notez qu'il est de la responsabilité de l'utilisateur de s'assurer que le nombre correct d'arguments
sont passés. La macro ARGV(n) renvoie un NULL si un argument demandé est en dehors des limites
du nombre réel d'arguments, résultant généralement en un SEGV s'il est traité à l'aveugle. Vérifier
le nombre d'arguments, utilisez la macro ARGC :

locales
long int graine=1 ;
double limite=0.8 ;
fin

before
if( ARGC >= 1 ) graine = atol(ARGV(0));
if( ARGC >= 2 ) limite = atof(ARGV(1));
srand48 (graine);
fin

if ( drand48() > limit ) continuez ;

La macro WRITE_ROW s'étend au FunTableRowPut() appel qui écrit la ligne actuelle. Ce
peut être utilisé pour écrire la ligne plus d'une fois. De plus, la macro NROW s'étend au
numéro de ligne en cours de traitement. L'utilisation de ces deux macros est illustrée ci-dessous.
Exemple:

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

Si la -p [programme] switch est spécifié, l'expression n'est pas exécutée. Au contraire, le
l'exécutable généré est enregistré avec le nom de programme spécifié pour une utilisation ultérieure.

Si la -n switch est spécifié, l'expression n'est pas exécutée. Au contraire, le code généré
est écrit sur stdout. Ceci est particulièrement utile si vous souhaitez générer un fichier squelette
et ajoutez votre propre code, ou si vous devez vérifier les erreurs de compilation. Notez que le commentaire
au début de la sortie donne la commande du compilateur nécessaire pour construire le programme sur cela
Plate-forme. (La commande peut changer de plate-forme en plate-forme en raison de l'utilisation de
différentes bibliothèques, commutateurs de compilateur, etc.)

Comme mentionné précédemment, funcalc déclarera automatiquement une variable scalaire (en tant que
double) si cette variable a été utilisée mais non déclarée. Cette installation est mise en œuvre
en utilisant un script sed nommé funcalc.sed, qui traite la sortie du compilateur pour détecter un
erreur de variable non déclarée. Ce script a été ensemencé avec l'erreur appropriée
informations pour gcc et pour cc sur les plates-formes Solaris, DecAlpha et SGI. Si tu trouves ça
la déclaration automatique des scalaires ne fonctionne pas sur votre plate-forme, vérifiez ce script sed ;
il peut être nécessaire d'ajouter ou de modifier certains des messages d'erreur qu'il détecte.

Afin de conserver l'analyse lexicale de funcalc expressions (raisonnablement) simples, nous avons choisi
accepter certaines limitations sur la précision avec laquelle les commentaires C, les espaces et les nouvelles lignes sont placés
dans le programme généré. En particulier, les commentaires associés aux variables locales déclarées
au début d'une expression (c'est-à-dire pas dans un local...fin bloc) finira généralement par
dans la boucle interne, pas avec les déclarations locales :

/* ce commentaire finira au mauvais endroit (c'est-à-dire dans la boucle interne) */
Double A; /* aussi au mauvais endroit */
/* ce sera au bon endroit (boucle interne) */
if( cur->x:D == cur->y:D ) continue ; /* aussi au bon endroit */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->moy:E = (cur->x+cur->y)/2.0;

De même, les espaces et les nouvelles lignes sont parfois omis ou ajoutés de manière apparemment arbitraire.
manière. Bien entendu, aucun de ces défauts stylistiques n'affecte l'exactitude de la
code généré.

Parce que funcalc doit analyser l'expression de l'utilisateur à l'aide du ou des fichiers de données transmis au
ligne de commande, le ou les fichiers d'entrée doivent être ouverts et lus deux fois : une fois pendant le programme
génération et une fois pendant l'exécution. Par conséquent, il n'est pas possible d'utiliser stdin pour le
fichier d'entrée : funcalc ne peut pas être utilisé comme filtre. Nous envisagerons de supprimer cette restriction
à un moment ultérieur.

Avec les commentaires C, funcalc les expressions peuvent avoir des commentaires internes d'une ligne qui sont
pas transmis au programme C généré. Ces commentaires internes commencent par le #
caractère et continuez jusqu'à la nouvelle ligne :

Double A; # ceci n'est pas transmis au fichier C généré
# ce n'est pas non plus
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* ce commentaire est passé au fichier C */
cur->moy:E = (cur->x+cur->y)/2.0;

Comme mentionné précédemment, les colonnes d'entrée sont normalement identifiées par leur utilisation dans
la boucle d'événement interne. Il existe de rares cas où vous voudrez peut-être lire une colonne et
le traiter en dehors de la boucle principale. Par exemple, qsort peut utiliser une colonne dans son tri
routine de comparaison qui n'est pas traitée à l'intérieur de la boucle interne (et donc pas
implicitement spécifié comme une colonne à lire). Pour s'assurer qu'une telle colonne est lue par le
boucle d'événement, utilisez le explicite mot-clé. Les arguments de ce mot-clé spécifient les colonnes qui
doivent être lus dans la structure d'enregistrement d'entrée même s'ils ne sont pas mentionnés dans le
Boucle intérieure. Par exemple:

explicite pi pha

garantira que les colonnes pi et pha sont lues pour chaque ligne, même si elles ne le sont pas
traité dans la boucle d'événement interne. Les explicite la déclaration peut être placée n'importe où.

Enfin, notez que funcalc travaille actuellement sur des expressions impliquant des tables binaires FITS et
fichiers d'événements bruts. Nous envisagerons d'ajouter la prise en charge des expressions d'image à un stade ultérieur,
s'il y a une demande pour un tel soutien de la part de la communauté.

Utilisez funcalc en ligne en utilisant les services onworks.net