funcalc - Dalam talian di Awan

JADUAL:

NAMA

funcalc - Kalkulator Funtools (untuk jadual binari)

SINOPSIS

funcalc [-n] [-a argstr] [-e expr] [-f fail] [-l link] [-p prog] [nama [lajur]]

PILIHAN

-a argstr # argumen pengguna untuk dihantar ke atur cara yang disusun
-e expr # ekspresi funcalc
-f fail # fail yang mengandungi ungkapan funcalc
-l libs # libs untuk ditambahkan pada arahan pautan
-n # output menjana kod dan bukannya menyusun dan melaksanakan
-p prog # jana program bernama, tiada pelaksanaan
-u # mati jika mana-mana pembolehubah tidak diisytiharkan (jangan auto-deklarasi)

DESCRIPTION

funcalc ialah program kalkulator yang membenarkan ungkapan sewenang-wenangnya dibina,
disusun dan dilaksanakan pada lajur dalam jadual Funtools (jadual binari FITS atau acara mentah
fail). Ia berfungsi dengan menyepadukan ungkapan yang dibekalkan pengguna ke dalam program templat C, kemudian
menyusun dan melaksanakan program. funcalc ungkapan adalah pernyataan C, walaupun beberapa
pemudahan penting (seperti pengisytiharan automatik pembolehubah) disokong.

funcalc ungkapan boleh ditentukan dalam tiga cara: pada baris arahan menggunakan -e
[ungkapan] suis, dalam fail menggunakan -f [fail] suis, atau daripada stdin (jika tidak -e
tidak -f dinyatakan). Sudah tentu fail yang mengandungi funcalc ungkapan boleh dibaca daripada
stdin.

Setiap seruan daripada funcalc memerlukan input fail jadual Funtools untuk ditentukan sebagai
hujah baris arahan pertama. Fail jadual Funtools output ialah pilihan kedua
hujah. Ia diperlukan hanya jika fail FITS output sedang dibuat (iaitu, dalam kes di mana
yang funcalc ungkapan hanya mencetak nilai, tiada fail output diperlukan). Jika input dan output
fail kedua-duanya ditentukan, hujah pilihan ketiga boleh menentukan senarai lajur untuk
aktifkan (menggunakan FunColumnActivate()). Perhatikan bahawa funcalc menentukan sama ada atau tidak
menjana kod untuk menulis fail output berdasarkan kehadiran atau ketiadaan output
hujah fail.

A funcalc ungkapan dilaksanakan pada setiap baris jadual dan terdiri daripada satu atau lebih C
pernyataan yang beroperasi pada lajur baris tersebut (mungkin menggunakan pembolehubah sementara).
Dalam ungkapan, rujukan dibuat kepada lajur semasa baris menggunakan struct C
sintaks cur-[colname]>, cth cur->x, cur->pha, dsb. Pembolehubah skalar tempatan boleh ditakrifkan
menggunakan pengisytiharan C pada permulaan ungkapan, atau ia boleh ditakrifkan
secara automatik oleh funcalc (menjadi jenis berganda). Oleh itu, sebagai contoh, pertukaran lajur x
dan y dalam jadual boleh dilakukan menggunakan salah satu daripada persamaan berikut funcalc
ungkapan:

suhu dua kali ganda;
temp = cur->x;
cur->x = cur->y;
cur->y = temp;

atau:

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

Apabila ungkapan ini dilaksanakan menggunakan arahan seperti:

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

fail yang terhasil akan mempunyai nilai lajur x dan y ditukar.

Secara lalai, jenis data pembolehubah untuk lajur adalah sama dengan jenis data bagi
lajur seperti yang disimpan dalam fail. Ini boleh diubah dengan menambahkan ":[dtype]" pada yang pertama
rujukan kepada ruangan itu. Dalam contoh di atas, untuk memaksa x dan y menjadi output sebagai dua kali ganda,
nyatakan jenis 'D' secara eksplisit:

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

Penentu jenis data mengikut sintaks jadual FITS standard untuk menentukan lajur menggunakan TFORM:

· A: aksara ASCII

· B: aksara 8-bit tidak ditandatangani

· I: ditandatangani 16-bit int

· U: int 16-bit tidak ditandatangani (bukan FITS standard)

· J: ditandatangani 32-bit int

· V: int 32-bit tidak ditandatangani (bukan FITS standard)

· E: terapung 32-bit

· D: terapung 64-bit

· X: bit (dilayan sebagai tatasusunan aksara)

Ambil perhatian bahawa hanya rujukan pertama kepada lajur harus mengandungi jenis data eksplisit
penentu.

Sudah tentu, adalah penting untuk mengendalikan jenis data lajur dengan betul. Salah satu daripada
punca ralat yang paling kerap dalam funcalc pengaturcaraan ialah penggunaan data yang salah secara tersirat
taip untuk lajur dalam ungkapan. Sebagai contoh, pengiraan:

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

