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

പട്ടിക:

NAME

minccalc - minc ഫയലുകളിൽ സങ്കീർണ്ണമായ ഗണിത പ്രവർത്തനങ്ങൾ നടത്തുക

സിനോപ്സിസ്

mincalc [ ] .mnc [ .mnc...] .mnc

വിവരണം

മിങ്കാൽക് ഒന്നോ അതിലധികമോ minc ഫയലുകളിൽ സങ്കീർണ്ണമായ, voxel-by-voxel ഗണിത പ്രവർത്തനങ്ങൾ നടത്തും
ഒരേ ആകൃതിയിലുള്ളതും ഒരേ കോർഡിനേറ്റ് സാമ്പിൾ ഉള്ളതും ഒരൊറ്റ ഔട്ട്‌പുട്ട് ഫയൽ നിർമ്മിക്കുന്നു.
നടത്തേണ്ട പ്രവർത്തനങ്ങൾ ഇൻപുട്ട് ഉപയോഗിച്ചാണ് -പ്രകടനം വാദം (കാണുക ഭാവങ്ങൾ).
സ്ഥിരസ്ഥിതിയായി, ഔട്ട്പുട്ട് ഫയൽ അവസാന നോൺ-ഓപ്ഷൻ ആർഗ്യുമെന്റ് ആണ്. എന്നിരുന്നാലും, എങ്കിൽ - outfile
ഓപ്ഷൻ ഉപയോഗിക്കുന്നു, തുടർന്ന് എല്ലാ നോൺ-ഓപ്ഷൻ ആർഗ്യുമെന്റുകളും ഇൻപുട്ട് ഫയലുകളും ഔട്ട്പുട്ടും ആയി കണക്കാക്കും
എന്നതിൽ നിന്നാണ് ഫയലിന്റെ പേരുകൾ വരുന്നത് - outfile ഓപ്ഷനുകൾ, അതിൽ ഒന്നിൽ കൂടുതൽ ഉണ്ടാകാം.

ഓപ്ഷനുകൾ

ഓപ്‌ഷനുകൾ സംക്ഷിപ്‌ത രൂപത്തിൽ (അവ അദ്വിതീയമായിരിക്കുന്നിടത്തോളം കാലം) വ്യക്തമാക്കാനാകുമെന്നത് ശ്രദ്ധിക്കുക
കമാൻഡ് ലൈനിൽ എവിടെയും നൽകാം.

-2 MINC 2.0 ഫോർമാറ്റ് ഔട്ട്പുട്ട് ഫയലുകൾ സൃഷ്ടിക്കുക.

-ഹെൽപ്പ് കമാൻഡ്-ലൈൻ ഓപ്ഷനുകളുടെ സംഗ്രഹം അച്ചടിച്ച് പുറത്തുകടക്കുക.

-പതിപ്പ്
പ്രോഗ്രാമിന്റെ പതിപ്പ് നമ്പർ പ്രിന്റ് ചെയ്ത് പുറത്തുകടക്കുക.

-ക്ലോബ്ബർ
നിലവിലുള്ള ഒരു ഫയൽ തിരുത്തിയെഴുതുക.

-നോക്ലോബർ
നിലവിലുള്ള ഒരു ഫയൽ തിരുത്തിയെഴുതരുത് (സ്ഥിരസ്ഥിതി).

-no_clobber
-നോക്ലോബറിന്റെ പര്യായപദം.

-വെർബോസ്
പകർത്തിയ ഓരോ ഡാറ്റയുടെയും പുരോഗതി വിവരങ്ങൾ പ്രിന്റ് ഔട്ട് ചെയ്യുക (സ്ഥിരസ്ഥിതി).

- നിശബ്ദം പുരോഗതി വിവരം പ്രിന്റ് ഔട്ട് ചെയ്യരുത്.

- ഡീബഗ് ഡീബഗ്ഗിംഗ് വിവരങ്ങൾ പ്രിന്റ് ഔട്ട് ചെയ്യുക.

-copy_header
ആദ്യ ഇൻപുട്ട് ഫയലിൽ നിന്ന് എല്ലാ ഹെഡർ വിവരങ്ങളും പകർത്തുക (ഒരു ഇൻപുട്ടിന്റെ സ്ഥിരസ്ഥിതി
ഫയൽ).

