സ്ക്രിപ്റ്റുകളിലെ "ബിസി" കാൽക്കുലേറ്റർ എങ്ങനെ ഉപയോഗിക്കാം

ലിനക്സ് പ്രോഗ്രാം bc ഉപയോഗിക്കാവുന്ന ഒരു ഡെസ്ക്ടോപ്പ് കംപ്കലേറ്റർ അല്ലെങ്കിൽ ഗണിതശാസ്ത്ര സ്ക്രിപ്റ്റിംഗ് ഭാഷയായി ഉപയോഗിക്കാം. Bc കമാൻഡ് ടെർമിനലിലൂടെ വിളിച്ചതിനെ പോലെ എളുപ്പമാണ്.

ബിസി യൂട്ടിലിറ്റി കൂടാതെ ബൾ ഷെൽ അരിത്മെറ്റിക് പ്രവർത്തനങ്ങൾ നടത്താൻ മറ്റ് ചില മാർഗ്ഗങ്ങൾ നൽകുന്നു.

കുറിപ്പ്: ബിസി പ്രോഗ്രാം അടിസ്ഥാന കാൽക്കുലേറ്റർ അല്ലെങ്കിൽ ബെഞ്ച് കാൽക്കുലേറ്റർ എന്നും വിളിക്കപ്പെടുന്നു.

bc കമാൻഡ് സിന്റാക്സ്

ബിസി കമാന്ഡിനുള്ള സിന്റാക്സ് സി പ്രോഗ്രാമിങ് ഭാഷയ്ക്ക് സമാനമാണ്, കൂടാതെ അനവധി ഓപ്പറേറ്റർമാർ പിന്തുണയും, ഉപഡ്രാക്ഷൻ, പ്ലസ് അല്ലെങ്കിൽ മൈനസ് എന്നിവയും അതിലധികവും പിന്തുണയ്ക്കുന്നു.

Bc കമാൻഡിനൊപ്പമുള്ള വിവിധ സ്വിച്ചുകൾ ഇവയാണ്:

• -h, --help: ഈ ഉപയോഗവും പുറത്തു് കടക്കുക.
• -i, --interactive: ഇന്ററാക്ടീവ് മോഡ് നിർബന്ധിയ്ക്കുന്നു.
• -l, --mathlib: മുൻ നിർവ്വഹണ ഗണിത മാർഗ്ഗങ്ങൾ ഉപയോഗിക്കുന്നു.
• -q, --quiet: പ്രാരംഭ ബാനർ പ്രിന്റ് ചെയ്യരുത്.
• -s, --standard: നിലവാരമില്ലാത്ത ബിസി നിർമാണങ്ങൾ പിശകുകളാണ്.
• -w, --warn: നിലവാരമില്ലാത്ത ബിസി നിർമ്മിതികളെപ്പറ്റി മുന്നറിയിപ്പ് നൽകുന്നു.
• -v, --version: അച്ചടി പതിപ്പ് വിവരങ്ങളും പുറത്ത് കടക്കുക.

നിങ്ങൾക്ക് അടിസ്ഥാന കണക്കുകൂട്ടൽ എങ്ങനെ ഉപയോഗിക്കാം എന്നതിനെക്കുറിച്ചുള്ള കൂടുതൽ വിവരങ്ങൾക്ക് bc കമാൻഡ് മാനുവൽ കാണുക.

bc കമാൻഡ് ഉദാഹരണം

സാധാരണ കംപ്കുലേറ്റർ ഒരു ടെർമിനലിൽ ഉപയോഗിയ്ക്കാം, അതു് ബിസിയിൽ പ്രവേശിയ്ക്കുന്നതിനു് ശേഷം, ഇതു് സാധാരണ ഗണിത എക്സ്ചേഞ്ചുകൾ ടൈപ്പ് ചെയ്യാം:

4 + 3

... ഇതുപോലുള്ള ഒരു ഫലം ലഭിക്കാൻ:

7

ഒരു കൂട്ടം കണക്കുകൂട്ടലുകൾ ആവർത്തിച്ച് ചെയ്യുമ്പോൾ, ഒരു സ്ക്രിപ്റ്റിന്റെ ഭാഗമായി BC കൽകുലേറ്റർ ഉപയോഗിക്കുന്നത് നല്ലതായിരിക്കും. അത്തരമൊരു സ്ക്രിപ്റ്റിന്റെ ഏറ്റവും ലളിതമായ രൂപം ഇതുപോലെയായിരിക്കും:

#! / bin / bash echo '6.5 / 2.7' | ബിസി

ആദ്യത്തെ വരി ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കുന്ന എക്സിക്യൂട്ടബിൾ പാത്ത് മാത്രമാണ്.

രണ്ടാമത്തെ വരിയിൽ രണ്ട് കമാൻഡുകൾ അടങ്ങിയിരിക്കുന്നു. സിംഗിൾ ഉദ്ധരണികളിൽ അടങ്ങിയ ഗണിത പദപ്രയോഗങ്ങളുള്ള ഒരു സ്ട്രിങായാണ് echo കമാൻഡ് നിർമ്മിക്കുന്നത് (6.5, 2.7 ഉപയോഗിച്ചാണ് ഈ ഉദാഹരണം). പൈപ്പ് ഓപ്പറേറ്റർ (|) ഈ സ്ട്രിങിനെ ബിസി പ്രോഗ്രാമിലേക്കുള്ള ആർഗ്യുമെന്റ് ആയി നൽകുന്നു. Bc പ്രോഗ്രാം ഔട്ട്പുട്ട് കമാൻഡ് ലൈനിൽ കാണിക്കുന്നു.