biasanya perlu dilakukan menggunakan aritmetik titik terapung. Dalam kes di mana x dan y
lajur ialah integer, ini boleh dilakukan dengan membaca lajur sebagai dua kali ganda menggunakan eksplisit
spesifikasi jenis:

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

Sebagai alternatif, ia boleh dilakukan menggunakan pemutus jenis C dalam ungkapan:

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

Selain mengakses lajur dalam baris semasa, rujukan juga boleh dibuat kepada
sebelumnya baris menggunakan sebelum-[colname]>, dan kepada seterusnya baris menggunakan seterusnya-[colname]>. Perhatikan bahawa
if sebelum-[colname]> dinyatakan dalam funcalc ungkapan, baris pertama tidak
telah di proses. Jika seterusnya-[colname]> dinyatakan dalam funcalc ungkapan, baris terakhir
tidak diproses. Dengan cara ini, prev and seterusnya dijamin sentiasa menunjuk ke baris yang sah.
Contohnya, untuk mencetak nilai lajur x semasa dan lajur y sebelumnya,
gunakan fungsi C fprintf dalam a funcalc ungkapan:

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

Lajur baharu boleh ditentukan menggunakan yang sama cur-[colname]> sintaks dengan menambahkan lajur
jenis (dan penentu tlmin/tlmax/binsiz pilihan), dipisahkan oleh titik bertindih. Sebagai contoh,
cur->avg:D akan mentakrifkan lajur baharu jenis berganda. Penentu jenis adalah sama
digunakan di atas untuk menentukan jenis data baharu bagi lajur sedia ada.

Contohnya, untuk mencipta dan mengeluarkan lajur baharu yang merupakan nilai purata bagi x dan y
lajur, lajur "purata" baharu boleh ditakrifkan:

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

Ambil perhatian bahawa ';' akhir tidak diperlukan untuk ungkapan satu baris.

Seperti spesifikasi jenis data FITS TFORM, penentu jenis data lajur boleh didahulukan
dengan kiraan berangka untuk menentukan tatasusunan, cth, "10I" bermaksud vektor 10 int pendek, "2E"
bermakna dua terapung ketepatan tunggal, dsb. Lajur baharu hanya perlu ditakrifkan sekali dalam a
funcalc ungkapan, selepas itu ia boleh digunakan tanpa menyatakan semula jenisnya. ini
termasuk rujukan kepada elemen tatasusunan lajur:

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

Jenis data 'X' (bit) dianggap sebagai tatasusunan aksara dimensi (bilangan_numeric/8), iaitu,
16X diproses sebagai tatasusunan aksara 2-bait. Setiap elemen tatasusunan 8-bit diakses secara berasingan:

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

Di sini, lajur 16-bit dibuat dengan MSB ditetapkan kepada 1 dan LSB ditetapkan kepada 2.

Secara lalai, semua baris yang diproses ditulis pada fail output yang ditentukan. Jika anda mahu
langkau menulis baris tertentu, hanya laksanakan pernyataan "teruskan" C di penghujung
funcalc ungkapan, kerana penulisan baris dilakukan sejurus selepas
ungkapan dilaksanakan. Sebagai contoh, untuk melangkau menulis baris yang puratanya adalah sama dengan
nilai x semasa:

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

Jika tiada hujah fail output dinyatakan pada funcalc baris arahan, tiada fail keluaran
dibuka dan tiada baris ditulis. Ini berguna dalam ungkapan yang hanya mencetak output
hasil daripada menjana fail baharu:

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

Dalam contoh di atas, kami menggunakan kedua-dua spesifikasi jenis eksplisit (untuk lajur "av") dan jenis
pemutus (untuk lajur "au") untuk memastikan semua operasi dilakukan dalam dua kali ganda
ketepatan.

Apabila fail output ditentukan, jadual input yang dipilih diproses dan baris output
disalin ke fail output. Ambil perhatian bahawa fail output boleh ditentukan sebagai "stdout" dalam
untuk menulis baris keluaran kepada keluaran standard. Jika argumen fail output ialah
diluluskan, hujah ketiga pilihan juga boleh diluluskan untuk menentukan lajur yang hendak diproses.

Dalam jadual binari FITS, kadangkala wajar untuk menyalin semua sambungan FITS yang lain
ke fail output juga. Ini boleh dilakukan dengan menambahkan tanda '+' pada nama
sambungan dalam nama fail input. Lihat funtable untuk contoh yang berkaitan.