-നോകോപ്പി_ഹെഡർ
ആദ്യ ഇൻപുട്ട് ഫയലിൽ നിന്ന് എല്ലാ തലക്കെട്ടുകളും പകർത്തരുത്; പകർപ്പ് മാത്രം ഏകോപിപ്പിക്കുക
വിവരങ്ങൾ (ഒന്നിലധികം ഇൻപുട്ട് ഫയലുകൾക്കുള്ള ഡിഫോൾട്ട്).

- ഫയൽ തരം
ആദ്യ ഇൻപുട്ട് ഫയലിന്റെ അതേ തരത്തിലുള്ള ഒരു ഔട്ട്പുട്ട് ഫയൽ സൃഷ്ടിക്കുക (സ്ഥിരസ്ഥിതി).

-ബൈറ്റ് ഔട്ട്‌പുട്ട് വോക്സലുകൾ 8-ബിറ്റ് ഇന്റിജർ ഫോർമാറ്റിൽ സംഭരിക്കുക.

- ചെറുത് ഔട്ട്‌പുട്ട് വോക്സലുകൾ 16-ബിറ്റ് ഇന്റിജർ ഫോർമാറ്റിൽ സംഭരിക്കുക.

-int ഔട്ട്‌പുട്ട് വോക്സലുകൾ 32-ബിറ്റ് ഇന്റിജർ ഫോർമാറ്റിൽ സംഭരിക്കുക.

-നീളമുള്ള അസാധുവാക്കിയത് -int.

- ഫ്ലോട്ട് ഔട്ട്പുട്ട് വോക്സലുകൾ 32-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റ് ഫോർമാറ്റിൽ സംഭരിക്കുക.

-ഇരട്ട
ഔട്ട്പുട്ട് വോക്സലുകൾ 64-ബിറ്റ് ഫ്ലോട്ടിംഗ് പോയിന്റ് ഫോർമാറ്റിൽ സംഭരിക്കുക.

- ഒപ്പിട്ടു
ഒപ്പിട്ട, രണ്ടിന്റെ പൂരക പൂർണ്ണസംഖ്യ ഫോർമാറ്റ് ഉപയോഗിക്കുക. ഔട്ട്‌പുട്ട് വോക്‌സൽ തരമാണെങ്കിൽ മാത്രമേ ബാധകമാകൂ
ഒരു പൂർണ്ണസംഖ്യ തരം (ഇതിൽ ഒന്ന് -ബൈറ്റ്, - ചെറുത്, -int or -നീളമുള്ള).

- ഒപ്പിടാത്തത്
ഒപ്പിടാത്ത പൂർണ്ണസംഖ്യ ഫോർമാറ്റ് ഉപയോഗിക്കുക. ഔട്ട്‌പുട്ട് വോക്‌സൽ തരം വ്യക്തമാക്കിയിട്ടുണ്ടെങ്കിൽ മാത്രമേ ബാധകമാകൂ
ഒരു പൂർണ്ണസംഖ്യ തരം (ഇതിൽ ഒന്ന് -ബൈറ്റ്, - ചെറുത്, -int or -നീളമുള്ള).

-പരിധി എന്നോട് പരമാവധി
പൂർണ്ണസംഖ്യ ഡാറ്റയുടെ സാധുവായ ശ്രേണി നിയന്ത്രിക്കുക. ഇവയിലൊന്നാണെങ്കിൽ മാത്രമേ ബാധകമാകൂ -ബൈറ്റ്,
- ചെറുത്, -int or -നീളമുള്ള ഓപ്ഷനുകൾ വ്യക്തമാക്കിയിട്ടുണ്ട്.

-max_buffer_size_in_kb വലുപ്പം
ആന്തരിക ബഫറുകളുടെ പരമാവധി വലുപ്പം വ്യക്തമാക്കുക (കെബൈറ്റിൽ). സ്ഥിരസ്ഥിതി 4096 ആണ്
(4 എംബി).

-അളവ് മങ്ങിയ പേര്
ഒരു ക്യുമുലേറ്റീവ് ഓപ്പറേഷൻ നടത്താൻ ഞങ്ങൾ ആഗ്രഹിക്കുന്ന ഒരു മാനം വ്യക്തമാക്കുക.

