funcalc - ക്ലൗഡിൽ ഓൺലൈനിൽ

പട്ടിക:

NAME

funcalc - Funtools കാൽക്കുലേറ്റർ (ബൈനറി പട്ടികകൾക്കായി)

സിനോപ്സിസ്

funcalc [-n] [-a argstr] [-e expr] [-f ഫയൽ] [-l ലിങ്ക്] [-p prog] [ഓണമേ [നിരകൾ]]

ഓപ്ഷനുകൾ

-a argstr # കംപൈൽ ചെയ്ത പ്രോഗ്രാമിലേക്ക് കൈമാറുന്നതിനുള്ള ഉപയോക്തൃ ആർഗ്യുമെന്റുകൾ
-e expr # funcalc എക്സ്പ്രഷൻ
-f ഫയൽ # ഫയൽ funcalc എക്സ്പ്രഷൻ അടങ്ങുന്നു
ലിങ്ക് കമാൻഡിലേക്ക് ചേർക്കാൻ -l libs # libs
-n # കംപൈൽ ചെയ്യുന്നതിനും എക്‌സിക്യൂട്ട് ചെയ്യുന്നതിനും പകരം കോഡ് സൃഷ്‌ടിച്ച ഔട്ട്‌പുട്ട്
-p പ്രോഗ് # പേരിട്ടിരിക്കുന്ന പ്രോഗ്രാം സൃഷ്ടിക്കുക, എക്സിക്യൂഷൻ ഇല്ല
ഏതെങ്കിലും വേരിയബിൾ പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിൽ -u # ഡൈ ചെയ്യുക (സ്വയം പ്രഖ്യാപിക്കരുത്)

വിവരണം

funcalc അനിയന്ത്രിതമായ പദപ്രയോഗങ്ങൾ നിർമ്മിക്കാൻ അനുവദിക്കുന്ന ഒരു കാൽക്കുലേറ്റർ പ്രോഗ്രാമാണ്,
ഒരു ഫണ്ടൂൾസ് ടേബിളിലെ (FITS ബൈനറി ടേബിൾ അല്ലെങ്കിൽ റോ ഇവന്റ്) കോളങ്ങളിൽ കംപൈൽ ചെയ്‌ത് നടപ്പിലാക്കുന്നു
ഫയൽ). ഉപയോക്താക്കൾ നൽകുന്ന എക്‌സ്‌പ്രഷൻ(കൾ) ഒരു ടെംപ്ലേറ്റ് സി പ്രോഗ്രാമിലേക്ക് സംയോജിപ്പിച്ച് ഇത് പ്രവർത്തിക്കുന്നു
പ്രോഗ്രാം കംപൈൽ ചെയ്യുകയും നടപ്പിലാക്കുകയും ചെയ്യുന്നു. funcalc പദപ്രയോഗങ്ങൾ സി പ്രസ്താവനകളാണ്, ചിലതെങ്കിലും
പ്രധാനപ്പെട്ട ലളിതവൽക്കരണങ്ങൾ (വേരിയബിളുകളുടെ ഓട്ടോമാറ്റിക് ഡിക്ലറേഷൻ പോലുള്ളവ) പിന്തുണയ്ക്കുന്നു.

funcalc എക്സ്പ്രഷനുകൾ മൂന്ന് തരത്തിൽ വ്യക്തമാക്കാം: കമാൻഡ് ലൈനിൽ -e
[പ്രകടനം] സ്വിച്ച്, ഉപയോഗിച്ച് ഒരു ഫയലിൽ -f [ഫയൽ] മാറുക, അല്ലെങ്കിൽ stdin-ൽ നിന്ന് (ഇല്ലെങ്കിൽ -e
വേണ്ടാ -f വ്യക്തമാക്കിയിട്ടുണ്ട്). തീർച്ചയായും അടങ്ങുന്ന ഒരു ഫയൽ funcalc പദപ്രയോഗങ്ങൾ വായിക്കാൻ കഴിയും
stdin.

എന്ന ഓരോ അഭ്യർത്ഥനയും funcalc എന്നതായി വ്യക്തമാക്കുന്നതിന് ഒരു ഇൻപുട്ട് Funtools ടേബിൾ ഫയൽ ആവശ്യമാണ്
ആദ്യ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ്. ഔട്ട്‌പുട്ട് Funtools ടേബിൾ ഫയൽ രണ്ടാമത്തെ ഓപ്‌ഷണലാണ്
വാദം. ഒരു ഔട്ട്‌പുട്ട് FITS ഫയൽ സൃഷ്‌ടിക്കുകയാണെങ്കിൽ മാത്രമേ ഇത് ആവശ്യമുള്ളൂ (അതായത്, സന്ദർഭങ്ങളിൽ
The funcalc എക്സ്പ്രഷൻ മൂല്യങ്ങൾ മാത്രം പ്രിന്റ് ചെയ്യുന്നു, ഔട്ട്പുട്ട് ഫയലൊന്നും ആവശ്യമില്ല). ഇൻപുട്ടും ഔട്ട്പുട്ടും ആണെങ്കിൽ
ഫയൽ രണ്ടും വ്യക്തമാക്കിയിട്ടുണ്ട്, ഒരു മൂന്നാമത്തെ ഓപ്ഷണൽ ആർഗ്യുമെന്റിന് നിരകളുടെ ലിസ്റ്റ് വ്യക്തമാക്കാൻ കഴിയും
സജീവമാക്കുക (ഉപയോഗിക്കുക FunColumnActivate()). അതല്ല funcalc വേണോ വേണ്ടയോ എന്ന് തീരുമാനിക്കുന്നു
ഒരു ഔട്ട്പുട്ടിന്റെ സാന്നിധ്യം അല്ലെങ്കിൽ അഭാവം അടിസ്ഥാനമാക്കി ഒരു ഔട്ട്പുട്ട് ഫയൽ എഴുതുന്നതിനുള്ള കോഡ് സൃഷ്ടിക്കുക
ഫയൽ വാദം.

