സി ഭാഷയുടെ ഗണിത പ്രവർത്തനങ്ങൾ

സി, സി++ ഭാഷകൾ പലതും വ്യത്യസ്തമായി നിർവചിക്കുന്നു ഗണിത പ്രവർത്തനങ്ങൾ. ആദ്യം, രണ്ട് ഭാഷകളും ഒരേ 22 ഗണിത പ്രവർത്തനങ്ങളെ പിന്തുണച്ചു. എന്നിരുന്നാലും, C++ ഭാഷ വികസിച്ചപ്പോൾ, അതിൽ നിർവചിക്കപ്പെട്ട പ്രവർത്തനങ്ങളുടെ ആയുധശേഖരം വികസിച്ചു. അപ്പോൾ C99 പതിപ്പിൽ വലിപ്പം ഗണിതശാസ്ത്ര ലൈബ്രറിഗണ്യമായി വർദ്ധിച്ചു. ഈ മാറ്റങ്ങളുടെ ഫലമായി, സി, സി ++ ഭാഷകളുടെ ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങളുടെ ലൈബ്രറികൾ പരസ്പരം ഗണ്യമായി വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. അതിനാൽ, ഈ അധ്യായം C ഭാഷയുടെ ഗണിത പ്രവർത്തനങ്ങളെ വിവരിക്കുന്നു (പതിപ്പ് C99 ൽ ചേർത്തവ ഉൾപ്പെടെ), കൂടാതെ അധ്യായം 9 C++ ഭാഷയുടെ പ്രവർത്തനങ്ങളിൽ മാത്രം ശ്രദ്ധ കേന്ദ്രീകരിക്കുന്നു. എന്നിരുന്നാലും, C, C++ എന്നിവയുടെ എല്ലാ പതിപ്പുകളും ഗണിത ഫംഗ്‌ഷനുകളുടെ യഥാർത്ഥ സെറ്റ് ഇപ്പോഴും പിന്തുണയ്‌ക്കുന്നുവെന്ന് ഓർമ്മിക്കുക.

എല്ലാ ഗണിത പ്രവർത്തനങ്ങളും ഉപയോഗിക്കുന്നതിന്, പ്രോഗ്രാമിൽ ഹെഡർ ഉൾപ്പെടുത്തണം . ഗണിത പ്രവർത്തനങ്ങൾ പ്രഖ്യാപിക്കുന്നതിനു പുറമേ, ഈ തലക്കെട്ട് ഒന്നോ അതിലധികമോ മാക്രോകളെ നിർവചിക്കുന്നു. പതിപ്പ് C89-ൽ തലക്കെട്ട് HUGE_VAL മാക്രോ മാത്രമേ നിർവചിച്ചിട്ടുള്ളൂ, ഇത് ഓവർഫ്ലോയെ സൂചിപ്പിക്കുന്ന ഇരട്ട മൂല്യമാണ്.

ഇനിപ്പറയുന്ന മാക്രോകൾ പതിപ്പ് C99 ൽ നിർവചിച്ചിരിക്കുന്നു.

C99 പതിപ്പ് ഒരു മൂല്യത്തെ തരംതിരിക്കുന്ന ഇനിപ്പറയുന്ന മാക്രോകൾ (ഫംഗ്ഷൻ പോലെയുള്ളത്) നിർവചിക്കുന്നു.

പതിപ്പ് C99 ൽ, ഇനിപ്പറയുന്ന താരതമ്യ മാക്രോകൾ നിർവചിച്ചിരിക്കുന്നു, അവയുടെ ആർഗ്യുമെൻ്റുകൾ (a, b) ഫ്ലോട്ടിംഗ് പോയിൻ്റ് മൂല്യങ്ങളായിരിക്കണം.

ഈ മാക്രോകൾ യഥാർത്ഥ തരം ഒഴിവാക്കലുകൾ ഒഴിവാക്കാതെ തന്നെ മികച്ച സംഖ്യകളല്ലാത്ത മൂല്യങ്ങൾ കൈകാര്യം ചെയ്യുന്നു.

EDOM, ERANGE മാക്രോകളും ഗണിത പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നു. ഈ മാക്രോകൾ തലക്കെട്ടിൽ നിർവചിച്ചിരിക്കുന്നു .

C89, C99 പതിപ്പുകളിലെ പിശകുകൾ വ്യത്യസ്തമായി കൈകാര്യം ചെയ്യുന്നു. അങ്ങനെ, C89-ൽ, ഒരു ഗണിത ഫംഗ്‌ഷൻ ആർഗ്യുമെൻ്റ് അത് നിർവചിച്ചിരിക്കുന്ന ഡൊമെയ്‌നിനുള്ളിൽ വരുന്നില്ലെങ്കിൽ, ചില നിർവ്വഹണ-നിർദ്ദിഷ്ട മൂല്യം തിരികെ നൽകുകയും അന്തർനിർമ്മിത ആഗോള പൂർണ്ണസംഖ്യ വേരിയബിൾ errno EDOM-ൻ്റെ മൂല്യത്തിലേക്ക് സജ്ജമാക്കുകയും ചെയ്യുന്നു. C99-ൽ, ഒരു ഡൊമെയ്ൻ ലംഘന പിശകും ഒരു നിർവ്വഹണ-നിർദ്ദിഷ്ട മൂല്യം തിരികെ നൽകുന്നതിന് കാരണമാകുന്നു. എന്നിരുന്നാലും, math_errhandling-ൻ്റെ മൂല്യം മറ്റ് പ്രവർത്തനങ്ങൾ നടത്തുന്നുണ്ടോ എന്ന് സൂചിപ്പിക്കാൻ കഴിയും. math_errhandling-ൽ MATH_ERRNO മൂല്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ബിൽറ്റ്-ഇൻ ഗ്ലോബൽ ഇൻ്റിജർ വേരിയബിൾ errno EDOM-ൻ്റെ മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു. math_errhandling-ൽ MATH_ERREXCEPT മൂല്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഒരു യഥാർത്ഥ അപവാദം നൽകപ്പെടും.

