funcalc - Online sa Cloud

PROGRAMA:

NAME

funcalc - Funtools calculator (para sa mga binary table)

SINOPSIS

funcalc [-n] [-a argstr] [-e expr] [-f file] [-l link] [-p prog] [pangalan [mga hanay]]

Opsyon

-a argstr # argumento ng user na ipapasa sa pinagsama-samang programa
-e expr # funcalc expression
-f file # file na naglalaman ng funcalc expression
-l libs # libs upang idagdag sa utos ng link
-n # output na nabuong code sa halip na i-compile at i-execute
-p prog # bumuo ng pinangalanang programa, walang execution
-u # mamatay kung ang anumang variable ay hindi idineklara (huwag awtomatikong magdeklara)

DESCRIPTION

funcalc ay isang calculator program na nagpapahintulot sa mga di-makatwirang expression na mabuo,
pinagsama-sama, at isinagawa sa mga column sa isang Funtools table (FITS binary table o raw event
file). Gumagana ito sa pamamagitan ng pagsasama ng (mga) expression na ibinigay ng user sa isang template C program, kung gayon
pag-compile at pagpapatupad ng programa. funcalc ang mga expression ay mga pahayag na C, bagaman ang ilan
mahalagang pagpapasimple (tulad ng awtomatikong pagdedeklara ng mga variable) ay suportado.

funcalc ang mga expression ay maaaring tukuyin sa tatlong paraan: sa command line gamit ang -e
[expression] switch, sa isang file gamit ang -f [file] lumipat, o mula sa stdin (kung wala -e
ni -f ay tinukoy). Siyempre isang file na naglalaman ng funcalc mababasa ang mga ekspresyon mula sa
stdin.

Ang bawat panawagan ng funcalc ay nangangailangan ng input na Funtools table file upang matukoy bilang ang
unang command line argument. Ang output na Funtools table file ay ang pangalawang opsyonal
argumento. Ito ay kinakailangan lamang kung ang isang output FITS file ay nilikha (ibig sabihin, sa mga kaso kung saan
ang funcalc expression ay nagpi-print lamang ng mga halaga, walang output file ang kailangan). Kung input at output
file ay parehong tinukoy, ang ikatlong opsyonal na argumento ay maaaring tukuyin ang listahan ng mga hanay sa
buhayin (gamit FunColumnActivate()). Tandaan na funcalc nagpapasiya kung gagawin o hindi
bumuo ng code para sa pagsulat ng isang output file batay sa presensya o kawalan ng isang output
argumento ng file.

A funcalc Ang expression ay isinasagawa sa bawat hilera ng isang talahanayan at binubuo ng isa o higit pang C
mga pahayag na gumagana sa mga column ng row na iyon (posibleng gumagamit ng mga pansamantalang variable).
Sa loob ng isang expression, ang sanggunian ay ginawa sa isang column ng kasalukuyan hilera gamit ang C struct
palaugnayan cur-[colname]>, hal. cur->x, cur->pha, atbp. Maaaring tukuyin ang mga lokal na scalar variable
gamit ang mga deklarasyon ng C sa pinakasimula ng expression, o kung hindi, maaari silang tukuyin
awtomatikong sa pamamagitan ng funcalc (para maging doble ang uri). Kaya, halimbawa, isang swap ng mga column x
at y sa isang talahanayan ay maaaring isagawa gamit ang alinman sa mga sumusunod na katumbas funcalc
mga expression:

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

o:

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

Kapag ang expression na ito ay naisakatuparan gamit ang isang command tulad ng:

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

ang magreresultang file ay magkakaroon ng mga halaga ng x at y na mga column na pinagpalit.

Bilang default, ang uri ng data ng variable para sa isang column ay kapareho ng uri ng data ng
column bilang nakaimbak sa file. Maaari itong baguhin sa pamamagitan ng pagdaragdag ng ":[dtype]" sa una
reference sa column na iyon. Sa halimbawa sa itaas, upang pilitin ang x at y na maging output bilang doble,
tahasang tukuyin ang uri ng 'D':

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