A funcalc ഒരു പട്ടികയുടെ ഓരോ വരിയിലും എക്‌സ്‌പ്രഷൻ എക്‌സിക്യൂട്ട് ചെയ്യുന്നു, അതിൽ ഒന്നോ അതിലധികമോ സി അടങ്ങിയിരിക്കുന്നു
ആ വരിയുടെ നിരകളിൽ പ്രവർത്തിക്കുന്ന പ്രസ്താവനകൾ (ഒരുപക്ഷേ താൽക്കാലിക വേരിയബിളുകൾ ഉപയോഗിച്ച്).
ഒരു എക്‌സ്‌പ്രഷനിൽ, എന്നതിന്റെ ഒരു നിരയെ പരാമർശിക്കുന്നു നിലവിലുള്ളത് സി സ്ട്രക്റ്റ് ഉപയോഗിച്ച് വരി
സിന്റാക്സ് കർ -[colname]>, ഉദാ cur->x, cur->pha, മുതലായവ. പ്രാദേശിക സ്കെയിലർ വേരിയബിളുകൾ നിർവചിക്കാം
പദപ്രയോഗത്തിന്റെ തുടക്കത്തിൽ തന്നെ C പ്രഖ്യാപനങ്ങൾ ഉപയോഗിക്കുന്നു, അല്ലെങ്കിൽ അവ നിർവചിക്കാം
സ്വയമേവ funcalc (ഇരട്ട തരത്തിലുള്ളതായിരിക്കണം). അതിനാൽ, ഉദാഹരണത്തിന്, x നിരകളുടെ ഒരു സ്വാപ്പ്
കൂടാതെ ഒരു പട്ടികയിലെ y ഇനിപ്പറയുന്ന തത്തുല്യമായ ഒന്ന് ഉപയോഗിച്ച് നടപ്പിലാക്കാം funcalc
ഭാവങ്ങൾ:

ഇരട്ട താപനില;
temp = cur->x;
cur->x = cur->y;
cur->y = temp;

അഥവാ:

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

ഇതുപോലുള്ള ഒരു കമാൻഡ് ഉപയോഗിച്ച് ഈ എക്സ്പ്രഷൻ എക്സിക്യൂട്ട് ചെയ്യുമ്പോൾ:

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

തത്ഫലമായുണ്ടാകുന്ന ഫയലിൽ x, y നിരകളുടെ മൂല്യങ്ങൾ സ്വാപ്പ് ചെയ്‌തിരിക്കും.

സ്ഥിരസ്ഥിതിയായി, ഒരു കോളത്തിനായുള്ള വേരിയബിളിന്റെ ഡാറ്റാ തരം, യുടെ ഡാറ്റാ തരത്തിന് സമാനമാണ്
ഫയലിൽ സംഭരിച്ചിരിക്കുന്ന കോളം. ആദ്യത്തേതിൽ ":[dtype]" ചേർത്തുകൊണ്ട് ഇത് മാറ്റാവുന്നതാണ്
ആ നിരയെക്കുറിച്ചുള്ള പരാമർശം. മുകളിലുള്ള ഉദാഹരണത്തിൽ, x ഉം y ഉം ഇരട്ടിയായി ഔട്ട്‌പുട്ട് ചെയ്യാൻ നിർബന്ധിക്കുന്നതിന്,
'D' തരം വ്യക്തമായി വ്യക്തമാക്കുക:

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

TFORM ഉപയോഗിച്ച് നിരകൾ നിർവചിക്കുന്നതിന് ഡാറ്റ തരം സ്പെസിഫയറുകൾ സ്റ്റാൻഡേർഡ് FITS ടേബിൾ സിന്റാക്സ് പിന്തുടരുന്നു:

A: ASCII പ്രതീകങ്ങൾ

· ബി: ഒപ്പിടാത്ത 8-ബിറ്റ് ചാർ

· ഞാൻ: ഒപ്പിട്ട 16-ബിറ്റ് ഇന്റ്

· യു: ഒപ്പിടാത്ത 16-ബിറ്റ് ഇൻറ്റ് (സാധാരണ FITS അല്ല)

· ജെ: ഒപ്പിട്ട 32-ബിറ്റ് ഇന്റ്

· വി: ഒപ്പിടാത്ത 32-ബിറ്റ് ഇൻറ്റ് (സാധാരണ FITS അല്ല)

· ഇ: 32-ബിറ്റ് ഫ്ലോട്ട്

· ഡി: 64-ബിറ്റ് ഫ്ലോട്ട്

X: ബിറ്റുകൾ (അക്ഷരങ്ങളുടെ ഒരു നിരയായി കണക്കാക്കുന്നു)

ഒരു കോളത്തിലേക്കുള്ള ആദ്യ റഫറൻസിൽ മാത്രമേ വ്യക്തമായ ഡാറ്റ തരം അടങ്ങിയിരിക്കാവൂ എന്നത് ശ്രദ്ധിക്കുക
സ്പെസിഫയർ.

തീർച്ചയായും, നിരകളുടെ ഡാറ്റ തരം ശരിയായി കൈകാര്യം ചെയ്യേണ്ടത് പ്രധാനമാണ്. ഉള്ളതിൽ ഒന്ന്
പിശകിന്റെ ഏറ്റവും പതിവ് കാരണം funcalc തെറ്റായ ഡാറ്റയുടെ പരോക്ഷമായ ഉപയോഗമാണ് പ്രോഗ്രാമിംഗ്
എക്സ്പ്രഷനിൽ ഒരു കോളം ടൈപ്പ് ചെയ്യുക. ഉദാഹരണത്തിന്, കണക്കുകൂട്ടൽ:

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

