funcalc - Bulutta Çevrimiçi

Program:

ADI

funcalc - Funtools hesaplayıcısı (ikili tablolar için)

SİNOPSİS

funcalc [-n] [-a argstr] [-e ifade] [-f dosyası] [-l bağlantı] [-p prog] [oname [sütunlar]]

SEÇENEKLER

-a argstr # derlenmiş programa iletilecek kullanıcı argümanları
-e ifade # funcalc ifadesi
-f dosyası # funcalc ifadesini içeren dosya
-l libs # libs link komutuna eklenecek
-n # derleme ve yürütme yerine üretilen kod çıktısı
-p prog # adlandırılmış program oluştur, yürütme yok
-u # herhangi bir değişken bildirilmemişse ölür (otomatik bildirimde bulunma)

TANIM

funcalc keyfi ifadelerin oluşturulmasına izin veren bir hesap makinesi programıdır,
bir Funtools tablosundaki sütunlarda derlenir ve yürütülür (FITS ikili tablo veya ham olay
dosya). Kullanıcı tarafından sağlanan ifadeleri bir şablon C programına entegre ederek çalışır, ardından
programı derlemek ve yürütmek. funcalc ifadeler C ifadeleridir, ancak bazıları
önemli basitleştirmeler (değişkenlerin otomatik olarak bildirilmesi gibi) desteklenir.

funcalc ifadeler üç şekilde belirtilebilir: komut satırında -e
[ifade] geçiş, kullanarak bir dosyada -f [dosya] geçiş yapın veya stdin'den (hiç değilse -e
ne de -f belirtilir). Tabii ki içeren bir dosya funcalc ifadeler okunabilir
stdin.

Her çağırma funcalc olarak belirtilecek bir giriş Funtools tablo dosyası gerektirir.
ilk komut satırı argümanı. Çıktı Funtools tablo dosyası ikinci isteğe bağlıdır
argüman. Yalnızca bir çıktı FITS dosyası oluşturuluyorsa gereklidir (örn.
the funcalc ifade yalnızca değerleri yazdırır, çıktı dosyası gerekmez). Giriş ve çıkış ise
dosyanın her ikisi de belirtilirse, üçüncü bir isteğe bağlı bağımsız değişken, sütunların listesini belirtebilir.
etkinleştirmek (kullanarak FunColumnActivate()). Bunu not et funcalc yapılıp yapılmayacağını belirler
bir çıktının varlığına veya yokluğuna dayalı olarak bir çıktı dosyası yazmak için kod oluşturmak
dosya argümanı.

A funcalc ifade bir tablonun her satırında yürütülür ve bir veya daha fazla C'den oluşur
o satırın sütunlarında çalışan ifadeler (muhtemelen geçici değişkenler kullanılarak).
Bir ifade içinde, ifadenin bir sütununa atıfta bulunulur. akım C yapısını kullanarak satır
sözdizimi kur-[colname]>, örneğin cur->x, cur->pha, vb. Yerel skaler değişkenler tanımlanabilir
ifadenin en başında C bildirimlerini kullanarak, aksi takdirde tanımlanabilirler
otomatik olarak funcalc (çift tip olmak üzere). Bu nedenle, örneğin, x sütunlarının bir takası
ve bir tablodaki y, aşağıdaki eşdeğerlerden biri kullanılarak gerçekleştirilebilir funcalc
ifade:

çift ​​sıcaklık;
sıcaklık = cur->x;
kür->x = kür->y;
cur->y = sıcaklık;

ya da alışveriş sepetinize tıklayın:

sıcaklık = cur->x;
kür->x = kür->y;
cur->y = sıcaklık;

Bu ifade, aşağıdaki gibi bir komut kullanılarak yürütüldüğünde:

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

sonuçtaki dosya, değiştirilen x ve y sütunlarının değerlerine sahip olacaktır.

