Mga pag-andar ng matematika ng wikang C

Ang mga wikang C at C++ ay tumutukoy sa maraming pagkakaiba mga function ng matematika. Sa una, sinusuportahan ng parehong wika ang parehong hanay ng 22 mathematical function. Gayunpaman, habang nabuo ang wikang C++, lumawak ang arsenal ng mga function na tinukoy dito. Tapos sa C99 version ang laki aklatan ng matematika tumaas nang malaki. Bilang resulta ng mga pagbabagong ito, ang mga aklatan ng mga pag-andar ng matematika ng mga wikang C at C++ ay nagsimulang magkaiba nang malaki sa isa't isa. Samakatuwid, inilalarawan ng kabanatang ito ang matematikal na pag-andar ng wikang C (kabilang ang mga idinagdag sa bersyon C99), at ang Kabanata 9 ay eksklusibong nakatuon sa mga paggana ng wikang C++. Gayunpaman, tandaan na ang orihinal na hanay ng mga function ng matematika ay sinusuportahan pa rin ng lahat ng bersyon ng C at C++.

Para magamit ang lahat ng mathematical function, dapat isama ng program ang header . Bilang karagdagan sa pagdedeklara ng mga mathematical function, tinutukoy ng header na ito ang isa o higit pang mga macro. Sa bersyon C89 ang header Ang HUGE_VAL macro lamang ang tinukoy, na isang dobleng halaga na nagpapahiwatig ng pag-apaw.

Ang mga sumusunod na macro ay tinukoy sa bersyon C99.

Tinutukoy ng bersyon ng C99 ang mga sumusunod na macro (tulad ng function) na nag-uuri ng isang halaga.

Sa bersyon C99, ang mga sumusunod na macro sa paghahambing ay tinukoy, ang mga argumento kung saan (a at b) ay dapat na mga floating point value.

Ang mga macro na ito ay pinangangasiwaan ang mga halaga na hindi mga numero nang maayos nang hindi nagtatapon ng mga tunay na uri ng pagbubukod.

Ang EDOM at ERANGE macros ay ginagamit din ng mga math function. Ang mga macro na ito ay tinukoy sa header .

Ang mga error sa mga bersyon C89 at C99 ay pinangangasiwaan nang iba. Kaya, sa C89, kung ang argumento ng math function ay hindi nasa loob ng domain kung saan ito tinukoy, ibinabalik ang ilang value na partikular sa pagpapatupad at ang built-in na global integer variable na errno ay nakatakda sa halaga ng EDOM. Sa C99, ang isang error sa paglabag sa domain ay nagreresulta din sa isang value na partikular sa pagpapatupad na ibinalik. Gayunpaman, ang halaga ng math_errhandling ay maaaring magpahiwatig kung ang ibang mga aksyon ay ginagawa. Kung ang math_errhandling ay naglalaman ng value na MATH_ERRNO, ang built-in na global integer variable na errno ay itatakda sa halaga ng EDOM. Kung ang math_errhandling ay naglalaman ng value na MATH_ERREXCEPT, isang tunay na exception ang ihahagis.

Sa C89, kung ang isang function ay bumubuo ng isang resulta na masyadong malaki para sa representasyon na pangasiwaan, isang overflow ang magaganap. Sa kasong ito, ang function ay nagbabalik ng HUGE_VAL at ang errno ay nakatakda sa ERANGE na halaga na nagpapahiwatig ng isang error sa saklaw. Kapag may nakitang underflow, ang function ay nagbabalik ng zero at itinatakda ang errno sa ERANGE. Sa C99, ang isang overflow na error ay nagiging sanhi din ng pag-andar na magbalik ng isang halaga. HUGE_VAL, at kung mawawalan ito ng kabuluhan - zero. Kung ang math_errhandling ay naglalaman ng value na MATH_ERRNO, ang global variable na errno ay itatakda sa value na ERANGE na nagsasaad ng error sa range. Kung ang math_errhandling ay naglalaman ng value na MATH_ERREXCEPT, isang tunay na exception ang ihahagis.

Sa bersyon C89, ang mga argumento sa mathematical function ay dapat na doble ang uri at ang mga halaga na ibinalik ng mga function ay may uri ng doble. Sa bersyon C99, idinagdag ang float at long double variant ng mga function na ito, na gumagamit ng mga suffix na f at l, ayon sa pagkakabanggit. Halimbawa, sa bersyon C89, ang sin() function ay tinukoy bilang mga sumusunod.

Dobleng kasalanan(double arg);

