funcalc - Online nel cloud

PROGRAMMA:

NOME

funcalc - Calcolatrice Funtools (per tabelle binarie)

SINOSSI

funzione [-n] [-a argstr] [-e expr] [-f file] [-l link] [-p prog] [oname [colonne]]

VERSIONI

-a argstr # argomenti utente da passare al programma compilato
-e expr # espressione funcalc
-f file # file contenente l'espressione funcalc
-l libs # libs da aggiungere al comando link
-n # genera codice generato invece di compilarlo ed eseguirlo
-p prog # genera un programma con nome, nessuna esecuzione
-u # die se una variabile non è dichiarata (non dichiarare automaticamente)

DESCRIZIONE

funzione è un programma di calcolo che permette di costruire espressioni arbitrarie,
compilato ed eseguito su colonne in una tabella Funtools (tabella binaria FITS o evento raw
file). Funziona integrando le espressioni fornite dall'utente in un programma C modello, quindi
compilazione ed esecuzione del programma. funzione le espressioni sono dichiarazioni C, sebbene alcune
sono supportate importanti semplificazioni (come la dichiarazione automatica delle variabili).

funzione le espressioni possono essere specificate in tre modi: sulla riga di comando utilizzando il tasto -e
[espressione] passare, in un file usando il -f [file] switch, o da stdin (se nessuno dei due -e
né -f è specificato). Ovviamente un file contenente funzione le espressioni possono essere lette da
standard.

Ogni invocazione di funzione richiede che un file di tabella Funtools di input sia specificato come
primo argomento della riga di comando. Il file di output della tabella Funtools è il secondo opzionale
discussione. È necessario solo se viene creato un file FITS di output (cioè, nei casi in cui
, il funzione espressione stampa solo valori, non è necessario alcun file di output). Se ingresso e uscita
file sono entrambi specificati, un terzo argomento opzionale può specificare l'elenco di colonne a
attivare (usando FunColumnActivate()). Nota che funzione determina se farlo o meno
generare codice per scrivere un file di output in base alla presenza o assenza di un output
argomento file.

A funzione l'espressione viene eseguita su ogni riga di una tabella e consiste in uno o più C
istruzioni che operano sulle colonne di quella riga (possibilmente utilizzando variabili temporanee).
All'interno di un'espressione, si fa riferimento a una colonna di corrente riga usando la struttura C
sintassi cur-[colname]>, ad es. cur->x, cur->pha, ecc. È possibile definire variabili scalari locali
usando dichiarazioni C all'inizio dell'espressione, altrimenti possono essere definiti
automaticamente da funzione (essere di tipo doppio). Quindi, ad esempio, uno scambio di colonne x
e y in una tabella può essere eseguita utilizzando uno dei seguenti equivalenti funzione
espressioni:

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

o:

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

Quando questa espressione viene eseguita utilizzando un comando come:

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

il file risultante avrà i valori delle colonne x e y scambiati.

Per impostazione predefinita, il tipo di dati della variabile per una colonna è lo stesso del tipo di dati del
colonna come memorizzata nel file. Questo può essere modificato aggiungendo ":[dtype]" al primo
riferimento a quella colonna. Nell'esempio sopra, per forzare x e y a essere emessi come doppi,
specificare esplicitamente il tipo 'D':

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

Gli identificatori del tipo di dati seguono la sintassi della tabella FITS standard per la definizione delle colonne utilizzando TFORM:

· A: caratteri ASCII

· B: carattere a 8 bit senza segno

· I: int 16 a XNUMX bit con segno

· U: int a 16 bit senza segno (non FITS standard)

· J: int a 32 bit con segno

· V: int a 32 bit senza segno (non FITS standard)

· E: float a 32 bit

· D: float a 64 bit

· X: bit (trattato come un array di caratteri)

Nota che solo il primo riferimento a una colonna dovrebbe contenere il tipo di dati esplicito
specificatore.

Ovviamente è importante gestire correttamente il tipo di dati delle colonne. Uno di
causa di errore più frequente in funzione la programmazione è l'uso implicito di dati errati
digitare per una colonna nell'espressione. Ad esempio, il calcolo:

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