സാധാരണയായി ഫ്ലോട്ടിംഗ് പോയിന്റ് അരിത്മെറ്റിക് ഉപയോഗിച്ച് നടത്തേണ്ടതുണ്ട്. x ഉം y ഉം ഉള്ള സന്ദർഭങ്ങളിൽ
നിരകൾ പൂർണ്ണസംഖ്യകളാണ്, ഒരു സ്പഷ്ടമായത് ഉപയോഗിച്ച് കോളങ്ങൾ ഇരട്ടകളായി വായിച്ചുകൊണ്ട് ഇത് ചെയ്യാൻ കഴിയും
തരം സ്പെസിഫിക്കേഷൻ:

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

പകരമായി, എക്സ്പ്രഷനിലെ സി ടൈപ്പ് കാസ്റ്റിംഗ് ഉപയോഗിച്ച് ഇത് ചെയ്യാം:

dx = ((ഇരട്ട) cur->x - (ഇരട്ട) cur->y)/((ഇരട്ട) cur->x + (ഇരട്ട) cur->y);

നിലവിലെ വരിയിലെ കോളങ്ങൾ ആക്‌സസ് ചെയ്യുന്നതിനു പുറമേ, റഫറൻസും ചെയ്യാം
മുമ്പത്തെ വരി ഉപയോഗിക്കുന്നത് മുൻ-[colname]>, ഒപ്പം തൊട്ടടുത്ത വരി ഉപയോഗിക്കുന്നത് അടുത്തത്-[colname]>. അതല്ല
if മുൻ-[colname]> എന്നതിൽ വ്യക്തമാക്കിയിരിക്കുന്നു funcalc എക്സ്പ്രഷൻ, ആദ്യ വരി തന്നെ അല്ല
പ്രോസസ്സ് ചെയ്തു. എങ്കിൽ അടുത്തത്-[colname]> എന്നതിൽ വ്യക്തമാക്കിയിരിക്കുന്നു funcalc എക്സ്പ്രഷൻ, അവസാന വരി
പ്രോസസ്സ് ചെയ്തിട്ടില്ല. ഈ വഴിയിൽ, മുമ്പത്തേത് ഒപ്പം തൊട്ടടുത്ത എല്ലായ്‌പ്പോഴും സാധുവായ വരികളിലേക്ക് പോയിന്റ് ചെയ്യുമെന്ന് ഉറപ്പുനൽകുന്നു.
ഉദാഹരണത്തിന്, നിലവിലെ x കോളത്തിന്റെയും മുമ്പത്തെ y കോളത്തിന്റെയും മൂല്യങ്ങൾ പ്രിന്റ് ചെയ്യാൻ,
a-ൽ C fprintf ഫംഗ്‌ഷൻ ഉപയോഗിക്കുക funcalc ആവിഷ്കാരം:

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

ഇത് ഉപയോഗിച്ച് പുതിയ കോളങ്ങൾ വ്യക്തമാക്കാം കർ -കോളം ചേർത്തുകൊണ്ട് [colname]> വാക്യഘടന
തരം (ഒപ്പം ഓപ്ഷണൽ tlmin/tlmax/binsiz സ്പെസിഫയറുകൾ), കോളണുകൾ കൊണ്ട് വേർതിരിച്ചിരിക്കുന്നു. ഉദാഹരണത്തിന്,
cur-> ശരാശരി:D ഇരട്ട ടൈപ്പിന്റെ ഒരു പുതിയ കോളം നിർവ്വചിക്കും. ടൈപ്പ് സ്പെസിഫയറുകൾ സമാനമാണ്
നിലവിലുള്ള കോളങ്ങൾക്കായി പുതിയ ഡാറ്റ തരങ്ങൾ വ്യക്തമാക്കുന്നതിന് മുകളിൽ ഉപയോഗിച്ചു.

ഉദാഹരണത്തിന്, x, y എന്നിവയുടെ ശരാശരി മൂല്യമായ ഒരു പുതിയ കോളം സൃഷ്ടിക്കുന്നതിനും ഔട്ട്പുട്ട് ചെയ്യുന്നതിനും
നിരകൾ, ഒരു പുതിയ "ശരാശരി" നിര നിർവചിക്കാം:

cur-> ശരാശരി:D = (cur->x + cur->y)/2.0

അവസാനത്തെ ';' സിംഗിൾ-ലൈൻ എക്സ്പ്രഷനുകൾക്ക് ആവശ്യമില്ല.

FITS TFORM ഡാറ്റാ ടൈപ്പ് സ്‌പെസിഫിക്കേഷൻ പോലെ, കോളം ഡാറ്റാ ടൈപ്പ് സ്‌പെസിഫയറിന് മുമ്പായി നൽകാം
ഒരു അറേ നിർവചിക്കുന്നതിനുള്ള ഒരു സംഖ്യാ കണക്കനുസരിച്ച്, ഉദാ, "10I" എന്നാൽ 10 ഷോർട്ട് ഇന്റുകളുടെ വെക്റ്റർ എന്നാണ് അർത്ഥമാക്കുന്നത്, "2E"
രണ്ട് സിംഗിൾ പ്രിസിഷൻ ഫ്ലോട്ടുകൾ മുതലായവ അർത്ഥമാക്കുന്നു. ഒരു പുതിയ കോളം ഒരു തവണ മാത്രം നിർവ്വചിച്ചാൽ മതിയാകും
funcalc എക്സ്പ്രഷൻ, അതിനുശേഷം അത് തരം വീണ്ടും വ്യക്തമാക്കാതെ ഉപയോഗിക്കാം. ഈ
ഒരു നിര നിരയുടെ ഘടകങ്ങളെക്കുറിച്ചുള്ള റഫറൻസ് ഉൾപ്പെടുന്നു:

cur-> ശരാശരി[0]:2D = (cur->x + cur->y)/2.0;
cur-> ശരാശരി[1] = (cur->x - cur->y)/2.0;

'X' (ബിറ്റ്‌സ്) ഡാറ്റ തരം അളവിന്റെ ഒരു ചാർ അറേ ആയി കണക്കാക്കുന്നു (numeric_count/8), അതായത്,
16X ഒരു 2-ബൈറ്റ് ചാർ അറേ ആയി പ്രോസസ്സ് ചെയ്യുന്നു. ഓരോ 8-ബിറ്റ് അറേ എലമെന്റും വെവ്വേറെ ആക്സസ് ചെയ്യുന്നു:

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

ഇവിടെ, MSB 16 ആയും LSB 1 ആയും സജ്ജീകരിച്ച് ഒരു 2-ബിറ്റ് കോളം സൃഷ്ടിക്കപ്പെടുന്നു.

സ്ഥിരസ്ഥിതിയായി, പ്രോസസ്സ് ചെയ്ത എല്ലാ വരികളും നിർദ്ദിഷ്ട ഔട്ട്പുട്ട് ഫയലിലേക്ക് എഴുതിയിരിക്കുന്നു. നിങ്ങൾക്ക് വേണമെങ്കിൽ
ചില വരികൾ എഴുതുന്നത് ഒഴിവാക്കുക, അവസാനത്തിൽ C "continue" എന്ന പ്രസ്താവന നടപ്പിലാക്കുക
funcalc എക്സ്പ്രഷൻ, കാരണം വരിയുടെ എഴുത്ത് ഉടൻ തന്നെ നടപ്പിലാക്കുന്നു
എക്സ്പ്രഷൻ എക്സിക്യൂട്ട് ചെയ്യുന്നു. ഉദാഹരണത്തിന്, ശരാശരി വരികൾ എഴുതുന്നത് ഒഴിവാക്കുന്നതിന്
നിലവിലെ x മൂല്യം:

cur-> ശരാശരി[0]:2D = (cur->x + cur->y)/2.0;
cur-> ശരാശരി[1] = (cur->x - cur->y)/2.0;
if( cur-> ശരാശരി[0] == cur->x )
തുടരുക;

ഔട്ട്‌പുട്ട് ഫയൽ ആർഗ്യുമെന്റ് ഒന്നും വ്യക്തമാക്കിയിട്ടില്ലെങ്കിൽ funcalc കമാൻഡ് ലൈൻ, ഔട്ട്പുട്ട് ഫയലൊന്നും ഇല്ല
തുറന്ന് വരികളൊന്നും എഴുതിയിട്ടില്ല. ഔട്ട്പുട്ട് പ്രിന്റ് ചെയ്യുന്ന എക്സ്പ്രഷനുകളിൽ ഇത് ഉപയോഗപ്രദമാണ്
ഒരു പുതിയ ഫയൽ സൃഷ്ടിക്കുന്നതിനുപകരം ഫലങ്ങൾ:

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

മുകളിലെ ഉദാഹരണത്തിൽ, ഞങ്ങൾ വ്യക്തമായ തരം സ്പെസിഫിക്കേഷനും ("av" നിരകൾക്കായി) തരവും ഉപയോഗിക്കുന്നു
എല്ലാ പ്രവർത്തനങ്ങളും ഇരട്ടിയായി നടക്കുന്നുണ്ടെന്ന് ഉറപ്പാക്കാൻ കാസ്റ്റിംഗ് ("au" നിരകൾക്കായി).
കൃത്യത.

ഒരു ഔട്ട്പുട്ട് ഫയൽ വ്യക്തമാക്കുമ്പോൾ, തിരഞ്ഞെടുത്ത ഇൻപുട്ട് ടേബിൾ പ്രോസസ്സ് ചെയ്യുകയും ഔട്ട്പുട്ട് വരികൾ നൽകുകയും ചെയ്യുന്നു
ഔട്ട്പുട്ട് ഫയലിലേക്ക് പകർത്തുന്നു. ഔട്ട്‌പുട്ട് ഫയലിനെ "stdout" എന്ന് വ്യക്തമാക്കാനാകുമെന്നത് ശ്രദ്ധിക്കുക
സ്റ്റാൻഡേർഡ് ഔട്ട്പുട്ടിലേക്ക് ഔട്ട്പുട്ട് വരികൾ എഴുതാൻ ഓർഡർ ചെയ്യുക. ഔട്ട്പുട്ട് ഫയൽ ആർഗ്യുമെന്റ് ആണെങ്കിൽ
പാസായി, ഏത് കോളങ്ങളാണ് പ്രോസസ്സ് ചെയ്യേണ്ടതെന്ന് വ്യക്തമാക്കുന്നതിന് ഒരു ഓപ്ഷണൽ മൂന്നാമത്തെ ആർഗ്യുമെന്റും പാസ്സാക്കാവുന്നതാണ്.

ഒരു FITS ബൈനറി പട്ടികയിൽ, മറ്റ് FITS വിപുലീകരണങ്ങളെല്ലാം പകർത്തുന്നത് ചിലപ്പോൾ അഭികാമ്യമാണ്.
ഔട്ട്പുട്ട് ഫയലിലേക്കും. എന്ന പേരിൽ ഒരു '+' ചിഹ്നം ചേർത്തുകൊണ്ട് ഇത് ചെയ്യാം
ഇൻപുട്ട് ഫയലിന്റെ പേരിലുള്ള വിപുലീകരണം. കാണുക പ്രവർത്തനക്ഷമമായ അനുബന്ധ ഉദാഹരണത്തിനായി.

