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

പട്ടിക:

NAME

funjoin - നിർദ്ദിഷ്ട നിരകളിൽ രണ്ടോ അതിലധികമോ FITS ബൈനറി പട്ടികകളിൽ ചേരുക

സിനോപ്സിസ്

funjoin [സ്വിച്ചുകൾ] ...

ഓപ്ഷനുകൾ

എല്ലാ ഫയലുകളിലും സജീവമാക്കാൻ -a cols # നിരകൾ
-a1 കോളുകൾ ... ഓരോ ഫയലിലും സജീവമാക്കാൻ ഒരു കോളം # നിരകൾ
-b 'c1:bvl,c2:bv2' # എല്ലാ ഫയലുകളിലെയും പൊതുവായ കോളങ്ങൾക്കുള്ള ശൂന്യമായ മൂല്യങ്ങൾ
-bn 'c1:bv1,c2:bv2' # നിർദ്ദിഷ്‌ട ഫയലുകളിലെ നിരകൾക്കുള്ള ശൂന്യ മൂല്യങ്ങൾ
എല്ലാ ഫയലുകളിലും ചേരാൻ -j col # കോളം
ഓരോ ഫയലിലും ചേരാൻ -j1 col ... jn col # കോളം
ഒരു വരി ഔട്ട്പുട്ട് ചെയ്യുന്നതിന് -m മിനിറ്റ് # മിനിറ്റ് പൊരുത്തപ്പെടുന്നു
ഒരു വരി ഔട്ട്‌പുട്ട് ചെയ്യുന്നതിന് -എം പരമാവധി # പരമാവധി പൊരുത്തങ്ങൾ
-s # 'jfiles' സ്റ്റാറ്റസ് കോളം ചേർക്കുക
-എസ് കോൾ # കോൾ സ്റ്റാറ്റസ് കോളമായി ചേർക്കുക
സംഖ്യാ കോളുകൾ ചേരുന്നതിനുള്ള -t ടോൾ # ടോളറൻസ് [2 ഫയലുകൾ മാത്രം]

വിവരണം

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

പ്രോഗ്രാമിലേക്കുള്ള ആദ്യ ആർഗ്യുമെന്റ്, ആദ്യ ഇൻപുട്ട് FITS പട്ടിക അല്ലെങ്കിൽ റോ ഇവന്റ് ഫയൽ വ്യക്തമാക്കുന്നു.
"stdin" വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ, സ്റ്റാൻഡേർഡ് ഇൻപുട്ടിൽ നിന്ന് ഡാറ്റ റീഡ് ചെയ്യും. തുടർന്നുള്ള വാദങ്ങൾ
ചേരുന്നതിനുള്ള അധിക ഇവന്റ് ഫയലുകളും പട്ടികകളും വ്യക്തമാക്കുക. അവസാന ആർഗ്യുമെന്റ് ഔട്ട്പുട്ട് FITS ആണ്
ഫയൽ.

NB: ചെയ്യൂ അല്ല എപ്പോൾ FITS വിപുലീകരണങ്ങളും വരി ഫിൽട്ടറുകളും വ്യക്തമാക്കാൻ Funtools ബ്രാക്കറ്റ് നോട്ടേഷൻ ഉപയോഗിക്കുക
funjoin പ്രവർത്തിപ്പിക്കുക അല്ലെങ്കിൽ നിങ്ങൾക്ക് തെറ്റായ ഫലങ്ങൾ ലഭിക്കും. വരികൾ ആക്‌സസ് ചെയ്യുകയും ജോയിൻ ചെയ്യുകയും ചെയ്യുന്നു
സൂചിക ഫയലുകൾ നേരിട്ട്, ഇത് എല്ലാ ഫിൽട്ടറിംഗും മറികടക്കുന്നു.

