Matematika#

Įvadas #

„Math“ apima ir integruotas „Python“ funkcijas, ir pilną math modulį, kuris automatiškai pasiekiamas „VEXcode AIR“. Šie įrankiai leidžia atlikti viską – nuo pagrindinių aritmetikos veiksmų iki sudėtingesnių trigonometrijos, apvalinimo ir logaritminių operacijų.

Naudokite šias funkcijas ir konstantas, kad apskaičiuotumėte VEX AIR drono valdiklio padėtis, kampus, atstumus ir kitas skaitines vertes. Taip pat galite konvertuoti laipsnius į radianus ir atvirkščiai, įvertinti išraiškas ir dirbti su specialiomis reikšmėmis, tokiomis kaip begalybė ir NaN.

Pastaba: Išskyrus atvejus, kai aiškiai nurodyta kitaip, visos grąžinamos reikšmės yra slankiojo kablelio formos, suformatuotos tiksliai iki penkių skaitmenų po kablelio. Reikšmės, kuriose yra daugiau nei penki skaitmenys po kablelio, yra suapvalinamos, o reikšmės, kuriose yra mažiau nei penki skaitmenys po kablelio, yra papildomos nuliais, kad visada būtų rodomos tiksliai penki skaitmenys po kablelio.

Žemiau pateikiamas galimų matematinių funkcijų, konstantų ir įrankių sąrašas:

Integruotos funkcijos – įprasti matematikos įrankiai, įtraukti į „Python“.

abs – Grąžina absoliučiąją skaičiaus reikšmę.
round – Suapvalina skaičių iki nurodyto skaičiaus po kablelio.
min – Grąžina mažiausią iš įvesties reikšmių.
max – Grąžina didžiausią iš įvesties reikšmių.
sum – Susumuoja visas iteruojamo elemento reikšmes.
divmod – Grąžina dalmenį ir liekaną kaip rinkinį.
pow – Kelia skaičių laipsniu, pasirinktinai su moduliu.
int – Konvertuoja reikšmę į sveikąjį skaičių.
float – Konvertuoja reikšmę į slankiojo kablelio skaičių.

Konstantos – iš anksto apibrėžtos reikšmės iš math modulio.

math.pi – Konstanta π (pi).
math.tau – Konstanta tau (2π).
math.e – Eulerio skaičius, natūralaus logaritmo pagrindas.
math.inf – Teigiama begalybė.
math.nan – ne skaičius (NaN).

Trigonometrija – apskaičiuokite kampus ir ryšius tarp kraštinių.

math.sin – Kampo sinusas radianais.
math.cos – Kampo kosinusas radianais.
math.tan – Kampo tangentas radianais.
math.asin – Radianais išreikštos reikšmės arcsinusas.
math.acos – Radianais nurodytos reikšmės arkkosinusas.
math.atan – Radianais išreikštos reikšmės arktangentas.
math.atan2 – y/x arktangentas radianais, atsižvelgiant į kvadrantą.
math.degrees – Konvertuoja radianus į laipsnius.
math.radians – Konvertuoja laipsnius į radianus.

Hiperbolika – išplėstinės trigonometrinės funkcijos.

math.sinh – Hiperbolinis reikšmės sinusas.
math.cosh – Hiperbolinis reikšmės kosinusas.
math.tanh – Hiperbolinis reikšmės tangentas.
math.asinh – Atvirkštinis hiperbolinis sinusas.
math.acosh – Atvirkštinis hiperbolinis kosinusas.
math.atanh – Atvirkštinis hiperbolinis tangentas.

Apvalinimas ir absoliuti vertė – koreguokite tikslumą arba kryptį.

math.ceil – Apvalina iki artimiausio sveikojo skaičiaus.
math.floor – Apvalina iki artimiausio sveikojo skaičiaus.
math.trunc – Pašalina dešimtainę dalį.
math.fabs – Grąžina absoliučią reikšmę kaip slankiojo skaičiaus vienetą.

