funcalc - Online in de cloud

PROGRAMMA:

NAAM

funcalc - Funtools rekenmachine (voor binaire tabellen)

KORTE INHOUD

funcalc [-n] [-a argstr] [-e expr] [-f bestand] [-l link] [-p prog] [onaam [kolommen]]

OPTIES

-a argstr # gebruikersargumenten die moeten worden doorgegeven aan het gecompileerde programma
-e expr # funcalc-expressie
-f bestand # bestand dat funcalc-expressie bevat
-l libs # libs om toe te voegen aan de linkopdracht
-n # output gegenereerde code in plaats van compileren en uitvoeren
-p prog # genereer een benoemd programma, geen uitvoering
-u # die als een variabele niet is gedeclareerd (niet automatisch declareren)

PRODUCTBESCHRIJVING

funcalc is een rekenprogramma waarmee willekeurige uitdrukkingen kunnen worden geconstrueerd,
gecompileerd en uitgevoerd op kolommen in een Funtools-tabel (FITS binaire tabel of onbewerkte gebeurtenis
bestand). Het werkt door door de gebruiker aangeleverde expressie(s) te integreren in een sjabloon C-programma
het samenstellen en uitvoeren van het programma. funcalc expressies zijn C-statements, hoewel sommige
belangrijke vereenvoudigingen (zoals automatische declaratie van variabelen) worden ondersteund.

funcalc expressies kunnen op drie manieren worden opgegeven: op de opdrachtregel met behulp van de -e
[uitdrukking] switch, in een bestand met behulp van de -f [het dossier] switch, of van stdin (als geen van beide -e
noch -f is gespecificeerd). Uiteraard een bestand met funcalc uitdrukkingen kunnen worden gelezen
standaard.

Elke aanroep van funcalc vereist dat een Funtools-tabelbestand wordt opgegeven als
eerste opdrachtregelargument. Het uitgevoerde Funtools-tabelbestand is het tweede optionele bestand
argument. Het is alleen nodig als er een FITS-uitvoerbestand wordt gemaakt (dat wil zeggen, in gevallen waarin
de funcalc expressie drukt alleen waarden af, er is geen uitvoerbestand nodig). Als invoer en uitvoer
bestand beide zijn opgegeven, kan een derde optioneel argument de lijst met kolommen specificeren
activeren (met FunColumnActivate()). Let daar op funcalc bepaalt of dat wel of niet moet
code genereren voor het schrijven van een uitvoerbestand op basis van de aan- of afwezigheid van een uitvoer
bestandsargument.

A funcalc expressie wordt uitgevoerd op elke rij van een tabel en bestaat uit een of meer C
instructies die op de kolommen van die rij werken (mogelijk met behulp van tijdelijke variabelen).
Binnen een uitdrukking wordt verwezen naar een kolom van de actueel rij met behulp van de C-structuur
syntaxis huidige-[colname]>, bijvoorbeeld cur->x, cur->pha, etc. Lokale scalaire variabelen kunnen worden gedefinieerd
door C-declaraties helemaal aan het begin van de expressie te gebruiken, of anders kunnen ze worden gedefinieerd
automatisch door funcalc (van het type dubbel zijn). Dus bijvoorbeeld een verwisseling van kolommen x
en y in een tabel kan worden uitgevoerd met behulp van een van de volgende equivalenten funcalc
uitdrukkingen:

dubbele temperatuur;
temp = huidig->x;
cur->x = cur->y;
cur->y = temperatuur;

of:

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

Wanneer deze expressie wordt uitgevoerd met behulp van een commando zoals:

funcalc -f swap.expritest.ev otest.ev

in het resulterende bestand zijn de waarden van de x- en y-kolommen verwisseld.

Standaard is het gegevenstype van de variabele voor een kolom hetzelfde als het gegevenstype van de
kolom zoals opgeslagen in het bestand. Dit kan worden gewijzigd door ":[dtype]" aan de eerste toe te voegen
verwijzing naar die kolom. Om in het bovenstaande voorbeeld te forceren dat x en y als dubbele waarden worden uitgevoerd,
specificeer het type 'D' expliciet:

temp = huidig->x:D;
huidige->x = huidige->y:D;
cur->y = temperatuur;

Gegevenstypespecificaties volgen de standaard FITS-tabelsyntaxis voor het definiëren van kolommen met behulp van TFORM:

· A: ASCII-tekens

· B: niet-ondertekende 8-bits tekens

· I: ondertekende 16-bit int

· U: unsigned 16-bit int (niet standaard FITS)

· J: ondertekende 32-bits int

· V: niet-ondertekende 32-bits int (niet standaard FITS)

· E: 32-bits float

· D: 64-bit float

· X: bits (behandeld als een reeks tekens)

Houd er rekening mee dat alleen de eerste verwijzing naar een kolom het expliciete gegevenstype mag bevatten
specificeerder.

Uiteraard is het belangrijk om correct om te gaan met het datatype van de kolommen. Een van de
meest voorkomende oorzaak van fouten in funcalc Programmeren is het impliciete gebruik van de verkeerde gegevens
typ voor een kolom in expressie. De berekening is bijvoorbeeld:

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

moet meestal worden uitgevoerd met behulp van drijvende-kommaberekeningen. In gevallen waarin de x en y
kolommen zijn gehele getallen, dit kan worden gedaan door de kolommen als dubbel te lezen met behulp van een expliciete
typespecificatie:

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

Als alternatief kan dit worden gedaan met behulp van C-type-casting in de uitdrukking:

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

Naast toegang tot kolommen in de huidige rij kan ook worden verwezen naar de
vorig rij gebruiken vorige-[colnaam]>, en naar de volgende rij gebruiken volgende-[colnaam]>. Let daar op
if vorige-[colnaam]> is opgegeven in het funcalc expressie, de allereerste rij niet
verwerkt. Als volgende-[colnaam]> is opgegeven in het funcalc uitdrukking, de allerlaatste rij
wordt niet verwerkt. Op deze manier, vorige en volgende verwijzen gegarandeerd altijd naar geldige rijen.
Als u bijvoorbeeld de waarden van de huidige x-kolom en de vorige y-kolom wilt afdrukken,
gebruik de Cfprintf-functie in a funcalc uitdrukking:

fprintf(stdout, "%d %d\n", huidige->x, vorige->y);

Nieuwe kolommen kunnen op dezelfde manier worden opgegeven huidige-[colname]> syntaxis door de kolom toe te voegen
type (en optionele tlmin/tlmax/binsiz-specificaties), gescheiden door dubbele punten. Bijvoorbeeld,
cur->avg:D definieert een nieuwe kolom van het type double. Typespecificaties zijn dezelfde
hierboven gebruikt om nieuwe gegevenstypen voor bestaande kolommen op te geven.

Om bijvoorbeeld een nieuwe kolom te maken en uit te voeren die de gemiddelde waarde is van x en y
kolommen, kan een nieuwe "gem"-kolom worden gedefinieerd:

huidige->gem:D = (huidige->x + huidige->y)/2.0

Merk op dat de laatste ';' is niet vereist voor uitdrukkingen met één regel.

Net als bij de FITS TFORM-gegevenstypespecificatie kan de kolomgegevenstypespecificatie worden voorafgegaan
door een numerieke telling om een ​​array te definiëren, bijvoorbeeld "10I" betekent een vector van 10 korte ints, "2E"
betekent twee enkele precisievlotters, enz. Een nieuwe kolom hoeft slechts één keer per keer te worden gedefinieerd
funcalc expressie, waarna deze kan worden gebruikt zonder het type opnieuw op te geven. Dit
bevat verwijzingen naar elementen van een kolomarray:

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

Het gegevenstype 'X' (bits) wordt behandeld als een char-array met dimensie (numeric_count/8), dwz
16X wordt verwerkt als een char-array van 2 bytes. Elk 8-bit array-element is afzonderlijk toegankelijk:

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

Hier wordt een 16-bits kolom gemaakt waarbij de MSB is ingesteld op 1 en de LSB is ingesteld op 2.