funcalc ഉപയോക്തൃ-നിർദ്ദിഷ്ട എക്സ്പ്രഷൻ ഒരു ടെംപ്ലേറ്റ് സി പ്രോഗ്രാമിലേക്ക് സംയോജിപ്പിച്ച് പ്രവർത്തിക്കുന്നു
tabcalc.c എന്ന് വിളിക്കുന്നു. പൂർത്തിയാക്കിയ പ്രോഗ്രാം പിന്നീട് കംപൈൽ ചെയ്യുകയും എക്സിക്യൂട്ട് ചെയ്യുകയും ചെയ്യുന്നു. വേരിയബിൾ
ആരംഭിക്കുന്ന പ്രഖ്യാപനങ്ങൾ funcalc പദപ്രയോഗം പ്രാദേശിക പ്രഖ്യാപന വിഭാഗത്തിൽ സ്ഥാപിച്ചിരിക്കുന്നു
ടെംപ്ലേറ്റ് പ്രധാന പ്രോഗ്രാമിന്റെ. മറ്റെല്ലാ വരികളും ടെംപ്ലേറ്റ് പ്രധാന പ്രോഗ്രാമിൽ സ്ഥാപിച്ചിരിക്കുന്നു
ആന്തരിക പ്രോസസ്സിംഗ് ലൂപ്പ്. പ്രോഗ്രാം ജനറേഷന്റെ മറ്റ് വിശദാംശങ്ങൾ സ്വയമേവ കൈകാര്യം ചെയ്യുന്നു. വേണ്ടി
ഉദാഹരണത്തിന്, വരികൾ പ്രോസസ്സ് ചെയ്യുന്നതിനായി ഒരു C സ്ട്രക്റ്റ് നിർമ്മിക്കുന്നതിന് കോളം സ്പെസിഫയറുകൾ വിശകലനം ചെയ്യുന്നു, അതായത്
ലേക്ക് കൈമാറി FunColumnSelect() ഉപയോഗിക്കുകയും ചെയ്തു FunTableRowGet(). ഒരു അജ്ഞാത വേരിയബിൾ ഉപയോഗിക്കുകയാണെങ്കിൽ
എക്‌സ്‌പ്രഷനിൽ, ഒരു കംപൈലേഷൻ പിശകിന് കാരണമായി, പ്രോഗ്രാം ബിൽഡ് പിന്നീട് വീണ്ടും ശ്രമിച്ചു
അജ്ഞാത വേരിയബിളിനെ ടൈപ്പ് ഡബിൾ എന്ന് നിർവചിക്കുന്നു.

സാധാരണയായി, funcalc എക്സ്പ്രഷൻ കോഡ് ചേർത്തു funcalc വരി പ്രോസസ്സിംഗ് ലൂപ്പ്. അതു സാധ്യമാണ്
പ്രത്യേക നിർദ്ദേശങ്ങൾക്കുള്ളിൽ ഈ കോഡ് സ്ഥാപിച്ച് പ്രോഗ്രാമിന്റെ മറ്റ് ഭാഗങ്ങളിലേക്ക് കോഡ് ചേർക്കുന്നതിന്
രൂപത്തിന്റെ:

[നിർദ്ദേശ നാമം]
... കോഡ് ഇവിടെ പോകുന്നു ...
അവസാനിക്കുന്നു

നിർദ്ദേശങ്ങൾ ഇവയാണ്:

· ഗ്ലോബൽ പ്രധാന ദിനചര്യയ്ക്ക് മുമ്പ് ആഗോള സ്ഥലത്ത് കോഡും പ്രഖ്യാപനങ്ങളും ചേർക്കുക.

· പ്രാദേശിക പ്രധാനമായും പ്രാദേശിക പ്രഖ്യാപനങ്ങൾക്ക് തൊട്ടുപിന്നാലെ പ്രഖ്യാപനങ്ങൾ (കോഡ്) ചേർക്കുക

· മുമ്പ് പ്രധാന വരി പ്രോസസ്സിംഗ് ലൂപ്പിലേക്ക് പ്രവേശിക്കുന്നതിന് തൊട്ടുമുമ്പ് കോഡ് ചേർക്കുക

· ശേഷം പ്രധാന വരി പ്രോസസ്സിംഗ് ലൂപ്പിൽ നിന്ന് പുറത്തുകടന്നതിന് ശേഷം കോഡ് ചേർക്കുക

അങ്ങനെ, താഴെ funcalc എക്സ്പ്രഷൻ ആഗോള വേരിയബിളുകൾ പ്രഖ്യാപിക്കുകയും സബ്റൂട്ടീൻ ഉണ്ടാക്കുകയും ചെയ്യും
പ്രധാന പ്രോസസ്സിംഗ് ലൂപ്പിന് തൊട്ടുമുമ്പും ശേഷവും കോളുകൾ:

ഗ്ലോബൽ
ഇരട്ട v1, v2;
ഇരട്ട init (അസാധു);
ഇരട്ട ഫിനിഷ് (ഇരട്ട വി);
അവസാനിക്കുന്നു
മുമ്പ്
v1 = init();
അവസാനിക്കുന്നു
... പ്രോസസ് വരികൾ, v1 ഉപയോഗിച്ചുള്ള കണക്കുകൂട്ടലുകൾ ...
ശേഷം
v2 = ഫിനിഷ് (v1);
if( v2 < 0.0 ){
fprintf(stderr, "പ്രോസസ്സിംഗ് പരാജയപ്പെട്ടു %g -> %g\n", v1, v2);
പുറത്ത്(1);
}
അവസാനിക്കുന്നു