Laimės rodikliai ir logaritmai – laipsnių kėlimas, šaknies ištraukimas ir logaritmų skaičiavimas.

math.pow – Kelia skaičių laipsniu.
math.sqrt – Grąžina kvadratinę šaknį.
math.exp – Apskaičiuoja e, pakeltą x laipsniu.
math.log – Natūralusis logaritmas (bazinis e).
math.log10 – Dešimtainis logaritmas.
math.log2 – 2 bazės logaritmas.
math.factorial – Sveikojo skaičiaus faktorialas.
math.expm1 – Tikslesnis e^x - 1 rezultatas.

Slankiojo kablelio operacijos – tikrinkite arba skaidykite slankiojo kablelio reikšmes.

math.modf – Grąžina slankiojo skaičiaus trupmeninę ir sveikąją dalis.
math.frexp – Suskaido skaičių į mantisą ir laipsnio rodiklį.
math.fmod – Liekamoji dalis su dalinio ženklu.
math.copysign – Grąžina reikšmę su kito ženklo simboliu.
math.ldexp – Apskaičiuoja x * (2 ** exp).

Palyginimas ir aproksimacija – patikrinkite vertes su tolerancijomis arba kategorijomis.

math.isfinite – Patikrina, ar skaičius yra baigtinis.
math.isinf – Patikrina, ar skaičius yra begalinis.
math.isnan – Patikrina, ar reikšmė yra NaN.

Paklaidos ir gama – specialios matematinės funkcijos.

math.gamma – Gama funkcija (apibendrintas faktorialas).
math.lgamma – Logaritminė gama.
math.erf – Klaidos funkcija.
math.erfc – Papildomoji klaidos funkcija.

Integruotos funkcijos #

„Python“ siūlo keletą integruotų funkcijų, kurios leidžia atlikti matematinius veiksmus projekto viduje.

abs #

abs grąžina absoliučiąją skaičiaus reikšmę, pašalinant bet kokį neigiamą ženklą.

Usage:
abs(x)

Parametras	Aprašymas
`x`	Sveikasis skaičius arba slankioji eilutė.

# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)

# abs_result = 10

round #

round grąžina suapvalintą skaičių iki nurodyto skaičiaus po kablelio kaip sveikąjį skaičių.

Usage:
round(x, ndigits)

Parametras	Aprašymas
`x`	Sveikasis skaičius arba slankioji eilutė.
`ndigits`	Pasirinktinai. Nustato, iki kiek dešimtainių skaičių apvalinti (nuo 0 iki 5). Numatytoji reikšmė yra 0. Kai naudojamas šis parametras, `round` grąžina slankiojo skaičiaus skaičių.

# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)

# round_int_result = 6

# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)

# round_result = 3.14000

min #

min grąžina mažiausią reikšmę iš kelių argumentų arba iteruojamo skaičiaus.

Usage:
min(arg1, arg2, …) or min(sequence)

Parametras	Aprašymas
`arg1`, `arg2`, …	Skaičiai, kuriuos galima palyginti.
`sequence`	Sąrašas, rinkinys arba kita seka, kurioje yra skaičiai.

# Get the smallest number from 3, 7, and 1
min_result = min(3, 7, 1)
controller.screen.print(min_result)

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.screen.print(min_list_result)

# min_list_result = 1

max #

max grąžina didžiausią reikšmę iš kelių argumentų arba iteruojamo skaičiaus.

Usage:
max(arg1, arg2, …) or max(sequence)

Parametras	Aprašymas
`arg1`, `arg2`, …	Skaičiai, kuriuos galima palyginti.
`sequence`	Sąrašas, rinkinys arba kita seka, kurioje yra skaičiai.

# Get the largest number from 3, 7, and 1
max_result = max(3, 7, 1)
controller.screen.print(max_result)

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.screen.print(max_list_result)

# max_list_result = 25

sum #

sum susumuoja visas iteruojamo elemento reikšmes su pasirenkama pradine reikšme.

Usage:
sum(sequence, start)

