funcalc - Online în cloud

PROGRAM:

NUME

funcalc - Calculator Funtools (pentru tabele binare)

REZUMAT

funcalc [-n] [-a argstr] [-e expr] [-f fișier] [-l link] [-p prog] [oname [coloane]]

OPŢIUNI

-a argstr # argumente utilizator de transmis programului compilat
-e expr # expresie funcalc
-f fișier # fișier care conține expresia funcalc
-l libs # libs de adăugat la comanda link
-n # scoate codul generat în loc de compilare și execuție
-p prog # genera program numit, fără execuție
-u # mor dacă orice variabilă este nedeclarată (nu declara automat)

DESCRIERE

funcalc este un program de calculator care permite construirea de expresii arbitrare,
compilat și executat pe coloane dintr-un tabel Funtools (tabel binar FITS sau eveniment brut
fişier). Funcționează prin integrarea expresiilor furnizate de utilizator într-un program șablon C, apoi
compilarea si executarea programului. funcalc expresiile sunt declarații C, deși unele
sunt acceptate simplificări importante (cum ar fi declararea automată a variabilelor).

funcalc expresiile pot fi specificate în trei moduri: pe linia de comandă folosind -e
[expresie] comutator, într-un fișier folosind -f [fişier] comutator sau de la stdin (dacă niciunul -e
nici -f este specificat). Desigur, un fișier care conține funcalc din se pot citi expresii
stdin.

Fiecare invocare a funcalc necesită ca un fișier de tabel Funtools de intrare să fie specificat ca
primul argument de linie de comandă. Fișierul tabel Funtools de ieșire este al doilea opțional
argument. Este necesar numai dacă este creat un fișier FITS de ieșire (adică, în cazurile în care
il funcalc expresia imprimă doar valori, nu este necesar niciun fișier de ieșire). Dacă intrare și ieșire
ambele sunt specificate, un al treilea argument opțional poate specifica lista de coloane către
activați (folosind FunColumnActivate()). Rețineți că funcalc determină dacă să fie sau nu
genera cod pentru scrierea unui fișier de ieșire pe baza prezenței sau absenței unei ieșiri
argument de fișier.

A funcalc expresia se execută pe fiecare rând al unui tabel și constă din unul sau mai multe C
instrucțiuni care operează pe coloanele acelui rând (eventual folosind variabile temporare).
În cadrul unei expresii, se face referire la o coloană din curent rând folosind structura C
sintaxă cur-[colname]>, de exemplu cur->x, cur->pha, etc. Pot fi definite variabile scalare locale
folosind declarații C chiar la începutul expresiei, sau pot fi definite
automat de către funcalc (sa fie de tip dublu). Astfel, de exemplu, un schimb de coloane x
iar y într-un tabel poate fi realizat folosind oricare dintre următoarele echivalente funcalc
expresii:

temperatură dublă;
temp = cur->x;
cur->x = cur->y;
cur->y = temp;

sau:

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

Când această expresie este executată folosind o comandă precum:

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

fișierul rezultat va avea valorile coloanelor x și y schimbate.

În mod implicit, tipul de date al variabilei pentru o coloană este același cu tipul de date al
coloana așa cum este stocată în fișier. Acest lucru poate fi modificat prin adăugarea „:[dtype]” la primul
referire la acea coloană. În exemplul de mai sus, pentru a forța x și y să fie scoase ca duble,
specificați în mod explicit tipul „D”:

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

Specificatorii tipului de date urmează sintaxa standard de tabel FITS pentru definirea coloanelor folosind TFORM:

· A: caractere ASCII

· B: caracter nesemnat pe 8 biți

· I: semnat int pe 16 biți

· U: int pe 16 biți nesemnat (nu FITS standard)

· J: semnat int pe 32 de biți

· V: int pe 32 de biți nesemnat (nu FITS standard)

· E: float pe 32 de biți

· D: float pe 64 de biți

· X: biți (tratați ca o matrice de caractere)

Rețineți că numai prima referință la o coloană ar trebui să conțină tipul de date explicit
specificatorul.

Desigur, este important să gestionați corect tipul de date al coloanelor. Unul dintre
cea mai frecventă cauză de eroare în funcalc programarea este utilizarea implicită a datelor greșite
tastați pentru o coloană în expresie. De exemplu, calculul:

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