ജോയിൻ കോളങ്ങൾ എന്നത് ഉപയോഗിച്ചാണ് വ്യക്തമാക്കിയിരിക്കുന്നത് -j കുപ്പായക്കഴുത്ത് മാറുക (ഇതിലേക്ക് ഒരു നിരയുടെ പേര് വ്യക്തമാക്കുന്നു
എല്ലാ ഫയലുകൾക്കും ഉപയോഗിക്കുക) അല്ലെങ്കിൽ കൂടെ -ജ 1 col1, -ജ 2 col2, ... ... -ജന കോളൻ സ്വിച്ചുകൾ (അത് വ്യക്തമാക്കുന്നു
ഓരോ ഫയലിനും ഉപയോഗിക്കേണ്ട കോളത്തിന്റെ പേര്). ഓരോ ഫയലിനും ഒരു ജോയിൻ കോളം വ്യക്തമാക്കിയിരിക്കണം. രണ്ടും ആണെങ്കിൽ
-j കുപ്പായക്കഴുത്ത് ഒപ്പം -ജന കോളൻ നൽകിയിരിക്കുന്ന ഫയലിനായി വ്യക്തമാക്കിയിരിക്കുന്നു, രണ്ടാമത്തേത് ഉപയോഗിക്കുന്നു. കോളങ്ങളിൽ ചേരുക
ഒന്നുകിൽ ടൈപ്പ് സ്ട്രിംഗ് അല്ലെങ്കിൽ ടൈപ്പ് ന്യൂമെറിക് ആയിരിക്കണം; സംഖ്യയും സ്ട്രിംഗും ഇടകലർത്തുന്നത് നിയമവിരുദ്ധമാണ്
തന്നിരിക്കുന്ന ജോയിനിലെ നിരകൾ. ഉദാഹരണത്തിന്, ഒരേ കീ കോളം ഉപയോഗിച്ച് മൂന്ന് ഫയലുകളിൽ ചേരുന്നതിന്
ഓരോ ഫയലും ഉപയോഗിക്കുക:

funjoin -j കീ in1.fits in2.fits in3.fits out.fits

മൂന്നാമത്തെ ഫയലിനായി മറ്റൊരു കീ ഈ രീതിയിൽ വ്യക്തമാക്കാം:

funjoin -j കീ -j3 മറ്റ് കീ in1.fits in2.fits in3.fits out.fits

ദി -a "കോൾസ്" സ്വിച്ചുചെയ്യുക (ഒപ്പം -എ 1 "col1", -എ 2 "cols2" എതിരാളികൾ) വ്യക്തമാക്കാൻ ഉപയോഗിക്കാം
ഓരോ ഇൻപുട്ട് ഫയലിനും സജീവമാക്കാനുള്ള നിരകൾ (അതായത് ഔട്ട്പുട്ട് ഫയലിലേക്ക് എഴുതുക). സ്ഥിരസ്ഥിതിയായി, എല്ലാം
നിരകൾ ഔട്ട്പുട്ട് ആകുന്നു.

വ്യത്യസ്‌ത ഫയലുകളിൽ നിന്നുള്ള രണ്ടോ അതിലധികമോ നിരകൾക്ക് ഒരേ പേരുണ്ടെങ്കിൽ, രണ്ടാമത്തേത് (തുടർന്നുള്ളതും)
അണ്ടർ സ്‌കോറും ഒരു സംഖ്യാ മൂല്യവും ചേർത്ത് കോളങ്ങളുടെ പേര് മാറ്റി.

ദി -m എന്നോട് ഒപ്പം -M പരമാവധി സ്വിച്ചുകൾ ആവശ്യമായ ഏറ്റവും കുറഞ്ഞതും കൂടിയതുമായ ജോയിനുകളുടെ എണ്ണം വ്യക്തമാക്കുന്നു
ഒരു വരി എഴുതുക. ഡിഫോൾട്ട് മിനിമം 0 ജോയിനുകൾ ആണ് (അതായത് എല്ലാ വരികളും എഴുതിയിരിക്കുന്നു) കൂടാതെ
സ്ഥിരസ്ഥിതി പരമാവധി 63 ആണ് (സാധ്യമായ പരമാവധി എണ്ണം 32 ഇൻപുട്ടിന്റെ പരിധിയിൽ ചേരുന്നു
ഫയലുകൾ). ഉദാഹരണത്തിന്, കൃത്യമായി രണ്ട് ഫയലുകൾക്ക് നിരകളുള്ള വരികൾ മാത്രം എഴുതുക
ആ പൊരുത്തം (അതായത് ഒരു ജോയിൻ):