Ang mga specifier ng uri ng data ay sumusunod sa karaniwang FITS table syntax para sa pagtukoy ng mga column gamit ang TFORM:

· A: ASCII character

· B: unsigned 8-bit char

· I: nilagdaan ang 16-bit int

· U: unsigned 16-bit int (hindi standard FITS)

· J: nilagdaan ang 32-bit int

· V: unsigned 32-bit int (hindi standard FITS)

· E: 32-bit na float

· D: 64-bit na float

· X: bits (itinuring bilang isang array ng mga character)

Tandaan na ang unang reference lang sa isang column ang dapat maglaman ng tahasang uri ng data
specifier.

Siyempre, mahalagang pangasiwaan nang tama ang uri ng data ng mga column. Isa sa mga
pinakamadalas na sanhi ng error sa funcalc Ang programming ay ang tahasang paggamit ng maling data
uri para sa isang column sa expression. Halimbawa, ang pagkalkula:

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

karaniwang kailangang isagawa gamit ang floating point arithmetic. Sa mga kaso kung saan ang x at y
Ang mga column ay mga integer, ito ay maaaring gawin sa pamamagitan ng pagbabasa ng mga column bilang mga doble gamit ang isang tahasang
pagtutukoy ng uri:

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

Bilang kahalili, maaari itong gawin gamit ang C type-casting sa expression:

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

Bilang karagdagan sa pag-access sa mga column sa kasalukuyang row, maaari ding gumawa ng reference sa
nakaraan hilera gamit nauna-[colname]>, at sa susunod hilera gamit susunod-[colname]>. Tandaan na
if nauna-[colname]> ay tinukoy sa funcalc expression, ang pinakaunang hilera ay hindi
naproseso. Kung susunod-[colname]> ay tinukoy sa funcalc expression, ang pinakahuling row
ay hindi naproseso. Sa ganitong paraan, nkrn at susunod ay garantisadong palaging tumuturo sa mga wastong row.
Halimbawa, upang i-print ang mga halaga ng kasalukuyang x column at nakaraang y column,
gamitin ang C fprintf function sa a funcalc pagpapahayag:

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

Maaaring tukuyin ang mga bagong column gamit ang pareho cur-[colname]> syntax sa pamamagitan ng pagdaragdag sa column
uri (at mga opsyonal na tlmin/tlmax/binsiz specifiers), na pinaghihiwalay ng mga colon. Halimbawa,
Ang cur->avg:D ay tutukuyin ng bagong column na doble ang uri. Ang mga uri ng specifier ay pareho sa mga iyon
ginamit sa itaas upang tumukoy ng mga bagong uri ng data para sa mga kasalukuyang column.

Halimbawa, upang lumikha at mag-output ng bagong column na ang average na halaga ng x at y
mga column, maaaring tukuyin ang isang bagong "avg" na column:

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

Tandaan na ang panghuling ';' ay hindi kinakailangan para sa mga single-line na expression.

Tulad ng FITS TFORM na detalye ng uri ng data, ang column data type specifier ay maaaring unahan
sa pamamagitan ng isang numerong bilang upang tukuyin ang isang array, hal, "10I" ay nangangahulugang isang vector ng 10 maikling ints, "2E"
nangangahulugang dalawang solong precision float, atbp. Isang bagong column ang kailangan lang tukuyin nang isang beses sa a
funcalc expression, pagkatapos nito ay magagamit ito nang hindi muling tinukoy ang uri. Ito
may kasamang reference sa mga elemento ng column array:

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

Ang 'X' (bits) na uri ng data ay itinuturing bilang isang char array ng dimensyon (numeric_count/8), ibig sabihin,
Ang 16X ay pinoproseso bilang isang 2-byte char array. Ang bawat 8-bit na elemento ng array ay hiwalay na ina-access:

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

Dito, nilikha ang isang 16-bit na column na ang MSB ay nakatakda sa 1 at ang LSB ay nakatakda sa 2.