Varsayılan olarak, bir sütun için değişkenin veri türü, sütunun veri türüyle aynıdır.
dosyada depolandığı gibi sütun. Bu, birinciye ":[dtype]" eklenerek değiştirilebilir.
bu sütuna referans. Yukarıdaki örnekte, x ve y'yi double olarak çıktı almaya zorlamak için,
'D' türünü açıkça belirtin:

sıcaklık = cur->x:D;
kür->x = kür->y:D;
cur->y = sıcaklık;

Veri türü belirteçleri, TFORM kullanarak sütunları tanımlamak için standart FITS tablosu sözdizimini takip eder:

· A: ASCII karakterleri

· B: imzasız 8 bit karakter

· I: imzalı 16 bit int

· U: işaretsiz 16 bit int (standart UYUM değil)

· J: imzalı 32 bit int

· V: imzasız 32 bit int (standart UYUM değil)

· E: 32-bit kayan nokta

· D: 64-bit kayan nokta

· X: bitler (bir dizi karakter olarak değerlendirilir)

Yalnızca bir sütuna yapılan ilk başvurunun açık veri türünü içermesi gerektiğini unutmayın.
belirleyici.

Elbette kolonların veri tipini doğru işlemek önemlidir. Biri
hatanın en sık nedeni funcalc programlama yanlış verilerin örtülü kullanımıdır
ifadede bir sütun için yazın. Örneğin, hesaplama:

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

genellikle kayan nokta aritmetiği kullanılarak gerçekleştirilmesi gerekir. x ve y olduğu durumlarda
sütunlar tamsayılardır, bu, sütunları açık bir şekilde çiftler olarak okuyarak yapılabilir.
tip özellikleri:

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

Alternatif olarak, ifadede C tipi döküm kullanılarak yapılabilir:

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

Geçerli satırdaki sütunlara erişmenin yanı sıra,
önceki kullanarak satır önceki[kolname]> ve sonraki kullanarak satır sonraki-[kolname]>. Bunu not et
if önceki[kolname]> içinde belirtilir funcalc ifade, ilk satır değil
işlenmiş. Eğer sonraki-[kolname]> içinde belirtilir funcalc ifade, en son satır
işlenmez. Böylece, prev ve sonraki her zaman geçerli satırlara işaret etmesi garanti edilir.
Örneğin, mevcut x sütununun ve önceki y sütununun değerlerini yazdırmak için,
içinde C fprintf işlevini kullanın funcalc ifadesi:

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

Yeni sütunlar aynı kullanılarak belirtilebilir kur-[colname]> sütunu ekleyerek sözdizimi
iki nokta üst üste ile ayrılmış tür (ve isteğe bağlı tlmin/tlmax/binsiz belirteçleri). Örneğin,
cur->avg:D double türünde yeni bir sütun tanımlayacaktır. Tür belirteçleri, bunlarla aynıdır
yukarıda mevcut sütunlar için yeni veri türleri belirtmek için kullanılır.

Örneğin, x ve y'nin ortalama değeri olan yeni bir sütun oluşturmak ve çıktısını almak için
sütunlar, yeni bir "ortalama" sütunu tanımlanabilir:

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

Son ';' tek satırlık ifadeler için gerekli değildir.

FITS TFORM veri türü belirtiminde olduğu gibi, sütun veri türü belirticisinden önce gelebilir
bir diziyi tanımlamak için sayısal bir sayı ile, örneğin, "10I", 10 kısa inçlik bir vektör anlamına gelir, "2E"
iki tek duyarlık, vb. anlamına gelir. Yeni bir sütunun her seferinde yalnızca bir kez tanımlanması gerekir
funcalc ifade, bundan sonra tür yeniden belirtilmeden kullanılabilir. Bu
bir sütun dizisinin öğelerine başvuru içerir:

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

'X' (bit) veri türü, bir karakter dizisi boyutu (sayısal_sayım/8) olarak kabul edilir, yani,
16X, 2 baytlık bir karakter dizisi olarak işlenir. Her 8 bitlik dizi öğesine ayrı ayrı erişilir:

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