funjoin -j കീ -m 1 -M 1 in1.fits in2.fits in3.fits ... out.fits

എല്ലാ ഫയലുകളും ജോയിൻ ചെയ്യാതെ തന്നെ തന്നിരിക്കുന്ന വരിയിൽ ആവശ്യമായ ജോയിനുകളുടെ എണ്ണം ഉണ്ടായിരിക്കും
(ഉദാ. മൂന്ന് ഫയലുകൾ ജോയിൻ ചെയ്യുന്നു, എന്നാൽ രണ്ടെണ്ണത്തിന് മാത്രമേ ജോയിൻ കീ മൂല്യമുള്ളൂ). ഇതിൽ
കേസ്, ചേരാത്ത ഫയലിന്റെ എല്ലാ കോളങ്ങളും സ്ഥിരസ്ഥിതിയായി, ശൂന്യത ഉപയോഗിച്ച് എഴുതിയിരിക്കുന്നു
(പൂജ്യം അല്ലെങ്കിൽ NULL). ദി -b c1:bv1,c2:bv2 കൂടാതെ -b1 'c1:bv1,c2:bv2' -b2 'c1:bv1,c2 - bv2' ...
എല്ലാ ഫയലുകൾക്കും കൂടാതെ/അല്ലെങ്കിൽ കോളങ്ങൾക്കും പൊതുവായുള്ള നിരകൾക്കുള്ള ശൂന്യമായ മൂല്യം സജ്ജമാക്കാൻ സ്വിച്ചുകൾ ഉപയോഗിക്കാം
യഥാക്രമം ഒരു നിർദ്ദിഷ്ട ഫയലിൽ. ഓരോ ശൂന്യമായ മൂല്യ സ്‌ട്രിംഗിലും കോമയാൽ വേർതിരിച്ച ഒരു ലിസ്റ്റ് അടങ്ങിയിരിക്കുന്നു
കോളത്തിന്റെ:blank_val സ്പെസിഫയറുകൾ. ഫ്ലോട്ടിംഗ് പോയിന്റ് മൂല്യങ്ങൾക്ക് (ഒറ്റ അല്ലെങ്കിൽ ഇരട്ട), ഒരു കേസ്-
"nan" എന്നതിന്റെ സെൻസിറ്റീവ് സ്ട്രിംഗ് മൂല്യം അർത്ഥമാക്കുന്നത് IEEE NaN (നമ്പർ അല്ല) ഉപയോഗിക്കണം എന്നാണ്.
അതിനാൽ, ഉദാഹരണത്തിന്:

funjoin -b "AKEY:???" -b1 "A:-1" -b3 "G:NaN,E:-1,F:-100" ...

ഏതെങ്കിലും ഫയലിൽ ചേരാത്ത AKEY കോളത്തിൽ "???" എന്ന സ്ട്രിംഗ് അടങ്ങിയിരിക്കും എന്നാണ് അർത്ഥമാക്കുന്നത്.
ചേർന്നു, ഫയൽ 1-ന്റെ ഒരു കോളത്തിൽ -1 എന്ന മൂല്യം അടങ്ങിയിരിക്കും, ഫയൽ 3-ന്റെ ജോയിൻ ചെയ്യാത്ത G കോളം
IEEE NaN-കൾ അടങ്ങിയിരിക്കും, അതേ ഫയലിന്റെ ജോയിൻ ചെയ്യാത്ത E, F കോളങ്ങളിൽ അടങ്ങിയിരിക്കും
യഥാക്രമം -1, -100 എന്നീ മൂല്യങ്ങൾ. തീർച്ചയായും, പൊതുവായതും നിർദ്ദിഷ്ടവുമായ ശൂന്യമായ മൂല്യങ്ങൾ എവിടെയാണ്
അതേ നിരയ്‌ക്കായി വ്യക്തമാക്കിയ, നിർദ്ദിഷ്ട ശൂന്യമായ മൂല്യം ഉപയോഗിക്കുന്നു.