funcalc berfungsi dengan menyepadukan ungkapan yang ditentukan pengguna ke dalam program templat C
dipanggil tabcalc.c. Program yang telah siap kemudiannya disusun dan dilaksanakan. Pembolehubah
pengisytiharan yang memulakan funcalc ungkapan diletakkan di bahagian perisytiharan tempatan
daripada program utama templat. Semua baris lain diletakkan dalam program utama templat
gelung pemprosesan dalaman. Butiran lain penjanaan program dikendalikan secara automatik. Untuk
contoh, penentu lajur dianalisis untuk membina struktur C untuk memproses baris, iaitu
berlalu ke FunColumnSelect() dan digunakan dalam FunTableRowGet(). Jika pembolehubah yang tidak diketahui digunakan
dalam ungkapan, mengakibatkan ralat penyusunan, binaan program dicuba semula selepas
mentakrifkan pembolehubah yang tidak diketahui sebagai jenis berganda.

Biasanya, funcalc kod ungkapan ditambah kepada funcalc gelung pemprosesan baris. Ia adalah mungkin
untuk menambah kod pada bahagian lain program dengan meletakkan kod ini di dalam arahan khas
borang:

[nama arahan]
... kod pergi ke sini ...
akhir

Arahan tersebut ialah:

· global tambah kod dan pengisytiharan dalam ruang global, sebelum rutin utama.

· tempatan tambahkan pengisytiharan (dan kod) sejurus selepas pengisytiharan tempatan dalam main

· sebelum tambah kod sejurus sebelum memasuki gelung pemprosesan baris utama

· selepas tambah kod hanya selepas keluar dari gelung pemprosesan baris utama

Justeru, berikut funcalc ungkapan akan mengisytiharkan pembolehubah global dan membuat subrutin
panggilan sebelum dan selepas gelung pemprosesan utama:

global
berganda v1, v2;
double init(kosong);
kemasan dua kali (double v);
akhir
sebelum
v1 = init();
akhir
... proses baris, dengan pengiraan menggunakan v1 ...
selepas
v2 = penamat(v1);
jika( v2 < 0.0 ){
fprintf(stderr, "pemprosesan gagal %g -> %g\n", v1, v2);
keluar(1);
}
akhir

Rutin seperti di dalamnya() and selesai () di atas dihantar ke program yang dijana untuk dipautkan
menggunakan -l [pautan arahan ...] suis. Rentetan yang ditentukan oleh suis ini ialah
ditambahkan pada baris pautan yang digunakan untuk membina program (sebelum perpustakaan funtools). Untuk
contoh, dengan mengandaikan bahawa di dalamnya() and selesai () berada di perpustakaan libmysubs.a dalam
/opt/special/lib direktori, gunakan:

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

Argumen pengguna boleh dihantar ke program funcalc yang disusun menggunakan argumen rentetan ke
suis "-a". Rentetan harus mengandungi semua hujah pengguna. Sebagai contoh, untuk lulus
integer 1 dan 2, gunakan:

funcalc -a "1 2" ...

Argumen disimpan dalam tatasusunan dalaman dan diakses sebagai rentetan melalui ARGV(n)
makro. Sebagai contoh, pertimbangkan ungkapan berikut:

tempatan
int pmin, pmax;
akhir

sebelum
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
akhir

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

Ungkapan ini akan mencetak nilai x, y dan pha untuk semua baris di mana nilai pha berada
antara dua nilai input pengguna:

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

Ambil perhatian bahawa adalah menjadi tanggungjawab pengguna untuk memastikan bilangan hujah yang betul
dilalui. Makro ARGV(n) mengembalikan NULL jika hujah yang diminta berada di luar had
daripada bilangan sebenar args, biasanya menghasilkan SEGV jika diproses secara membuta tuli. Untuk memeriksa
kiraan hujah, gunakan makro ARGC:

tempatan
benih int panjang=1;
had dua kali ganda=0.8;
akhir

sebelum
jika( ARGC >= 1 ) biji = atol(ARGV(0));
jika( ARGC >= 2 ) had = atof(ARGV(1));
srand48(benih);
akhir

jika ( drand48() > had ) diteruskan;

Makro WRITE_ROW berkembang ke FunTableRowPut() panggilan yang menulis baris semasa. Ia
boleh digunakan untuk menulis baris lebih daripada sekali. Di samping itu, NROW makro berkembang ke
nombor baris sedang diproses. Penggunaan kedua-dua makro ini ditunjukkan dalam yang berikut
contoh:

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

Jika -p [prog] suis ditentukan, ungkapan tidak dilaksanakan. Sebaliknya, yang
boleh laku yang dihasilkan disimpan dengan nama program yang ditentukan untuk kegunaan kemudian.