Standaard worden alle verwerkte rijen naar het opgegeven uitvoerbestand geschreven. Als je wilt
sla het schrijven van bepaalde rijen over, voer eenvoudigweg de C "continu" -instructie uit aan het einde van de
funcalc expressie, aangezien het schrijven van de rij onmiddellijk na de
expressie wordt uitgevoerd. Als u bijvoorbeeld schrijfrijen wilt overslaan waarvan het gemiddelde hetzelfde is als de
huidige x-waarde:

huidige->gem[0]:2D = (huidige->x + huidige->y)/2.0;
huidige->gem[1] = (huidige->x - huidige->y)/2.0;
if( huidige->avg[0] == huidige->x )
voort te zetten;

Als er geen uitvoerbestandsargument is opgegeven in het funcalc opdrachtregel, er is geen uitvoerbestand
geopend en er zijn geen rijen geschreven. Dit is handig bij expressies die eenvoudigweg uitvoer afdrukken
resultaten in plaats van een nieuw bestand te genereren:

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/(dubbel)(cur->au1+cur->au2+cur->au3);
fprintf(stdout, "%f\t%f\t%f\t%f\n", fpv, fbv, fpu, fbu);

In het bovenstaande voorbeeld gebruiken we zowel expliciete typespecificatie (voor "av"-kolommen) als type
casting (voor "au"-kolommen) om ervoor te zorgen dat alle bewerkingen dubbel worden uitgevoerd
precisie.

Wanneer een uitvoerbestand is opgegeven, wordt de geselecteerde invoertabel verwerkt en worden er rijen uitgevoerd
worden naar het uitvoerbestand gekopieerd. Merk op dat het uitvoerbestand kan worden opgegeven als "stdout" in
om de uitvoerrijen naar de standaarduitvoer te schrijven. Als het argument van het uitvoerbestand
doorgegeven, kan er ook een optioneel derde argument worden doorgegeven om aan te geven welke kolommen moeten worden verwerkt.

In een binaire FITS-tabel is het soms wenselijk om alle andere FITS-extensies te kopiëren
ook naar het uitvoerbestand. Dit kunt u doen door een '+'-teken achter de naam van de naam te plaatsen
extensie in de invoerbestandsnaam. Zien funtabel voor een verwant voorbeeld.

funcalc werkt door de door de gebruiker opgegeven expressie te integreren in een sjabloon C-programma
genaamd tabcalc.c. Het voltooide programma wordt vervolgens gecompileerd en uitgevoerd. Variabel
verklaringen die beginnen met de funcalc expressie worden in de lokale declaratiesectie geplaatst
van het sjabloonhoofdprogramma. Alle overige regels worden in de sjabloonhoofdprogramma's geplaatst
innerlijke verwerkingslus. Andere details van het genereren van programma's worden automatisch afgehandeld. Voor
Kolomspecificaties worden bijvoorbeeld geanalyseerd om een ​​C-structuur te bouwen voor het verwerken van rijen, dat wil zeggen
doorgegeven aan FunColumnSelect() en gebruikt in FunTabelRijGet(). Als een onbekende variabele wordt gebruikt
in de expressie, resulterend in een compilatiefout, wordt daarna opnieuw geprobeerd het programma te bouwen
definiëren dat de onbekende variabele van het type double is.

Normaal funcalc expressiecode wordt toegevoegd funcalc rijverwerkingslus. Het is mogelijk
om code aan andere delen van het programma toe te voegen door deze code in speciale richtlijnen te plaatsen
van het formulier:

[richtlijnnaam]
...de code komt hier...
einde

De richtlijnen zijn:

· globaal voeg code en verklaringen toe in de mondiale ruimte, vóór de hoofdroutine.

· lokaal voeg declaraties (en code) toe net na de lokale declaraties in main

· vaardigheden voeg code toe net voordat u de verwerkingslus van de hoofdrij binnengaat

· na voeg code toe net na het verlaten van de verwerkingslus in de hoofdrij

Dus het volgende funcalc expressie zal globale variabelen declareren en een subroutine maken
roept net voor en net na de hoofdverwerkingslus:

globaal
dubbel v1, v2;
dubbele init(void);
dubbele afwerking (dubbele v);
einde
vaardigheden
v1 = begin();
einde
... rijen verwerken, met berekeningen met v1 ...
na
v2 = afwerking(v1);
als( v2 < 0.0 ){
fprintf(stderr, "verwerking mislukt %g -> %g\n", v1, v2);
afrit(1);
}
einde

