Matematika#
Zavedení#
Math obsahuje jak vestavěné funkce Pythonu, tak i kompletní modul math , který je automaticky dostupný ve VEXcode AIR. Tyto nástroje vám umožňují provádět vše od základní aritmetiky až po pokročilou trigonometrii, zaokrouhlování a logaritmické operace.
Tyto funkce a konstanty použijte k výpočtu poloh, úhlů, vzdáleností a dalších číselných hodnot pro ovladač dronu VEX AIR. Můžete také převádět mezi stupni a radiány, vyhodnocovat výrazy a pracovat se speciálními hodnotami, jako je nekonečno a NaN.
Poznámka: Pokud není výslovně uvedeno jinak, všechny návratové hodnoty jsou čísla s desetinnou čárkou formátovaná přesně na pět desetinných míst. Hodnoty s více než pěti desetinnými místy se zaokrouhlí a hodnoty s méně než pěti desetinnými místy se doplní nulami, takže se vždy zobrazí přesně pět desetinných míst.
Níže je uveden seznam dostupných matematických funkcí, konstant a utilit:
Vestavěné funkce – Běžné matematické nástroje zahrnuté v Pythonu.
abs– Vrátí absolutní hodnotu čísla.round– Zaokrouhlí číslo na zadaný počet desetinných míst.min– Vrátí nejmenší ze vstupních hodnot.max– Vrací největší ze vstupních hodnot.sum– Sečte všechny hodnoty v iterovatelném objektu.divmod– Vrátí podíl a zbytek jako n-tici.pow– Umocní číslo, volitelně s modulem.int– Převede hodnotu na celé číslo.float– Převede hodnotu na číslo s plovoucí desetinnou čárkou.
Konstanty – Předdefinované hodnoty z modulu math.
math.pi– Konstanta π (pí).math.tau– Konstanta tau (2π).math.e– Eulerovo číslo, základ přirozeného logaritmu.math.inf– Kladné nekonečno.math.nan– Není číslo (NaN).
Trigonometrie – Výpočet úhlů a vztahů mezi stranami.
math.sin– Sinus úhlu v radiánech.math.cos– Kosinus úhlu v radiánech.math.tan– Tangens úhlu v radiánech.math.asin– Arkus sinus hodnoty v radiánech.math.acos– Arkuskosinus hodnoty v radiánech.math.atan– Arkustangens hodnoty v radiánech.math.atan2– Arkustangens osy y/x v radiánech, s ohledem na kvadrant.math.degrees– Převede radiány na stupně.math.radians– Převede stupně na radiány.
Hyperbolické funkce – Pokročilé goniometrické funkce.
math.sinh– Hyperbolický sinus hodnoty.math.cosh– Hyperbolický kosinus čísla.math.tanh– Hyperbolický tangens hodnoty.math.asinh– Inverzní hyperbolický sinus.math.acosh– Inverzní hyperbolický kosinus.math.atanh– Inverzní hyperbolický tangens.
Zaokrouhlování a absolutní hodnota – Úprava přesnosti nebo směru.
math.ceil– Zaokrouhlí nahoru na nejbližší celé číslo.math.floor– Zaokrouhlí dolů na nejbližší celé číslo.math.trunc– Odstraní desetinnou část.math.fabs– Vrátí absolutní hodnotu jako číslo s desetinnou čárkou.
Exponenty a logaritmy – Výpočty mocnin, odmocnin a logaritmů.
math.pow– Umocní číslo.math.sqrt– Vrátí druhou odmocninu.math.exp– Vypočítá e umocněné na x.math.log– Přirozený logaritmus (o základu e).math.log10– Desetinový logaritmus.math.log2– Dvojkový logaritmus.math.factorial– Faktoriál celého čísla.math.expm1– Přesnější výsledek proe^x - 1.
Operace s plovoucí desetinnou čárkou – Kontrola nebo rozklad hodnot s plovoucí desetinnou čárkou.
math.modf– Vrací zlomkovou a celočíselnou část čísla s desetinnou čárkou.math.frexp– Rozloží číslo na mantisu a exponent.math.fmod– Zbytek se znaménkem dělence.math.copysign– Vrátí hodnotu se znaménkem jiné hodnoty.math.ldexp– Vypočítáx * (2 ** exp).
Porovnání a aproximace – Porovnání hodnot s tolerancemi nebo kategoriemi.
math.isfinite– Zkontroluje, zda je číslo konečné.math.isinf– Zkontroluje, zda je číslo nekonečné.math.isnan– Zkontroluje, zda je hodnota NaN.
Chyba a gama – Speciální matematické funkce.
math.gamma– Gama funkce (zobecněný faktoriál).math.lgamma– Logaritmická gama.math.erf– Funkce pro výpočet chyby.math.erfc– Doplňková chybová funkce.
Vestavěné funkce#
Python nabízí několik vestavěných funkcí, které umožňují provádět matematické operace uvnitř projektu.
abs#
abs vrací absolutní hodnotu čísla bez záporného znaménka.
Usage:
abs(x)
Parametr |
Popis |
|---|---|
|
Celé číslo nebo číslo s plovoucí desetinnou čárkou. |
# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)
# abs_result = 10
round#
round vrací zaokrouhlené číslo na zadaný počet desetinných míst jako celé číslo.
Usage:
round(x, ndigits)
Parametr |
Popis |
|---|---|
|
Celé číslo nebo číslo s plovoucí desetinnou čárkou. |
|
Volitelné. Určuje, na kolik desetinných míst se má zaokrouhlit (mezi 0 a 5). Výchozí hodnota je 0. Při použití tohoto parametru vrátí funkce |
# 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 vrací nejmenší hodnotu z více argumentů nebo iterovatelného objektu.
Usage:
min(arg1, arg2, …) or min(sequence)
Parametr |
Popis |
|---|---|
|
Čísla k porovnání. |
|
Seznam, n-tice nebo jiná posloupnost obsahující čísla. |
# 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 vrací největší hodnotu z více argumentů nebo iterovatelného objektu.
Usage:
max(arg1, arg2, …) or max(sequence)
Parametr |
Popis |
|---|---|
|
Čísla k porovnání. |
|
Seznam, n-tice nebo jiná posloupnost obsahující čísla. |
# 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#
Funkce sum sečte všechny hodnoty v iterovatelném objektu s volitelnou počáteční hodnotou.
Usage:
sum(sequence, start)
Parametr |
Popis |
|---|---|
|
Seznam, n-tice nebo jiná posloupnost obsahující čísla. |
|
Volitelné. Hodnota, která se má přičíst k součtu. Výchozí hodnota je 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 vrací n-tici obsahující podíl a zbytek operace dělení.
Usage:
divmod(a, b)
Parametr |
Popis |
|---|---|
|
Dividenda. |
|
Dělitel. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow vrací číslo umocněné na danou mocninu a volitelně provádí operaci s modulem jako celé číslo.
Usage:
pow(x, y, mod)
Parametr |
Popis |
|---|---|
|
Základní číslo. |
|
Exponent. |
|
Volitelné. Hodnota modulu. Pokud je zadána, vrátí |
# 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 převede číslo nebo řetězec na celé číslo. Podporuje také převod základů při převodu z řetězce.
Usage:
int(x, base)
Parametr |
Popis |
|---|---|
|
Číslo, řetězec nebo jiný objekt, který má být převeden. |
|
Volitelné. Číselný základ, který se má použít pro převod. Výchozí hodnota je 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 převede číslo nebo řetězec na číslo s plovoucí desetinnou čárkou.
Usage:
float(x)
Parametr |
Popis |
|---|---|
|
Číslo, řetězec nebo jiný objekt, který má být převeden. |
# 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
Matematický modul#
Modul math v MicroPythonu poskytuje další metody pro provádění běžných matematických výpočtů. Mezi tyto metody patří trigonometrické, logaritmické a další numerické operace.
Modul math je ve VEXcode importován standardně.
Constants#
Konstanty jsou předdefinované hodnoty, které zůstávají během projektu neměnné. Lze je použít ve výpočtech bez nutnosti jakékoli definice nebo přiřazení.
pí#
pi udává matematickou konstantu π, poměr obvodu kruhu k jeho průměru.
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 dává hodnotu 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
E#
e udává základ přirozeného logaritmu.
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
informace#
inf dává kladné nekonečno jako číslo s plovoucí čárkou.
Usage:
math.inf
# Check if infinity is infinite
inf_value = math.inf
if math.isinf(inf_value):
controller.screen.print("Infinity")
# Prints "Infinity"
babička#
nan představuje speciální číslo s plovoucí čárkou pro “Není číslo” (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#
hřích#
sin vypočítá sinus úhlu v radiánech a vrátí číslo s desetinnou čárkou.
Usage:
math.sin(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující úhel v radiánech. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
cos#
Funkce cos vypočítá kosinus úhlu v radiánech a vrátí číslo s desetinnou čárkou.
Usage:
math.cos(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující úhel v radiánech. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
opálení#
Funkce tan vypočítá tangens úhlu v radiánech a vrátí číslo s desetinnou čárkou.
Usage:
math.tan(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující úhel v radiánech. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
asin#
Funkce asin vypočítá inverzní sinus (arkus sinus) čísla a vrátí číslo s desetinnou čárkou, které představuje úhel v radiánech.
Usage:
math.asin(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo mezi -1 a 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
ACOS#
acos vypočítá inverzní kosinus (arkuskosinus) čísla a vrátí číslo s desetinnou čárkou představující úhel v radiánech.
Usage:
>math.acos(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo mezi -1 a 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
atan#
Funkce atan vypočítá inverzní tangens (arkustangens) čísla a vrátí číslo s desetinnou čárkou, které představuje úhel v radiánech.
Usage:
math.atan(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# 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 vypočítá hlavní hodnotu inverzního tangensu osy y/x a vrátí číslo s desetinnou čárkou reprezentující úhel v radiánech.
Usage:
math.atan2(y, x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující souřadnici y. |
|
Číslo s desetinnou čárkou nebo celé číslo představující souřadnici x. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
stupňů#
degrees převede úhel z radiánů na stupně.
Usage:
math.degrees(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující úhel v radiánech. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
radiány#
radians převede úhel ze stupňů na radiány.
Usage:
math.radians(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující úhel ve stupních. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)
# radians_result = 3.14159
Hyperbolics#
sinh#
sinh vypočítá hyperbolický sinus x.
Usage:
math.sinh(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
šmejd#
Funkce cosh vypočítá hyperbolický kosinus čísla x.
Usage:
math.cosh(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
tanh#
tanh vypočítá hyperbolický tangens událiče x.
Usage:
math.tanh(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh vypočítá inverzní hyperbolický sinus čísla x.
Usage:
math.asinh(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
akoš#
Funkce acosh vypočítá inverzní hyperbolický kosinus čísla x.
Usage:
math.acosh(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo větší nebo rovno 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
atanh#
atanh vypočítá inverzní hyperbolický tangens událače x.
Usage:
math.atanh(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou mezi -1 a 1 (exkluzivně). |
# 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#
strop#
ceil zaokrouhlí číslo nahoru na nejbližší celé číslo.
Usage:
math.ceil(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo, které má být zaokrouhleno nahoru. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)
# ceil_result = 4
patro#
floor zaokrouhlí číslo dolů na nejbližší celé číslo.
Usage:
math.floor(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo, které se má zaokrouhlit dolů. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)
# floor_result = 3
kmen#
trunc odstraní desetinnou část čísla bez zaokrouhlení.
Usage:
math.trunc(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí … |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)
# trunc_result = 3
továrny#
fabs vrací absolutní hodnotu čísla jako desetinné číslo.
Usage:
math.fabs(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# 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 umocní x na y (xy) a vrátí číslo s plovoucí desetinnou čárkou.
Usage:
math.pow(x, y)
Parametr |
Popis |
|---|---|
|
Základ s plovoucí desetinnou čárkou nebo celočíselným číslem. |
|
Celočíselný nebo float exponent. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)
# power_result = 8.00000
čtvereční#
Funkce sqrt vypočítá druhou odmocninu z čísla a vrátí hodnotu typu float.
Usage:
math.sqrt(x)
Parametr |
Popis |
|---|---|
|
Nezáporné číslo s desetinnou čárkou nebo celé číslo. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp vrací e umocněné na x (ex) a jako číslo s desetinnou čárkou.
Usage:
math.exp(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
protokol#
Funkce log vypočítá přirozený logaritmus čísla a vrátí hodnotu typu float.
Usage:
math.log(x)
Parametr |
Popis |
|---|---|
|
Kladné číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# 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 vypočítá desátkový logaritmus čísla a vrátí číslo s desetinnou čárkou.
Usage:
math.log10(x)
Parametr |
Popis |
|---|---|
|
Kladné číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
Funkce log2 vypočítá logaritmus čísla se základem 2 a vrátí číslo s desetinnou čárkou, a to i v případě, že x je mocnina čísla 2.
Usage:
math.log2(x)
Parametr |
Popis |
|---|---|
|
Kladné číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)
# log2_result = 3.00000
faktoriál#
Funkce faktoriál factorial vrací faktoriál celého čísla x, což je součin všech kladných celých čísel až do x.
Usage:
math.factorial(x)
Parametr |
Popis |
|---|---|
|
Nezáporné celé číslo. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 vypočítá ex - 1, což je přesnější pro malé x.
Usage:
math.expm1(x)
Parametr |
Popis |
|---|---|
|
Hodnota exponentu. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
Floating Point Operations#
modf#
modf rozloží číslo na zlomkovou a celočíselnou část a vrátí n-tici (fractional part, integer part), obě jako čísla s desetinnou čárkou.
Usage:
math.modf(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo, které se má rozložit. |
# 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#
Funkce frexp rozloží číslo na mantissu a exponent a vrátí n-tici (mantissa, exponent), kde mantisa je číslo s desetinnou čárkou a exponent je celé číslo.
Usage:
math.frexp(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo, které se má rozložit. |
# 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#
Funkce fmod vrací zbytek po dělení se zachováním znaménka dělence (x).
Usage:
math.fmod(x, y)
Parametr |
Popis |
|---|---|
|
Dividenda. |
|
Dělitel. |
# 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
autorský podpis#
copysign vrací x se znaménkem y.
Usage:
math.copysign(x, y)
Parametr |
Popis |
|---|---|
|
Hodnota, která má být upravena. |
|
Hodnota, jejíž znaménko bude zkopírováno. |
# 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 vypočítá x * (2 ** exp), což je ekvivalentní x * 2exp.
Usage:
math.ldexp(x, exp)
Parametr |
Popis |
|---|---|
|
Základní hodnota. |
|
Exponent. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
je nekonečný#
isfinite kontroluje, zda je číslo konečné. Tato metoda vrací booleovskou hodnotu:
True- Číslo je konečné.False- Číslo je nekonečné.
Usage:
math.isfinite(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo, které se má zkontrolovat. |
# 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 kontroluje, zda je číslo nekonečné. Tato metoda vrací booleovskou hodnotu:
True- Číslo je nekonečné.False- Číslo je konečné.
Usage:
math.isinf(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo, které se má zkontrolovat. |
# 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
isnan#
isnan kontroluje, zda je číslo NaN (není číslo). Tato metoda vrací booleovskou hodnotu:
True- Číslo je NaN.False- Číslo je platné.
Usage:
math.isnan(x)
Parametr |
Popis |
|---|---|
|
Číslo s plovoucí desetinnou čárkou nebo celé číslo, které se má zkontrolovat. |
# 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#
Funkce gamma vypočítá gama funkci x, která zobecňuje faktoriálovou funkci pro reálná a komplexní čísla. Pro celé číslo n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parametr |
Popis |
|---|---|
|
Kladné číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
lgama#
Funkce lgamma vypočítá přirozený logaritmus funkce gamma.
Usage:
math.lgamma(x)
Parametr |
Popis |
|---|---|
|
Kladné číslo s plovoucí desetinnou čárkou nebo celé číslo. |
# 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 vypočítá chybovou funkci x.
Usage:
math.erf(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)
# erf_result = 0.84270
erfc#
erfc computes the complementary error function of x, which is defined as 1 - erf(x).
Usage:
math.erfc(x)
Parametr |
Popis |
|---|---|
|
Číslo s desetinnou čárkou nebo celé číslo představující vstupní hodnotu. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)
# erfc_result = 0.15730