Matematika#

Įvadas #

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

Naudokite šias funkcijas ir konstantas roboto padėčiai, kampams, atstumams ir kitoms skaitinėms reikšmėms apskaičiuoti. Taip pat galite konvertuoti tarp laipsnių ir radianų, įvertinti išraiškas ir dirbti su specialiomis reikšmėmis, tokiomis kaip begalybė ir NaN.

Ž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.atan – Radianais išreikštos reikšmės arktangentas.
math.atan2 – y/x arktangentas radianais, atsižvelgiant į kvadrantą.
math.asin – Radianais išreikštos reikšmės arcsinusas.
math.acos – Radianais nurodytos reikšmės arkkosinusas.
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 – patikrinkite arba suskaidykite 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.isclose – Patikrina, ar dvi reikšmės yra apytiksliai lygios.
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)
robot.screen.print(abs_result)

# abs_result = 10

round #

round suapvalina skaičių iki nurodyto skaičiaus po kablelio.

Usage:
round(x, ndigits)

Parametras	Aprašymas
`x`	Sveikasis skaičius arba slankioji eilutė.
`ndigits`	Pasirinktinai. Apvalinimo iki dešimtainių vietų skaičius. Numatytoji reikšmė yra 0.

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

# round_int_result = 6

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

# round_result = 3.14

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)
robot.screen.print(min_result)

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
robot.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)
robot.screen.print(max_result)

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
robot.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])
robot.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)
robot.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)
robot.screen.print(divmod_result)

# divmod_result = (3, 1)

pow #

pow kelia skaičių laipsniu ir pasirinktinai atlieka modulio operaciją.

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)
robot.screen.print(pow_result)

# pow_result = 8

# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
robot.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)
robot.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)
robot.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
robot.screen.print(apples_per_person)

# Output: 3.00

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

# Output: 70.20

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
robot.screen.print(circle_area)

# circle_area = 78.54

tau #

tau atitinka 2π reikšmę.

Usage:
math.tau

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

# circumference = 31.42

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)
robot.screen.print(e_power)

# e_power = 7.39

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):
    robot.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):
    robot.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`	Plokščiadugnis arba sveikasis skaičius, vaizduojantis kampą radianais.

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

# sine_result = 0.50

nes #

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

Usage:
math.cos(x)

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

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

# cosine_result = 0.50

įdegis #

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

Usage:
math.tan(x)

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

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

# tangent_result = 1.00

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 degrees
arc_tangent_result = math.degrees(math.atan(1.0))
robot.screen.print(arc_tangent_result)

# arc_tangent_result = 45.00

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 1/1 in degrees
atan2_result = math.degrees(math.atan2(1.0, 1.0))
robot.screen.print(atan2_result)

# atan2_result = 45.00

š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 degrees
arc_sine_result = math.degrees(math.asin(0.5))
robot.screen.print(arc_sine_result)

# arc_sine_result = 30.00

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 degrees
arc_cosine_result = math.degrees(math.acos(0.5))
robot.screen.print(arc_cosine_result)

# arc_cosine_result = 60.00

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)
robot.screen.print(degrees_result)

# degrees_result = 180.00

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)
robot.screen.print(radians_result)

# radians_result = 3.14

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)
robot.screen.print(sinh_result)

# sinh_result = 1.18

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)
robot.screen.print(cosh_result)

# cosh_result = 1.54

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)
robot.screen.print(tanh_result)

# tanh_result = 0.76

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)
robot.screen.print(asinh_result)

# asinh_result = 0.88

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)
robot.screen.print(acosh_result)

# acosh_result = 1.32

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)
robot.screen.print(atanh_result)

# atanh_result = 0.55

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)
robot.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)
robot.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)
robot.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)
robot.screen.print(fabs_result)

# fabs_result = 3.70

Exponents & Logarithms #

pow #

pow kelia x y laipsniu ir grąžina slankiąją kablelį, net jei abu įėjimai yra sveikieji skaičiai.

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)
robot.screen.print(power_result)

# power_result = 8.00

kv. m.#

Funkcija sqrt apskaičiuoja skaičiaus kvadratinę šaknį ir grąžina slankiojo kablelio reikšmę net ir idealiųjų kvadratų atveju.

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)
robot.screen.print(sqrt_result)

# sqrt_result = 4.00

patirtis #

exp apskaičiuoja skaičiaus eksponentę ir grąžina slankiąją kablelį.

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)
robot.screen.print(exp_result)

# exp_result = 2.72

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)
robot.screen.print(log_result)

# log_result = 2.00

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)
robot.screen.print(log10_result)

# log10_result = 3.00

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)
robot.screen.print(log2_result)

# log2_result = 3.00

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)
robot.screen.print(factorial_result)

# factorial_result = 120

expm1 #

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

Usage:
math.expm1(x)

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

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

# expm1_result = 1.72

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)
robot.screen.print(fractional_part)
robot.screen.next_row()
robot.screen.print(integer_part)

# fractional_part = 0.14
# integer_part = 3.00

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)
robot.screen.print(mantissa)
robot.screen.next_row()
robot.screen.print(exponent)

# mantissa = 0.50
# exponent = 5

fmod #

fmod grąžina dalybos liekaną, išlaikant 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)
robot.screen.print(fmod_result)

# fmod_result = 1.00

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)
robot.screen.print(copysign_result)

# copysign_result = 10.00

ldexp #

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

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)
robot.screen.print(ldexp_result)

# ldexp_result = 48.00

Comparison & Approximation #

yra arti #

isclose tikrina, ar du skaičiai yra maždaug vienodi neviršijant tolerancijos ribos.

Usage:
math.isclose(a, b, rel_tol, abs_tol)

Parametras	Aprašymas
`a`	Pirmas skaičius, kurį reikia palyginti.
`b`	Antras skaičius, kurį reikia palyginti.
`rel_tol`	Pasirinktinai. Didžiausias leidžiamas skirtumas tarp a ir b, atsižvelgiant į jų dydį. Numatytoji reikšmė yra 1e-09 (labai mažas).
`abs_tol`	Pasirinktinai. Fiksuota paklaidos riba, naudinga lyginant skaičius, artimus nuliui. Numatytoji reikšmė yra 0,0.

Pastaba: Jei pateiktos ir rel_tol , ir abs_tol , rezultatas priklauso nuo to, kuri sąlyga įvykdoma anksčiau.

# Check if 1.000000001 and 1.0 are close
# within the default tolerance
isclose_result = math.isclose(1.000000001, 1.0)
robot.screen.print(isclose_result)

# isclose_result = True

# Check if 0.0000001 and 0.0 are close
# using absolute tolerance
isclose_result = math.isclose(0.0000001, 0.0, abs_tol=1e-07)
robot.screen.print(isclose_result)

# isclose_result = True

# Check if 1000000.0 and 1000000.1 are close
# with a stricter tolerance
isclose_result = math.isclose(1000000.0, 1000000.1, rel_tol=1e-10)
robot.screen.print(isclose_result)

# isclose_result = False

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)
robot.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)
robot.screen.print(is_finite_false)

# is_finite_false = False

isinf #

isinf tikrina, 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)
robot.screen.print(is_inf_true)

# is_inf_true = True

# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
robot.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)
robot.screen.print(is_nan_true)

# is_nan_true = True

# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
robot.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)
robot.screen.print(gamma_result)

# gamma_result = 24.00

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)
robot.screen.print(lgamma_result)

# lgamma_result = 3.18

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)
robot.screen.print(erf_result)

# erf_result = 0.84

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)
robot.screen.print(erfc_result)

# erfc_result = 0.16