Parametras	Aprašymas
`sequence`	Sąrašas, rinkinys arba kita seka, kurioje yra skaičiai.
`start`	Pasirinktinai. Reikšmė, kurią reikia pridėti prie sumos. Numatytoji reikšmė yra 0.

# Calculate the sum of a list of numbers
sum_result = sum([1, 2, 3, 4, 5])
controller.screen.print(sum_result)

# sum_result = 15

# Calculate the sum of a list with a starting value of 10
sum_with_start = sum([1, 2, 3], 10)
controller.screen.print(sum_with_start)

# sum_with_start = 16

divmod #

divmod grąžina rinkinį, kuriame yra dalybos operacijos dalmuo ir liekana.

Usage:
divmod(a, b)

Parametras	Aprašymas
`a`	Dividendas.
`b`	Daliklis.

# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)

# divmod_result = (3, 1)

pow #

pow grąžina skaičių, pakeltą laipsniu, ir pasirinktinai atlieka modulio operaciją kaip sveikąjį skaičių.

Usage:
pow(x, y, mod)

Parametras	Aprašymas
`x`	Bazinis skaičius.
`y`	Laipsniškas rodiklis.
`mod`	Pasirinktinai. Modulio reikšmė. Jei nurodyta, grąžina `(x ** y) % mod`.

# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
controller.screen.print(pow_result)

# pow_result = 8

# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.screen.print(pow_mod_result)

# pow_mod_result = 6

int #

>int konvertuoja skaičių arba eilutę į sveikąjį skaičių. Ji taip pat palaiko bazinį konvertavimą konvertuojant iš eilutės.

Usage:
int(x, base)

Parametras	Aprašymas
`x`	Skaičius, eilutė arba kitas objektas, kurį reikia konvertuoti.
`base`	Pasirinktinai. Skaičių bazė, naudojama konvertavimui. Numatytoji reikšmė yra 10.

# Convert a float to an integer to get rid of decimals
price = 19.99
price_int = int(price)
controller.screen.print(f"{price_int} coins")

# Output: 19 coins

# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
controller.screen.print(user_number * 2)

# Output: 110

float #

float konvertuoja skaičių arba eilutę į slankiojo kablelio skaičių.

Usage:
float(x)

Parametras	Aprašymas
`x`	Skaičius, eilutė arba kitas objektas, kurį reikia konvertuoti.

# Convert division result to a float
num_apples = 6
num_people = 2
apples_per_person = float(num_apples) / num_people
controller.screen.print(apples_per_person)

# Output: 3.00000

# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)

# Output: 70.20000

Matematikos modulis #

„MicroPython“ modulis math suteikia papildomų metodų, skirtų atlikti įprastus matematinius skaičiavimus. Šie metodai apima trigonometrines, logaritmines ir kitas skaitines operacijas.

math modulis pagal numatytuosius nustatymus importuojamas į „VEXcode“.

Constants #

Konstantos yra iš anksto nustatytos vertės, kurios išlieka fiksuotos viso projekto metu. Jas galima naudoti skaičiavimuose nereikalaujant jokio apibrėžimo ar priskyrimo.

pi #

pi nurodo matematinę konstantą π – apskritimo apimties ir skersmens santykį.

Usage:
math.pi

# Calculate the area of a circle with radius 5 using pi
circle_area = math.pi * 5 * 5
controller.screen.print(circle_area)

# circle_area = 78.53982

tau #

tau atitinka 2π reikšmę.

Usage:
math.tau

# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)

# circumference = 31.41593

e #

e yra natūralaus logaritmo pagrindas.

Usage:
math.e

# Calculate e raised to the power of 2
e_power = math.pow(math.e, 2)
controller.screen.print(e_power)

# e_power = 7.38906

informacija #

inf suteikia teigiamą begalybę kaip slankiojantį skaičių.

Usage:
math.inf

# Check if infinity is infinite
inf_value = math.inf

if math.isinf(inf_value):
    controller.screen.print("Infinity")