C89-ൽ, പ്രാതിനിധ്യം കൈകാര്യം ചെയ്യാൻ കഴിയാത്തത്ര വലിയ ഫലം ഒരു ഫംഗ്ഷൻ സൃഷ്ടിക്കുകയാണെങ്കിൽ, ഒരു ഓവർഫ്ലോ സംഭവിക്കുന്നു. ഈ സാഹചര്യത്തിൽ, ഫംഗ്‌ഷൻ HUGE_VAL നൽകുന്നു, കൂടാതെ errno ഒരു ശ്രേണി പിശകിനെ സൂചിപ്പിക്കുന്ന ERANGE മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു. ഒരു അണ്ടർഫ്ലോ കണ്ടെത്തുമ്പോൾ, ഫംഗ്ഷൻ പൂജ്യം തിരികെ നൽകുകയും ERANGE എന്നതിലേക്ക് errno സജ്ജമാക്കുകയും ചെയ്യുന്നു. C99-ൽ, ഒരു ഓവർഫ്ലോ പിശക് ഫംഗ്‌ഷൻ ഒരു മൂല്യം നൽകുന്നതിന് കാരണമാകുന്നു. HUGE_VAL, അതിന് പ്രാധാന്യം നഷ്‌ടപ്പെടുകയാണെങ്കിൽ - പൂജ്യം. math_errhandling-ൽ MATH_ERRNO മൂല്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ആഗോള വേരിയബിൾ errno ഒരു ശ്രേണി പിശക് സൂചിപ്പിക്കുന്ന ERANGE മൂല്യത്തിലേക്ക് സജ്ജീകരിച്ചിരിക്കുന്നു. math_errhandling-ൽ MATH_ERREXCEPT മൂല്യം അടങ്ങിയിട്ടുണ്ടെങ്കിൽ, ഒരു യഥാർത്ഥ അപവാദം നൽകപ്പെടും.

പതിപ്പ് C89 ൽ, ഗണിതശാസ്ത്ര പ്രവർത്തനങ്ങളിലേക്കുള്ള ആർഗ്യുമെൻ്റുകൾ ഇരട്ട മൂല്യങ്ങളും ഫംഗ്ഷനുകൾ നൽകുന്ന മൂല്യങ്ങൾ ഇരട്ട മൂല്യങ്ങളും ആയിരിക്കണം. C99 പതിപ്പിൽ, യഥാക്രമം f, l എന്നീ പ്രത്യയങ്ങൾ ഉപയോഗിക്കുന്ന ഈ ഫംഗ്‌ഷനുകളുടെ ഫ്ലോട്ടും നീളമുള്ള ഇരട്ട വേരിയൻ്റുകളും ചേർത്തു. ഉദാഹരണത്തിന്, പതിപ്പ് C89 ൽ, sin() ഫംഗ്ഷൻ ഇനിപ്പറയുന്ന രീതിയിൽ നിർവചിച്ചിരിക്കുന്നു.

ഇരട്ട പാപം (ഡബിൾ ആർഗ്);

പതിപ്പ് C99 ൽ, sin() ഫംഗ്‌ഷൻ്റെ മുകളിലുള്ള നിർവചനം പിന്തുണയ്ക്കുന്നു, കൂടാതെ രണ്ട് പരിഷ്‌ക്കരണങ്ങൾ കൂടി ചേർത്തു - sinf() ഉം sinl().

ഫ്ലോട്ട് സിൻഫ് (ഫ്ലോട്ട് ആർഗ്); നീണ്ട ഇരട്ട sinl (നീണ്ട ഇരട്ട ആർഗ്);

മൂന്ന് ഫംഗ്ഷനുകളും നടത്തുന്ന പ്രവർത്തനങ്ങൾ ഒന്നുതന്നെയാണ്; ഈ പ്രവർത്തനങ്ങൾക്ക് വിധേയമായ ഡാറ്റ മാത്രം വ്യത്യാസപ്പെട്ടിരിക്കുന്നു. ഗണിത പ്രവർത്തനങ്ങളിൽ f-, 1- പരിഷ്കാരങ്ങൾ ചേർക്കുന്നത് നിങ്ങളുടെ ഡാറ്റയ്ക്ക് ഏറ്റവും അനുയോജ്യമായ പതിപ്പ് ഉപയോഗിക്കാൻ നിങ്ങളെ അനുവദിക്കുന്നു.

C99 നിരവധി പുതിയ സവിശേഷതകൾ ചേർത്തതിനാൽ, C89 പിന്തുണയ്ക്കുന്ന സവിശേഷതകൾ പ്രത്യേകം ലിസ്റ്റുചെയ്യുന്നത് മൂല്യവത്താണ് (അവ C++ ലും ഉപയോഗിക്കുന്നു).

ഒരു കാര്യം കൂടി: എല്ലാ കോണുകളും റേഡിയൻസിൽ വ്യക്തമാക്കിയിരിക്കുന്നു.

ഇതും കാണുക