de obicei, trebuie efectuată folosind aritmetica în virgulă mobilă. În cazurile în care x și y
coloanele sunt numere întregi, acest lucru se poate face citind coloanele ca duble folosind un explicit
specificație tip:

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

Alternativ, se poate face folosind C type-casting în expresia:

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

Pe lângă accesarea coloanelor din rândul curent, se poate face referire și la
precedent rând folosind anterior-[colname]>, iar la următor rând folosind Următorul-[colname]>. Rețineți că
if anterior-[colname]> este specificat în funcalc expresie, chiar primul rând nu este
prelucrate. Dacă Următorul-[colname]> este specificat în funcalc expresie, ultimul rând
nu este procesat. În acest fel, precedentă și următor sunt garantate că indică întotdeauna către rânduri valide.
De exemplu, pentru a tipări valorile coloanei x curente și ale coloanei anterioare y,
utilizați funcția C fprintf în a funcalc expresie:

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

Pot fi specificate coloane noi folosind același lucru cur-[colname]> sintaxă prin adăugarea coloanei
tip (și specificatorii opționali tlmin/tlmax/binsiz), separate prin două puncte. De exemplu,
cur->avg:D va defini o nouă coloană de tip double. Specificatorii de tip sunt aceiași
folosit mai sus pentru a specifica noi tipuri de date pentru coloanele existente.

De exemplu, pentru a crea și scoate o coloană nouă care este valoarea medie a x și y
coloane, o nouă coloană „avg” poate fi definită:

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

Rețineți că finalul „;” nu este necesar pentru expresiile cu o singură linie.

Ca și în cazul specificației tipului de date FITS TFORM, specificatorul tipului de date al coloanei poate fi precedat
printr-o numărătoare numerică pentru a defini o matrice, de exemplu, „10I” înseamnă un vector de 10 inți scurti, „2E”
înseamnă două flotoare simple de precizie etc. O coloană nouă trebuie definită o singură dată la a
funcalc expresie, după care poate fi folosită fără a respecifica tipul. Acest
include referință la elementele unui tablou de coloane:

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

Tipul de date „X” (biți) este tratat ca o matrice char de dimensiune (numeric_count/8), adică,
16X este procesat ca o matrice de caractere de 2 octeți. Fiecare element de matrice de 8 biți este accesat separat:

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

Aici, o coloană de 16 biți este creată cu MSB setat la 1 și LSB setat la 2.

În mod implicit, toate rândurile procesate sunt scrise în fișierul de ieșire specificat. Dacă doriți să
sări peste scrierea anumitor rânduri, pur și simplu executați instrucțiunea C „continue” la sfârșitul textului
funcalc expresie, deoarece scrierea rândului se realizează imediat după
expresia este executată. De exemplu, pentru a sări peste scrierea rândurilor a căror medie este aceeași cu
valoarea x curentă:

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;

Dacă nu este specificat niciun argument pentru fișierul de ieșire pe fișierul funcalc linie de comandă, niciun fișier de ieșire nu este
deschis și nu sunt scrise rânduri. Acest lucru este util în expresiile care pur și simplu imprimă rezultate
rezultate în loc să genereze un fișier nou:

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

În exemplul de mai sus, folosim atât specificația explicită de tip (pentru coloanele „av”), cât și tipul
turnare (pentru coloanele „au”) pentru a se asigura că toate operațiunile sunt efectuate în dublu
precizie.

Când este specificat un fișier de ieșire, tabelul de intrare selectat este procesat și rândurile de ieșire
sunt copiate în fișierul de ieșire. Rețineți că fișierul de ieșire poate fi specificat ca „stdout” în
pentru a scrie rândurile de ieșire în ieșirea standard. Dacă argumentul fișierului de ieșire este
trecut, un al treilea argument opțional poate fi transmis și pentru a specifica ce coloane să proceseze.

Într-un tabel binar FITS, uneori este de dorit să copiați toate celelalte extensii FITS
și la fișierul de ieșire. Acest lucru se poate face prin adăugarea unui semn „+” la numele
extensia în numele fișierului de intrare. Vedea funtable pentru un exemplu înrudit.