Routines zoals in het() en af hebben() hierboven worden doorgegeven aan het gegenereerde programma om te koppelen
met de -l [koppeling richtlijnen ​ schakelaar. De tekenreeks die door deze schakeloptie wordt opgegeven, is
toegevoegd aan de linklijn die werd gebruikt om het programma te bouwen (vóór de funtools-bibliotheek). Voor
ervan uitgaande dat dat bijvoorbeeld het geval is in het() en af hebben() bevinden zich in de bibliotheek libmysubs.a in de
/opt/special/lib directory, gebruik:

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

Gebruikersargumenten kunnen worden doorgegeven aan een gecompileerd funcalc-programma met behulp van een stringargument aan de
"-een knop. De string moet alle gebruikersargumenten bevatten. Passeren bijvoorbeeld
de gehele getallen 1 en 2, gebruik:

funcalc -a "1 2" ...

De argumenten worden opgeslagen in een interne array en zijn toegankelijk als strings via de ARGV(n)
macro. Beschouw bijvoorbeeld de volgende uitdrukking:

lokaal
int pmin, pmax;
einde

vaardigheden
pmin=atoi(ARGV(0));
pmax=atoi(ARGV(1));
einde

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

Deze expressie drukt x-, y- en pha-waarden af ​​voor alle rijen waarin de pha-waarde zich bevindt
tussen de twee door de gebruiker ingevoerde waarden:

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

Houd er rekening mee dat het de verantwoordelijkheid van de gebruiker is om ervoor te zorgen dat het juiste aantal argumenten wordt opgegeven
zijn gepasseerd. De macro ARGV(n) retourneert een NULL als een opgevraagd argument buiten de limieten valt
van het werkelijke aantal argumenten, wat meestal resulteert in een SEGV als deze blind wordt verwerkt. Controleren
het aantal argumenten, gebruik de ARGC-macro:

lokaal
lange int-seed=1;
dubbele limiet=0.8;
einde

vaardigheden
if( ARGC >= 1 ) zaad = atol(ARGV(0));
if( ARGC >= 2 ) limiet = atof(ARGV(1));
strand48(zaad);
einde

if ( drand48() > limit ) ga door;

De macro WRITE_ROW breidt zich uit naar de FunTabelRijPut() call die de huidige rij schrijft. Het
kan worden gebruikt om de rij meer dan één keer te schrijven. Bovendien breidt de macro NROW zich uit naar de
rijnummer dat momenteel wordt verwerkt. Het gebruik van deze twee macro's wordt hieronder weergegeven
voorbeeld:

if( cur->pha:I == cur->pi:I ) ga door;
a = cur->pha;
cur->pha = cur->pi;
cur->pi = a;
huidige->AVG:E = (huidige->pha+cur->pi)/2.0;
cur->NR:I = NROW;
als( NROW < 10 ) SCHRIJF_ROW;

Indien de -p [prog] switch is opgegeven, wordt de expressie niet uitgevoerd. Integendeel, de
Het gegenereerde uitvoerbare bestand wordt opgeslagen met de opgegeven programmanaam voor later gebruik.

Indien de -n switch is opgegeven, wordt de expressie niet uitgevoerd. Integendeel, de gegenereerde code
is geschreven naar stdout. Dit is vooral handig als u een skeletbestand wilt genereren
en voeg uw eigen code toe, of als u compilatiefouten moet controleren. Let op de opmerking
geeft aan het begin van de uitvoer de compileropdracht die nodig is om het programma daarop te bouwen
platform. (De opdracht kan van platform tot platform veranderen vanwege het gebruik van
verschillende bibliotheken, compilerschakelaars, enz.)

Zoals eerder vermeld, funcalc declareert automatisch een scalaire variabele (als een
double) als die variabele is gebruikt maar niet is gedeclareerd. Deze voorziening is geïmplementeerd
met behulp van een sed-script met de naam funcalc.sed, dat de uitvoer van de compiler verwerkt om een
niet-gedeclareerde variabele fout. Dit script is voorzien van de juiste fout
informatie voor gcc en voor cc op Solaris-, DecAlpha- en SGI-platforms. Als je dat vindt
automatische declaratie van scalairen werkt niet op uw platform, controleer dit sed-script;
het kan nodig zijn om enkele van de gedetecteerde foutmeldingen toe te voegen of te bewerken.

Om de lexicale analyse van te behouden funcalc uitdrukkingen (redelijk) eenvoudig, kozen we
om enkele beperkingen te accepteren over hoe nauwkeurig C-opmerkingen, spaties en nieuwe regels worden geplaatst
in het gegenereerde programma. In het bijzonder worden opmerkingen geassocieerd met lokale variabelen verklaard
aan het begin van een uitdrukking (dat wil zeggen, niet in a lokaal...einde blok) zal meestal eindigen
in de binnenste lus, niet met de lokale declaraties:

/* deze opmerking zal op de verkeerde plaats terechtkomen (dwz in de binnenste lus) */
dubbel A; /* ook op de verkeerde plaats */
/* dit komt op de juiste plaats (binnenste lus) */
if( huidige->x:D == huidige->y:D ) doorgaan; /* ook op de juiste plaats */
a = huidig->x;
cur->x = cur->y;
cur->y = a;
huidige->gem:E = (huidige->x+cur->y)/2.0;

Op dezelfde manier worden spaties en nieuwe regels soms weggelaten of schijnbaar willekeurig toegevoegd
manier. Uiteraard heeft geen van deze stilistische onvolkomenheden invloed op de juistheid van de tekst
gegenereerde code.

Omdat funcalc moet de gebruikersexpressie analyseren met behulp van de gegevensbestanden die zijn doorgegeven op de
opdrachtregel, moeten de invoerbestanden twee keer worden geopend en gelezen: één keer tijdens het programmeren
genereren en één keer tijdens de uitvoering. Als gevolg hiervan is het niet mogelijk om stdin te gebruiken voor de
Invoer bestand: funcalc kan niet als filter worden gebruikt. We zullen overwegen deze beperking op te heffen
op een later tijdstip.

Samen met C-opmerkingen, funcalc expressies kunnen interne opmerkingen van één regel bevatten
niet doorgegeven aan het gegenereerde C-programma. Deze interne opmerkingen beginnen met de #
karakter en ga verder naar de nieuwe regel:

dubbel A; # dit wordt niet doorgegeven aan het gegenereerde C-bestand
# Dit is ook niet het geval
a = huidig->x;
cur->x = cur->y;
cur->y = a;
/* deze opmerking wordt doorgegeven aan het C-bestand */
huidige->gem:E = (huidige->x+cur->y)/2.0;

Zoals eerder vermeld, worden invoerkolommen normaal gesproken geïdentificeerd doordat ze erin worden gebruikt
de binnenste gebeurtenislus. Er zijn zeldzame gevallen waarin u misschien een column wilt lezen en
Verwerk het buiten de hoofdlus. Qsort kan bijvoorbeeld een kolom in zijn sortering gebruiken
vergelijkingsroutine die niet binnen de binnenlus wordt verwerkt (en dus ook niet
impliciet gespecificeerd als een te lezen kolom). Om ervoor te zorgen dat een dergelijke kolom wordt gelezen door de
gebeurtenislus, gebruik de uitdrukkelijk trefwoord. De argumenten voor dit trefwoord specificeren kolommen die
moeten in de invoerrecordstructuur worden ingelezen, ook al worden ze niet vermeld in de
binnenste lus. Bijvoorbeeld:

expliciete pi pha

zorgt ervoor dat de pi- en pha-kolommen voor elke rij worden gelezen, zelfs als dat niet het geval is
verwerkt in de binnenste gebeurtenislus. De uitdrukkelijk verklaring kan overal worden geplaatst.

Merk ten slotte op dat funcalc werkt momenteel aan expressies met binaire FITS-tabellen en
onbewerkte gebeurtenisbestanden. We zullen op een later moment overwegen om ondersteuning voor beelduitdrukkingen toe te voegen.
als er vraag is naar dergelijke steun vanuit de gemeenschap.

Gebruik funcalc online met behulp van onworks.net-services