di solito deve essere eseguito utilizzando l'aritmetica in virgola mobile. Nei casi in cui x e y
le colonne sono interi, questo può essere fatto leggendo le colonne come doppie usando un esplicito
specificazione del tipo:

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

In alternativa, può essere eseguito utilizzando il casting di tipo C nell'espressione:

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

Oltre ad accedere alle colonne della riga corrente, si può fare riferimento anche al
precedente riga usando pre-[colname]>, e al GENERAZIONE riga usando prossimo-[colnome]>. Notare che
if pre-[colname]> è specificato nel funzione espressione, la prima riga non lo è
elaborato. Se prossimo-[colname]> è specificato nel funzione espressione, l'ultima riga
non viene elaborato. In questo modo, prev ed GENERAZIONE sono garantiti per puntare sempre a righe valide.
Ad esempio, per stampare i valori della colonna x corrente e della colonna y precedente,
usa la funzione C fprintf in a funzione espressione:

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

È possibile specificare nuove colonne utilizzando lo stesso cur-[colname]> sintassi aggiungendo la colonna
type (e identificatori facoltativi tlmin/tlmax/binsiz), separati da due punti. Per esempio,
cur->avg:D definirà una nuova colonna di tipo double. Gli identificatori di tipo sono gli stessi
utilizzato sopra per specificare nuovi tipi di dati per le colonne esistenti.

Ad esempio, per creare ed emettere una nuova colonna che è il valore medio di x e y
colonne, è possibile definire una nuova colonna "media":

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

Nota che il finale ';' non è richiesto per le espressioni a riga singola.

Come con la specifica del tipo di dati FITS TFORM, l'identificatore del tipo di dati della colonna può essere preceduto
da un conteggio numerico per definire un array, ad esempio, "10I" significa un vettore di 10 interi brevi, "2E"
significa due float a precisione singola, ecc. Una nuova colonna deve essere definita solo una volta in a
funzione espressione, dopodiché può essere utilizzata senza specificare nuovamente il tipo. Questo
include il riferimento agli elementi di un array di colonne:

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

Il tipo di dati 'X' (bit) viene trattato come un array di caratteri di dimensione (numeric_count/8), cioè,
16X viene elaborato come un array di caratteri a 2 byte. Ogni elemento dell'array a 8 bit è accessibile separatamente:

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

Qui viene creata una colonna a 16 bit con MSB impostato su 1 e LSB impostato su 2.

Per impostazione predefinita, tutte le righe elaborate vengono scritte nel file di output specificato. Se lo desidera
salta la scrittura di determinate righe, esegui semplicemente l'istruzione C "continua" alla fine del
funzione espressione, poiché la scrittura della riga viene eseguita immediatamente dopo il
l'espressione viene eseguita. Ad esempio, per saltare la scrittura di righe la cui media è uguale a
valore x corrente:

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

Se non viene specificato alcun argomento del file di output in funzione riga di comando, nessun file di output è
aperto e non vengono scritte righe. Questo è utile nelle espressioni che stampano semplicemente l'output
risultati invece di generare un nuovo file:

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);

Nell'esempio sopra, usiamo sia la specificazione esplicita del tipo (per le colonne "av") che type
casting (per le colonne "au") per garantire che tutte le operazioni vengano eseguite in doppio
precisione.

Quando viene specificato un file di output, la tabella di input selezionata viene elaborata e le righe di output
vengono copiati nel file di output. Nota che il file di output può essere specificato come "stdout" in
per scrivere le righe di output nello standard output. Se l'argomento del file di output è
passato, è possibile passare anche un terzo argomento facoltativo per specificare quali colonne elaborare.

In una tabella binaria FITS, a volte è desiderabile copiare tutte le altre estensioni FITS
anche al file di output. Questo può essere fatto aggiungendo un segno '+' al nome del
estensione nel nome del file di input. Vedere divertente per un esempio correlato.