funcalc funcționează prin integrarea expresiei specificate de utilizator într-un program șablon C
numit tabcalc.c. Programul finalizat este apoi compilat și executat. Variabil
declarații care încep funcalc expresia sunt plasate în secțiunea declarație locală
a programului principal șablon. Toate celelalte linii sunt plasate în programul principal șablon
buclă interioară de procesare. Alte detalii despre generarea programului sunt gestionate automat. Pentru
de exemplu, specificatorii de coloană sunt analizați pentru a construi o structură C pentru procesarea rândurilor, adică
transferat la FunColumnSelect() și folosit în FunTableRowGet(). Dacă se utilizează o variabilă necunoscută
în expresie, rezultând o eroare de compilare, construirea programului este reîncercată după
definind ca variabila necunoscută să fie de tip double.

In mod normal, funcalc se adaugă codul expresiei la funcalc buclă de procesare a rândurilor. Este posibil
pentru a adăuga cod la alte părți ale programului prin plasarea acestui cod în directive speciale
de forma:

[numele directivei]
... codul merge aici...
capăt

Directivele sunt:

· global adăugați cod și declarații în spațiul global, înainte de rutina principală.

· local adăugați declarații (și cod) imediat după declarațiile locale în principal

· înainte adăugați cod chiar înainte de a intra în bucla de procesare a rândului principal

· după adăugați cod imediat după ieșirea din bucla de procesare a rândului principal

Astfel, următoarele funcalc expresia va declara variabilele globale și va face subrutine
apeluri chiar înainte și imediat după bucla principală de procesare:

global
dublu v1, v2;
dublu init(void);
finisaj dublu(v dublu);
capăt
înainte
v1 = init();
capăt
... procesează rânduri, cu calcule folosind v1 ...
după
v2 = finisare(v1);
if( v2 < 0.0 ){
fprintf(stderr, „procesarea a eșuat %g -> %g\n”, v1, v2);
ieşire(1);
}
capăt

Rutine precum init () și finalizarea() de mai sus sunt transmise programului generat pentru conectare
folosind -l [legătură instrucțiuni ...] intrerupator. Șirul specificat de acest comutator va fi
adăugat la linia de legătură folosită pentru a construi programul (înainte de biblioteca funtools). Pentru
exemplu, presupunând că init () și finalizarea() sunt în biblioteca libmysubs.a în
directorul /opt/special/lib, utilizați:

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

Argumentele utilizatorului pot fi transmise unui program funcalc compilat folosind un argument șir la
comutator „-a”. Șirul ar trebui să conțină toate argumentele utilizatorului. De exemplu, a trece
numerele întregi 1 și 2, utilizați:

funcalc -a "1 2" ...

Argumentele sunt stocate într-o matrice internă și sunt accesate ca șiruri prin intermediul ARGV(n)
macro. De exemplu, luați în considerare următoarea expresie:

local
int pmin, pmax;
capăt

înainte
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
capăt

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

Această expresie va tipări valorile x, y și pha pentru toate rândurile în care se află valoarea pha
între cele două valori introduse de utilizator:

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

Rețineți că este responsabilitatea utilizatorului să se asigure că numărul corect de argumente
sunt trecute. Macro-ul ARGV(n) returnează un NULL dacă un argument solicitat este în afara limitelor
a numărului real de argumente, de obicei rezultând un SEGV dacă este procesat în orb. A verifica
numărul de argumente, utilizați macro-ul ARGC:

local
long int seed=1;
limită dublă=0.8;
capăt

înainte
if( ARGC >= 1 ) seed = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48(samanta);
capăt

if ( drand48() > limit ) continua;

Macrocomanda WRITE_ROW se extinde la FunTableRowPut() apel care scrie rândul curent. Aceasta
poate fi folosit pentru a scrie rândul de mai multe ori. În plus, macro-ul NROW se extinde la
numărul rândului în curs de procesare. Utilizarea acestor două macrocomenzi este prezentată în cele ce urmează
exemplu:

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;

În cazul în care -p [prog] switch este specificat, expresia nu este executată. Mai degrabă, cel
executabilul generat este salvat cu numele de program specificat pentru utilizare ulterioară.