# Prints "Infinity"

nan #

nan reiškia specialų slankiojo kablelio skaičių, reiškiantį „Ne skaičius“ (NaN).

Usage:
math.nan

# Check if nan is Not a Number
nan_value = math.nan

if math.isnan(nan_value):
    controller.screen.print("Not a Number")

# Prints "Not a Number"

Trigonometry #

nuodėmė #

sin apskaičiuoja kampo sinusą radianais ir grąžina slankiąją kablelį.

Usage:
math.sin(x)

Parametras	Aprašymas
`x`	A float or integer representing an angle in radians.

# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)

# sine_result = 0.50000

nes #

cos apskaičiuoja kampo kosinusą radianais ir grąžina slankiąją kablelį.

Usage:
math.cos(x)

Parametras	Aprašymas
`x`	A float or integer representing an angle in radians.

# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)

# cosine_result = 0.50000

įdegis #

tan apskaičiuoja kampo tangentą radianais ir grąžina slankiojo skaičiaus kablelį.

Usage:
math.tan(x)

Parametras	Aprašymas
`x`	A float or integer representing an angle in radians.

# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)

# tangent_result = 1.00000

šiukšlės #

asin apskaičiuoja skaičiaus atvirkštinį sinusą (arkinsusą) ir grąžina slankiojo kablelio reikšmę, rodančią kampą radianais.