-ചെക്ക്_ഡൈമൻഷനുകൾ
എല്ലാ ഇൻപുട്ട് ഫയലുകൾക്കും ലോക അളവുകളിൽ (സ്ഥിരസ്ഥിതി) പൊരുത്തപ്പെടുന്ന സാമ്പിൾ ഉണ്ടോയെന്ന് പരിശോധിക്കുക.

-nocheck_dimensions
ഇൻപുട്ട് ഫയലുകൾക്കായുള്ള ലോക അളവുകളുടെ സാമ്പിളിലെ വ്യത്യാസങ്ങൾ അവഗണിക്കുക.

-പ്രൊപഗേറ്റ്_നാൻ
ക്യുമുലേറ്റീവ് വെക്റ്റർ പ്രവർത്തനങ്ങൾക്ക് (തുക, ഉത്പന്നം ഒപ്പം ശരാശരി), അസാധുവായ ഡാറ്റ (എ-നമ്പർ അല്ല
അല്ലെങ്കിൽ NaN) വെക്‌ടറിന്റെ ഏതെങ്കിലും ഘടകത്തിലെ ഫലത്തിൽ അസാധുവായ ഡാറ്റ ഉണ്ടാക്കും
(സ്ഥിരസ്ഥിതി).

-ignore_nan
ക്യുമുലേറ്റീവ് വെക്റ്റർ പ്രവർത്തനങ്ങൾക്ക്, വെക്റ്ററിലെ അസാധുവായ ഡാറ്റ (NaN) അവഗണിക്കപ്പെടുന്നു, അതായത്.
അത് നിലവിലില്ല എന്ന മട്ടിൽ കൈകാര്യം ചെയ്യുന്നു.

-നാൻ ഒരു വോക്സലിൽ ഒരു നിയമവിരുദ്ധ പ്രവർത്തനം ശ്രമിക്കുമ്പോൾ (പൂജ്യം കൊണ്ട് ഹരിക്കുക പോലെ),
ഫലം അസാധുവായ ഡാറ്റയാണ് (NaN) (സ്ഥിരസ്ഥിതി). ഒരു ക്യുമുലേറ്റീവിന് സാധുവായ ഇൻപുട്ട് ഡാറ്റ ഇല്ല
എപ്പോൾ ഓപ്പറേഷൻ നിയമവിരുദ്ധ പ്രവർത്തനമായി കണക്കാക്കുന്നു -ignore_nan ഉപയോഗിക്കുന്നു.

-പൂജ്യം ഒരു വോക്സലിൽ ഒരു നിയമവിരുദ്ധ പ്രവർത്തനം ശ്രമിക്കുമ്പോൾ (പൂജ്യം കൊണ്ട് ഹരിക്കുക പോലെ),
ഫലം പൂജ്യമാണ്.

-നിയമവിരുദ്ധ_മൂല്യം മൂല്യം
ഒരു വോക്സലിൽ ഒരു നിയമവിരുദ്ധ പ്രവർത്തനം ശ്രമിക്കുമ്പോൾ (പൂജ്യം കൊണ്ട് ഹരിക്കുക പോലെ),
ഫലം ഈ ഓപ്ഷൻ വ്യക്തമാക്കിയ മൂല്യമാണ്.

-പ്രകടനം സ്ട്രിംഗ്
ഓരോ വോക്സലിലും വിലയിരുത്താൻ എക്സ്പ്രഷൻ വ്യക്തമാക്കുക (എക്സ്പ്രഷൻസ് കാണുക).

-expfile ഫയലിന്റെ പേര്
ഓരോ വോക്സലിലും വിലയിരുത്തുന്നതിന് ഒരു എക്സ്പ്രഷൻ അടങ്ങുന്ന ഒരു ഫയൽ വ്യക്തമാക്കുക (കാണുക
ഭാവങ്ങൾ). ഫയലിന്റെ പേര് ``-'' നൽകിയാൽ, എക്സ്പ്രഷൻ stdin-ൽ നിന്ന് വായിക്കും.
കമാൻഡ്-ലൈൻ എക്സ്പ്രഷനുകളിൽ നിന്നുള്ള ഒരേയൊരു വ്യത്യാസം അഭിപ്രായങ്ങൾ നൽകാം എന്നതാണ്
ഫയല്. ആദ്യത്തെ നോൺ ആയി ഒരു ``#'' ഇട്ടുകൊണ്ട് ഒരു കമന്റ് ലൈൻ വ്യക്തമാക്കുന്നു
വരിയുടെ വൈറ്റ്‌സ്‌പേസ് പ്രതീകം. സജ്ജീകരിച്ച് Minccalc സ്ക്രിപ്റ്റുകൾ സൃഷ്ടിക്കാൻ കഴിയും
ആദ്യ വരി

