Matek#
Bevezetés#
A Math tartalmaz beépített Python függvényeket és a teljes math modult is, amely automatikusan elérhető a VEXcode AIM-ben. Ezek az eszközök lehetővé teszik az alapvető aritmetikai műveletektől a haladó trigonometriai, kerekítési és logaritmikus műveletekig mindent.
Ezekkel a függvényekkel és állandókkal kiszámíthatja a robot pozícióit, szögeit, távolságait és egyéb numerikus értékeit. Fokok és radiánok között is válthat, kifejezéseket értékelhet ki, és speciális értékekkel, például végtelennel és NaN-nal dolgozhat.
Az alábbiakban a rendelkezésre álló matematikai függvények, konstansok és segédprogramok listája látható:
Beépített függvények – A Pythonban megtalálható gyakori matematikai eszközök.
abs– Egy szám abszolút értékét adja vissza.round– Egy számot megadott számú tizedesjegyre kerekít.min– Visszaadja a bemeneti értékek közül a legkisebbet.max– Visszaadja a bemeneti értékek közül a legnagyobbat.sum– Összeadja egy iterálható objektum összes értékét.divmod– Visszaadja a hányadost és a maradékot egy tuple-ként.pow– Egy számot adott hatványra emel, opcionálisan egy modulussal.int– Egy értéket egész számmá alakít.float– Lebegőpontos számmá alakít egy értéket.
Konstansok – Előre definiált értékek a math modulból.
math.pi– A π (pi) állandó.math.tau– A tau (2π) állandó.math.e– Euler-szám, a természetes logaritmus alapja.math.inf– Pozitív végtelen.math.nan– Nem szám (NaN).
Trigonometria – Szögek és oldalak közötti kapcsolatok kiszámítása.
math.sin– Egy szög szinuszai radiánban.math.cos– Egy szög koszinusza radiánban.math.tan– Egy szög tangense radiánban.math.atan– Egy radiánban megadott érték arkusz tangense.math.atan2– Az y/x arkusz tangense radiánban, figyelembe véve a kvadránst.math.asin– Egy radiánban megadott érték arkusz szinuszja.math.acos– Egy radiánban megadott érték arkusz koszinusza.math.degrees– Radiánból fokot vált át.math.radians– Fokokat radiánokká alakít.
Hiperbolika – Haladó trigonometriai függvények.
math.sinh– Egy érték hiperbolikus szinuszát adja meg.math.cosh– Egy érték hiperbolikus koszinusza.math.tanh– Egy érték hiperbolikus tangense.math.asinh– Inverz hiperbolikus szinusz.math.acosh– Inverz hiperbolikus koszinusz.math.atanh– Inverz hiperbolikus tangens.
Kerekítés és abszolút érték – Pontosság vagy irány beállítása.
math.ceil– Felfelé kerekíti a legközelebbi egész számra.math.floor– Lefelé kerekíti a legközelebbi egész számra.math.trunc– Eltávolítja a tizedes részt.math.fabs– Visszaadja az abszolút értéket lebegőpontos számként.
Kitevők és logaritmusok – Hatvány-, gyök- és logaritmusszámítások.
math.pow– Egy számot adott hatványra emel.math.sqrt– Visszaadja a négyzetgyököt.math.exp– Kiszámítja az e-t x hatványán.math.log– Természetes logaritmus (e alapú).math.log10– 10-es alapú logaritmus.math.log2– 2-es alapú logaritmus.math.factorial– Egy egész szám faktoriálisa.math.expm1– Pontosabb eredmény ae^x - 1függvényre.
Lebegőpontos műveletek – Lebegőpontos értékek vizsgálata vagy bontása.
math.modf– Visszaadja egy lebegőpontos szám tört és egész részét.math.frexp– Egy számot mantisszára és kitevőjére bont.math.fmod– Az osztandó előjelével jelölt maradék.math.copysign– Egy másik előjelű értéket ad vissza.math.ldexp– Kiszámítjax * (2 ** exp).
Összehasonlítás és közelítés – Értékek ellenőrzése tűréshatárokkal vagy kategóriákkal.
math.isclose– Ellenőrzi, hogy két érték közelítőleg egyenlő-e.math.isfinite– Ellenőrzi, hogy egy szám véges-e.math.isinf– Ellenőrzi, hogy egy szám végtelen-e.math.isnan– Ellenőrzi, hogy egy érték NaN-e.
Hiba és gamma – Speciális matematikai függvények.
math.gamma– Gammafüggvény (általánosított faktoriális).math.lgamma– Logaritmikus gamma.math.erf– Hibafüggvény.math.erfc– Kiegészítő hibafüggvény.
Beépített függvények#
A Python számos beépített függvényt kínál, amelyek lehetővé teszik matematikai műveletek végrehajtását a projekten belül.
abs#
abs egy szám abszolút értékét adja vissza, eltávolítva a negatív előjeleket.
Usage:
abs(x)
Paraméter |
Leírás |
|---|---|
|
Egész szám vagy lebegőpontos szám. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round egy számot megadott számú tizedesjegyre kerekít.
Usage:
round(x, ndigits)
Paraméter |
Leírás |
|---|---|
|
Egész szám vagy lebegőpontos szám. |
|
Opcionális. A tizedesjegyek száma, amelyekre kerekíteni kell. Az alapértelmezett érték 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 a több argumentumból vagy egy iterálható függvényből származó legkisebb értéket adja vissza.
Usage:
min(arg1, arg2, …) or min(sequence)
Paraméter |
Leírás |
|---|---|
|
Az összehasonlításhoz szükséges számok. |
|
Számokat tartalmazó lista, tuple vagy más sorozat. |
# 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 a több argumentum vagy egy iterálható függvény közül a legnagyobb értéket adja vissza.
Usage:
max(arg1, arg2, …) or max(sequence)
Paraméter |
Leírás |
|---|---|
|
Az összehasonlításhoz szükséges számok. |
|
Számokat tartalmazó lista, tuple vagy más sorozat. |
# 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 függvény összeadja egy iterálható objektum összes értékét, opcionális kezdőértékkel.
Usage:
sum(sequence, start)
Paraméter |
Leírás |
|---|---|
|
Számokat tartalmazó lista, tuple vagy más sorozat. |
|
Opcionális. Az összeghez hozzáadandó érték. Az alapértelmezett érték 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 egy olyan tuple-t ad vissza, amely egy osztási művelet hányadosát és maradékát tartalmazza.
Usage:
divmod(a, b)
Paraméter |
Leírás |
|---|---|
|
Az osztalék. |
|
Az osztó. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow egy számot hatványoz, és opcionálisan modulusműveletet hajt végre.
Usage:
pow(x, y, mod)
Paraméter |
Leírás |
|---|---|
|
Az alapszám. |
|
A kitevő. |
|
Opcionális. Egy modulusérték. Ha meg van adva, |
# 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 függvény egy számot vagy karakterláncot egész számmá alakít. Karakterláncból történő konvertáláskor támogatja az alapkonverziót is.
Usage:
int(x, base)
Paraméter |
Leírás |
|---|---|
|
Egy szám, karakterlánc vagy más, konvertálandó objektum. |
|
Opcionális. Az átváltáshoz használandó számrendszer. Az alapértelmezett érték 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 egy számot vagy karakterláncot lebegőpontos számmá alakít.
Usage:
float(x)
Paraméter |
Leírás |
|---|---|
|
Egy szám, karakterlánc vagy más, konvertálandó objektum. |
# 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
Matematikai modul#
A MicroPython math modulja további metódusokat biztosít a gyakori matematikai számítások elvégzéséhez. Ezek a metódusok magukban foglalják a trigonometrikus, logaritmikus és egyéb numerikus műveleteket.
A math modul alapértelmezés szerint importálva van a VEXcode-ban.
Constants#
A konstansok előre definiált értékek, amelyek egy projekt során rögzítettek maradnak. Számításokban felhasználhatók anélkül, hogy bármilyen definíciót vagy értékadást igényelnének.
pi#
pi megadja a π matematikai állandót, a kör kerületének és átmérőjének arányát.
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 értéke 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)
# circumference = 31.42
e#
e a természetes logaritmus alapját adja.
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
infó#
inf pozitív végtelent ad lebegőpontos számként.
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 egy speciális lebegőpontos számot jelöl a “Not a Number” (NaN) helyett.
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#
bűn#
sin függvény egy szög szinuszát számítja ki radiánban, és lebegőpontos értéket ad vissza.
Usage:
math.sin(x)
Paraméter |
Leírás |
|---|---|
|
Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)
# sine_result = 0.50
kötözősaláta#
cos függvény egy szög koszinuszát számítja ki radiánban, és egy lebegőpontos értéket ad vissza.
Usage:
math.cos(x)
Paraméter |
Leírás |
|---|---|
|
Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
cserszínű#
tan egy szög tangensét számítja ki radiánban, és lebegőpontos értéket ad vissza.
Usage:
math.tan(x)
Paraméter |
Leírás |
|---|---|
|
Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
robot.screen.print(tangent_result)
# tangent_result = 1.00
Atán#
atan függvény kiszámítja egy szám inverz tangensét (ívtangenst), és egy lebegőpontos értéket ad vissza, amely a szöget jelenti radiánban.
Usage:
math.atan(x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szá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 függvény kiszámítja az y/x függvény inverz tangensének főértékét, és egy lebegőpontos számot ad vissza, amely a szöget jelenti radiánban.
Usage:
math.atan2(y, x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szám, amely az y koordinátát jelöli. |
|
Az x koordinátát reprezentáló lebegőpontos szám vagy egész szám. |
# 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
szamár#
asin függvény egy szám inverz szinuszát (arc szinuszát) számítja ki, és egy lebegőpontos számot ad vissza, amely a szöget jelenti radiánban.
Usage:
math.asin(x)
Paraméter |
Leírás |
|---|---|
|
Egy -1 és 1 közötti lebegőpontos szám vagy egész szám. |
# 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
ákosok#
acos függvény kiszámítja egy szám inverz koszinuszát (arkus koszinuszát), és egy lebegőpontos számot ad vissza, amely a szöget jelenti radiánban.
Usage:
math.acos(x)
Paraméter |
Leírás |
|---|---|
|
Egy -1 és 1 közötti lebegőpontos szám vagy egész szám. |
# 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
fok#
degrees képlettel radiánból fokokba konvertálható a szög.
Usage:
math.degrees(x)
Paraméter |
Leírás |
|---|---|
|
Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radián#
radians egy szöget fokból radiánba konvertál.
Usage:
math.radians(x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szám, amely egy szöget ábrázol fokban. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh függvény a x hiperbolikus szinuszát számítja ki.
Usage:
math.sinh(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
bunkó#
cosh függvény a x hiperbolikus koszinuszát számítja ki.
Usage:
math.cosh(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh függvény kiszámítja a x hiperbolikus tangensét.
Usage:
math.tanh(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
aszin#
asinh függvény a x inverz hiperbolikus szinuszát számítja ki.
Usage:
math.asinh(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
ákos#
acosh függvény kiszámítja a x inverz hiperbolikus koszinuszát.
Usage:
math.acosh(x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szám, amely nagyobb vagy egyenlő, mint 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh függvény kiszámítja a x inverz hiperbolikus tangensét.
Usage:
math.atanh(x)
Paraméter |
Leírás |
|---|---|
|
Egy -1 és 1 közötti lebegőpontos szám (kizárólagos). |
# 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#
mennyezet#
ceil függvény egy számot felfelé kerekít a legközelebbi egész számra.
Usage:
math.ceil(x)
Paraméter |
Leírás |
|---|---|
|
Felfelé kerekítendő lebegőpontos szám vagy egész szám. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
emelet#
floor függvény egy számot lefelé kerekít a legközelebbi egész számra.
Usage:
math.floor(x)
Paraméter |
Leírás |
|---|---|
|
Lefelé kerekítendő lebegőpontos szám vagy egész szám. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
csonk#
trunc parancs kerekítés nélkül eltávolítja a szám tizedes részét.
Usage:
math.trunc(x)
Paraméter |
Leírás |
|---|---|
|
Egy csonkolandó úszótest. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
fabrikáltak#
fabs Egy szám abszolút értékét adja vissza lebegőpontos számként.
Usage:
math.fabs(x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szá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#
hadifogoly#
pow függvény x értékét y hatványára emeli, és lebegőpontos számot ad vissza, még akkor is, ha mindkét bemenet egész szám.
Usage:
math.pow(x, y)
Paraméter |
Leírás |
|---|---|
|
Lebegőpontos vagy egész alapú szám. |
|
Egy lebegőpontos vagy egész kitevőjű. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
négyzetméter#
sqrt függvény kiszámítja egy szám négyzetgyökét, és lebegőpontos számot ad vissza, még tökéletes négyzetszámok esetén is.
Usage:
math.sqrt(x)
Paraméter |
Leírás |
|---|---|
|
Nemnegatív lebegőpontos szám vagy egész szám. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
tapasztalat#
exp Kiszámítja egy szám exponenciálisát és lebegőpontos számot ad vissza.
Usage:
math.exp(x)
Paraméter |
Leírás |
|---|---|
|
Egy lebegőpontos szám vagy egész szám. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
napló#
log függvény egy szám természetes logaritmusát számítja ki, és lebegőpontos értéket ad vissza.
Usage:
math.log(x)
Paraméter |
Leírás |
|---|---|
|
Pozitív lebegőpontos szám vagy egész szám. |
# 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 egy szám 10-es alapú logaritmusát számítja ki, és lebegőpontos értéket ad vissza.
Usage:
math.log10(x)
Paraméter |
Leírás |
|---|---|
|
Pozitív lebegőpontos szám vagy egész szám. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
log2 függvény egy szám kettes alapú logaritmusát számítja ki, és lebegőpontos értéket ad vissza, még akkor is, ha x a 2 hatványa.
Usage:
math.log2(x)
Paraméter |
Leírás |
|---|---|
|
Pozitív lebegőpontos szám vagy egész szám. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
faktoriális#
factorial függvény egy xegész szám faktoriálisát adja vissza, amely az összes pozitív egész szám szorzata x -ig.
Usage:
math.factorial(x)
Paraméter |
Leírás |
|---|---|
|
Nemnegatív egész szám. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 függvény kiszámítja ex - 1képletet, ami pontosabb kis x esetén.
Usage:
math.expm1(x)
Paraméter |
Leírás |
|---|---|
|
A kitevő értéke. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
robot.screen.print(expm1_result)
# expm1_result = 1.72
Floating Point Operations#
modf#
modf függvény egy számot tört és egész részeire bont, és egy tuple-t ad vissza (fractional part, integer part), mindkettőt lebegőpontos számként.
Usage:
math.modf(x)
Paraméter |
Leírás |
|---|---|
|
Egy felbontandó lebegőpontos szám vagy egész szám. |
# 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 függvény egy számot mantisszára és kitevőjére bont, és egy tuple-t ad vissza (mantissa, exponent), ahol a mantissza egy lebegőpontos szám, a kitevő pedig egy egész szám.
Usage:
math.frexp(x)
Paraméter |
Leírás |
|---|---|
|
Egy felbontandó lebegőpontos szám vagy egész szám. |
# 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 függvény visszaadja az osztás maradékát, miközben megtartja az osztandó előjelét (x).
Usage:
math.fmod(x, y)
Paraméter |
Leírás |
|---|---|
|
Az osztalék. |
|
Az osztó. |
# 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
szerzői aláírás#
copysign függvény x értékét adja vissza y előjellel.
Usage:
math.copysign(x, y)
Paraméter |
Leírás |
|---|---|
|
A módosítandó érték. |
|
Az az érték, amelynek az előjelét másolni fogják. |
# 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 kiszámítja x * (2 ** exp), ami egyenértékű x * 2exp{code} képlettel.
Usage:
math.ldexp(x, exp)
Paraméter |
Leírás |
|---|---|
|
Az alapérték. |
|
A kitevő. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
közel van#
isclose azt vizsgálja, hogy két szám megközelítőleg egyenlő-e egy tűréshatáron belül.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Paraméter |
Leírás |
|---|---|
|
Az első összehasonlítandó szám. |
|
A második összehasonlítandó szám. |
|
Opcionális. Az a és b közötti maximálisan megengedett különbség a méretükhöz viszonyítva. Az alapértelmezett érték 1e-09 (nagyon kicsi). |
|
Opcionális. Fix hibahatár, amely nullához közeli számok összehasonlításakor hasznos. Az alapértelmezett érték 0,0. |
Megjegyzés: Ha mind rel_tol , mind abs_tol meg van adva, akkor az előbb teljesülő feltétel határozza meg az eredményt.
# 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
végtelen#
isfinite ellenőrzi, hogy egy szám véges-e. Ez a metódus egy logikai értéket ad vissza:
True– A szám véges.False– A szám végtelen.
Usage:
math.isfinite(x)
Paraméter |
Leírás |
|---|---|
|
Egy ellenőrizendő lebegőpontos szám vagy egész szám. |
# 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 ellenőrzi, hogy egy szám végtelen-e. Ez a metódus egy logikai értéket ad vissza:
True– A szám végtelen.False– A szám véges.
Usage:
math.isinf(x)
Paraméter |
Leírás |
|---|---|
|
Egy ellenőrizendő lebegőpontos szám vagy egész szám. |
# 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
isnan#
isnan metódus ellenőrzi, hogy egy szám NaN (nem szám-e). Ez a metódus egy logikai értéket ad vissza:
True– A szám NaN.False– A szám érvényes szám.
Usage:
math.isnan(x)
Paraméter |
Leírás |
|---|---|
|
Egy ellenőrizendő lebegőpontos szám vagy egész szám. |
# 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#
gamma#
gamma kiszámítja a xgammafüggvényét, amely általánosítja a faktoriális függvényt valós és komplex számokra. Egy negész szám esetén gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Paraméter |
Leírás |
|---|---|
|
Pozitív lebegőpontos szám vagy egész szám. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)
# gamma_result = 24.00
lgamma#
lgamma a gamma függvény természetes logaritmusát számítja ki.
Usage:
math.lgamma(x)
Paraméter |
Leírás |
|---|---|
|
Pozitív lebegőpontos szám vagy egész szám. |
# 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 kiszámítja a x hibafüggvényét.
Usage:
math.erf(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc kiszámítja a xkomplementer hibafüggvényét, amely a következőképpen van definiálva: 1 - erf(x).
Usage:
math.erfc(x)
Paraméter |
Leírás |
|---|---|
|
A bemeneti értéket reprezentáló lebegőpontos vagy egész szám. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16