തുടങ്ങിയ ദിനചര്യകൾ init() ഒപ്പം പൂർത്തിയാക്കുക() ലിങ്കിംഗിനായി ജനറേറ്റ് ചെയ്ത പ്രോഗ്രാമിലേക്ക് മുകളിൽ നൽകിയിരിക്കുന്നു
ഉപയോഗിച്ച് -l [ലിങ്ക് നിർദ്ദേശങ്ങൾ ...] സ്വിച്ച്. ഈ സ്വിച്ച് വ്യക്തമാക്കിയ സ്ട്രിംഗ് ആയിരിക്കും
പ്രോഗ്രാം നിർമ്മിക്കാൻ ഉപയോഗിക്കുന്ന ലിങ്ക് ലൈനിലേക്ക് ചേർത്തു (fantools ലൈബ്രറിക്ക് മുമ്പ്). വേണ്ടി
ഉദാഹരണത്തിന്, അത് അനുമാനിക്കുന്നു init() ഒപ്പം പൂർത്തിയാക്കുക() libmysubs.a എന്ന ലൈബ്രറിയിലാണ്
/opt/special/lib ഡയറക്ടറി, ഉപയോഗിക്കുക:

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

ഒരു സ്ട്രിംഗ് ആർഗ്യുമെന്റ് ഉപയോഗിച്ച് ഉപയോക്തൃ ആർഗ്യുമെന്റുകൾ സമാഹരിച്ച ഫൺകാൽക് പ്രോഗ്രാമിലേക്ക് കൈമാറാൻ കഴിയും
"-a" സ്വിച്ച്. സ്ട്രിംഗിൽ എല്ലാ ഉപയോക്തൃ ആർഗ്യുമെന്റുകളും അടങ്ങിയിരിക്കണം. ഉദാഹരണത്തിന്, കടന്നുപോകാൻ
പൂർണ്ണസംഖ്യകൾ 1, 2 എന്നിവ ഉപയോഗിക്കുക:

funcalc -a "1 2" ...

ആർഗ്യുമെന്റുകൾ ഒരു ആന്തരിക അറേയിൽ സംഭരിക്കുകയും ARGV(n) വഴി സ്ട്രിംഗുകളായി ആക്‌സസ് ചെയ്യുകയും ചെയ്യുന്നു
മാക്രോ. ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന പദപ്രയോഗം പരിഗണിക്കുക:

പ്രാദേശിക
int pmin, pmax;
അവസാനിക്കുന്നു

മുമ്പ്
pmin=atoi(എ.ആർ.ജി.വി(0));
pmax=atoi(എ.ആർ.ജി.വി(1));
അവസാനിക്കുന്നു

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

ഈ എക്സ്പ്രഷൻ pha മൂല്യമുള്ള എല്ലാ വരികൾക്കും x, y, pha മൂല്യങ്ങൾ പ്രിന്റ് ചെയ്യും
രണ്ട് ഉപയോക്തൃ ഇൻപുട്ട് മൂല്യങ്ങൾക്കിടയിൽ:

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

ആർഗ്യുമെന്റുകളുടെ ശരിയായ എണ്ണം ഉറപ്പാക്കേണ്ടത് ഉപയോക്താവിന്റെ ഉത്തരവാദിത്തമാണെന്നത് ശ്രദ്ധിക്കുക
പാസാക്കപ്പെടുന്നു. അഭ്യർത്ഥിച്ച ആർഗ്യുമെന്റ് പരിധിക്ക് പുറത്താണെങ്കിൽ ARGV(n) മാക്രോ ഒരു NULL നൽകുന്നു
അന്ധമായി പ്രോസസ്സ് ചെയ്താൽ, സാധാരണയായി ഒരു SEGV-ൽ കലാശിക്കുന്ന യഥാർത്ഥ ആർഗുകളുടെ എണ്ണം. പരിശോധിക്കാൻ
ആർഗ്യുമെന്റ് എണ്ണം, ARGC മാക്രോ ഉപയോഗിക്കുക:

പ്രാദേശിക
നീളമുള്ള ഇൻറ്റ് വിത്ത്=1;
ഇരട്ട പരിധി=0.8;
അവസാനിക്കുന്നു

മുമ്പ്
if( ARGC >= 1 ) വിത്ത് = ആറ്റോൾ(എ.ആർ.ജി.വി(0));
if( ARGC >= 2 ) പരിധി = atof(എ.ആർ.ജി.വി(1));
srand48(വിത്ത്);
അവസാനിക്കുന്നു

എങ്കിൽ ( drand48() > പരിധി ) തുടരുക;

മാക്രോ WRITE_ROW ഇതിലേക്ക് വികസിക്കുന്നു FunTableRowPut() നിലവിലെ വരി എഴുതുന്ന കോൾ. അത്
ഒന്നിലധികം തവണ വരി എഴുതാൻ ഉപയോഗിക്കാം. കൂടാതെ, മാക്രോ NROW വികസിക്കുന്നു
വരി നമ്പർ നിലവിൽ പ്രോസസ്സ് ചെയ്യുന്നു. ഈ രണ്ട് മാക്രോകളുടെ ഉപയോഗം താഴെ കാണിച്ചിരിക്കുന്നു
ഉദാഹരണം:

if( cur->pha:I == cur->pi:I ) തുടരുക;
a = cur->pha;
cur->pha = cur->pi;
cur->pi = a;
cur->AVG:E = (cur->pha+cur->pi)/2.0;
cur->NR:I = NROW;
എങ്കിൽ ( NROW < 10 ) WRITE_ROW;

എങ്കില് -p [പ്രോഗ്] സ്വിച്ച് വ്യക്തമാക്കിയിട്ടുണ്ട്, എക്സ്പ്രഷൻ എക്സിക്യൂട്ട് ചെയ്തിട്ടില്ല. മറിച്ച്, ദി
ജനറേറ്റഡ് എക്സിക്യൂട്ടബിൾ പിന്നീടുള്ള ഉപയോഗത്തിനായി നിർദ്ദിഷ്ട പ്രോഗ്രാമിന്റെ പേരിൽ സേവ് ചെയ്യുന്നു.