#! /usr/local/mni/bin/minccalc -expfile

- outfile ചിഹ്നം ഔട്ട്പുട്ട്-ഫയൽ
എന്നതിൽ നിന്ന് മൂല്യങ്ങൾ എടുത്ത് നിർദ്ദിഷ്ട ഫയലിലേക്ക് ഔട്ട്പുട്ട് എഴുതണമെന്ന് വ്യക്തമാക്കുക
പദപ്രയോഗത്തിൽ സൃഷ്ടിക്കേണ്ട ചിഹ്നം (കാണുക ഉദാഹരണങ്ങൾ വിഭാഗം). എങ്കിൽ
ഈ ഓപ്ഷൻ നൽകിയിരിക്കുന്നു, തുടർന്ന് എല്ലാ നോൺ-ഓപ്ഷൻ ആർഗ്യുമെന്റുകളും ഇൻപുട്ട് ഫയലുകളായി എടുക്കും. ഈ
ഒന്നിലധികം ഔട്ട്‌പുട്ട് ഫയലുകൾക്കായി ഓപ്ഷൻ ഒന്നിലധികം തവണ ഉപയോഗിക്കാം.

-eval_width മൂല്യം
സമാന്തരമായി പ്രോസസ്സ് ചെയ്യേണ്ട വോക്സലുകളുടെ എണ്ണം വ്യക്തമാക്കുക. സ്ഥിരസ്ഥിതി 200 ആണ്.

ഭാവങ്ങൾ

ദി -പ്രകടനം മൂല്യനിർണ്ണയ പ്രവർത്തനത്തെ വിവരിക്കുന്ന ഒരൊറ്റ സ്ട്രിംഗാണ് ആർഗ്യുമെന്റ്. ദി
ഫംഗ്ഷൻ എക്സ്പ്രഷൻ സാധാരണയായി വെക്റ്റർ എയുടെ അടിസ്ഥാനത്തിൽ എഴുതിയിരിക്കുന്നു.

ഉദാഹരണത്തിന്, ഇനിപ്പറയുന്ന എക്സ്പ്രഷൻ ആദ്യത്തെ രണ്ട് ഇൻപുട്ട് ഫയലുകളെ ഒന്നിച്ചു ചേർക്കും:

എ[0] + എ[1]

ഒന്നിലധികം പദപ്രയോഗങ്ങൾ അർദ്ധവിരാമങ്ങളാൽ വേർതിരിച്ച് നൽകാം, ഈ സാഹചര്യത്തിൽ മൂല്യം മാത്രം
അവസാന പദപ്രയോഗം ഉപയോഗിക്കുന്നു. ഈ എക്സ്പ്രഷൻ ലിസ്റ്റുകൾ അസൈൻമെന്റിനൊപ്പം ഉപയോഗിക്കാം
വാക്യഘടനയെ വളരെ സി-ലൈക്ക് ആക്കുന്നതിനുള്ള എക്സ്പ്രഷനുകൾ:

അനുപാതം = A[0]/A[1]; എ[2]*എക്‌സ്‌പി(-അനുപാതം)

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

ഭാഷയിൽ രണ്ട് തരം മൂല്യങ്ങളുണ്ട്: വെക്റ്ററുകളും സ്കെയിലറുകളും. സ്കെയിലറുകൾ അക്ഷരങ്ങളാണ്
ഫ്ലോട്ടിംഗ് പോയിന്റ് നമ്പറുകൾ അല്ലെങ്കിൽ ഒരു ചെറിയ അക്ഷരത്തിൽ പേര് ആരംഭിക്കുന്ന ചിഹ്നങ്ങളായി പ്രത്യക്ഷപ്പെടാം.