Sa bersyon C99, ang kahulugan sa itaas ng sin() function ay sinusuportahan at dalawa pang pagbabago ang idinagdag - sinf() at sinl().

Float sinf(float arg); mahabang double sinl(mahabang double arg);

Ang mga operasyon na ginagawa ng lahat ng tatlong mga function ay pareho; tanging ang data na sumailalim sa mga operasyong ito ang naiiba. Ang pagdaragdag ng f- at 1-modifications sa mga mathematical function ay nagbibigay-daan sa iyong gamitin ang bersyon na pinakaangkop sa iyong data.

Dahil nagdagdag ang C99 ng napakaraming bagong feature, sulit na ilista nang hiwalay ang mga feature na sinusuportahan ng C89 (ginagamit din ang mga ito sa C++).

At isa pang bagay: ang lahat ng mga anggulo ay tinukoy sa mga radian.

Tingnan din

acos - Ibinabalik ang halaga ng arc cosine
acosh - Ibinabalik ang halaga ng hyperbolic arc cosine
asin - Ibinabalik ang halaga ng arcsine
asinh - Ibinabalik ang hyperbolic arcsine value
atan - Ibinabalik ang halaga ng arctangent
atan2 - Ibinabalik ang arctangent ng a/b
atanh - Ibinabalik ang halaga ng hyperbolic arctangent
cbrt - Ibinabalik ang cube root value
ceil - Ibinabalik ang pinakamaliit na integer na mas malaki kaysa sa halaga ng ibinigay na argumento
copysign - Binibigyan ang ibinigay na argumento ng tanda na mayroon ang tinukoy na argumento
cos - Ibinabalik ang halaga ng cosine
cosh - Ibinabalik ang halaga ng hyperbolic cosine
erf - Ibinabalik ang halaga ng function ng error
erfc - Nagbabalik ng opsyonal na halaga ng function ng error
exp - Ibinabalik ang exponent value
exp2 - Ibinabalik ang numero 2 na itinaas sa ibinigay na kapangyarihan
expm1 - Ibinabalik ang halaga ng natural na logarithm e binawasan ng isa
fabs - Nagbabalik ganap na halaga
fdim - Nagbabalik ng zero o ang pagkakaiba ng dalawang ibinigay na argumento
floor - Ibinabalik ang pinakamalaking integer na mas mababa sa o katumbas ng halaga ng ibinigay na argumento
fma - Ibinabalik ang halaga ng a*b+c na ibinigay na mga argumento
fmax - Ibinabalik ang mas malaki sa dalawang value
fmin - Ibinabalik ang mas maliit sa dalawang value
fmod - Ibinabalik ang natitirang bahagi ng dibisyon
frexp - Mga break binigay na numero sa mantissa at exponent
hypot - Ibinabalik ang haba ng hypotenuse na ibinigay sa haba ng dalawang binti
ilogb - Kinukuha ang exponential value
ldexp - Ibinabalik ang halaga ng expression na num*2^exp.

Ang mga operasyon +, -, * at ** ay tinukoy para sa mga integer. Ang dibisyon / operasyon para sa mga integer ay bumabalik tunay na numero(ibig sabihin uri ng float). Gayundin, ang exponentiation function ay nagbabalik ng float value kung ang exponent ay negatibong numero.

Ngunit mayroon ding isang espesyal na operasyon integer division, na ginagawa sa pamamagitan ng pagtatapon ng fractional na bahagi, na tinutukoy ng // (ito ay tumutugma sa div operation sa Pascal). Nagbabalik ito ng integer: ang integer na bahagi ng quotient. Ang isa pang kaugnay na operasyon ay ang operasyon ng pagkuha ng natitirang bahagi, na tinutukoy ng % (ito ay tumutugma sa mod operation sa Pascal). Halimbawa:

Print(17 / 3) # ay magpi-print ng 5.66666666667 print(17 // 3) # will print 5 print(17 % 3) # will print 2

Ang ilan sa nakalistang mga function(int , round , abs) ay karaniwan at hindi nangangailangan ng math module na gagamitin.

Ang lahat ng mga function sa matematika ay nangangailangan ng isang header . Ang mga C program ay gumagamit ng isang header

Ang mga sumusunod na operator ng arithmetic ay tinukoy sa C++.

Pagdaragdag;

– pagbabawas;

* pagpaparami

/ dibisyon

% modulo division

– – pagbaba (bawasan ng 1)

Pagtaas (pagtaas ng 1).

Ang aksyon ng mga operator +, –, * at / ay kasabay ng pagkilos ng mga katulad na operator sa algebra. Maaaring ilapat ang mga ito sa anumang built-in na numeric na uri ng data.