എങ്കില് -n സ്വിച്ച് വ്യക്തമാക്കിയിട്ടുണ്ട്, എക്സ്പ്രഷൻ എക്സിക്യൂട്ട് ചെയ്തിട്ടില്ല. പകരം, സൃഷ്ടിച്ച കോഡ്
stdout-ലേക്ക് എഴുതിയിരിക്കുന്നു. നിങ്ങൾക്ക് ഒരു അസ്ഥികൂടം ഫയൽ സൃഷ്ടിക്കണമെങ്കിൽ ഇത് പ്രത്യേകിച്ചും ഉപയോഗപ്രദമാണ്
കൂടാതെ നിങ്ങളുടെ സ്വന്തം കോഡ് ചേർക്കുക, അല്ലെങ്കിൽ നിങ്ങൾക്ക് കംപൈലേഷൻ പിശകുകൾ പരിശോധിക്കണമെങ്കിൽ. കമന്റ് എന്നത് ശ്രദ്ധിക്കുക
ഔട്ട്പുട്ടിന്റെ തുടക്കത്തിൽ പ്രോഗ്രാം നിർമ്മിക്കുന്നതിന് ആവശ്യമായ കമ്പൈലർ കമാൻഡ് നൽകുന്നു
പ്ലാറ്റ്ഫോം. (ഉപയോഗം കാരണം കമാൻഡ് പ്ലാറ്റ്‌ഫോമിൽ നിന്ന് പ്ലാറ്റ്‌ഫോമിലേക്ക് മാറാം
വ്യത്യസ്ത ലൈബ്രറികൾ, കംപൈലർ സ്വിച്ചുകൾ മുതലായവ)

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, funcalc ഒരു സ്കെയിലർ വേരിയബിൾ സ്വയമേവ പ്രഖ്യാപിക്കും (a
ഇരട്ട) ആ വേരിയബിൾ ഉപയോഗിച്ചിട്ടുണ്ടെങ്കിലും പ്രഖ്യാപിച്ചിട്ടില്ലെങ്കിൽ. ഈ സൗകര്യം നടപ്പാക്കുന്നത്
funcalc.sed എന്ന് പേരുള്ള ഒരു സെഡ് സ്‌ക്രിപ്റ്റ് ഉപയോഗിക്കുന്നു, ഇത് കംപൈലർ ഔട്ട്‌പുട്ട് പ്രോസസ്സ് ചെയ്യുന്നു
പ്രഖ്യാപിക്കാത്ത വേരിയബിൾ പിശക്. ഈ സ്ക്രിപ്റ്റ് ഉചിതമായ പിശകോടെ സീഡ് ചെയ്തിരിക്കുന്നു
ജിസിസി, സോളാരിസ്, ഡെക്ആൽഫ, എസ്ജിഐ പ്ലാറ്റ്‌ഫോമുകളിലെ സിസി എന്നിവയ്ക്കുള്ള വിവരങ്ങൾ. നിങ്ങൾ അത് കണ്ടെത്തുകയാണെങ്കിൽ
സ്കെയിലറുകളുടെ സ്വയമേവയുള്ള പ്രഖ്യാപനം നിങ്ങളുടെ പ്ലാറ്റ്ഫോമിൽ പ്രവർത്തിക്കുന്നില്ല, ഈ സെഡ് സ്ക്രിപ്റ്റ് പരിശോധിക്കുക;
അത് മനസ്സിലാക്കുന്ന ചില പിശക് സന്ദേശങ്ങളിൽ ചേർക്കാനോ എഡിറ്റ് ചെയ്യാനോ ആവശ്യമായി വന്നേക്കാം.

എന്ന ലെക്സിക്കൽ വിശകലനം നിലനിർത്താൻ വേണ്ടി funcalc പദപ്രയോഗങ്ങൾ (ന്യായമായും) ലളിതമാണ്, ഞങ്ങൾ തിരഞ്ഞെടുത്തു
സി കമന്റുകൾ, സ്‌പെയ്‌സുകൾ, ന്യൂ-ലൈനുകൾ എന്നിവ എത്ര കൃത്യമായി സ്ഥാപിക്കുന്നു എന്നതിന്റെ ചില പരിമിതികൾ അംഗീകരിക്കുന്നതിന്
സൃഷ്ടിച്ച പ്രോഗ്രാമിൽ. പ്രത്യേകിച്ചും, ലോക്കൽ വേരിയബിളുകളുമായി ബന്ധപ്പെട്ട അഭിപ്രായങ്ങൾ പ്രഖ്യാപിച്ചു
ഒരു പദപ്രയോഗത്തിന്റെ തുടക്കത്തിൽ (അതായത്, a-ൽ അല്ല പ്രാദേശിക...അവസാനം ബ്ലോക്ക്) സാധാരണയായി അവസാനിക്കും
ആന്തരിക ലൂപ്പിൽ, പ്രാദേശിക പ്രഖ്യാപനങ്ങൾക്കൊപ്പമല്ല:

/* ഈ അഭിപ്രായം തെറ്റായ സ്ഥലത്ത് അവസാനിക്കും (അതായത്, ആന്തരിക ലൂപ്പ്) */
ഇരട്ട എ; /* അതും തെറ്റായ സ്ഥലത്താണ് */
/* ഇത് ശരിയായ സ്ഥലത്ത് ആയിരിക്കും (ഇന്നർ ലൂപ്പ്) */
if( cur->x:D == cur->y:D ) തുടരുക; /* അതും ശരിയായ സ്ഥലത്ത് */
a = cur->x;
cur->x = cur->y;
cur->y = a;
cur-> ശരാശരി:E = (cur->x+cur->y)/2.0;