Burada, MSB 16'e ve LSB 1'ye ayarlı olarak 2 bitlik bir sütun oluşturulur.

Varsayılan olarak, işlenen tüm satırlar belirtilen çıktı dosyasına yazılır. İsterseniz
belirli satırları yazmayı atlayın, satırın sonundaki C "devam" ifadesini yürütmeniz yeterlidir.
funcalc ifadesi, satırın yazılmasından hemen sonra yapıldığından
ifadesi yürütülür. Örneğin, ortalama değeri ile aynı olan satırları yazmayı atlamak için
geçerli x değeri:

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

Çıktı dosyası bağımsız değişkeni belirtilmemişse funcalc komut satırı, çıktı dosyası yok
açılır ve satır yazılmaz. Bu, çıktıyı basitçe yazdıran ifadelerde kullanışlıdır.
yeni bir dosya oluşturmak yerine sonuçlar:

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

Yukarıdaki örnekte, hem açık tür belirtimini ("av" sütunları için) hem de türü kullanıyoruz
tüm işlemlerin çift olarak gerçekleştirilmesini sağlamak için döküm ("au" sütunları için)
hassas.

Bir çıktı dosyası belirtildiğinde, seçilen girdi tablosu işlenir ve çıktı satırları
çıktı dosyasına kopyalanır. Çıktı dosyasının "stdout" olarak belirtilebileceğini unutmayın.
çıktı satırlarını standart çıktıya yazmak için. Çıktı dosyası argümanı ise
geçilirse, hangi sütunların işleneceğini belirtmek için isteğe bağlı bir üçüncü bağımsız değişken de iletilebilir.

Bir FITS ikili tablosunda, bazen diğer tüm FITS uzantılarının kopyalanması istenir.
çıktı dosyasına da. Bu, dosyanın adına bir '+' işareti eklenerek yapılabilir.
giriş dosyası adındaki uzantı. Görmek eğlenceli ilgili bir örnek için.

funcalc kullanıcı tarafından belirtilen ifadeyi bir şablon C programına entegre ederek çalışır
tabcalc.c denir. Tamamlanan program daha sonra derlenir ve yürütülür. Değişken
başlayan beyannameler funcalc ifade yerel bildirim bölümüne yerleştirilir
şablon ana programı. Diğer tüm satırlar, şablon ana programın
iç işleme döngüsü. Program oluşturmanın diğer ayrıntıları otomatik olarak işlenir. İçin
örneğin, sütun belirteçleri, satırları işlemek için bir C yapısı oluşturmak üzere analiz edilir;
geçirilen FunColumnSelect() ve kullanılır FunTableRowGet(). Bilinmeyen bir değişken kullanılırsa
ifadede, bir derleme hatasıyla sonuçlanıyorsa, program derlemesi daha sonra yeniden denenir.
bilinmeyen değişkeni double türünde tanımlayın.

Normalde, funcalc ifade kodu eklenir funcalc satır işleme döngüsü. Bu mümkün
bu kodu özel yönergeler içine yerleştirerek programın diğer bölümlerine kod eklemek
şeklinde:

[yönerge adı]
... kod buraya gelir ...
son

Direktifler şunlardır:

· global ana rutinden önce global alana kod ve bildirimler ekleyin.

· yerel main içindeki yerel bildirimlerden hemen sonra bildirimler (ve kod) ekleyin

· önce ana satır işleme döngüsüne girmeden hemen önce kod ekleyin

· sonra ana satır işleme döngüsünden çıktıktan hemen sonra kod ekleyin

Böylece, aşağıdakiler funcalc ifade global değişkenleri bildirecek ve alt yordam oluşturacaktır
ana işleme döngüsünden hemen önce ve sonra çağrılar:

global
çift ​​v1, v2;
çift ​​init(void);
çift ​​bitiş (çift v);
son
önce
v1 = başlatma();
son
... v1 kullanarak hesaplamalar ile işlem satırları ...
sonra
v2 = bitiş(v1);
if( v2 < 0.0 ){
fprintf(stderr, "işleme başarısız %g -> %g\n", v1, v2);
çıkış(1);
}
son