Bilang default, ang lahat ng naprosesong row ay isinulat sa tinukoy na output file. Kung gusto mo
laktawan ang pagsulat ng ilang mga hilera, i-execute lang ang C "continue" na pahayag sa dulo ng
funcalc expression, dahil ang pagsulat ng row ay isinasagawa kaagad pagkatapos ng
ang pagpapahayag ay naisakatuparan. Halimbawa, upang laktawan ang pagsusulat ng mga hilera na ang average ay pareho sa
kasalukuyang halaga ng x:

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

Kung walang output file argument na tinukoy sa funcalc command line, walang output file
binuksan at walang nakasulat na mga hilera. Ito ay kapaki-pakinabang sa mga expression na nagpi-print lamang ng output
mga resulta sa halip na makabuo ng bagong 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);

Sa halimbawa sa itaas, ginagamit namin ang parehong tahasang detalye ng uri (para sa mga column na "av") at uri
pag-cast (para sa mga column na "au") upang matiyak na ang lahat ng mga operasyon ay isinasagawa nang doble
katumpakan.

Kapag ang isang output file ay tinukoy, ang napiling input table ay pinoproseso at output row
ay kinopya sa output file. Tandaan na ang output file ay maaaring tukuyin bilang "stdout" sa
upang isulat ang mga hilera ng output sa karaniwang output. Kung ang output file argument ay
naipasa, maaari ding ipasa ang isang opsyonal na ikatlong argumento upang tukuyin kung aling mga column ang ipoproseso.

Sa isang FITS binary table, minsan ay kanais-nais na kopyahin ang lahat ng iba pang FITS extension
sa output file din. Magagawa ito sa pamamagitan ng pagdaragdag ng sign na '+' sa pangalan ng
extension sa pangalan ng input file. Tingnan mo funtable para sa isang kaugnay na halimbawa.

funcalc gumagana sa pamamagitan ng pagsasama ng expression na tinukoy ng user sa isang template C program
tinatawag na tabcalc.c. Ang nakumpletong programa pagkatapos ay pinagsama-sama at naisakatuparan. Variable
mga deklarasyon na nagsisimula sa funcalc expression ay inilalagay sa seksyon ng lokal na deklarasyon
ng pangunahing programa ng template. Ang lahat ng iba pang mga linya ay inilalagay sa pangunahing programa ng template
panloob na pagpoproseso ng loop. Ang iba pang mga detalye ng pagbuo ng programa ay awtomatikong hinahawakan. Para sa
halimbawa, sinusuri ang mga specifier ng column upang bumuo ng C struct para sa pagproseso ng mga row, which is
ipasa kay FunColumnSelect() at ginamit sa FunTableRowGet(). Kung gumamit ng hindi kilalang variable
sa expression, na nagreresulta sa isang error sa compilation, ang program build ay muling sinubukan pagkatapos
pagtukoy sa hindi kilalang variable na doble ang uri.

Karaniwan, funcalc idinagdag ang expression code sa funcalc row processing loop. Posible
upang magdagdag ng code sa ibang bahagi ng programa sa pamamagitan ng paglalagay ng code na ito sa loob ng mga espesyal na direktiba
ng anyo:

[pangalan ng direktiba]
... napupunta ang code dito ...
dulo

Ang mga direktiba ay:

· global magdagdag ng code at mga deklarasyon sa pandaigdigang espasyo, bago ang pangunahing gawain.

· lokal magdagdag ng mga deklarasyon (at code) pagkatapos lamang ng mga lokal na deklarasyon sa main

· bago magdagdag ng code bago ipasok ang pangunahing row processing loop

· pagkatapos magdagdag ng code pagkatapos lamang lumabas sa pangunahing row processing loop

Kaya, ang mga sumusunod funcalc ang expression ay magdedeklara ng mga global variable at gagawing subroutine
mga tawag bago at pagkatapos lamang ng pangunahing pagpoproseso ng loop:

global
dobleng v1, v2;
double init(walang bisa);
dobleng pagtatapos (doble v);
dulo
bago
v1 = init();
dulo
... proseso ng mga hilera, na may mga kalkulasyon gamit ang v1 ...
pagkatapos
v2 = tapusin(v1);
kung( v2 < 0.0 ){
fprintf(stderr, "nabigo ang pagproseso %g -> %g\n", v1, v2);
lumabas(1);
}
dulo