acos - ആർക്ക് കോസൈൻ മൂല്യം നൽകുന്നു
acosh - ഹൈപ്പർബോളിക് ആർക്ക് കോസൈൻ്റെ മൂല്യം നൽകുന്നു
asin - ആർക്സൈൻ മൂല്യം നൽകുന്നു
asinh - ഹൈപ്പർബോളിക് ആർക്സൈൻ മൂല്യം നൽകുന്നു
atan - ആർക്റ്റഞ്ചൻ്റ് മൂല്യം നൽകുന്നു
atan2 - a/b യുടെ ആർക്റ്റാൻജൻ്റ് നൽകുന്നു
atanh - ഹൈപ്പർബോളിക് ആർക്റ്റഞ്ചൻ്റിൻ്റെ മൂല്യം നൽകുന്നു
cbrt - ക്യൂബ് റൂട്ട് മൂല്യം നൽകുന്നു
ceil - തന്നിരിക്കുന്ന ആർഗ്യുമെൻ്റിൻ്റെ മൂല്യത്തേക്കാൾ വലുതായ ഏറ്റവും ചെറിയ പൂർണ്ണസംഖ്യ നൽകുന്നു
കോപ്പിസൈൻ - നൽകിയിരിക്കുന്ന ആർഗ്യുമെൻ്റിന് നിർദ്ദിഷ്‌ട ആർഗ്യുമെൻ്റിനുള്ള അടയാളം നൽകുന്നു
cos - കോസൈൻ മൂല്യം നൽകുന്നു
cosh - ഹൈപ്പർബോളിക് കോസൈൻ്റെ മൂല്യം നൽകുന്നു
erf - പിശക് പ്രവർത്തനത്തിൻ്റെ മൂല്യം നൽകുന്നു
erfc - ഒരു ഓപ്ഷണൽ പിശക് ഫംഗ്ഷൻ മൂല്യം നൽകുന്നു
exp - എക്‌സ്‌പോണൻ്റ് മൂല്യം നൽകുന്നു
exp2 - നൽകിയിരിക്കുന്ന ശക്തിയിലേക്ക് ഉയർത്തിയ സംഖ്യ 2 നൽകുന്നു
expm1 - സ്വാഭാവിക ലോഗരിതത്തിൻ്റെ മൂല്യം നൽകുന്നു e ഒന്ന് കുറച്ചു
ഫാബ്സ് - റിട്ടേൺസ് യഥാർത്ഥ മൂല്യം
fdim - നൽകിയിരിക്കുന്ന രണ്ട് ആർഗ്യുമെൻ്റുകളുടെ പൂജ്യം അല്ലെങ്കിൽ വ്യത്യാസം നൽകുന്നു
തറ - നൽകിയിരിക്കുന്ന ആർഗ്യുമെൻ്റിൻ്റെ മൂല്യത്തേക്കാൾ കുറവോ തുല്യമോ ആയ ഏറ്റവും വലിയ പൂർണ്ണസംഖ്യ നൽകുന്നു
fma - a*b+c നൽകിയ ആർഗ്യുമെൻ്റുകളുടെ മൂല്യം നൽകുന്നു
fmax - രണ്ട് മൂല്യങ്ങളിൽ കൂടുതലുള്ളത് നൽകുന്നു
fmin - രണ്ട് മൂല്യങ്ങളിൽ ചെറുത് നൽകുന്നു
fmod - ഡിവിഷൻ്റെ ബാക്കി ഭാഗം നൽകുന്നു
frexp - ബ്രേക്കുകൾ നൽകിയ നമ്പർമാൻ്റിസ്സയിലേക്കും എക്‌സ്‌പോണൻ്റിലേക്കും
hypot - രണ്ട് കാലുകളുടെ നീളം നൽകിയിരിക്കുന്ന ഹൈപ്പോടെനസിൻ്റെ നീളം നൽകുന്നു
ilogb - എക്‌സ്‌പോണൻഷ്യൽ മൂല്യം വേർതിരിച്ചെടുക്കുന്നു
ldexp - num*2^exp എന്ന പദപ്രയോഗത്തിൻ്റെ മൂല്യം നൽകുന്നു.

+, -, *, ** എന്നീ പ്രവർത്തനങ്ങൾ പൂർണ്ണസംഖ്യകൾക്കായി നിർവ്വചിച്ചിരിക്കുന്നു. പൂർണ്ണസംഖ്യകൾക്കുള്ള വിഭജനം / പ്രവർത്തനം നൽകുന്നു യഥാർത്ഥ സംഖ്യ(അർത്ഥം ഫ്ലോട്ട് തരം). കൂടാതെ, എക്‌സ്‌പോണൻ്റ് ഒരു നെഗറ്റീവ് സംഖ്യയാണെങ്കിൽ എക്‌സ്‌പോണൻഷ്യേഷൻ ഫംഗ്‌ഷൻ ഒരു ഫ്ലോട്ട് മൂല്യം നൽകുന്നു.

എന്നാൽ ഒരു പ്രത്യേക ഓപ്പറേഷനും ഉണ്ട് പൂർണ്ണസംഖ്യ വിഭജനം. ഇത് ഒരു പൂർണ്ണസംഖ്യ നൽകുന്നു: ഘടകത്തിൻ്റെ പൂർണ്ണസംഖ്യ. മറ്റൊരു അനുബന്ധ പ്രവർത്തനമാണ് ഡിവിഷൻ്റെ ശേഷിക്കുന്ന ഭാഗം എടുക്കൽ, % കൊണ്ട് സൂചിപ്പിച്ചിരിക്കുന്നു (ഇത് പാസ്കലിലെ മോഡ് ഓപ്പറേഷനുമായി യോജിക്കുന്നു). ഉദാഹരണത്തിന്:

പ്രിൻ്റ് (17 / 3) # 5.66666666667 പ്രിൻ്റ് (17 // 3) # പ്രിൻ്റ് ചെയ്യും 5 പ്രിൻ്റ് (17 % 3) # 2 പ്രിൻ്റ് ചെയ്യും

ചിലത് ലിസ്റ്റുചെയ്ത പ്രവർത്തനങ്ങൾ(int , round , abs) സ്റ്റാൻഡേർഡ് ആയതിനാൽ ഗണിത മൊഡ്യൂൾ ഉപയോഗിക്കേണ്ടതില്ല.

എല്ലാ ഗണിത പ്രവർത്തനങ്ങൾക്കും ഒരു തലക്കെട്ട് ആവശ്യമാണ് . സി പ്രോഗ്രാമുകൾ ഒരു തലക്കെട്ട് ഉപയോഗിക്കുന്നു

ഇനിപ്പറയുന്ന ഗണിത ഓപ്പറേറ്റർമാരെ C++ ൽ നിർവചിച്ചിരിക്കുന്നു.

കൂട്ടിച്ചേർക്കൽ;

- കുറയ്ക്കൽ;

* ഗുണനം

/ ഡിവിഷൻ

% മൊഡ്യൂളോ ഡിവിഷൻ

– – കുറവ് (1 കുറയുക)

വർദ്ധനവ് (1 വർദ്ധിപ്പിക്കുക).

+, –, * കൂടാതെ / എന്നീ ഓപ്പറേറ്റർമാരുടെ പ്രവർത്തനം ബീജഗണിതത്തിലെ സമാന ഓപ്പറേറ്റർമാരുടെ പ്രവർത്തനവുമായി പൊരുത്തപ്പെടുന്നു. ഏത് ബിൽറ്റ്-ഇൻ സംഖ്യാ ഡാറ്റ തരത്തിലും അവ പ്രയോഗിക്കാൻ കഴിയും.