funzione funziona integrando l'espressione specificata dall'utente in un programma C modello
chiamato tabcalc.c. Il programma completato viene quindi compilato ed eseguito. Variabile
dichiarazioni che iniziano il funzione l'espressione è posizionata nella sezione della dichiarazione locale
del programma principale del modello. Tutte le altre righe sono posizionate nel programma principale del modello
ciclo di elaborazione interno. Altri dettagli della generazione del programma vengono gestiti automaticamente. Per
Ad esempio, gli specificatori di colonna vengono analizzati per creare una struttura C per l'elaborazione delle righe, che è
passato a FunColumnSelect() e utilizzato in FunTableRowGet(). Se viene utilizzata una variabile sconosciuta
nell'espressione, risultando in un errore di compilazione, la compilazione del programma viene ritentata dopo
definendo la variabile sconosciuta come di tipo double.

Normalmente, funzione il codice dell'espressione viene aggiunto a funzione ciclo di elaborazione delle righe. È possibile
per aggiungere codice ad altre parti del programma inserendo questo codice all'interno di direttive speciali
del modulo:

[nome della direttiva]
... il codice va qui ...
fine

Le direttive sono:

· globale aggiungi codice e dichiarazioni nello spazio globale, prima della routine principale.

· locale aggiungi dichiarazioni (e codice) subito dopo le dichiarazioni locali in main

· prima aggiungi il codice appena prima di entrare nel ciclo di elaborazione della riga principale

· dopo aggiungi il codice subito dopo essere uscito dal ciclo di elaborazione della riga principale

Pertanto, il seguente funzione espressione dichiarerà variabili globali e creerà subroutine
chiama appena prima e subito dopo il ciclo di elaborazione principale:

globale
doppia v1, v2;
double init(vuoto);
doppia finitura (doppia v);
fine
prima
v1 = inizia();
fine
... righe di processo, con calcoli che utilizzano v1 ...
dopo
v2 = fine (v1);
if( v2 < 0.0 ){
fprintf(stderr, "elaborazione non riuscita %g -> %g\n", v1, v2);
exit(1);
}
fine

Routine come dentro() ed finire() sopra vengono passati al programma generato per il collegamento
usando il -l [collegamento direttive ...] interruttore. La stringa specificata da questo interruttore sarà
aggiunto alla linea di collegamento usata per costruire il programma (prima della libreria funtools). Per
esempio, supponendo che dentro() ed finire() sono nella libreria libmysubs.a nel
/opt/special/lib directory, usa:

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

Gli argomenti utente possono essere passati a un programma funcalc compilato utilizzando un argomento stringa al
"-un interruttore. La stringa dovrebbe contenere tutti gli argomenti dell'utente. Ad esempio, per passare
gli interi 1 e 2, utilizzare:

funcalc -a "1 2" ...

Gli argomenti sono memorizzati in un array interno e vi si accede come stringhe tramite ARGV(n)
macro. Si consideri ad esempio la seguente espressione:

locale
int pmmin, pmax;
fine

prima
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
fine

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

Questa espressione stamperà i valori x, y e pha per tutte le righe in cui il valore pha è
tra i due valori inseriti dall'utente:

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

Si noti che è responsabilità dell'utente assicurarsi che il numero corretto di argomenti
sono passati. La macro ARGV(n) restituisce un NULL se un argomento richiesto è al di fuori dei limiti
del numero effettivo di argomenti, di solito risultando in un SEGV se elaborato alla cieca. Controllare
il conteggio degli argomenti, usa la macro ARGC:

locale
long int seme=1;
doppio limite=0.8;
fine

prima
if( ARGC >= 1 ) seme = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48 (seme);
fine

if ( drand48() > limit ) continua;

La macro WRITE_ROW si espande al FunTableRowPut() chiamata che scrive la riga corrente. Esso
può essere utilizzato per scrivere la riga più di una volta. Inoltre, la macro NROW si espande al
numero di riga attualmente in elaborazione. L'uso di queste due macro è mostrato di seguito
esempio:

if( cur->pha:I == cur->pi:I ) continua;
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;

Se l' -p [programma] switch è specificato, l'espressione non viene eseguita. Piuttosto, il
l'eseguibile generato viene salvato con il nome del programma specificato per un uso successivo.