În cazul în care -n switch este specificat, expresia nu este executată. Mai degrabă, codul generat
este scris în stdout. Acest lucru este util mai ales dacă doriți să generați un fișier schelet
și adăugați propriul cod sau dacă trebuie să verificați erorile de compilare. Rețineți că comentariul
la începutul ieșirii oferă comanda compilatorului necesară pentru a construi programul pe aceasta
platformă. (Comanda se poate schimba de la o platformă la alta din cauza utilizării
biblioteci diferite, comutatoare de compilator etc.)

După cum sa menționat anterior, funcalc va declara automat o variabilă scalară (ca a
dublu) dacă acea variabilă a fost folosită, dar nu a fost declarată. Această facilitate este implementată
folosind un script sed numit funcalc.sed, care procesează ieșirea compilatorului pentru a detecta an
eroare variabilă nedeclarată. Acest script a fost generat cu eroarea corespunzătoare
informații pentru gcc și pentru cc pe platformele Solaris, DecAlpha și SGI. Daca gasesti asta
declararea automată a scalarilor nu funcționează pe platforma dvs., verificați acest script sed;
ar putea fi necesar să adăugați sau să editați unele dintre mesajele de eroare pe care le detectează.

Pentru a păstra analiza lexicală a funcalc expresii (rezonabil) simple, am ales
pentru a accepta unele limitări cu privire la cât de precis sunt plasate comentariile C, spațiile și liniile noi
în programul generat. În special, comentariile asociate cu variabilele locale declarate
la începutul unei expresii (adică nu în a local...sfarsit bloc) va ajunge de obicei
în bucla interioară, nu cu declarațiile locale:

/* acest comentariu va ajunge în locul greșit (adică, bucla interioară) */
dublu a; /* de asemenea, în locul greșit */
/* acesta va fi în locul potrivit (bucla interioară) */
if( cur->x:D == cur->y:D ) continua; /* de asemenea la locul potrivit */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

În mod similar, spațiile și liniile noi sunt uneori omise sau adăugate într-un mod aparent arbitrar
manieră. Desigur, niciuna dintre aceste pete stilistice nu afectează corectitudinea
codul generat.

pentru că funcalc trebuie să analizeze expresia utilizatorului folosind fișierele de date transmise
linia de comandă, fișierele de intrare trebuie să fie deschise și citite de două ori: o dată în timpul programului
generație și o dată în timpul execuției. Ca rezultat, nu este posibil să utilizați stdin pentru
fișier de intrare: funcalc nu poate fi folosit ca filtru. Vom lua în considerare eliminarea acestei restricții
mai târziu.

Împreună cu comentariile C, funcalc expresiile pot avea comentarii interne pe o linie care sunt
nu este transmis programului C generat. Aceste comentarii interne încep cu #
caracter și continuă până la noua linie:

dublu a; # acesta nu este transmis fișierului C generat
# nici asta nu este
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* acest comentariu este trecut în fișierul C */
cur->avg:E = (cur->x+cur->y)/2.0;

După cum sa menționat anterior, coloanele de intrare sunt în mod normal identificate prin utilizarea lor în interior
bucla interioară a evenimentelor. Există cazuri rare în care s-ar putea să doriți să citiți o coloană și
procesați-l în afara buclei principale. De exemplu, qsort ar putea folosi o coloană în sortarea sa
Rutină de comparație care nu este procesată în bucla interioară (și, prin urmare, nu
specificat implicit ca o coloană de citit). Pentru a vă asigura că o astfel de coloană este citită de către
bucla de evenimente, utilizați explicit cuvânt cheie. Argumentele acestui cuvânt cheie specifică coloanele care
ar trebui citite în structura înregistrării de intrare chiar dacă nu sunt menționate în
buclă interioară. De exemplu:

explicit pi pha

se va asigura că coloanele pi și pha sunt citite pentru fiecare rând, chiar dacă nu sunt
procesate în bucla interioară de evenimente. The explicit declarația poate fi plasată oriunde.

În cele din urmă, rețineți că funcalc în prezent lucrează la expresii care implică tabele binare FITS și
fișiere de evenimente brute. Vom lua în considerare adăugarea de suport pentru expresiile de imagine la un moment ulterior,
dacă există cerere pentru un astfel de sprijin din partea comunității.

Utilizați funcalc online folosind serviciile onworks.net