gibi rutinler içinde() ve bitiş() yukarıdakiler, bağlantı için oluşturulan programa iletilir
ile -l [bağlantı direktifler ...] değiştirmek. Bu anahtar tarafından belirtilen dize olacak
programı oluşturmak için kullanılan bağlantı satırına eklenir (funtools kitaplığından önce). İçin
örneğin, varsayarsak içinde() ve bitiş() libmysubs.a kütüphanesindedir.
/opt/private/lib dizini için şunu kullanın:

funcalc -l "-L/opt/özel/lib -lmysubs" ...

Kullanıcı bağımsız değişkenleri, bir dizge bağımsız değişkeni kullanılarak derlenmiş bir funcalc programına geçirilebilir.
"-Bir anahtar. Dize, tüm kullanıcı bağımsız değişkenlerini içermelidir. Örneğin, geçmek
1 ve 2 tamsayıları için şunu kullanın:

funcalc -a "1 2" ...

Argümanlar dahili bir dizide saklanır ve ARGV(n) aracılığıyla diziler olarak erişilir.
makro. Örneğin, aşağıdaki ifadeyi göz önünde bulundurun:

yerel
int pmin, pmaks;
son

önce
pmin=atoi(ARGV(0));
pmaks=atoi(ARGV(1));
son

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

Bu ifade, pha değerinin olduğu tüm satırlar için x, y ve pha değerlerini yazdıracaktır.
iki kullanıcı girişi değeri arasında:

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

Doğru sayıda argümanın olduğundan emin olmanın kullanıcının sorumluluğunda olduğunu unutmayın.
geçildi. ARGV(n) makrosu, istenen bağımsız değişken sınırların dışındaysa bir NULL döndürür
gerçek arg sayısı, genellikle kör olarak işlenirse bir SEGV ile sonuçlanır. Kontrol etmek
argüman sayısı, ARGC makrosunu kullanın:

yerel
uzun int tohum=1;
çift ​​limit=0.8;
son

önce
if( ARGC >= 1 ) tohum = atol(ARGV(0));
if( ARGC >= 2 ) limit = atof(ARGV(1));
srand48(tohum);
son

eğer ( drand48() > limit ) devam ederse;

WRITE_ROW makrosu şu şekilde genişler: FunTableRowPut() geçerli satırı yazan çağrı. Bilişim Teknoloji
satırı birden fazla kez yazmak için kullanılabilir. Ek olarak, NROW makrosu aşağıdakilere genişler:
satır numarası şu anda işleniyor. Bu iki makronun kullanımı aşağıda gösterilmiştir.
örnek:

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

Eğer -p [program] switch belirtilirse, ifade yürütülmez. daha doğrusu
oluşturulan yürütülebilir dosya, daha sonra kullanılmak üzere belirtilen program adıyla kaydedilir.

Eğer -n switch belirtilirse, ifade yürütülmez. Bunun yerine, oluşturulan kod
stdout'a yazılır. Bu, özellikle bir iskelet dosyası oluşturmak istiyorsanız kullanışlıdır.
ve kendi kodunuzu ekleyin veya derleme hatalarını kontrol etmeniz gerekiyorsa. yorum olduğunu unutmayın
çıktının başında, programı bunun üzerine inşa etmek için gereken derleyici komutunu verir.
platform. (Komut, kullanımı nedeniyle platformdan platforma değişebilir.
farklı kitaplıklar, derleyici anahtarları vb.)

Daha önce bahsedildiği gibi, funcalc otomatik olarak bir skaler değişken bildirecektir (bir
double) bu değişken kullanılmış ancak bildirilmemişse. Bu tesis uygulanıyor
derleyici çıktısını algılamak için işleyen funcalc.sed adlı bir sed komut
bildirilmemiş değişken hatası. Bu komut dosyası uygun hatayla tohumlandı
Solaris, DecAlpha ve SGI platformlarında gcc ve cc için bilgiler. bunu bulursan
otomatik skaler bildirimi platformunuzda çalışmıyor, bu sed betiğini kontrol edin;
Algıladığı bazı hata mesajlarını eklemek veya düzenlemek gerekli olabilir.