അതുപോലെ, സ്‌പെയ്‌സുകളും പുതിയ-ലൈനുകളും ചിലപ്പോൾ ഒഴിവാക്കുകയോ ഏകപക്ഷീയമായി തോന്നുകയോ ചെയ്യുന്നു
വിധത്തിൽ. തീർച്ചയായും, ഈ സ്റ്റൈലിസ്റ്റിക് പാടുകളൊന്നും അതിന്റെ കൃത്യതയെ ബാധിക്കുന്നില്ല
സൃഷ്ടിച്ച കോഡ്.

കാരണം funcalc നൽകിയ ഡാറ്റ ഫയൽ(കൾ) ഉപയോഗിച്ച് ഉപയോക്തൃ എക്സ്പ്രഷൻ വിശകലനം ചെയ്യണം
കമാൻഡ് ലൈൻ, ഇൻപുട്ട് ഫയൽ(കൾ) തുറന്ന് രണ്ടുതവണ വായിക്കണം: പ്രോഗ്രാമിനിടയിൽ ഒരിക്കൽ
തലമുറയും ഒരിക്കൽ എക്സിക്യൂഷൻ സമയത്ത്. തൽഫലമായി, ഇതിനായി stdin ഉപയോഗിക്കാൻ സാധ്യമല്ല
ഇൻപുട്ട് ഫയൽ: funcalc ഒരു ഫിൽട്ടറായി ഉപയോഗിക്കാൻ കഴിയില്ല. ഈ നിയന്ത്രണം നീക്കുന്നത് ഞങ്ങൾ പരിഗണിക്കും
പിന്നീടുള്ള സമയത്ത്.

സി അഭിപ്രായങ്ങൾക്കൊപ്പം, funcalc എക്സ്പ്രഷനുകൾക്ക് ഒറ്റവരി ആന്തരിക അഭിപ്രായങ്ങൾ ഉണ്ടാകാം
ജനറേറ്റ് ചെയ്ത C പ്രോഗ്രാമിലേക്ക് കൈമാറിയില്ല. ഈ ആന്തരിക അഭിപ്രായങ്ങൾ ആരംഭിക്കുന്നു #
പ്രതീകം, പുതിയ വരി വരെ തുടരുക:

ഇരട്ട എ; # ഇത് ജനറേറ്റ് ചെയ്ത C ഫയലിലേക്ക് കൈമാറില്ല
# ഇതും അല്ല
a = cur->x;
cur->x = cur->y;
cur->y = a;
/* ഈ അഭിപ്രായം C ഫയലിലേക്ക് കൈമാറി */
cur-> ശരാശരി:E = (cur->x+cur->y)/2.0;

മുമ്പ് സൂചിപ്പിച്ചതുപോലെ, ഇൻപുട്ട് കോളങ്ങൾ സാധാരണയായി തിരിച്ചറിയുന്നത് അവയുടെ ഉള്ളിൽ ഉപയോഗിക്കുന്നതിലൂടെയാണ്
ആന്തരിക ഇവന്റ് ലൂപ്പ്. നിങ്ങൾ ഒരു കോളം വായിക്കാൻ ആഗ്രഹിച്ചേക്കാവുന്ന അപൂർവ സന്ദർഭങ്ങളുണ്ട്
പ്രധാന ലൂപ്പിന് പുറത്ത് ഇത് പ്രോസസ്സ് ചെയ്യുക. ഉദാഹരണത്തിന്, qsort അതിന്റെ ക്രമത്തിൽ ഒരു കോളം ഉപയോഗിച്ചേക്കാം
ആന്തരിക ലൂപ്പിനുള്ളിൽ പ്രോസസ്സ് ചെയ്യാത്ത താരതമ്യ ദിനചര്യ (അതിനാൽ അല്ല
വായിക്കേണ്ട കോളമായി പരോക്ഷമായി സൂചിപ്പിച്ചിരിക്കുന്നു). ഇത്തരമൊരു കോളം വായിക്കുന്നത് ഉറപ്പാക്കാൻ
ഇവന്റ് ലൂപ്പ്, ഉപയോഗിക്കുക സ്പഷ്ടമായത് കീവേഡ്. ഈ കീവേഡിനുള്ള ആർഗ്യുമെന്റുകൾ നിരകൾ വ്യക്തമാക്കുന്നു
ഇൻപുട്ട് റെക്കോർഡ് ഘടനയിൽ അവ സൂചിപ്പിച്ചിട്ടില്ലെങ്കിലും അവ വായിക്കണം
ആന്തരിക ലൂപ്പ്. ഉദാഹരണത്തിന്:

വ്യക്തമായ pi pha

പൈ, ഫാ കോളങ്ങൾ ഓരോ വരിയിലും വായിച്ചിട്ടുണ്ടെന്ന് ഉറപ്പുവരുത്തും, അവ ഇല്ലെങ്കിലും
ആന്തരിക ഇവന്റ് ലൂപ്പിൽ പ്രോസസ്സ് ചെയ്തു. ദി സ്പഷ്ടമായത് പ്രസ്താവന എവിടെയും സ്ഥാപിക്കാം.

അവസാനമായി, അത് ശ്രദ്ധിക്കുക funcalc നിലവിൽ FITS ബൈനറി പട്ടികകൾ ഉൾപ്പെടുന്ന എക്സ്പ്രഷനുകളിൽ പ്രവർത്തിക്കുന്നു
അസംസ്കൃത ഇവന്റ് ഫയലുകൾ. ഇമേജ് എക്സ്പ്രഷനുകൾക്ക് പിന്തുണ ചേർക്കുന്നത് ഞങ്ങൾ പിന്നീട് പരിഗണിക്കും,
സമൂഹത്തിൽ നിന്ന് അത്തരം പിന്തുണ ആവശ്യമുണ്ടെങ്കിൽ.

onworks.net സേവനങ്ങൾ ഉപയോഗിച്ച് ഓൺലൈനിൽ funcalc ഉപയോഗിക്കുക