Mga gawain tulad ng sa loob() at tapusin() sa itaas ay ipinapasa sa nabuong programa para sa pag-link
gamit ang -l [link direktiba ...] lumipat. Ang string na tinukoy ng switch na ito ay magiging
idinagdag sa linya ng link na ginamit upang buuin ang programa (bago ang funtools library). Para sa
halimbawa, ipagpalagay na sa loob() at tapusin() ay nasa library libmysubs.a sa
/opt/special/lib directory, gamitin ang:

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

Ang mga argumento ng gumagamit ay maaaring maipasa sa isang pinagsama-samang funcalc program gamit ang isang string argument sa
"-a" switch. Ang string ay dapat maglaman ng lahat ng mga argumento ng user. Halimbawa, para pumasa
ang mga integer 1 at 2, gamitin ang:

funcalc -a "1 2" ...

Ang mga argumento ay naka-imbak sa isang panloob na hanay at ina-access bilang mga string sa pamamagitan ng ARGV(n)
macro. Halimbawa, isaalang-alang ang sumusunod na expression:

lokal
int pmin, pmax;
dulo

bago
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
dulo

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

Ang expression na ito ay magpi-print ng mga x, y, at pha value para sa lahat ng row kung saan ang pha value ay
sa pagitan ng dalawang value ng user-input:

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

Tandaan na responsibilidad ng user na tiyakin na ang tamang bilang ng mga argumento
ay nakapasa. Ang ARGV(n) macro ay nagbabalik ng NULL kung ang isang hiniling na argumento ay lampas sa mga limitasyon
ng aktwal na bilang ng mga arg, kadalasang nagreresulta sa isang SEGV kung naproseso nang walang taros. Upang suriin
ang bilang ng argumento, gamitin ang ARGC macro:

lokal
long int seed=1;
dobleng limitasyon=0.8;
dulo

bago
if( ARGC >= 1 ) seed = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48(binhi);
dulo

kung ( drand48() > limit ) magpapatuloy;

Lumalawak ang macro WRITE_ROW sa FunTableRowPut() tawag na nagsusulat ng kasalukuyang hilera. Ito
maaaring gamitin upang isulat ang hilera nang higit sa isang beses. Bilang karagdagan, ang macro NWOW ay lumalawak sa
row number na kasalukuyang pinoproseso. Ang paggamit ng dalawang macro na ito ay ipinapakita sa sumusunod
halimbawa:

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 = NWOW;
if( NROW < 10 ) WRITE_ROW;

Kung ang -p [prog] switch ay tinukoy, ang expression ay hindi naisakatuparan. Sa halip, ang
ang nabuong executable ay nai-save gamit ang tinukoy na pangalan ng program para magamit sa ibang pagkakataon.