സാധാരണ സ്കെയിലർ ഓപ്പറേറ്റർമാരായ +, -, * കൂടാതെ / കൂടാതെ, എക്സ്പ്രഷൻ ഭാഷയും
സാധാരണ റിലേഷണൽ ഓപ്പറേറ്റർമാരായ <, <=, >, infix എക്സ്പോണൻഷ്യേഷൻ ഓപ്പറേറ്റർ ^ പിന്തുണയ്ക്കുന്നു
>=, ==, != അതുപോലെ ബൂളിയൻ ഓപ്പറേറ്റർമാർ && (ഒപ്പം), || (അല്ലെങ്കിൽ) ഒപ്പം! (അല്ല). എന്നത് ശ്രദ്ധിക്കുക
&& ഒപ്പം || C. സ്കെലാർ മാത്തമാറ്റിക്കലിൽ നിന്ന് വ്യത്യസ്തമായി ബൂളിയൻ ഓപ്പറേറ്റർമാർ രണ്ട് ഓപ്പറണ്ടുകളും എപ്പോഴും വിലയിരുത്തുന്നു.
പ്രവർത്തനങ്ങൾ ഉൾപ്പെടുന്നു എബിഎസ്, ചതുരശ്ര, exp, ലോഗ്, പാപം, cos, ടാൻ, എന്നപോലെ, അക്കോസ് ഒപ്പം അവൻ. അത് കൂടാതെ
ചില പ്രത്യേക പ്രവർത്തനങ്ങൾ:

isnan(v) - v അസാധുവാണെങ്കിൽ 1, അല്ലാത്തപക്ഷം 0
ക്ലാമ്പ്(v1,v2,v3) - v1 പരിമിതപ്പെടുത്തിയിരിക്കുന്നത് [v2, v3]
സെഗ്‌മെന്റ്(v1,v2,v3) - v1 [v2, v3] ൽ ആണോ എന്ന് പരിശോധിക്കുന്നു

സ്കെയിലർ സ്ഥിരാങ്കം NaN നിർവചിച്ചിരിക്കുന്നത് ഇസ്നാൻ(NaN) റിട്ടേൺ 1 ആണ്.