Jika -n suis ditentukan, ungkapan tidak dilaksanakan. Sebaliknya, kod yang dihasilkan
ditulis kepada stdout. Ini amat berguna jika anda ingin menjana fail rangka
dan tambah kod anda sendiri, atau jika anda perlu menyemak ralat kompilasi. Perhatikan bahawa komen
pada permulaan output memberikan arahan pengkompil yang diperlukan untuk membina atur cara pada itu
platform. (Arahan boleh berubah dari platform ke platform kerana penggunaan
perpustakaan yang berbeza, suis pengkompil, dsb.)

Seperti yang dinyatakan sebelum ini, funcalc akan mengisytiharkan pembolehubah skalar secara automatik (sebagai a
double) jika pembolehubah itu telah digunakan tetapi tidak diisytiharkan. Kemudahan ini dilaksanakan
menggunakan skrip sed bernama funcalc.sed, yang memproses output pengkompil untuk mengesan an
ralat pembolehubah yang tidak diisytiharkan. Skrip ini telah disemai dengan ralat yang sesuai
maklumat untuk gcc dan untuk cc pada platform Solaris, DecAlpha dan SGI. Jika anda mendapati itu
pengisytiharan automatik skalar tidak berfungsi pada platform anda, semak skrip sed ini;
mungkin perlu menambah atau mengedit beberapa mesej ralat yang dirasainya.

Untuk mengekalkan analisis leksikal funcalc ungkapan (munasabah) mudah, kami pilih
untuk menerima beberapa pengehadan tentang ketepatan ulasan C, ruang dan baris baharu diletakkan
dalam program yang dihasilkan. Khususnya, ulasan yang dikaitkan dengan pembolehubah tempatan diisytiharkan
pada permulaan ungkapan (iaitu, bukan dalam a tempatan...akhir blok) biasanya akan berakhir
dalam gelung dalaman, bukan dengan pengisytiharan tempatan:

/* ulasan ini akan berakhir di tempat yang salah (iaitu, gelung dalam) */
ganda a; /* juga di tempat yang salah */
/* ini akan berada di tempat yang betul (gelung dalam) */
if( cur->x:D == cur->y:D ) continue; /* juga di tempat yang betul */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur->avg:E = (cur->x+cur->y)/2.0;

Begitu juga, ruang dan baris baharu kadangkala ditinggalkan atau ditambah dalam bentuk yang kelihatan sewenang-wenangnya
cara. Sudah tentu, tiada satu pun daripada kecacatan gaya ini menjejaskan ketepatan
kod yang dihasilkan.

Kerana funcalc mesti menganalisis ungkapan pengguna menggunakan fail data yang dihantar pada
baris arahan, fail input mesti dibuka dan dibaca dua kali: sekali semasa program
generasi dan sekali semasa pelaksanaan. Akibatnya, tidak mungkin menggunakan stdin untuk
fail input: funcalc tidak boleh digunakan sebagai penapis. Kami akan mempertimbangkan untuk mengalih keluar sekatan ini
di kemudian hari.

Bersama-sama dengan komen C, funcalc ungkapan boleh mempunyai ulasan dalaman satu baris iaitu
tidak diteruskan kepada program C yang dihasilkan. Komen dalaman ini bermula dengan #
watak dan teruskan ke baris baharu:

ganda a; # ini tidak dihantar ke fail C yang dijana
# mahupun ini
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* komen ini dihantar ke fail C */
cur->avg:E = (cur->x+cur->y)/2.0;

Seperti yang dinyatakan sebelum ini, lajur input biasanya dikenal pasti dengan penggunaannya di dalamnya
gelung acara dalaman. Terdapat kes yang jarang berlaku di mana anda mungkin ingin membaca lajur dan
memprosesnya di luar gelung utama. Sebagai contoh, qsort mungkin menggunakan lajur dalam jenisnya
rutin perbandingan yang tidak diproses di dalam gelung dalam (dan oleh itu tidak
dinyatakan secara tersirat sebagai lajur untuk dibaca). Untuk memastikan lajur sedemikian dibaca oleh
gelung acara, gunakan jelas kata kunci. Argumen untuk kata kunci ini menentukan lajur yang
hendaklah dibaca ke dalam struktur rekod input walaupun ia tidak disebut dalam
gelung dalam. Sebagai contoh:

pi pha yang jelas

akan memastikan lajur pi dan pha dibaca untuk setiap baris, walaupun tidak
diproses dalam gelung acara dalaman. The jelas kenyataan boleh diletakkan di mana-mana sahaja.

Akhirnya, ambil perhatian bahawa funcalc kini berfungsi pada ungkapan yang melibatkan jadual binari FITS dan
fail acara mentah. Kami akan mempertimbangkan untuk menambah sokongan untuk ekspresi imej pada masa akan datang,
jika ada permintaan untuk sokongan tersebut daripada masyarakat.

Gunakan funcalc dalam talian menggunakan perkhidmatan onworks.net