Usage:
math.asin(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius nuo -1 iki 1.

# Calculate the arc sine of 0.5 in radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)

# arc_sine_result = 0.52360

akosai #

acos apskaičiuoja skaičiaus atvirkštinį kosinusą (arkkosinusą) ir grąžina slankiojo kablelio, reiškiančio kampą radianais, reikšmę.

Usage:
>math.acos(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius nuo -1 iki 1.

# Calculate the arc cosine of 0.5 in radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)

# arc_cosine_result = 1.04720

Atanas #

atan apskaičiuoja skaičiaus atvirkštinę liestinę (arktangentą) ir grąžina slankiojo kablelio reikšmę, rodančią kampą radianais.

Usage:
math.atan(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė.

# Calculate the arc tangent of 1 in radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)

# arc_tangent_result = 0.78540

atan2 #

atan2 apskaičiuoja atvirkštinės y/x tangento pagrindinę reikšmę ir grąžina slankiojo kablelio reikšmę, vaizduojančią kampą radianais.

Usage:
math.atan2(y, x)

Parametras	Aprašymas
`y`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis y koordinatę.
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis x koordinatę.

# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)

# atan2_result = 0.64350

laipsniai #

degrees konvertuoja kampą iš radianų į laipsnius.

Usage:
math.degrees(x)

Parametras	Aprašymas
`x`	Plokščiadugnis arba sveikasis skaičius, vaizduojantis kampą radianais.

# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)

# degrees_result = 180.00000

radianai #

radians konvertuoja kampą iš laipsnių į radianus.

Usage:
math.radians(x)

Parametras	Aprašymas
`x`	Plūdinis skaičius arba sveikasis skaičius, vaizduojantis kampą laipsniais.

# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)

# radians_result = 3.14159

Hyperbolics #

sinh #

sinh apskaičiuoja x hiperbolinį sinusą.

Usage:
math.sinh(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)

# sinh_result = 1.7520

prabangus #

Funkcija cosh apskaičiuoja hiperbolinį x kosinusą.

Usage:
math.cosh(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)

# cosh_result = 1.54308

tanh #

tanh apskaičiuoja x hiperbolinį tangentą.

Usage:
math.tanh(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)

# tanh_result = 0.76159

asinh #

asinh apskaičiuoja atvirkštinį hiperbolinį x sinusą.

Usage:
math.asinh(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)

# asinh_result = 0.88137

akosas #

Funkcija acosh apskaičiuoja atvirkštinį hiperbolinį x kosinusą.

Usage:
math.acosh(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, didesnis arba lygus 1.

# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)

# acosh_result = 1.31696

atanh #

atanh apskaičiuoja atvirkštinę hiperbolinę liestinę x.

Usage:
math.atanh(x)

Parametras	Aprašymas
`x`	Plūdinis skaičius tarp -1 ir 1 (išskyrus).

# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
controller.screen.print(atanh_result)

# atanh_result = 0.54931

Rounding & Absolute Values #

lubos #

ceil suapvalina skaičių iki artimiausio sveikojo skaičiaus.

Usage:
math.ceil(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė, kuri turi būti apvalinama į didesnę pusę.

# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)

# ceil_result = 4

grindys #

floor suapvalina skaičių iki artimiausio sveikojo skaičiaus.

Usage:
math.floor(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė, kurią reikia apvalinti į mažesnę pusę.

# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)

# floor_result = 3

trumpinys #

trunc pašalina dešimtainę skaičiaus dalį neapvalindama.

Usage:
math.trunc(x)

Parametras	Aprašymas
`x`	Plūdinis skaičius, kuris bus sutrumpintas.

# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)

# trunc_result = 3

pagaminti produktai #

fabs grąžina absoliučią skaičiaus reikšmę kaip slankiojo kablelio formą.

Usage:
math.fabs(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė.

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)

# fabs_result = 3.70000

Exponents & Logarithms #

pow #

pow kelia x į y (x^y) laipsnį ir grąžina slankiąją kablelį.

Usage:
math.pow(x, y)

Parametras	Aprašymas
`x`	Slankiojo arba sveikojo skaičiaus bazė.
`y`	Slankiojo skaičiaus arba sveikojo skaičiaus rodiklis.

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)

# power_result = 8.00000

kv. m.#

Funkcija sqrt apskaičiuoja skaičiaus kvadratinę šaknį ir grąžina slankiojo kablelio reikšmę.

Usage:
math.sqrt(x)

Parametras	Aprašymas
`x`	Neigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)

# sqrt_result = 4.00000

patirtis #

exp grąžina e, pakeltą x laipsniu (e^x), kaip slankiojo skaičiaus vienetą.

Usage:
math.exp(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė.

# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)

# exp_result = 2.71828

rąstas #

log apskaičiuoja skaičiaus natūrinį logaritmą ir grąžina slankiąją kablelį.

Usage:
math.log(x)

Parametras	Aprašymas
`x`	Teigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
controller.screen.print(log_result)

# log_result = 2.00000

log10 #

log10 apskaičiuoja skaičiaus dešimtainį logaritmą ir grąžina slankiąją kablelį.

Usage:
math.log10(x)

Parametras	Aprašymas
`x`	Teigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)

# log10_result = 3.00000

log2 #

log2 apskaičiuoja skaičiaus dvitaškį logaritmą ir grąžina slankiąją kablelį, net kai x yra 2 laipsnis.

Usage:
math.log2(x)

Parametras	Aprašymas
`x`	Teigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)

# log2_result = 3.00000

faktorialas #

factorial grąžina sveikojo skaičiaus xfaktorialą, kuris yra visų teigiamų sveikųjų skaičių iki x sandauga.

Usage:
math.factorial(x)

Parametras	Aprašymas
`x`	Neigiamas sveikasis skaičius.

# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)

# factorial_result = 120

expm1 #

expm1 apskaičiuoja e^x - 1, kuris yra tikslesnis mažoms x formulėms.

Usage:
math.expm1(x)

Parametras	Aprašymas
`x`	Eksponento reikšmė.

# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)

# expm1_result = 1.71828

Floating Point Operations #

modifikavimas #

modf suskaido skaičių į trupmeninę ir sveikąją dalis ir grąžina rinkinį (fractional part, integer part), abu kaip slankiuosius skaičius.

Usage:
math.modf(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė, kurią reikia suskaidyti.

# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)

# fractional_part = 0.14159
# integer_part = 3.00000

frexp #

frexp suskaido skaičių į jo mantisą ir laipsnio rodiklį ir grąžina rinkinį (mantissa, exponent), kur mantisa yra slankioji reikšmė, o laipsnio rodiklis yra sveikasis skaičius.

Usage:
math.frexp(x)

Parametras	Aprašymas
`x`	Slankioji arba sveikoji reikšmė, kurią reikia suskaidyti.

# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)

# mantissa = 0.50000
# exponent = 5

fmod #

fmod grąžina dalybos liekaną, išlaikydamas dalinio ženklą (x).

Usage:
math.fmod(x, y)

Parametras	Aprašymas
`x`	Dividendas.
`y`	Daliklis.

# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
controller.screen.print(fmod_result)

# fmod_result = 1.00000

autoriaus teisės #

copysign grąžina x su y ženklu.

Usage:
math.copysign(x, y)

Parametras	Aprašymas
`x`	Reikšmė, kurią reikia modifikuoti.
`y`	Reikšmė, kurios ženklas bus nukopijuotas.

# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
controller.screen.print(copysign_result)

# copysign_result = 10.00000

ldexp #

ldexp apskaičiuoja x * (2 ** exp), kas atitinka x * 2^exp.

Usage:
math.ldexp(x, exp)

Parametras	Aprašymas
`x`	Bazinė vertė.
`exp`	Laipsniškas rodiklis.

# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)

# ldexp_result = 48.00000

Comparison & Approximation #

begalinis #

isfinite tikrina, ar skaičius yra baigtinis. Šis metodas grąžina loginę reikšmę:

True – Skaičius yra baigtinis.
False – Skaičius yra begalinis.

Usage:
math.isfinite(x)

Parametras	Aprašymas
`x`	Slankiojo tipo arba sveikasis skaičius, kurį reikia patikrinti.

# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
controller.screen.print(is_finite_true)

# is_finite_true = True

# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
controller.screen.print(is_finite_false)

# is_finite_false = False

isinf #

isinf patikrina, ar skaičius yra begalinis. Šis metodas grąžina loginę reikšmę:

True – Skaičius yra begalinis.
False – Skaičius yra baigtinis.

Usage:
math.isinf(x)

Parametras	Aprašymas
`x`	Slankiojo tipo arba sveikasis skaičius, kurį reikia patikrinti.

# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
controller.screen.print(is_inf_true)

# is_inf_true = True

# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.screen.print(is_inf_false)

# is_inf_false = False

isnanas #

isnan patikrina, ar skaičius yra NaN (ne skaičius). Šis metodas grąžina loginę reikšmę:

True – skaičius yra NaN.
False – Numeris yra galiojantis.

Usage:
math.isnan(x)

Parametras	Aprašymas
`x`	Slankiojo tipo arba sveikasis skaičius, kurį reikia patikrinti.

# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
controller.screen.print(is_nan_true)

# is_nan_true = True

# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.screen.print(is_nan_false)

# is_nan_false = False

Error and Gamma Calculations #

gama #

Funkcija gamma apskaičiuoja xgama funkciją, kuri apibendrina faktorialinę funkciją realiiesiems ir kompleksiniams skaičiams. Sveikajam skaičiui n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

Parametras	Aprašymas
`x`	Teigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)

# gamma_result = 24.00000

lgama #

lgamma apskaičiuoja funkcijos gamma natūrinį logaritmą.

Usage:
math.lgamma(x)

Parametras	Aprašymas
`x`	Teigiamas slankiojantis skaičius arba sveikasis skaičius.

# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)

# lgamma_result = 3.17805

erf #

erf apskaičiuoja x paklaidos funkciją.

Usage:
math.erf(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)

# erf_result = 0.84270

erfc #

erfc apskaičiuoja xkomplementariąją paklaidos funkciją, kuri apibrėžiama kaip 1 - erf(x).

Usage:
math.erfc(x)

Parametras	Aprašymas
`x`	Slankiojo skaičiaus arba sveikasis skaičius, vaizduojantis įvesties reikšmę.

# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)

# erfc_result = 0.15730