Matemātika#
Ievads#
Math ietver gan iebūvētas Python funkcijas, gan pilnu math moduli, kas ir automātiski pieejams VEXcode AIM. Šie rīki ļauj veikt visu, sākot no pamata aritmētikas līdz pat sarežģītākām trigonometrijas, noapaļošanas un logaritmiskām darbībām.
Izmantojiet šīs funkcijas un konstantes, lai aprēķinātu robota pozīcijas, leņķus, attālumus un citas skaitliskās vērtības. Varat arī konvertēt starp grādiem un radiāniem, novērtēt izteiksmes un strādāt ar īpašām vērtībām, piemēram, bezgalību un NaN.
Zemāk ir pieejamo matemātisko funkciju, konstantu un utilītu saraksts:
Iebūvētās funkcijas — izplatīti matemātikas rīki, kas iekļauti Python valodā.
abs– Atgriež skaitļa absolūto vērtību.round– Noapaļo skaitli līdz norādītajam decimālzīmju skaitam.min– Atgriež mazāko no ievades vērtībām.max– Atgriež lielāko no ievades vērtībām.sum– Saskaita visas iterējamā objekta vērtības.divmod– Atgriež dalījumu un atlikumu kā kortežu.pow– Kāpina skaitli noteiktā pakāpē, pēc izvēles ar moduli.int– Pārvērš vērtību par veselu skaitli.float– Pārvērš vērtību par peldošā komata skaitli.
Konstantes – iepriekš definētas vērtības no math moduļa.
math.pi– Konstante π (pi).math.tau– Konstante tau (2π).math.e– Eilera skaitlis, naturālā logaritma bāze.math.inf– Pozitīva bezgalība.math.nan— nav skaitlis (NaN).
Trigonometrija — aprēķiniet leņķus un attiecības starp malām.
math.sin– Leņķa sinuss radiānos.math.cos– Leņķa kosinuss radiānos.math.tan– Leņķa pieskare radiānos.math.atan– Radiānos izteiktas vērtības arktangenss.math.atan2– y/x arktangens radiānos, ņemot vērā kvadrantu.math.asin– Radiānos norādītas vērtības arksinuss.math.acos– Radiānos norādītas vērtības arkkosinuss.math.degrees– Pārvērš radiānus grādos.math.radians– Pārvērš grādus radiānos.
Hiperbolika – uzlabotas trigonometriskās funkcijas.
math.sinh– Vērtības hiperboliskais sinuss.math.cosh– Vērtības hiperboliskais kosinuss.math.tanh– Vērtības hiperboliskais tangenss.math.asinh– Apgrieztais hiperboliskais sinuss.math.acosh– Apgrieztais hiperboliskais kosinuss.math.atanh– Apgrieztais hiperboliskais tangenss.
Noapaļošana un absolūtā vērtība — pielāgojiet precizitāti vai virzienu.
math.ceil– Noapaļo uz augšu līdz tuvākajam veselajam skaitlim.math.floor– Noapaļo uz leju līdz tuvākajam veselajam skaitlim.math.trunc– Noņem decimāldaļu.math.fabs– Atgriež absolūto vērtību kā peldošo skaitli.
Pakāpes rādītāji un logaritmi – pakāpes, saknes un logaritma aprēķini.
math.pow– Kāpina skaitli noteiktā pakāpē.math.sqrt– Atgriež kvadrātsakni.math.exp– Aprēķina e kāpināšanu x pakāpē.math.log– Naturālais logaritms (bāze e).math.log10– desmitdaļu logaritms.math.log2– 2. bāzes logaritms.math.factorial– Vesela skaitļa faktoriāls.math.expm1– Precīzāks rezultāts formulaie^x - 1.
Peldošā komata operācijas — pārbaudiet vai sadaliet peldošā komata vērtības.
math.modf– Atgriež peldošā skaitļa daļskaitļa un veselo skaitli.math.frexp– Sadala skaitli mantisā un eksponentē.math.fmod– Atlikums ar dalāmā zīmi.math.copysign– Atgriež vērtību ar citas vērtības zīmi.math.ldexp– Computesx * (2 ** exp).
Salīdzināšana un tuvināšana — pārbaudiet vērtības ar pielaidēm vai kategorijām.
math.isclose– Pārbauda, vai divas vērtības ir aptuveni vienādas.math.isfinite– Pārbauda, vai skaitlis ir galīgs.math.isinf– Pārbauda, vai skaitlis ir bezgalīgs.math.isnan– Pārbauda, vai vērtība ir NaN.
Kļūda un gamma – īpašas matemātiskas funkcijas.
math.gamma– Gamma funkcija (vispārināts faktoriāls).math.lgamma– Logaritmiskā gamma.math.erf– Kļūdas funkcija.math.erfc– Papildinošā kļūdas funkcija.
Iebūvētās funkcijas#
Python nodrošina vairākas iebūvētas funkcijas, kas ļauj veikt matemātiskas darbības projekta ietvaros.
abs#
abs atgriež skaitļa absolūto vērtību, noņemot jebkuru negatīvo zīmi.
Usage:
abs(x)
Parametrs |
Apraksts |
|---|---|
|
Vesels skaitlis vai peldošs skaitlis. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round noapaļo skaitli līdz norādītajam decimālzīmju skaitam.
Usage:
round(x, ndigits)
Parametrs |
Apraksts |
|---|---|
|
Vesels skaitlis vai peldošs skaitlis. |
|
Neobligāti. Decimālzīmju skaits, līdz kuram jānoapaļo. Noklusējuma vērtība ir 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 atgriež mazāko vērtību no vairākiem argumentiem vai iterējama.
Usage:
min(arg1, arg2, …) or min(sequence)
Parametrs |
Apraksts |
|---|---|
|
Skaitļi, ar ko salīdzināt. |
|
Saraksts, kortežs vai cita secība, kas satur skaitļus. |
# 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 atgriež lielāko vērtību no vairākiem argumentiem vai iterējamas vērtības.
Usage:
max(arg1, arg2, …) or max(sequence)
Parametrs |
Apraksts |
|---|---|
|
Skaitļi, ar ko salīdzināt. |
|
Saraksts, kortežs vai cita secība, kas satur skaitļus. |
# 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 saskaita visas iterējamā objekta vērtības ar izvēles sākuma vērtību.
Usage:
sum(sequence, start)
Parametrs |
Apraksts |
|---|---|
|
Saraksts, kortežs vai cita secība, kas satur skaitļus. |
|
Neobligāti. Vērtība, kas jāpieskaita summai. Noklusējuma vērtība ir 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 atgriež kortežu, kas satur dalīšanas operācijas dalījumu un atlikumu.
Usage:
divmod(a, b)
Parametrs |
Apraksts |
|---|---|
|
Dividende. |
|
Dalītājs. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow kāpina skaitli pakāpē un pēc izvēles veic moduļa darbību.
Usage:
pow(x, y, mod)
Parametrs |
Apraksts |
|---|---|
|
Bāzes skaitlis. |
|
Eksponents. |
|
Neobligāti. Moduļa vērtība. Ja norādīta, atgriež |
# 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 konvertē skaitli vai virkni par veselu skaitli. Tā atbalsta arī bāzes konvertēšanu, konvertējot no virknes.
Usage:
int(x, base)
Parametrs |
Apraksts |
|---|---|
|
Skaitlis, virkne vai cits objekts, kas jāpārveido. |
|
Neobligāti. Skaitļu bāze, kas jāizmanto konvertēšanai. Noklusējuma vērtība ir 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 pārveido skaitli vai virkni par peldošā komata skaitli.
Usage:
float(x)
Parametrs |
Apraksts |
|---|---|
|
Skaitlis, virkne vai cits objekts, kas jāpārveido. |
# 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
Matemātikas modulis#
MicroPython math modulis nodrošina papildu metodes bieži sastopamu matemātisko aprēķinu veikšanai. Šīs metodes ietver trigonometriskās, logaritmiskās un citas skaitliskās darbības.
Modulis math pēc noklusējuma tiek importēts VEXcode.
Constants#
Konstantes ir iepriekš definētas vērtības, kas projekta laikā paliek nemainīgas. Tās var izmantot aprēķinos bez nepieciešamības pēc definīcijas vai piešķiršanas.
pī#
pi norāda matemātisko konstanti π, apļa apkārtmēra attiecību pret tā diametru.
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 dod 2π vērtību.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)
# circumference = 31.42
e#
e dod naturālā logaritma bāzi.
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
informācija#
inf dod pozitīvu bezgalību kā peldošo skaitli.
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 apzīmē īpašu peldošo skaitli “Nav skaitlis” (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#
grēks#
sin aprēķina leņķa sinusu radiānos un atgriež peldošo skaitli.
Usage:
math.sin(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo leņķi radiānos. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)
# sine_result = 0.50
jo#
cos aprēķina leņķa kosinusu radiānos un atgriež peldošo skaitli.
Usage:
math.cos(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo leņķi radiānos. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
iedegums#
tan aprēķina leņķa tangensu radiānos un atgriež peldošo skaitli.
Usage:
math.tan(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo leņķi radiānos. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
robot.screen.print(tangent_result)
# tangent_result = 1.00
Atans#
atan aprēķina skaitļa apgriezto tangensu (arktangensu) un atgriež peldošo skaitli, kas attēlo leņķi radiānos.
Usage:
math.atan(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis. |
# 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 aprēķina y/x apgrieztā tangensa galveno vērtību un atgriež peldošo skaitli, kas attēlo leņķi radiānos.
Usage:
math.atan2(y, x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo y koordinātu. |
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo x koordinātu. |
# 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
muļķis#
asin aprēķina skaitļa apgriezto sinusu (arksinusu) un atgriež peldošo skaitli, kas attēlo leņķi radiānos.
Usage:
math.asin(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis no -1 līdz 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
akos#
acos aprēķina skaitļa apgriezto kosinusu (arkkosinusu) un atgriež peldošo skaitli, kas attēlo leņķi radiānos.
Usage:
math.acos(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis no -1 līdz 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
grādi#
degrees konvertē leņķi no radiāniem uz grādiem.
Usage:
math.degrees(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo leņķi radiānos. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radiāni#
radians konvertē leņķi no grādiem uz radiāniem.
Usage:
math.radians(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas attēlo leņķi grādos. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh aprēķina x hiperbolisko sinusu.
Usage:
math.sinh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
lēts#
cosh aprēķina x hiperbolisko kosinusu.
Usage:
math.cosh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh aprēķina x hiperbolisko tangensu.
Usage:
math.tanh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
Āzija#
asinh aprēķina x apgriezto hiperbolisko sinusu.
Usage:
math.asinh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
akoss#
acosh aprēķina x apgriezto hiperbolisko kosinusu.
Usage:
math.acosh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis, kas lielāks vai vienāds ar 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh aprēķina x apgriezto hiperbolisko tangensu.
Usage:
math.atanh(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis starp -1 un 1 (neierobežojoši). |
# 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#
griesti#
ceil noapaļo skaitli uz augšu līdz tuvākajam veselajam skaitlim.
Usage:
math.ceil(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas jānoapaļo uz augšu. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
grīda#
floor noapaļo skaitli uz leju līdz tuvākajam veselajam skaitlim.
Usage:
math.floor(x)
Parametrs |
Apraksts |
|---|---|
|
Pludiņskaitlis vai vesels skaitlis, kas jānoapaļo uz leju. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
saīsinājums#
trunc noņem skaitļa decimāldaļu bez noapaļošanas.
Usage:
math.trunc(x)
Parametrs |
Apraksts |
|---|---|
|
Apcirpšanai paredzēts pludiņskaitlis. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs atgriež skaitļa absolūto vērtību kā peldošo skaitli.
Usage:
math.fabs(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
pulveris#
pow kāpina x y pakāpē un atgriež peldošo skaitli, pat ja abas ievades vērtības ir veseli skaitļi.
Usage:
math.pow(x, y)
Parametrs |
Apraksts |
|---|---|
|
Pludiņa vai vesela skaitļa bāze. |
|
Peldošs vai vesels skaitlis. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
kvadrātmetrs#
Funkcija sqrt aprēķina skaitļa kvadrātsakni un atgriež peldošo skaitli pat perfektiem kvadrātiem.
Usage:
math.sqrt(x)
Parametrs |
Apraksts |
|---|---|
|
Nenegatīvs peldošs skaitlis vai vesels skaitlis. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
pieredze#
exp aprēķina skaitļa eksponenci un atgriež peldošo skaitli.
Usage:
math.exp(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
žurnāls#
log aprēķina skaitļa naturālo logaritmu un atgriež peldošo skaitli.
Usage:
math.log(x)
Parametrs |
Apraksts |
|---|---|
|
Pozitīvs peldošs skaitlis vai vesels skaitlis. |
# 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 aprēķina skaitļa desmitdaļlogaritmu un atgriež peldošo skaitli.
Usage:
math.log10(x)
Parametrs |
Apraksts |
|---|---|
|
Pozitīvs peldošs skaitlis vai vesels skaitlis. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
log2 aprēķina skaitļa divpakāpju logaritmu un atgriež peldošo skaitli, pat ja x ir 2 pakāpe.
Usage:
math.log2(x)
Parametrs |
Apraksts |
|---|---|
|
Pozitīvs peldošs skaitlis vai vesels skaitlis. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
faktoriāls#
factorial atgriež vesela skaitļa xfaktoriālu, kas ir visu pozitīvo veselo skaitļu līdz x reizinājums.
Usage:
math.factorial(x)
Parametrs |
Apraksts |
|---|---|
|
Nenegatīvs vesels skaitlis. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 aprēķina ex - 1, kas ir precīzāks maziem x.
Usage:
math.expm1(x)
Parametrs |
Apraksts |
|---|---|
|
Eksponenta vērtība. |
# 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 sadala skaitli tā daļskaitļa un vesela skaitļa daļās un atgriež kortežu (fractional part, integer part), abus kā peldošos skaitļus.
Usage:
math.modf(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis sadalīšanai. |
# 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 sadala skaitli tā mantisā un eksponentā un atgriež kortežu (mantissa, exponent), kur mantisa ir peldošā vērtība un eksponents ir vesels skaitlis.
Usage:
math.frexp(x)
Parametrs |
Apraksts |
|---|---|
|
Peldskaitlis vai vesels skaitlis sadalīšanai. |
# 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 atgriež dalīšanas atlikumu, saglabājot dalāmā zīmi (x).
Usage:
math.fmod(x, y)
Parametrs |
Apraksts |
|---|---|
|
Dividende. |
|
Dalītājs. |
# 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
autortiesību paraksts#
copysign atgriež x ar y zīmi.
Usage:
math.copysign(x, y)
Parametrs |
Apraksts |
|---|---|
|
Vērtība, kas jāmodificē. |
|
Vērtība, kuras zīme tiks kopēta. |
# 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 aprēķina x * (2 ** exp), kas ir līdzvērtīgs x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parametrs |
Apraksts |
|---|---|
|
Bāzes vērtība. |
|
Eksponents. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
ir tuvu#
isclose pārbauda, vai divi skaitļi ir aptuveni vienādi pielaides robežās.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parametrs |
Apraksts |
|---|---|
|
Pirmais salīdzinājumam nepieciešamais skaitlis. |
|
Otrais salīdzināšanas skaitlis. |
|
Neobligāti. Maksimāli pieļaujamā atšķirība starp a un b attiecībā pret to lielumu. Noklusējuma vērtība ir 1e-09 (ļoti maza). |
|
Neobligāti. Fiksēta kļūdas robeža, kas noderīga, salīdzinot skaitļus, kas ir tuvu nullei. Noklusējuma vērtība ir 0,0. |
Piezīme: Ja ir norādīti gan rel_tol , gan abs_tol , rezultātu nosaka tas nosacījums, kas tiek izpildīts pirmais.
# 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
bezgalīgs#
isfinite pārbauda, vai skaitlis ir galīgs. Šī metode atgriež Būla vērtību:
True– Skaitlis ir galīgs.False– Skaitlis ir bezgalīgs.
Usage:
math.isfinite(x)
Parametrs |
Apraksts |
|---|---|
|
Pārbaudāms peldošs skaitlis vai vesels skaitlis. |
# 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 pārbauda, vai skaitlis ir bezgalīgs. Šī metode atgriež Būla vērtību:
True– Skaitlis ir bezgalīgs.False– Skaitlis ir galīgs.
Usage:
math.isinf(x)
Parametrs |
Apraksts |
|---|---|
|
Pārbaudāms peldošs skaitlis vai vesels skaitlis. |
# 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 pārbauda, vai skaitlis ir NaN (nav skaitlis). Šī metode atgriež Būla vērtību:
True– Skaitlis ir NaN.False– Skaitlis ir derīgs skaitlis.
Usage:
math.isnan(x)
Parametrs |
Apraksts |
|---|---|
|
Pārbaudāms peldošs skaitlis vai vesels skaitlis. |
# 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 aprēķina xgamma funkciju, kas vispārina faktoriālo funkciju reāliem un kompleksiem skaitļiem. Veselam skaitlim n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parametrs |
Apraksts |
|---|---|
|
Pozitīvs peldošs skaitlis vai vesels skaitlis. |
# 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 aprēķina funkcijas gamma naturālo logaritmu.
Usage:
math.lgamma(x)
Parametrs |
Apraksts |
|---|---|
|
Pozitīvs peldošs skaitlis vai vesels skaitlis. |
# 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 aprēķina x kļūdas funkciju.
Usage:
math.erf(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc aprēķina xkomplementāro kļūdas funkciju, kas ir definēta kā 1 - erf(x).
Usage:
math.erfc(x)
Parametrs |
Apraksts |
|---|---|
|
Peldošs skaitlis vai vesels skaitlis, kas apzīmē ievades vērtību. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16