ഈ സ്ക്രിപ്റ്റ് പ്രവർത്തിപ്പിക്കാൻ, ഒരു ടെർമിനൽ വിൻഡോ തുറന്ന്, സ്ക്രിപ്റ്റ് സ്ഥിതി ചെയ്യുന്ന ഡയറക്ടറിയിലേക്ക് നാവിഗേറ്റുചെയ്യുക. നമ്മൾ സ്ക്രിപ്റ്റ് ഫയൽ bc_script.sh എന്ന് വിളിക്കുന്നു. Chmod കമാൻഡ് ഉപയോഗിച്ച് ഫയൽ എക്സിക്യൂട്ട് ചെയ്യുന്നു എന്ന് ഉറപ്പുവരുത്തുക:

chmod 755 bc_script.sh

നിങ്ങൾ അതിൽ പ്രവേശിക്കും:

./bc_script.sh

ഫലം ഇതായിരിക്കും:

2

യഥാർത്ഥ ഉത്തരം 2.407407 ആയതിനാൽ 3 ദശാംശസ്ഥാനങ്ങൾ കാണിക്കാൻ ... സിംഗിൾ ഉദ്ധരണികൾ വഴി വേർതിരിച്ച സ്ട്രിംഗിനുള്ളിൽ ഒരു സ്കെയിൽ സ്റ്റേറ്റ്മെന്റ് ഉപയോഗിക്കുക:

#! / bin / bash echo 'scale = 3; 6.5 / 2.7 '| ബിസി

മെച്ചപ്പെട്ട വായനയ്ക്കായി, കണക്കുകൂട്ടലുകളുമായുള്ള ലൈൻ ഒന്നിലധികം വരികളിൽ പുനർവിതരണം ചെയ്യാനാകും. പല വരികളായി കമാൻഡ് ലൈൻ ബ്രേക്ക് ക്രമത്തിൽ നിങ്ങൾക്ക് വരിയുടെ അവസാനം ഒരു ബാക്കപ്പ് എടുക്കാം:

echo 'scale = 3; var1 = 6.5 / 2.7; var1 '\ | ബിസി

നിങ്ങളുടെ bc കണക്കുകൂട്ടലുകളിൽ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റുകൾ ഉൾപ്പെടുത്തുന്നതിന്, സിംഗിൾ ഉദ്ധരണികൾ ഇരട്ട ഉദ്ധരണികളാക്കി മാറ്റണം. അങ്ങനെ കമാൻഡ് ലൈൻ പാരാമീറ്റർ ചിഹ്നങ്ങൾ ബാഷ് ഷെൽ ഉപയോഗിച്ച് വ്യാഖ്യാനിക്കപ്പെടും:

echo "scale = 3; var1 = 6.5 / 2.7; var2 = 14 * var1; var2 * = $ 1; var2" \ | ബിസി

"$ 1" എന്ന വേരിയബിൾ ഉപയോഗിച്ചാണ് ആദ്യ കമാൻഡ് ലൈൻ ആർഗ്യുമെന്റ് ആക്സസ് ചെയ്യപ്പെടുന്നത്, രണ്ടാമത്തെ ആർഗ്യുമെന്റ് "$ 2" ഉപയോഗിക്കുന്നു.

ഇപ്പോൾ നിങ്ങൾക്ക് നിങ്ങളുടെ ഇഷ്ടാനുസൃതമാക്കിയ അരിത്മെറ്റിക് ഫംഗ്ഷനുകൾ പ്രത്യേക ബാഷ് സ്ക്രീനിൽ എഴുതാനും മറ്റ് സ്ക്രിപ്റ്റുകളിൽ നിന്ന് അവയെ വിളിക്കാനുമാകും.

ഉദാഹരണത്തിന്, സ്ക്രിപ്റ്റ് 1 ഉണ്ടെങ്കിൽ:

#! / bin / bash echo "scale = 3; var1 = 6.5 / 2.7; var2 = 14 * var1; var2 * = $ 1; var2" \ | ബിസി

... കൂടാതെ സ്ക്രിപ്റ്റ് 2 അടങ്ങിയിരിക്കുന്നു

#! / bin / bash var0 = "100" echo "var0: $ var0" function fun1 {echo "scale = 3; var1 = 10; var2 = var1 * $ var0; var2" \ | bc} fres = $ (രസകരമായ 1) echo "fres:" $ fres var10 = $ (./ script1 $ fres); echo "var10:" $ var10;

... കൂടാതെ സ്ക്രിപ്റ്റ് 2 എക്സിക്യൂട്ട് ചെയ്യുന്നത് സ്ക്രിപ്റ്റ് 2 ൽ കണക്കുകൂട്ടിയ ഒരു വ്യത്യാസം $ fres ഉപയോഗിച്ച് സ്ക്രിപ്റ്റായ 1 സ്ക്രിപ്റ്റ് 1 എന്ന് വിളിക്കുന്നു.