Sözcük analizini sürdürmek için funcalc ifadeler (makul derecede) basit, seçtik
C yorumlarının, boşlukların ve yeni satırların ne kadar doğru yerleştirildiğine ilişkin bazı sınırlamaları kabul etmek
oluşturulan programda Bilhassa, beyan edilen yerel değişkenlerle ilgili yorumlar
bir ifadenin başında (yani, bir yerel...son blok) genellikle sona erer
yerel bildirimlerle değil, iç döngüde:

/* bu yorum yanlış yere gelecek (yani iç döngü) */
çift ​​a; /* ayrıca yanlış yerde */
/* bu doğru yerde olacak (iç döngü) */
if( cur->x:D == cur->y:D ) devam; /* ayrıca doğru yerde */
a = kür->x;
kür->x = kür->y;
cur->y = a;
cur->ort:E = (cur->x+cur->y)/2.0;

Benzer şekilde, boşluklar ve yeni satırlar bazen atlanır veya görünüşte keyfi bir şekilde eklenir.
tavır. Tabii ki, bu üslup kusurlarının hiçbiri metnin doğruluğunu etkilemez.
oluşturulan kod.

Çünkü funcalc üzerinde iletilen veri dosyalarını kullanarak kullanıcı ifadesini analiz etmelidir.
komut satırında, giriş dosyaları açılmalı ve iki kez okunmalıdır: program sırasında bir kez
oluşturma ve yürütme sırasında bir kez. Sonuç olarak, stdin'i aşağıdakiler için kullanmak mümkün değildir.
giriş dosyası: funcalc filtre olarak kullanılamaz. Bu kısıtlamayı kaldırmayı düşüneceğiz
daha sonra.

C yorumlarıyla birlikte, funcalc ifadeler tek satırlık dahili yorumlara sahip olabilir.
oluşturulan C programına aktarılmaz. Bu dahili yorum şu şekilde başlar: #
karakter ve yeni satıra kadar devam edin:

çift ​​a; # bu oluşturulan C dosyasına iletilmez
# ne de bu
a = kür->x;
kür->x = kür->y;
cur->y = a;
/* bu yorum C dosyasına iletilir */
cur->ort:E = (cur->x+cur->y)/2.0;

Daha önce belirtildiği gibi, giriş sütunları normalde içinde kullanıldıkları ile tanımlanır.
iç olay döngüsü. Bir sütunu okumak isteyebileceğiniz nadir durumlar vardır ve
ana döngünün dışında işleyin. Örneğin, qsort, sıralamada bir sütun kullanabilir.
iç döngü içinde işlenmeyen (ve dolayısıyla
örtük olarak okunacak bir sütun olarak belirtilir). Böyle bir sütunun kullanıcı tarafından okunmasını sağlamak için
olay döngüsü, açık anahtar kelime. Bu anahtar kelimenin bağımsız değişkenleri, şu sütunları belirtir:
içinde bahsedilmese bile giriş kayıt yapısına okunmalıdır.
iç döngü. Örneğin:

açık pi pha

pi ve pha sütunlarının, olmasalar bile her satır için okunmasını sağlayacaktır.
iç olay döngüsünde işlenir. NS açık ifadesi herhangi bir yere yerleştirilebilir.

Son olarak, şunu unutmayın funcalc şu anda FITS ikili tablolarını içeren ifadeler üzerinde çalışıyor ve
ham olay dosyaları. Daha sonra resim ifadeleri için destek eklemeyi düşüneceğiz,
toplumdan böyle bir destek talebi varsa.

onworks.net hizmetlerini kullanarak funcalc'ı çevrimiçi kullanın