തന്നിരിക്കുന്ന വരിയുടെ ശൂന്യമല്ലാത്ത ഘടകങ്ങളാണ് ഫയലുകൾ എന്ന് വേർതിരിച്ചറിയാൻ, the -s (സ്റ്റാറ്റസ്) സ്വിച്ച്
ഔട്ട്പുട്ട് ഫയലിലേക്ക് "JFILES" എന്ന് പേരുള്ള ഒരു ബിറ്റ്മാസ്ക് കോളം ചേർക്കാൻ ഉപയോഗിക്കാം. ഈ കോളത്തിൽ, എ
തന്നിരിക്കുന്ന വരി രചിക്കുന്ന ഓരോ നോൺ-ബ്ലാങ്ക് ഫയലിനും ബിറ്റ് സജ്ജീകരിച്ചിരിക്കുന്നു, ബിറ്റ് 0 എന്നതിനോട് യോജിക്കുന്നു
ആദ്യ ഫയൽ, രണ്ടാമത്തെ ഫയലിലേക്ക് ബിറ്റ് 1, തുടങ്ങിയവ. ഫയൽ നാമങ്ങൾ തന്നെ സംഭരിച്ചിരിക്കുന്നു
JFILE1, JFILE2 എന്നിങ്ങനെ പേരുള്ള പാരാമീറ്ററുകളായി FITS തലക്കെട്ട് -S കുപ്പായക്കഴുത്ത് സ്വിച്ച് നിങ്ങളെ അനുവദിക്കുന്നു
സ്ഥിരസ്ഥിതി "JFILES" ൽ നിന്ന് സ്റ്റാറ്റസ് കോളത്തിന്റെ പേര് മാറ്റുക.

വരികൾക്കിടയിലുള്ള ഒരു ജോയിൻ എന്നത് നൽകിയിരിക്കുന്ന ജോയിൻ ഉള്ള ഒരു ഫയലിലെ എല്ലാ വരികളുടെയും കാർട്ടിസിയൻ ഉൽപ്പന്നമാണ്
രണ്ടാമത്തെ ഫയലിലെ എല്ലാ വരികളുമുള്ള കോളം മൂല്യം, അതിന്റെ ജോയിൻ കോളത്തിനും അതേ മൂല്യമുള്ളതും
ഉടൻ. അങ്ങനെ, file1-ൽ 2-ന്റെ ജോയിൻ കോളം മൂല്യമുള്ള 100 വരികൾ ഉണ്ടെങ്കിൽ, file2-ന് 3 വരികളുണ്ട്.
ഒരേ മൂല്യം, ഫയൽ3 ന് 4 വരികൾ ഉണ്ട്, തുടർന്ന് ജോയിൻ ചെയ്യുന്നത് 2*3*4=24 വരികളിൽ ഔട്ട്പുട്ട് ആയി മാറുന്നു.

എന്ന ജോയിൻ കോളവുമായി ബന്ധപ്പെട്ട സൂചിക ഫയൽ ജോയിൻ അൽഗോരിതം നേരിട്ട് പ്രോസസ്സ് ചെയ്യുന്നു
ഓരോ ഫയലും. നിലവിലുള്ള എല്ലാ നിരകളുടെയും ഏറ്റവും ചെറിയ മൂല്യം അടിസ്ഥാനമായി തിരഞ്ഞെടുത്തു, ഇത്
മൂല്യം മറ്റ് ഫയലുകളിൽ തുല്യ മൂല്യമുള്ള കോളങ്ങളിൽ ചേരാൻ ഉപയോഗിക്കുന്നു. ഈ രീതിയിൽ, സൂചിക
ഫയലുകൾ കൃത്യമായി ഒരു പ്രാവശ്യം കടന്നുപോകുന്നു.