Se l' -n switch è specificato, l'espressione non viene eseguita. Piuttosto, il codice generato
è scritto su stdout. Questo è particolarmente utile se vuoi generare un file scheletro
e aggiungi il tuo codice, o se hai bisogno di controllare gli errori di compilazione. Nota che il commento
all'inizio dell'output fornisce il comando del compilatore necessario per costruire il programma su quello
piattaforma. (Il comando può cambiare da piattaforma a piattaforma a causa dell'uso di
diverse librerie, opzioni del compilatore, ecc.)

Come menzionato in precedenza, funzione dichiarerà automaticamente una variabile scalare (come a
double) se quella variabile è stata utilizzata ma non dichiarata. Questa struttura è implementata
utilizzando uno script sed denominato funcalc.sed, che elabora l'output del compilatore per rilevare an
errore variabile non dichiarato. Questo script è stato seminato con l'errore appropriato
informazioni per gcc e per cc su piattaforme Solaris, DecAlpha e SGI. Se lo trovi
la dichiarazione automatica degli scalari non funziona sulla tua piattaforma, controlla questo script sed;
potrebbe essere necessario aggiungere o modificare alcuni dei messaggi di errore rilevati.

Al fine di mantenere l'analisi lessicale di funzione espressioni (ragionevolmente) semplici, abbiamo scelto
accettare alcune limitazioni sulla precisione con cui vengono posizionati commenti, spazi e nuove righe in C
nel programma generato. In particolare, i commenti associati alle variabili locali dichiarate
all'inizio di un'espressione (cioè, non in a locale...fine blocco) di solito finisce
nel ciclo interno, non con le dichiarazioni locali:

/* questo commento finirà nel posto sbagliato (es. ciclo interno) */
doppia a; /* anche nel posto sbagliato */
/* questo sarà nel posto giusto (loop interno) */
if( cur->x:D == cur->y:D ) continua; /* anche al posto giusto */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

Allo stesso modo, gli spazi e le nuove righe a volte vengono omessi o aggiunti in modo apparentemente arbitrario
maniera. Ovviamente nessuno di questi inestetismi stilistici pregiudica la correttezza del
codice generato.

Perché funzione deve analizzare l'espressione dell'utente utilizzando i file di dati passati sul
riga di comando, i file di input devono essere aperti e letti due volte: una volta durante il programma
generazione e una volta durante l'esecuzione. Di conseguenza, non è possibile utilizzare stdin per il
file di input: funzione non può essere utilizzato come filtro. Prenderemo in considerazione la rimozione di questa restrizione
più tardi.

Insieme ai commenti C, funzione le espressioni possono avere commenti interni di una riga che sono
non passato al programma C generato. Questi commenti interni iniziano con il #
carattere e continua fino alla nuova riga:

doppia a; # questo non viene passato al file C generato
# né è questo
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* questo commento viene passato al file C */
cur->avg:E = (cur->x+cur->y)/2.0;

Come accennato in precedenza, le colonne di input normalmente sono identificate dal loro utilizzo all'interno
il ciclo di eventi interno. Ci sono rari casi in cui potresti voler leggere una colonna e
elaborarlo al di fuori del ciclo principale. Ad esempio, qsort potrebbe usare una colonna nel suo ordinamento
routine di confronto che non viene elaborata all'interno del ciclo interno (e quindi non
implicitamente specificato come colonna da leggere). Per garantire che tale colonna venga letta dal
ciclo di eventi, usa il esplicito parola chiave. Gli argomenti di questa parola chiave specificano le colonne che
devono essere letti nella struttura del record di input anche se non sono menzionati nel
anello interno. Per esempio:

esplicito pi pha

assicurerà che le colonne pi e pha vengano lette per ogni riga, anche se non lo sono
elaborato nel ciclo di eventi interno. Il esplicito la dichiarazione può essere posizionata ovunque.

Infine, nota quello funzione attualmente lavora su espressioni che coinvolgono tabelle binarie FITS e
file di eventi non elaborati. Prenderemo in considerazione l'aggiunta del supporto per le espressioni dell'immagine in un secondo momento,
se c'è richiesta di tale sostegno da parte della comunità.

Usa funcalc online utilizzando i servizi onworks.net