Pagkatapos ilapat ang division operator (/) sa isang integer, ang natitira ay itatapon. Halimbawa, ang resulta ng integer division 10/3 ay 3. Ang natitira sa dibisyon ay maaaring makuha gamit ang modulo operator (%). Halimbawa, ang 10%3 ay katumbas ng 1. Nangangahulugan ito na sa C++ ang % operator ay hindi magagamit sa mga non-integer na uri ng data.

Ang increment (++) at decrement (– –) operator ay may napakakagiliw-giliw na katangian. Samakatuwid, dapat silang bigyan ng espesyal na pansin.

Ang increment operator ay nagdaragdag ng numero 1 sa operand nito, at ang decrement operator ay nagbabawas ng 1 mula sa operand nito. Nangangahulugan ito na ang mga tagubilin:

katulad ng tagubiling ito:

At ang mga tagubilin:

katulad ng tagubiling ito:

Ang increment at decrement operator ay maaaring lumitaw alinman sa harap ng kanilang operand (prefix form) o pagkatapos nito (postfix form). Halimbawa, mga tagubilin

maaaring muling isulat bilang unlapi

X;//prefix form ng increment operator

o postfix form:

x++;//postfix form ng increment operator

Sa nakaraang halimbawa, hindi mahalaga kung ginamit ang increment operator sa anyong prefix o postfix. Ngunit kung ang increment o decrement operator ay ginagamit bilang bahagi ng isang mas malaking expression, kung gayon ang form kung saan ito ginagamit ay napakahalaga. Kung ang naturang operator ay ginagamit sa anyo ng prefix, pagkatapos ay gagawin muna ng C++ ang operasyong ito upang ang operand ay makakuha ng bagong halaga, na pagkatapos ay gagamitin ng natitirang bahagi ng expression. Kung ang operator ay ginagamit sa postfix form, ginagamit ng C++ ang lumang value nito sa expression at pagkatapos ay nagsasagawa ng operasyon na nagiging sanhi ng operand na kumuha ng bagong value.

Mga function ng matematika

Ang wikang C++ ay may mga espesyal na function para sa pagkalkula ng mga algebraic na expression. Ang lahat ng naturang function ay nakapaloob sa isang hiwalay na header file, math.h. Samakatuwid, upang magamit ang mga function sa code ng programa, dapat kang kumonekta ang file na ito gamit ang direktiba

#isama

Narito ang mga pangunahing algebraic function ng C++.

abs(x) - modulus ng isang integer;

labs(x) - module ng isang "mahabang" integer;

fabs(x) - modulus ng isang floating point number;

sqrt(x) - square root extraction;

pow(x,y) - pagtataas ng x sa kapangyarihan y;

cos(x) - cosine;

kasalanan(x) - sine;

tan(x) - padaplis;

acos(x) - arc cosine;

asin(x) - arcsine;

atan(x) - arctangent;

exp(x) - exponent sa x power;

log(x) - natural logarithm;

log10(x) - decimal logarithm

Kapag tinataas ang isang numero sa isang fractional na kapangyarihan, ang denominator ng fractional na kapangyarihan ay dapat na nakasulat sa tunay na anyo. Halimbawa: ang square root ng a ay nakasulat na ganito: pow(a,1/ 2.0 )

Ipakita natin ang paggamit ng mga function na may mga halimbawa.

5. I/O operator sa C++

Upang magpakita ng mensahe sa screen, gamitin ang sumusunod na pahayag ng C++:

cout<<”текст”;

#isama

Ang impormasyong nakapaloob sa dobleng panipi ay ang mensaheng dapat ipakita. Sa C++, ang anumang pagkakasunud-sunod ng mga character na nakapaloob sa double quote ay tinatawag na isang string dahil binubuo ito ng ilang mga character na pinagsama-sama upang bumuo ng isang mas malaking bloke (elemento).

Ang linya sa pahayag ng COUT ay maaaring maglaman ng tinatawag na mga wildcard na character - mga character na wala sa keyboard o ginagamit para sa mga pangunahing character sa teksto ng programa. Ang bawat wildcard na character ay pinangungunahan ng isang "\" character.

Narito ang isang listahan ng mga naturang simbolo:

\a – signal ng tunog

\n – pumunta sa bagong linya

\t – pahalang na tab

\v – patayong tab

\\ - backslash

\’ – nag-iisang quote

\” – dobleng panipi

\? – tandang pananong.

Halimbawa, isang operator tulad ng:

cout>>“halimbawa\nteksto”;

Ang salitang "halimbawa" ay lalabas sa isang linya, at ang salitang "teksto" sa kabilang linya.

Operator ng form:

cout>>“shop\””seagull\””;

Ang salitang "Seagull" ay ipapakita sa double quotes.

Bilang karagdagan sa teksto, maaaring ipakita ng operator ang mga halaga ng mga variable sa screen, pagsamahin ang mga ito sa teksto.

cout<<”a=”<

Naka-format na output

Upang ibalik ang mga halaga ng isang ibinigay na haba o katumpakan, ang cout operator ay may ilang mga setting:

cout.width(number) – kabuuang haba ng output value

cout.precision(number) – bilang ng mga decimal na lugar

cout.fill(‘filler symbol’) – isang simbolo na pumupuno sa mga karagdagang posisyon sa screen

Ang setting ng cout.width ay ni-reset sa paunang halaga nito pagkatapos magsagawa ng isang output statement. Samakatuwid, dapat itong tukuyin nang hiwalay para sa bawat variable o linya.

Ang mga setting para sa mga parameter na ito ay dapat gawin bago tumawag sa output operator.

Halimbawa:

//ilarawan ang mga variable

float a=125.478, b=625.365;

//itakda ang bilang ng mga character sa comma field

cout.precision(2);

//magtakda ng placeholder para sa mga karagdagang posisyon

cout.fill('0');

//magpakita ng mga variable na halaga sa screen

cout<<”a=”;

cout<<” b=”;

//itakda ang kabuuang haba para sa numero

Ang pagsasaayos ng lapad ng field (lapad) at tagapuno (punan) ay may katuturan kapag naglalabas ng data sa isang talahanayan. Kadalasan, makakalampas ka lang gamit ang precision setting.

Nililinis ang screen

Ang wikang C++ ay may function na nagbibigay-daan sa iyong i-clear ang screen ng impormasyon ng teksto. Ang function na ito ay mukhang:

Ang function na ito ay matatagpuan sa conio.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama

Pag-aayos ng isang pause upang tingnan ang resulta

Pagkatapos isagawa ang programa, kadalasan ay may awtomatikong pagbabalik sa window na may pinagmulang teksto. Hindi ito nagpapahintulot sa iyo na tingnan ang resulta na ipinapakita ng programa sa screen. Ang isang paraan sa labas ng sitwasyong ito ay maaaring gamitin ang Alt+F5 key, kapag pinindot, nakatago ang window na may program code. Kapag pinindot muli ang mga key na ito, ibabalik ang window ng code sa screen.

Gayunpaman, kung lumikha ka ng executable EXE file, imposibleng gamitin ang mga key na ito at ang resulta ay mananatiling hindi nakikita ng user.

Upang malutas ang problemang ito, maaari kang magdagdag ng isang function sa dulo ng program na humihinto hanggang sa pindutin ang anumang key. Ang function na ito ay mukhang:

getch();

Ang function na ito ay matatagpuan sa conio.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama

Operator sa pagpasok ng data ng keyboard

Upang mag-input ng data mula sa keyboard sa C++ mayroong isang operator:

cin >> variable;

Ang pahayag na ito ay naka-pause sa programa at naghihintay hanggang sa ipasok ng user ang halaga ng variable at pinindot ang ENTER.

Gamit ang isang operator, maaari mong ipasok ang mga halaga ng ilang mga variable. Upang gawin ito, ang operator ay nakasulat sa form:

cin>>variable1>>variable2>>. . .>>variablen;

Kapag sinimulan ang programa, ipasok ang bawat halaga na pinaghihiwalay ng isang puwang at pindutin ang ENTER sa dulo.

Ang pahayag ng COUT ay nasa iostream.h header file. Samakatuwid, upang magamit ito, dapat isama ang file na ito gamit ang direktiba:

#isama (simula)

6. Halimbawa ng programa sa C++

Upang ipakita, lutasin natin ang isang problema. Sumulat ng isang programa upang mahanap ang halaga ng isang function:

Ang programa ay maaaring magmukhang:

//ikonekta ang file upang ayusin ang I/O

#isama

//isama ang file upang gumamit ng mga algebraic function

#isama

//isama ang file para tawagan ang screen clearing function

#isama

//pamagat ng pangunahing programa

//ilarawan ang tatlong variable ng totoong uri

// i-clear ang screen

//magpakita ng text hint sa screen

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

//humiling ng keyboard input ng dalawang variable: a at b

//kalkulahin ang halaga ng function

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