ദി -t tol സ്വിച്ച് സംഖ്യാ നിരകൾക്കായി ഒരു ടോളറൻസ് മൂല്യം വ്യക്തമാക്കുന്നു. നിലവിൽ, എ
ടോളറൻസ് മൂല്യത്തിന് ഒരു സമയം രണ്ട് ഫയലുകൾ മാത്രമേ ചേരാൻ കഴിയൂ. (തികച്ചും വ്യത്യസ്തമായ അൽഗോരിതം
ഒരു ടോളറൻസ് ഉപയോഗിച്ച് രണ്ടിൽ കൂടുതൽ ഫയലുകൾ ജോയിൻ ചെയ്യേണ്ടതുണ്ട്, ഞങ്ങൾ പരിഗണിച്ചേക്കാവുന്ന ചിലത്
ഭാവിയിൽ നടപ്പിലാക്കുന്നു.)

ഇനിപ്പറയുന്ന ഉദാഹരണം funjoin-ന്റെ പല സവിശേഷതകളും കാണിക്കുന്നു. ഇൻപുട്ട് ഫയലുകൾ t1.fits,
t2.fits, t3.fits എന്നിവയിൽ ഇനിപ്പറയുന്ന നിരകൾ അടങ്ങിയിരിക്കുന്നു:

[sh] fundisp t1.fits
എകെ കീ എബി
-------------------------------
aaa 0 0 1
ബിബിബി 1 3 4
ccc 2 6 7
ഡിഡിഡി 3 9 10
eee 4 12 13
fff 5 15 16
ggg 6 18 19
hhh 7 21 22

fundisp t2.fits
AKEY കീ സിഡി
-------------------------------
iii 8 24 25
ggg 6 18 19
eee 4 12 13
ccc 2 6 7
aaa 0 0 1

fundisp t3.fits
AKEY KEY EFG -------------------------------------
----------
ggg 6 18 19 100.10
jjj 9 27 28 200.20
aaa 0 0 1 300.30
ഡിഡിഡി 3 9 10 400.40

ഈ ഇൻപുട്ട് ഫയലുകൾ നൽകിയാൽ, ഇനിപ്പറയുന്ന funjoin കമാൻഡ്:

funjoin -s -a1 "-B" -a2 "-D" -a3 "-E" -b \
"ഒരു താക്കോല്:???" -b1 "AKEY:XXX,A:255" -b3 "G:NaN,E:-1,F:-100" \
-j കീ t1.fits t2.fits t3.fits foo.fits

B (t1.fits-ൽ), D (ഇൻ) ഒഴികെയുള്ള എല്ലാ കോളങ്ങളും ഔട്ട്പുട്ട് ചെയ്ത്, KEY കോളത്തിലെ ഫയലുകളിൽ ചേരും.
t2.fits), E (t3.fits-ൽ), കൂടാതെ AKEY-യ്‌ക്കായി ശൂന്യമായ മൂല്യങ്ങൾ സജ്ജീകരിക്കുന്നു (ആഗോളമായി, എന്നാൽ അസാധുവാക്കിയത്
t1.fits) കൂടാതെ A (ഫയൽ 1-ൽ), G, E, F (ഫയൽ 3-ൽ). ഒരു JFILES കോളം ആയിരിക്കും
ഓരോ വരിയിലും ഏത് ഫയലുകളാണ് ഉപയോഗിച്ചതെന്ന് ഫ്ലാഗ് ചെയ്യുന്നതിനുള്ള ഔട്ട്പുട്ട്:

AKEY കീ A AKEY_2 KEY_2 C AKEY_3 KEY_3 FG JFILES
---------------------------------------------------- ---------- ----------------------------------
aaa 0 0 aaa 0 0 aaa 0 1 300.30 7
bbb 1 3 ??? 0 0 ??? 0 -100 nan 1
ccc 2 6 ccc 2 6 ??? 0 -100 nan 3
ddd 3 9 ??? 0 0 ddd 3 10 400.40 5
ഇഇഇ 4 12 ഈഇ 4 12 ??? 0 -100 nan 3
fff 5 15 ??? 0 0 ??? 0 -100 nan 1
ggg 6 18 ggg 6 18 ggg 6 19 100.10 7
hhh 7 21 ??? 0 0 ??? 0 -100 nan 1
XXX 0 255 iii 8 24 ??? 0 -100 nan 2
XXX 0 255 ??? 0 0 jjj 9 28 200.20 4

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