Kung ang -n switch ay tinukoy, ang expression ay hindi naisakatuparan. Sa halip, ang nabuong code
ay nakasulat sa stdout. Ito ay lalong kapaki-pakinabang kung gusto mong bumuo ng isang skeleton file
at magdagdag ng sarili mong code, o kung kailangan mong suriin ang mga error sa compilation. Tandaan na ang komento
sa simula ng output ay nagbibigay ng compiler command na kailangan para buuin ang program doon
platform. (Ang command ay maaaring magbago mula sa platform hanggang sa platform dahil sa paggamit ng
iba't ibang mga aklatan, mga switch ng compiler, atbp.)

Tulad ng nabanggit dati, funcalc ay awtomatikong magdedeklara ng scalar variable (bilang a
double) kung ang variable na iyon ay ginamit ngunit hindi idineklara. Ang pasilidad na ito ay ipinatupad
gamit ang isang sed script na pinangalanang funcalc.sed, na nagpoproseso ng output ng compiler upang makaramdam ng an
hindi ipinahayag na variable na error. Na-seed ang script na ito ng naaangkop na error
impormasyon para sa gcc, at para sa cc sa mga platform ng Solaris, DecAlpha, at SGI. Kung nahanap mo yan
awtomatikong deklarasyon ng mga scalar ay hindi gumagana sa iyong platform, suriin ang sed script na ito;
maaaring kailanganing idagdag o i-edit ang ilan sa mga mensahe ng error na nararamdaman nito.

Upang mapanatili ang leksikal na pagsusuri ng funcalc mga expression (makatuwirang) simple, pinili namin
upang tanggapin ang ilang limitasyon sa kung gaano katumpak ang paglalagay ng mga komento, espasyo, at bagong linya ng C
sa nabuong programa. Sa partikular, ipinahayag ang mga komentong nauugnay sa mga lokal na variable
sa simula ng isang expression (ibig sabihin, hindi sa a lokal...tapos block) ay karaniwang magtatapos
sa panloob na loop, hindi kasama ang mga lokal na deklarasyon:

/* mapupunta ang komentong ito sa maling lugar (ibig sabihin, panloob na loop) */
doble a; /* nasa maling lugar din */
/* ito ay nasa tamang lugar (inner loop) */
if( cur->x:D == cur->y:D ) continue; /* nasa tamang lugar din */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

Katulad nito, ang mga puwang at bagong-linya kung minsan ay inalis o idinaragdag sa isang tila arbitrary
paraan. Siyempre, wala sa mga stylistic blemishes na ito ang nakakaapekto sa kawastuhan ng
nabuong code.

dahil sa funcalc dapat suriin ang expression ng user gamit ang (mga) file ng data na ipinasa sa
command line, ang (mga) input file ay dapat buksan at basahin nang dalawang beses: isang beses sa panahon ng programa
henerasyon at isang beses sa panahon ng pagpapatupad. Bilang resulta, hindi posibleng gumamit ng stdin para sa
input file: funcalc hindi maaaring gamitin bilang isang filter. Isasaalang-alang namin na alisin ang paghihigpit na ito
sa ibang panahon.

Kasama ng mga komento ni C, funcalc ang mga expression ay maaaring magkaroon ng isang linyang panloob na mga komento na
hindi naipasa sa nabuong C program. Ang mga panloob na komentong ito ay nagsisimula sa #
character at magpatuloy hanggang sa bagong linya:

doble a; # hindi ito naipapasa sa nabuong C file
# at hindi rin ito
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* ang komentong ito ay ipinasa sa C file */
cur->avg:E = (cur->x+cur->y)/2.0;

Gaya ng naunang nabanggit, ang mga column ng input ay karaniwang nakikilala sa pamamagitan ng paggamit ng mga ito sa loob
ang panloob na loop ng kaganapan. May mga bihirang kaso kung saan maaaring gusto mong magbasa ng column at
iproseso ito sa labas ng pangunahing loop. Halimbawa, maaaring gumamit ang qsort ng column sa pag-uuri nito
paghahambing na gawain na hindi naproseso sa loob ng panloob na loop (at samakatuwid ay hindi
tahasang tinukoy bilang isang hanay na babasahin). Upang matiyak na ang naturang kolum ay binabasa ng
loop ng kaganapan, gamitin ang malinaw keyword. Ang mga argumento sa keyword na ito ay tumutukoy sa mga column na iyon
dapat basahin sa istraktura ng rekord ng input kahit na hindi sila nabanggit sa
panloob na loop. Halimbawa:

tahasang pi pha

titiyakin na ang pi at pha column ay nababasa para sa bawat row, kahit na hindi
naproseso sa panloob na loop ng kaganapan. Ang malinaw maaaring ilagay ang pahayag kahit saan.

Sa wakas, tandaan na funcalc kasalukuyang gumagana sa mga expression na kinasasangkutan ng FITS binary table at
raw na mga file ng kaganapan. Isasaalang-alang namin ang pagdaragdag ng suporta para sa mga expression ng imahe sa ibang pagkakataon,
kung may pangangailangan para sa naturang suporta mula sa komunidad.

Gumamit ng funcalc online gamit ang mga serbisyo ng onworks.net