വെക്‌ടറുകൾ ഇനിപ്പറയുന്ന `വിപുലീകരണ' രൂപത്തിൽ എഴുതാം

[മൂല്യം1, മൂല്യം2, ...]

അല്ലെങ്കിൽ ഇനിപ്പറയുന്ന ശ്രേണി സൃഷ്ടിക്കുന്ന നൊട്ടേഷനുകൾ ഉപയോഗിച്ച്:

[ a : b ] {a, a+1, ..., b-1, b} സൃഷ്ടിക്കുന്നു
[ a : b ) {a, a+1, ..., b-1} സൃഷ്ടിക്കുന്നു
(a: b ] {a+1, ..., b-1, b} സൃഷ്ടിക്കുന്നു
( a : b ) {a+1, ..., b-1} സൃഷ്ടിക്കുന്നു

അല്ലെങ്കിൽ 'ഉദ്ദേശ്യം' വഴി സൃഷ്ടിക്കപ്പെടും. ഇനിപ്പറയുന്ന തീവ്രത എക്സ്പ്രഷൻ വെക്റ്റർ സൃഷ്ടിക്കുന്നു
{3,2,1}:

{ ഞാൻ [1:3] | 4 - ഞാൻ }

വെക്‌ടറുകൾ വലിയക്ഷരത്തിൽ തുടങ്ങുന്ന പേരിന്റെ ചിഹ്നങ്ങളായും പ്രത്യക്ഷപ്പെടാം.

സ്കെയിലർ ഓപ്പറേറ്റർമാർക്ക് പുറമേ, ഇനിപ്പറയുന്ന വെക്റ്റർ ഓപ്പറേറ്റർമാരും വിതരണം ചെയ്യുന്നു:

ശരാശരി - വെക്റ്ററിലെ സ്കെയിലറുകളുടെ ശരാശരി മൂല്യം
ലെൻ - നീളം
തുക - മൂലകങ്ങളുടെ ആകെത്തുക
prod - മൂലകങ്ങളുടെ ഉൽപ്പന്നം
പരമാവധി - പരമാവധി മൂല്യം
മിനിറ്റ് - ഏറ്റവും കുറഞ്ഞ മൂല്യം
imax - പരമാവധി മൂല്യത്തിന്റെ സൂചിക
imin - ഏറ്റവും കുറഞ്ഞ മൂല്യത്തിന്റെ സൂചിക
V[s] - ഉത്ഭവം 0 ഉള്ള വെക്റ്റർ V യുടെ s'th ഘടകം.

എന്നതിന്റെ അസൈൻമെന്റ് എക്സ്പ്രഷനുകൾ വഴി ഒരു ആഗോള ചിഹ്ന പട്ടികയിലേക്ക് ചിഹ്ന നാമങ്ങൾ അവതരിപ്പിക്കപ്പെടുന്നു
രൂപം

a = A[2] * ലോഗ്(2)

ഒരു ചെറിയ അക്ഷരത്തിൽ ആരംഭിക്കുന്ന ചിഹ്നങ്ങൾ സ്കെയിലറുകളെ പ്രതിനിധീകരിക്കുന്നു, അതേസമയം ഒരു അക്ഷരത്തിൽ ആരംഭിക്കുന്നവ
വലിയക്ഷരം വെക്റ്ററുകളെ പ്രതിനിധീകരിക്കുന്നു. = ഒരു ഓപ്പറേറ്ററായതിനാൽ, അതിന്റെ ഫലം an-ൽ ഉപയോഗിക്കാം
എക്സ്പ്രഷൻ (സിയിലെ പോലെ).

കുറച്ച് നിയന്ത്രണ നിർമ്മാണങ്ങൾ നൽകിയിരിക്കുന്നു:

ഒരു വെക്‌ടറിനു മുകളിലൂടെ ലൂപ്പുചെയ്യാൻ ലൂപ്പുകൾ സൃഷ്‌ടിക്കാൻ കഴിയും, ഓരോ മൂല്യവും ഒരു ചിഹ്നത്തിന് നൽകുകയും തുടർന്ന്
ഒരു പദപ്രയോഗം വിലയിരുത്തുന്നു. ഫോമിന്റെ എക്സ്പ്രഷനുകൾ ഉപയോഗിച്ചാണ് ഇത് ചെയ്യുന്നത്

ആകെ=0; for{i in [0:len(A))} total=total+A[i]; ആകെ

തുക (എ) ന് തുല്യമാണ്. ഇത് ഉപയോഗിക്കുന്നതിന് സമാനമാണെന്നത് ശ്രദ്ധിക്കുക

ആകെ=0; len{i in [0:len(A)) | ആകെ=മൊത്തം+എ[i]}; ആകെ

അതിനു ശേഷം വേണ്ടി കൺസ്ട്രക്‌റ്റ് യഥാർത്ഥത്തിൽ ഒരു ഓപ്പറേറ്ററാണ് (ഇത് സാധാരണയായി ഉപയോഗിക്കുന്നുണ്ടെങ്കിലും
ചിഹ്ന മൂല്യങ്ങൾ മാറ്റുന്നു). അവസാന "മൊത്തം" ഇല്ലാതെ, എക്സ്പ്രഷൻ ആകും എന്നതും ശ്രദ്ധിക്കുക
വെക്‌ടറിന്റെ ദൈർഘ്യം മാത്രം നൽകുന്നതിനാൽ ഇത് വളരെ ഉപയോഗപ്രദമല്ല.

C ലെ പോലെ, പദപ്രയോഗങ്ങളുടെ ഒരു ലിസ്റ്റ് ചുരുളുകളിൽ വ്യക്തമാക്കാം:

ആകെ=ആകെ2 = 0;
{i ൽ [0:len(A))} {
ആകെ = ആകെ + A[i];
total2 = total2 + A[i]^2
}

യുടെ ചില രൂപങ്ങളും ഉണ്ട് എങ്കിൽ-പിന്നെ-മറ്റൊരു നിർമ്മിക്കുക:

A[0]<0 ? 0 : എ[0]

എങ്കിൽ (A[0]<0) ഫലം=0 മറ്റെന്തെങ്കിലും ഫലം=A[0]

ദി മറ്റാരെങ്കിലും ഓപ്ഷണൽ ആണ്. വീണ്ടും, if കൺസ്ട്രക്റ്റ് ഒരു ഓപ്പറേറ്ററാണ്, കൂടാതെ അപ്പോള് or മറ്റാരെങ്കിലും
എക്സ്പ്രഷനുകൾ ചുരുളുകളിൽ എക്സ്പ്രഷൻ ലിസ്റ്റുകളാകാം, ഈ സാഹചര്യത്തിൽ അവസാനത്തേതിന്റെ മൂല്യം
പദപ്രയോഗം തിരികെ ലഭിച്ചു. എങ്കിൽ മറ്റാരെങ്കിലും എക്സ്പ്രഷൻ കാണുന്നില്ല, തുടർന്ന് മൂല്യം 0 നൽകുന്നു
ടെസ്റ്റ് എക്സ്പ്രഷൻ 0 ആയിരിക്കുമ്പോൾ (തെറ്റ്).

എന്നതുമായുള്ള പ്രധാന വിചിത്രത വേണ്ടി ഒപ്പം if C പ്രസ്താവനകളിൽ നിന്ന് വ്യത്യസ്തമായി, അവ നിർബന്ധമാണ്
ഒരു എക്സ്പ്രഷൻ ലിസ്റ്റ് ഉള്ളപ്പോൾ പോലും അടുത്ത എക്സ്പ്രഷനിൽ നിന്ന് ഒരു അർദ്ധവിരാമം കൊണ്ട് വേർതിരിക്കുക
curlies ഉപയോഗിക്കുന്നു:

എനിക്ക് [0:len(A)) {ആകെ=ആകെ+A[i]} ; ആകെ/ലെൻ(എ)
എങ്കിൽ (A[i]>0) {ഫലം=2;} വേറെ {ഫലം=1} ; ഫലം*5

ചിഹ്ന നാമങ്ങൾ പരിചയപ്പെടുത്തുന്നതിനുള്ള ഒരു ബദൽ മാർഗമാണ് ചെയ്യട്ടെ-ഭാവങ്ങൾ. ഉദാഹരണത്തിന്, ദി
ഇനിപ്പറയുന്ന പദപ്രയോഗം എല്ലായ്പ്പോഴും 3 ആയി വിലയിരുത്തും:

a = 1, b = 2 in a + b

മൂല്യനിർണ്ണയ എക്സ്പ്രഷനിൽ മാത്രം വേരിയബിളുകൾ സൃഷ്ടിക്കുന്നതിനാണ് ഇവ യഥാർത്ഥത്തിൽ രൂപകൽപ്പന ചെയ്തിരിക്കുന്നത്,
എന്നാൽ ആഗോള ചിഹ്ന പട്ടിക മാറ്റുന്ന തരത്തിൽ മാറ്റങ്ങൾ വരുത്തിയിട്ടുണ്ട്.

ഉദാഹരണങ്ങൾ

സ്റ്റാൻഡേർഡ് ഡീവിയേഷൻ കണക്കാക്കുന്നതിനുള്ള ഒരു പദപ്രയോഗം ഇവിടെയുണ്ട്
അസാധുവായ ഇൻപുട്ട് ഡാറ്റയുടെ സാധ്യത, അവഗണിച്ചിരിക്കുന്നു:

s0 = s1 = s2 = 0;

{ i ൽ [0:len(A))} {
v=A[i];
എങ്കിൽ (!isnan(v)) {
s0 = s0 + 1;
s1 = s1 + v;
s2 = s2 + v * v;
}
};

എങ്കിൽ (s0 > 1) {
sqrt((s2 - s1*s1/s0) / (s0-1));
}
else {
NaN;
};

s0 > 0 എന്നാൽ <= 0 ആണെങ്കിൽ അവസാനത്തെ if എന്നത് 1 ആയി മാറ്റാം. ഞങ്ങൾ ചുരുണ്ടതും ഇടുന്നു
ബ്രാക്കറ്റുകൾ, എന്നാൽ ഒരു ";" ഉണ്ടാകാൻ പാടില്ല. if എന്നതിനും മറ്റേതിനും ഇടയിൽ

എങ്കിൽ (s0 > 1)
sqrt((s2 - s1*s1/s0) / (s0-1))
അല്ലെങ്കിൽ (s0 > 0)
0
മറ്റാരെങ്കിലും
ഇല്ല

ശരാശരിയും സ്റ്റാൻഡേർഡ് ഡീവിയേഷനും വേണമെങ്കിൽ, നമുക്ക് ഉപയോഗിക്കാം - outfile ഓപ്ഷൻ,
കൂടെ കമാൻഡ് അഭ്യർത്ഥിക്കുന്നു

minccalc -expfile stdev
-outfile അർത്ഥം mean.mnc
-outfile stdev stdev.mnc
infile1.mnc infile2.mnc ...

എക്‌സ്‌പ്രഷൻ ഫയൽ ഉപയോഗിക്കുന്നു (ഇഫ് എക്‌സ്‌പ്രഷന്റെ മറ്റൊരു രൂപത്തോടെ):

s0 = s1 = s2 = 0;

{i ൽ [0:len(A))} {
v=A[i];
എങ്കിൽ (!isnan(v)) {
s0 = s0 + 1;
s1 = s1 + v;
s2 = s2 + v * v;
}
};

stdev = (s0 > 1) ? sqrt((s2 - s1*s1/s0) / (s0-1)):
(s0 > 0) ? 0 : NaN ;
ശരാശരി = (s0 > 0) ? s1 / s0 : NaN ;

മുന്നറിയിപ്പ്

നിങ്ങൾ ഓർക്കേണ്ട ചില കാര്യങ്ങൾ...

വെക്റ്റർ വേരിയബിളുകൾ വലിയക്ഷരത്തിൽ തുടങ്ങണം.

വെക്റ്റർ വേരിയബിൾ പേരുകൾ ഫംഗ്ഷൻ കീവേഡുകളിൽ ഒന്നായിരിക്കരുത്,
തുക, ലെൻ, ഉൽപ്പന്നം, ... തുടങ്ങിയവ

ലൂപ്പുകൾക്കും എക്‌സ്‌പ്രഷനുകൾക്കും എല്ലായ്‌പ്പോഴും അടുത്ത എക്‌സ്‌പ്രഷനിൽ നിന്ന് a കൊണ്ട് വേർതിരിക്കേണ്ടതുണ്ട്
അർദ്ധവിരാമം.

ചിഹ്ന പട്ടിക ആഗോളമാണ്.

ബൂളിയൻ ഓപ്പറേറ്റർമാർ && ഒപ്പം || രണ്ട് പ്രവർത്തനങ്ങളും എപ്പോഴും വിലയിരുത്തുക.

സമാന്തരതയെക്കുറിച്ചുള്ള ഒരു കുറിപ്പ്: കാര്യക്ഷമത കാരണങ്ങളാൽ, ഒരേസമയം നിരവധി വോക്സലുകളിൽ മൂല്യനിർണ്ണയം നടത്തുന്നു
(വോക്സലുകളുടെ എണ്ണത്തെ മൂല്യനിർണ്ണയത്തിന്റെ വീതി എന്ന് വിളിക്കുന്നു, ഒപ്പം മാറ്റുകയും ചെയ്യുന്നു
The -eval_width ഓപ്ഷൻ). ഇതിന്റെ ഒരു വിചിത്രമായ അനന്തരഫലം, if-else-ന്റെ ഇരുവശങ്ങളും
പ്രസ്താവനകൾ എല്ലായ്പ്പോഴും വിലയിരുത്തപ്പെടുന്നു (എല്ലാ വോക്സലുകളും ഒരേ ടെസ്റ്റ് ഫലം നൽകുന്നില്ലെങ്കിൽ), പക്ഷേ
ഓരോ അനന്തരഫലത്തിലുമുള്ള പ്രസ്താവനകൾ ഉചിതമായ വോക്സലുകളിൽ മാത്രം വിലയിരുത്തപ്പെടുന്നു. ഇൻ
പ്രത്യേകിച്ചും, ചിഹ്ന പട്ടികയിലെ എൻട്രികൾ ഒരു വോക്സൽ മാസ്കിന് അനുസൃതമായി മാത്രമേ പരിഷ്കരിക്കൂ. എ
ഇതിന്റെ പാർശ്വഫലം, if-else consequent-ൽ സജ്ജീകരിച്ചിരിക്കുന്ന ഏതെങ്കിലും വെക്റ്റർ ചിഹ്നം മാറാൻ പാടില്ല എന്നതാണ്
ചിഹ്നത്തിന്റെ ദൈർഘ്യം (അത് സൃഷ്ടിക്കാൻ കഴിയുമെങ്കിലും) അനന്തരഫലത്തിന്റെ ഇരുവശങ്ങളും നിർബന്ധമായും
അവ രണ്ടും പരിഷ്കരിക്കുന്ന ഏതെങ്കിലും വെക്റ്റർ ചിഹ്നങ്ങളുടെ ദൈർഘ്യം അംഗീകരിക്കുന്നു. ഇത് വ്യക്തമല്ലെങ്കിൽ,
ഇത് പരീക്ഷിക്കുക - പ്രോഗ്രാം സന്തോഷകരമല്ലെങ്കിൽ പരാതിപ്പെടും.

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