ഡിവിഷൻ ഓപ്പറേറ്റർ (/) ഒരു പൂർണ്ണസംഖ്യയിൽ പ്രയോഗിച്ചതിന് ശേഷം, ബാക്കിയുള്ളത് ഉപേക്ഷിക്കപ്പെടും. ഉദാഹരണത്തിന്, പൂർണ്ണസംഖ്യാ ഡിവിഷൻ 10/3 ൻ്റെ ഫലം 3 ആണ്. ഡിവിഷൻ്റെ ബാക്കി ഭാഗം മോഡുലോ ഓപ്പറേറ്റർ (%) ഉപയോഗിച്ച് ലഭിക്കും. ഉദാഹരണത്തിന്, 10% 3 എന്നത് 1 ന് തുല്യമാണ്. ഇതിനർത്ഥം C++ ൽ % ഓപ്പറേറ്റർ നോൺ-ഇൻ്റേജർ ഡാറ്റാ തരങ്ങളിൽ ഉപയോഗിക്കാൻ കഴിയില്ല എന്നാണ്.

ഇൻക്രിമെൻ്റ് (++), ഡിക്രിമെൻ്റ് (––) ഓപ്പറേറ്റർമാർക്ക് വളരെ രസകരമായ ഗുണങ്ങളുണ്ട്. അതിനാൽ, അവർക്ക് പ്രത്യേക ശ്രദ്ധ നൽകണം.

ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്റർ അതിൻ്റെ ഓപ്പറണ്ടിലേക്ക് നമ്പർ 1 ചേർക്കുന്നു, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർ അതിൻ്റെ പ്രവർത്തനത്തിൽ നിന്ന് 1 കുറയ്ക്കുന്നു. ഇതിനർത്ഥം നിർദ്ദേശങ്ങൾ:

ഈ നിർദ്ദേശത്തിന് സമാനമാണ്:

ഒപ്പം നിർദ്ദേശങ്ങളും:

ഈ നിർദ്ദേശത്തിന് സമാനമാണ്:

ഇൻക്രിമെൻ്റ്, ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർമാർക്ക് അവരുടെ ഓപ്പറണ്ടിന് മുമ്പോ (പ്രിഫിക്സ് ഫോം) അതിനു ശേഷമോ (പോസ്റ്റ്ഫിക്സ് ഫോം) പ്രത്യക്ഷപ്പെടാം. ഉദാഹരണത്തിന്, നിർദ്ദേശങ്ങൾ

ഒരു ഉപസർഗ്ഗമായി മാറ്റിയെഴുതാം

X;// increment operator-ൻ്റെ prefix form

അല്ലെങ്കിൽ പോസ്റ്റ്ഫിക്സ് ഫോം:

x++;//ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്ററുടെ പോസ്റ്റ്ഫിക്സ് ഫോം

മുമ്പത്തെ ഉദാഹരണത്തിൽ, ഇൻക്രിമെൻ്റ് ഓപ്പറേറ്റർ പ്രീഫിക്സിലോ പോസ്റ്റ്ഫിക്സ് രൂപത്തിലോ ഉപയോഗിച്ചിട്ടുണ്ടോ എന്നത് പ്രശ്നമല്ല. എന്നാൽ ഇൻക്രിമെൻ്റ് അല്ലെങ്കിൽ ഡിക്രിമെൻ്റ് ഓപ്പറേറ്റർ ഒരു വലിയ പദപ്രയോഗത്തിൻ്റെ ഭാഗമായാണ് ഉപയോഗിക്കുന്നതെങ്കിൽ, അത് ഉപയോഗിക്കുന്ന ഫോം വളരെ പ്രധാനമാണ്. അത്തരം ഒരു ഓപ്പറേറ്റർ ഉപയോഗിക്കുകയാണെങ്കിൽ പ്രിഫിക്സ് ഫോം, അപ്പോൾ C++ ഈ പ്രവർത്തനം ആദ്യം നിർവഹിക്കും, അങ്ങനെ operand-ന് ഒരു പുതിയ മൂല്യം ലഭിക്കും, അത് പിന്നീട് ബാക്കിയുള്ള എക്സ്പ്രഷനും ഉപയോഗിക്കും. പോസ്റ്റ്ഫിക്സ് ഫോമിലാണ് ഓപ്പറേറ്റർ ഉപയോഗിക്കുന്നതെങ്കിൽ, C++ അതിൻ്റെ പഴയ മൂല്യം എക്‌സ്‌പ്രഷനിൽ ഉപയോഗിക്കുകയും തുടർന്ന് ഓപ്പറാൻഡിന് പുതിയ മൂല്യം ലഭിക്കുന്നതിന് കാരണമാകുന്ന ഒരു പ്രവർത്തനം നടത്തുകയും ചെയ്യുന്നു.

ഗണിത പ്രവർത്തനങ്ങൾ

ബീജഗണിത പദപ്രയോഗങ്ങൾ കണക്കാക്കുന്നതിന് C++ ഭാഷയ്ക്ക് പ്രത്യേക പ്രവർത്തനങ്ങൾ ഉണ്ട്. അത്തരം എല്ലാ ഫംഗ്ഷനുകളും ഒരു പ്രത്യേക ഹെഡർ ഫയലിൽ അടങ്ങിയിരിക്കുന്നു, math.h. അതിനാൽ, പ്രോഗ്രാം കോഡിലെ ഫംഗ്ഷനുകൾ ഉപയോഗിക്കുന്നതിന്, നിങ്ങൾ ബന്ധിപ്പിക്കണം ഈ ഫയൽനിർദ്ദേശം ഉപയോഗിക്കുന്നു

#ഉൾപ്പെടുന്നു

C++ ൻ്റെ അടിസ്ഥാന ബീജഗണിത പ്രവർത്തനങ്ങൾ ഇതാ.

abs(x) - ഒരു പൂർണ്ണസംഖ്യയുടെ മോഡുലസ്;

labs(x) - ഒരു "നീണ്ട" പൂർണ്ണസംഖ്യയുടെ മൊഡ്യൂൾ;

fabs(x) - ഫ്ലോട്ടിംഗ് പോയിൻ്റ് നമ്പറിൻ്റെ മോഡുലസ്;