//itakda ang katumpakan ng output ng resulta sa 3 decimal na lugar

cout.precision(3);

//ipakita ang resulta sa screen

cout<<"Функция равна:"<

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

//pause para tingnan ang resulta

//tapusin ang pangunahing programa

Huling na-update: 10/31/2015

Ang Math class ay ginagamit upang magsagawa ng iba't ibang mathematical operations sa .NET class library. Ito ay static, kaya lahat ng mga pamamaraan nito ay static din.

Tingnan natin ang mga pamamaraan ng klase sa Math:

Abs(double value) : Ibinabalik ang absolute value para sa value argument

Dobleng resulta = Math.Abs(-12.4); // 12.4

Acos(double value): Ibinabalik ang arc cosine ng value. Ang value parameter ay dapat may value sa pagitan ng -1 at 1

Dobleng resulta = Math.Acos(1); // 0

Asin(double value): Ibinabalik ang arc sine ng halaga. Ang value parameter ay dapat may value sa pagitan ng -1 at 1

Atan(double value): ibinabalik ang arctangent ng halaga

BigMul(int x, int y) : ibinabalik ang produkto x * y bilang isang mahabang bagay

Dobleng resulta = Math.BigMul(100, 9340); // 934000

Ceiling(double value): ibinabalik ang pinakamaliit na floating point integer na hindi bababa sa value

Dobleng resulta = Math.Ceiling(2.34); // 3

Cos(double d): ibinabalik ang cosine ng anggulo d

Cosh(double d): ibinabalik ang hyperbolic cosine ng anggulo d

DivRem(int a, int b, out int result): ibinabalik ang resulta ng division a/b, at ang natitira ay inilalagay sa parameter ng resulta

Int resulta; int div = Math.DivRem(14, 5, out result); //resulta = 4 // div = 2

Exp(double d) : Ibinabalik ang base ng natural na logarithm na nakataas sa kapangyarihan d

Floor(decimal d): ibinabalik ang pinakamalaking integer na hindi hihigit sa d

Dobleng resulta = Math.Floor(2.56); // 2

IEEERemainder(double a, double b): ibinabalik ang natitira sa isang hinati ng b

Dobleng resulta = Math.IEEERemainder(26, 4); // 2 = 26-24

Log(double d) : ibinabalik ang natural na logarithm ng d

Log(double a, double newBase): ibinabalik ang logarithm ng isang numero batay sa newBase

Log10(double d) : Ibinabalik ang decimal logarithm ng d

Max(double a, double b): ibinabalik ang maximum na numero sa pagitan ng a at b

Min(double a, double b): ibinabalik ang pinakamababang numero sa pagitan ng a at b

Pow(double a, double b): ibinabalik ang numero a na nakataas sa kapangyarihan ng b

Round(double d): Ibinabalik ang d rounded sa pinakamalapit na integer

Dobleng resulta1 = Math.Round(20.56); // 21 double result2 = Math.Round(20.46); //20

Round(double a, round b): Ibinabalik ang numerong a na binilog sa tinukoy na bilang ng mga decimal na lugar na kinakatawan ng b

Dobleng resulta1 = Math.Round(20.567, 2); // 20.57 double result2 = Math.Round(20.463, 1); //20.5

Sign(double value): Nagbabalik ng 1 kung positibo ang value, at -1 kung negatibo ang value. Kung ang halaga ay 0, ibabalik ang 0

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

Sin(double value): ibinabalik ang sine ng angle value

Sinh(double value): ibinabalik ang hyperbolic sine ng angle value

Sqrt(double value): ibinabalik ang square root ng value

Dobleng resulta1 = Math.Sqrt(16); // 4

Tan(double value): ibinabalik ang tangent ng angle value

Tanh(double value): ibinabalik ang hyperbolic tangent ng angle value

Truncate(double value): itinatapon ang fractional na bahagi ng value, ibinabalik lamang ang integer value

Dobleng resulta = Math.Truncate(16.89); // 16

Tinutukoy din ng klase ng Math ang dalawang constant: Math.E at Math.PI. Halimbawa, kalkulahin natin ang lugar ng isang bilog:

Console.WriteLine("Ipasok ang radius ng bilog"); double radius = Double.Parse(Console.ReadLine()); double area = Math.PI * Math.Pow(radius, 2); Console.WriteLine("Ang lugar ng isang bilog na may radius (0) ay (1)", radius, area);

Output ng console:

Ipasok ang radius ng bilog 20 Ang lugar ng isang bilog na may radius 20 ay 1256.63706143592