sqrt (x) - സ്ക്വയർ റൂട്ട് എക്സ്ട്രാക്ഷൻ;

pow(x,y) - x നെ പവർ y ആയി ഉയർത്തുന്നു;

cos(x) - കോസൈൻ;

sin(x) - സൈൻ;

ടാൻ (x) - ടാൻജെൻ്റ്;

acos (x) - ആർക്ക് കോസൈൻ;

അസിൻ (x) - ആർക്സൈൻ;

അടൻ(x) - ആർക്റ്റഞ്ചൻ്റ്;

exp(x) - x പവറിലേക്കുള്ള ഘാതം;

ലോഗ് (x) - സ്വാഭാവിക ലോഗരിതം;

log10(x) - ദശാംശ ലോഗരിതം

ഒരു സംഖ്യയെ ഫ്രാക്ഷണൽ പവറിലേക്ക് ഉയർത്തുമ്പോൾ, ഭിന്നശക്തിയുടെ ഡിനോമിനേറ്റർ യഥാർത്ഥ രൂപത്തിൽ എഴുതണം. ഉദാഹരണത്തിന്: a യുടെ വർഗ്ഗമൂല്യം ഇങ്ങനെ എഴുതിയിരിക്കുന്നു: pow(a,1// 2.0 )

ഫംഗ്‌ഷനുകളുടെ ഉപയോഗം ഉദാഹരണങ്ങൾക്കൊപ്പം കാണിക്കാം.

5. C++ ലെ I/O ഓപ്പറേറ്റർമാർ

സ്ക്രീനിൽ ഒരു സന്ദേശം പ്രദർശിപ്പിക്കുന്നതിന്, ഇനിപ്പറയുന്ന C++ പ്രസ്താവന ഉപയോഗിക്കുക:

കട്ട്<<”текст”;

#ഉൾപ്പെടുന്നു

ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന വിവരങ്ങൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കേണ്ട സന്ദേശമാണ്. C++ ൽ, ഇരട്ട ഉദ്ധരണികളിൽ ഉൾപ്പെടുത്തിയിരിക്കുന്ന പ്രതീകങ്ങളുടെ ഏത് ശ്രേണിയെയും ഒരു സ്ട്രിംഗ് എന്ന് വിളിക്കുന്നു, കാരണം അതിൽ ഒരു വലിയ ബ്ലോക്ക് (ഘടകം) രൂപപ്പെടുത്തുന്നതിന് നിരവധി പ്രതീകങ്ങൾ ഒരുമിച്ച് ചേർക്കുന്നു.

COUT പ്രസ്താവനയിലെ വരിയിൽ വൈൽഡ്കാർഡ് പ്രതീകങ്ങൾ എന്ന് വിളിക്കപ്പെടുന്നവ അടങ്ങിയിരിക്കാം - കീബോർഡിൽ ഇല്ലാത്ത അല്ലെങ്കിൽ പ്രോഗ്രാം വാചകത്തിലെ പ്രധാന പ്രതീകങ്ങൾക്കായി ഉപയോഗിക്കുന്ന പ്രതീകങ്ങൾ. അത്തരം ഓരോ വൈൽഡ്കാർഡ് പ്രതീകത്തിനും മുമ്പായി ഒരു "\" പ്രതീകമുണ്ട്.

അത്തരം ചിഹ്നങ്ങളുടെ ഒരു ലിസ്റ്റ് ഇതാ:

\a - ശബ്ദ സിഗ്നൽ

\n – പുതിയ വരിയിലേക്ക് പോകുക

\t - തിരശ്ചീന ടാബ്

\v - ലംബ ടാബ്

\\ - ബാക്ക്സ്ലാഷ്

\’ - ഒറ്റ ഉദ്ധരണി

\” – ഇരട്ട ഉദ്ധരണി

\? - ചോദ്യചിഹ്നം.

ഉദാഹരണത്തിന്, ഇതുപോലുള്ള ഒരു ഓപ്പറേറ്റർ:

cout>>“ഉദാഹരണം\nടെക്സ്റ്റ്”;

"ഉദാഹരണം" എന്ന വാക്ക് ഒരു വരിയിലും "ടെക്സ്റ്റ്" എന്ന വാക്ക് മറുവശത്തും ദൃശ്യമാകും.

ഫോമിൻ്റെ ഓപ്പറേറ്റർ:

cout>>“ഷോപ്പ്\””കടൽ\””;

"സീഗൽ" എന്ന വാക്ക് ഇരട്ട ഉദ്ധരണികളിൽ പ്രദർശിപ്പിക്കും.

ടെക്‌സ്‌റ്റിന് പുറമേ, ഓപ്പറേറ്റർക്ക് സ്‌ക്രീനിൽ വേരിയബിളുകളുടെ മൂല്യങ്ങൾ പ്രദർശിപ്പിക്കാൻ കഴിയും, അവ വാചകവുമായി സംയോജിപ്പിക്കുന്നു.

കട്ട്<<”a=”<

ഫോർമാറ്റ് ചെയ്ത ഔട്ട്പുട്ട്

തന്നിരിക്കുന്ന ദൈർഘ്യത്തിൻ്റെയോ കൃത്യതയുടെയോ മൂല്യങ്ങൾ നൽകുന്നതിന്, കൗട്ട് ഓപ്പറേറ്റർക്ക് നിരവധി ക്രമീകരണങ്ങളുണ്ട്:

cout.width(number) - ഔട്ട്പുട്ട് മൂല്യത്തിൻ്റെ ആകെ നീളം

cout.precision(നമ്പർ) - ദശാംശ സ്ഥാനങ്ങളുടെ എണ്ണം

cout.fill ('ഫില്ലർ ചിഹ്നം') - സ്ക്രീനിൽ അധിക സ്ഥാനങ്ങൾ നിറയ്ക്കുന്ന ഒരു ചിഹ്നം

ഒരു ഔട്ട്‌പുട്ട് സ്റ്റേറ്റ്‌മെൻ്റ് എക്‌സിക്യൂട്ട് ചെയ്‌തതിന് ശേഷം cout.width ക്രമീകരണം അതിൻ്റെ പ്രാരംഭ മൂല്യത്തിലേക്ക് പുനഃസജ്ജമാക്കുന്നു. അതിനാൽ, ഓരോ വേരിയബിളിനും അല്ലെങ്കിൽ ലൈനിനും ഇത് പ്രത്യേകം വ്യക്തമാക്കണം.

ഔട്ട്പുട്ട് ഓപ്പറേറ്ററെ വിളിക്കുന്നതിന് മുമ്പ് ഈ പരാമീറ്ററുകൾക്കുള്ള ക്രമീകരണങ്ങൾ ഉണ്ടാക്കിയിരിക്കണം.

ഉദാഹരണത്തിന്:

//വേരിയബിളുകൾ വിവരിക്കുക

ഫ്ലോട്ട് a=125.478, b=625.365;

//കോമ ഫീൽഡിലെ പ്രതീകങ്ങളുടെ എണ്ണം സജ്ജമാക്കുക

cout.Precision(2);

//അധിക സ്ഥാനങ്ങൾക്കായി ഒരു പ്ലെയ്‌സ്‌ഹോൾഡർ സജ്ജമാക്കുക

cout.fill('0');

// വേരിയബിൾ മൂല്യങ്ങൾ സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുക

കട്ട്<<”a=”;

കട്ട്<<” b=”;

//സംഖ്യയുടെ ആകെ നീളം സജ്ജമാക്കുക

ഒരു പട്ടികയിലേക്ക് ഡാറ്റ ഔട്ട്പുട്ട് ചെയ്യുമ്പോൾ ഫീൽഡ് വീതിയും (വീതി) ഫില്ലറും (ഫിൽ) ക്രമീകരിക്കുന്നത് അർത്ഥമാക്കുന്നു. മിക്കപ്പോഴും, നിങ്ങൾക്ക് കൃത്യമായ ക്രമീകരണത്തിലൂടെ മാത്രമേ എത്തിച്ചേരാനാകൂ.

സ്ക്രീൻ വൃത്തിയാക്കുന്നു

ടെക്‌സ്‌റ്റ് വിവരങ്ങളുടെ സ്‌ക്രീൻ മായ്‌ക്കാൻ നിങ്ങളെ അനുവദിക്കുന്ന ഒരു ഫംഗ്‌ഷൻ C++ ഭാഷയ്‌ക്കുണ്ട്. ഈ പ്രവർത്തനം ഇതുപോലെ കാണപ്പെടുന്നു:

ഈ ഫംഗ്‌ഷൻ conio.h ഹെഡർ ഫയലിൽ സ്ഥിതിചെയ്യുന്നു. അതിനാൽ, ഇത് ഉപയോഗിക്കുന്നതിന്, നിർദ്ദേശം ഉപയോഗിച്ച് ഈ ഫയൽ ഉൾപ്പെടുത്തണം:

#ഉൾപ്പെടുന്നു

ഫലം കാണുന്നതിന് ഒരു ഇടവേള സംഘടിപ്പിക്കുന്നു

പ്രോഗ്രാം എക്സിക്യൂട്ട് ചെയ്ത ശേഷം, സോഴ്സ് ടെക്സ്റ്റിനൊപ്പം വിൻഡോയിലേക്ക് സാധാരണയായി ഒരു ഓട്ടോമാറ്റിക് റിട്ടേൺ ഉണ്ട്. സ്ക്രീനിൽ പ്രോഗ്രാം പ്രദർശിപ്പിക്കുന്ന ഫലം കാണാൻ ഇത് നിങ്ങളെ അനുവദിക്കുന്നില്ല. ഈ സാഹചര്യത്തിൽ നിന്ന് ഒരു വഴി Alt + F5 കീകൾ ഉപയോഗിക്കുക എന്നതാണ്, അമർത്തുമ്പോൾ, പ്രോഗ്രാം കോഡുള്ള വിൻഡോ മറഞ്ഞിരിക്കുന്നു. ഈ കീകൾ വീണ്ടും അമർത്തുന്നത് കോഡ് വിൻഡോ സ്ക്രീനിലേക്ക് തിരികെ നൽകുന്നു.

എന്നിരുന്നാലും, നിങ്ങൾ ഒരു എക്സിക്യൂട്ടബിൾ EXE ഫയൽ സൃഷ്ടിക്കുകയാണെങ്കിൽ, ഈ കീകൾ ഉപയോഗിക്കുന്നത് അസാധ്യമായിരിക്കും, ഫലം ഉപയോക്താവിന് അദൃശ്യമായി തുടരും.

ഈ പ്രശ്നം പരിഹരിക്കാൻ, ഏതെങ്കിലും കീ അമർത്തുന്നത് വരെ താൽക്കാലികമായി നിർത്തുന്ന പ്രോഗ്രാമിൻ്റെ അവസാനം നിങ്ങൾക്ക് ഒരു ഫംഗ്ഷൻ ചേർക്കാൻ കഴിയും. ഈ പ്രവർത്തനം ഇതുപോലെ കാണപ്പെടുന്നു:

നേടുക();

ഈ ഫംഗ്‌ഷൻ conio.h ഹെഡർ ഫയലിൽ സ്ഥിതിചെയ്യുന്നു. അതിനാൽ, ഇത് ഉപയോഗിക്കുന്നതിന്, നിർദ്ദേശം ഉപയോഗിച്ച് ഈ ഫയൽ ഉൾപ്പെടുത്തണം:

#ഉൾപ്പെടുന്നു

കീബോർഡ് ഡാറ്റാ എൻട്രി ഓപ്പറേറ്റർ

C++ ൽ കീബോർഡിൽ നിന്ന് ഡാറ്റ ഇൻപുട്ട് ചെയ്യുന്നതിന് ഒരു ഓപ്പറേറ്റർ ഉണ്ട്:

cin >> വേരിയബിൾ;

ഈ പ്രസ്താവന പ്രോഗ്രാം താൽക്കാലികമായി നിർത്തുകയും ഉപയോക്താവ് വേരിയബിളിൻ്റെ മൂല്യം നൽകുകയും ENTER അമർത്തുന്നതുവരെ കാത്തിരിക്കുകയും ചെയ്യുന്നു.

ഒരു ഓപ്പറേറ്റർ ഉപയോഗിച്ച്, നിങ്ങൾക്ക് നിരവധി വേരിയബിളുകളുടെ മൂല്യങ്ങൾ നൽകാം. ഇത് ചെയ്യുന്നതിന്, ഓപ്പറേറ്റർ ഫോമിൽ എഴുതിയിരിക്കുന്നു:

cin>>variable1>>variable2>>. . .>> വേരിയബിൾ;

പ്രോഗ്രാം ആരംഭിക്കുമ്പോൾ, ഓരോ മൂല്യവും ഒരു സ്പെയ്സ് കൊണ്ട് വേർതിരിച്ച് അവസാനം ENTER അമർത്തുക.

COUT പ്രസ്താവന iostream.h ഹെഡർ ഫയലിലാണ്. അതിനാൽ, ഇത് ഉപയോഗിക്കുന്നതിന്, നിർദ്ദേശം ഉപയോഗിച്ച് ഈ ഫയൽ ഉൾപ്പെടുത്തണം:

#ഉൾപ്പെടുന്നു (ആരംഭിക്കുക)

6. സി++ ലെ ഉദാഹരണം പ്രോഗ്രാം

തെളിയിക്കാൻ, നമുക്ക് ഒരു പ്രശ്നം പരിഹരിക്കാം. ഒരു ഫംഗ്‌ഷൻ്റെ മൂല്യം കണ്ടെത്താൻ ഒരു പ്രോഗ്രാം എഴുതുക:

പ്രോഗ്രാം ഇതുപോലെയാകാം:

//I/O ഓർഗനൈസുചെയ്യാൻ ഫയൽ ബന്ധിപ്പിക്കുക

#ഉൾപ്പെടുന്നു

//ബീജഗണിത പ്രവർത്തനങ്ങൾ ഉപയോഗിക്കുന്നതിന് ഫയൽ ഉൾപ്പെടുത്തുക

#ഉൾപ്പെടുന്നു

//സ്ക്രീൻ ക്ലിയറിംഗ് ഫംഗ്ഷനിലേക്ക് വിളിക്കാൻ ഫയൽ ഉൾപ്പെടുത്തുക

#ഉൾപ്പെടുന്നു

//പ്രധാന പ്രോഗ്രാമിൻ്റെ പേര്

//യഥാർത്ഥ തരത്തിൻ്റെ മൂന്ന് വേരിയബിളുകൾ വിവരിക്കുക

//സ്ക്രീൻ മായ്ക്കുക

//സ്‌ക്രീനിൽ ഒരു വാചക സൂചന പ്രദർശിപ്പിക്കുക

കട്ട്<<"Введите значения a и b:";

//രണ്ട് വേരിയബിളുകളുടെ കീബോർഡ് ഇൻപുട്ട് അഭ്യർത്ഥിക്കുക: a, b

//ഫംഗ്ഷൻ്റെ മൂല്യം കണക്കാക്കുക

c=sin(a)+pow(cos(b),2);

//ഫല ഔട്ട്‌പുട്ടിൻ്റെ കൃത്യത 3 ദശാംശ സ്ഥാനങ്ങളിലേക്ക് സജ്ജമാക്കുക

cout.Precision(3);

//ഫലം സ്ക്രീനിൽ പ്രദർശിപ്പിക്കുക

കട്ട്<<"Функция равна:"<

കട്ട്<<"Для продолжения нажмите любую клавишу. . .";

//ഫലം കാണാൻ താൽക്കാലികമായി നിർത്തുക

//പ്രധാന പരിപാടി അവസാനിപ്പിക്കുക

അവസാനം അപ്ഡേറ്റ് ചെയ്തത്: 10/31/2015

.NET ക്ലാസ് ലൈബ്രറിയിൽ വിവിധ ഗണിത പ്രവർത്തനങ്ങൾ നടത്താൻ രൂപകൽപ്പന ചെയ്തിട്ടുള്ളതാണ് ഗണിത ക്ലാസ്. ഇത് നിശ്ചലമാണ്, അതിനാൽ അതിൻ്റെ എല്ലാ രീതികളും നിശ്ചലമാണ്.

ഗണിത ക്ലാസിൻ്റെ രീതികൾ നോക്കാം:

Abs(ഇരട്ട മൂല്യം) : മൂല്യ ആർഗ്യുമെൻ്റിനുള്ള കേവല മൂല്യം നൽകുന്നു

ഇരട്ട ഫലം = Math.Abs(-12.4); // 12.4

Acos(ഇരട്ട മൂല്യം) : മൂല്യത്തിൻ്റെ ആർക്ക് കോസൈൻ നൽകുന്നു. മൂല്യ പാരാമീറ്ററിന് -1 നും 1 നും ഇടയിലുള്ള ഒരു മൂല്യം ഉണ്ടായിരിക്കണം

ഇരട്ട ഫലം = Math.Acos(1); // 0

അസിൻ(ഇരട്ട മൂല്യം) : മൂല്യത്തിൻ്റെ ആർക്ക് സൈൻ നൽകുന്നു. മൂല്യ പാരാമീറ്ററിന് -1 നും 1 നും ഇടയിലുള്ള ഒരു മൂല്യം ഉണ്ടായിരിക്കണം

ആറ്റൻ(ഇരട്ട മൂല്യം) : മൂല്യത്തിൻ്റെ ആർക്റ്റഞ്ചൻ്റ് നൽകുന്നു

BigMul(int x, int y) : ഉൽപ്പന്നം x * y ഒരു നീണ്ട വസ്തുവായി നൽകുന്നു

ഇരട്ട ഫലം = Math.BigMul(100, 9340); // 934000

സീലിംഗ് (ഇരട്ട മൂല്യം) : മൂല്യത്തിൽ കുറയാത്ത ഏറ്റവും ചെറിയ ഫ്ലോട്ടിംഗ് പോയിൻ്റ് പൂർണ്ണസംഖ്യ നൽകുന്നു

ഇരട്ട ഫലം = Math.Ceiling(2.34); // 3

കോസ്(ഇരട്ട ഡി) : ആംഗിൾ ഡിയുടെ കോസൈൻ നൽകുന്നു

കോഷ്(ഡബിൾ ഡി) : ആംഗിൾ ഡിയുടെ ഹൈപ്പർബോളിക് കോസൈൻ നൽകുന്നു

DivRem(int a, int b, out int result) : ഡിവിഷൻ a/b ൻ്റെ ഫലം നൽകുന്നു, ബാക്കിയുള്ളത് ഫല പരാമീറ്ററിൽ സ്ഥാപിക്കുന്നു

ഇൻ്റർ ഫലം; int div = Math.DivRem(14, 5, out result); //ഫലം = 4 // div = 2

Exp(ഇരട്ട d) : പവർ d ലേക്ക് ഉയർത്തിയ സ്വാഭാവിക ലോഗരിതം അടിസ്ഥാനം നൽകുന്നു

ഫ്ലോർ(ദശാംശം d) : d-നേക്കാൾ വലുതല്ലാത്ത ഏറ്റവും വലിയ പൂർണ്ണസംഖ്യ നൽകുന്നു

ഇരട്ട ഫലം = Math.Floor(2.56); // 2

IEEERമൈൻഡർ(ഇരട്ട a, ഇരട്ട ബി) : a യുടെ ബാക്കി ഭാഗം b കൊണ്ട് ഹരിക്കുന്നു

ഇരട്ട ഫലം = Math.IEEERമൈൻഡർ(26, 4); // 2 = 26-24

ലോഗ്(ഇരട്ട d) : d യുടെ സ്വാഭാവിക ലോഗരിതം നൽകുന്നു

ലോഗ് (ഇരട്ട a, ഇരട്ട ന്യൂബേസ്) : newBase അടിസ്ഥാനമാക്കി ഒരു സംഖ്യയുടെ ലോഗരിതം നൽകുന്നു

Log10(ഇരട്ട d) : d യുടെ ദശാംശ ലോഗരിതം നൽകുന്നു

പരമാവധി(ഇരട്ട a, ഇരട്ട ബി) : a യ്ക്കും bയ്ക്കും ഇടയിലുള്ള പരമാവധി സംഖ്യ നൽകുന്നു

മിനി(ഡബിൾ എ, ഡബിൾ ബി) : എയ്ക്കും ബിക്കും ഇടയിലുള്ള ഏറ്റവും കുറഞ്ഞ സംഖ്യ നൽകുന്നു

Pow(ഇരട്ട a, ഇരട്ട b) : a എന്ന സംഖ്യ b യുടെ ശക്തിയിലേക്ക് ഉയർത്തുന്നു

വൃത്തം(ഇരട്ട d) : ഏറ്റവും അടുത്തുള്ള പൂർണ്ണസംഖ്യയിലേക്ക് d വൃത്താകാരം നൽകുന്നു

ഇരട്ട ഫലം1 = Math.Round(20.56); // 21 ഇരട്ട ഫലം2 = Math.Round(20.46); //20

റൗണ്ട്(ഇരട്ട a, റൗണ്ട് b) : b കൊണ്ട് പ്രതിനിധീകരിക്കുന്ന ദശാംശ സ്ഥാനങ്ങളുടെ നിർദ്ദിഷ്‌ട എണ്ണത്തിലേക്ക് a വൃത്താകൃതിയിലുള്ള സംഖ്യ നൽകുന്നു

ഇരട്ട ഫലം1 = Math.Round(20.567, 2); // 20.57 ഇരട്ട ഫലം2 = Math.Round(20.463, 1); //20.5

അടയാളം (ഇരട്ട മൂല്യം) : മൂല്യം പോസിറ്റീവ് ആണെങ്കിൽ 1, മൂല്യം നെഗറ്റീവ് ആണെങ്കിൽ -1 എന്നിവ നൽകുന്നു. മൂല്യം 0 ആണെങ്കിൽ, 0 നൽകുന്നു

Int result1 = Math.Sign(15); // 1 int result2 = Math.Sign(-5); //-1

Sin(ഇരട്ട മൂല്യം) : ആംഗിൾ മൂല്യത്തിൻ്റെ സൈൻ നൽകുന്നു

Sinh(ഇരട്ട മൂല്യം) : ആംഗിൾ മൂല്യത്തിൻ്റെ ഹൈപ്പർബോളിക് സൈൻ നൽകുന്നു

Sqrt(ഇരട്ട മൂല്യം) : മൂല്യത്തിൻ്റെ വർഗ്ഗമൂല്യം നൽകുന്നു

ഇരട്ട ഫലം1 = Math.Sqrt(16); // 4

ടാൻ(ഇരട്ട മൂല്യം) : ആംഗിൾ മൂല്യത്തിൻ്റെ ടാൻജെൻ്റ് നൽകുന്നു

Tanh(ഇരട്ട മൂല്യം) : ആംഗിൾ മൂല്യത്തിൻ്റെ ഹൈപ്പർബോളിക് ടാൻജെൻ്റ് നൽകുന്നു

വെട്ടിച്ചുരുക്കുക(ഇരട്ട മൂല്യം) : മൂല്യത്തിൻ്റെ ഫ്രാക്ഷണൽ ഭാഗം ഉപേക്ഷിക്കുന്നു, പൂർണ്ണസംഖ്യ മൂല്യം മാത്രം നൽകുന്നു

ഇരട്ട ഫലം = Math.Truncate(16.89); // 16

ഗണിത ക്ലാസ് രണ്ട് സ്ഥിരാങ്കങ്ങളെ നിർവചിക്കുന്നു: Math.E, Math.PI. ഉദാഹരണത്തിന്, നമുക്ക് ഒരു സർക്കിളിൻ്റെ വിസ്തീർണ്ണം കണക്കാക്കാം:

Console.WriteLine("സർക്കിളിൻ്റെ ആരം നൽകുക"); ഇരട്ട ആരം = Double.Parse(Console.ReadLine()); ഇരട്ട ഏരിയ = Math.PI * Math.Pow(റേഡിയസ്, 2); Console.WriteLine("ആരം (0) ഉള്ള ഒരു വൃത്തത്തിൻ്റെ വിസ്തീർണ്ണം (1)", ആരം, ഏരിയ);

കൺസോൾ ഔട്ട്പുട്ട്:

സർക്കിൾ ആരം 20 നൽകുക