Matemātika#
Ievads#
Math ietver gan iebūvētas Python funkcijas, gan pilnu math moduli, kas ir automātiski pieejams VEXcode AIR. Š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 pozīcijas, leņķus, attālumus un citas skaitliskās vērtības VEX AIR drona kontrolierim. 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.
Piezīme: Ja vien nav skaidri norādīts citādi, visas atgrieztās vērtības ir peldošās vērtības, kas formatētas ar precīzi piecām zīmēm aiz komata. Vērtības ar vairāk nekā piecām zīmēm aiz komata tiek noapaļotas, un vērtības ar mazāk nekā piecām zīmēm aiz komata tiek papildinātas ar nullēm, lai vienmēr tiktu parādītas tieši piecas zīmes aiz komata.
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.asin– Radiānos norādītas vērtības arksinuss.math.acos– Radiānos norādītas vērtības arkkosinuss.math.atan– Radiānos izteiktas vērtības arktangenss.math.atan2– y/x arktangens radiānos, ņemot vērā kvadrantu.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.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)
controller.screen.print(abs_result)
# abs_result = 10
round#
round atgriež noapaļotu skaitli līdz norādītajam decimālzīmju skaitam kā veselu skaitli.
Usage:
round(x, ndigits)
Parametrs |
Apraksts |
|---|---|
|
Vesels skaitlis vai peldošs skaitlis. |
|
Neobligāti. Nosaka, līdz cik zīmēm aiz komata jānoapaļo (no 0 līdz 5). Noklusējuma vērtība ir 0. Ja tiek izmantots šis parametrs, |
# 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 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)
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 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)
controller.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.screen.print(max_list_result)
# max_list_result = 25
sum#
sum 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])
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 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)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow atgriež skaitli, kas kāpināts pakāpē, un pēc izvēles veic moduļa darbību kā veselu skaitli.
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)
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 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)
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ā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
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
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
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau dod 2π vērtību.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
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)
controller.screen.print(e_power)
# e_power = 7.38906
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):
controller.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):
controller.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 |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
jo#
cos aprēķina leņķa kosinusu radiānos un atgriež peldošo skaitli.
Usage:
math.cos(x)
Parametrs |
Apraksts |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
iedegums#
tan aprēķina leņķa tangensu radiānos un atgriež peldošo skaitli.
Usage:
math.tan(x)
Parametrs |
Apraksts |
|---|---|
|
A float or integer representing an angle in radians. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
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 radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
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 radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
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 radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
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 apzīmē x koordinātu. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
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)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
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)
controller.screen.print(radians_result)
# radians_result = 3.14159
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)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
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)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
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)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
Ā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)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
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)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
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)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
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)
controller.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)
controller.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)
controller.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)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
pulveris#
pow kāpina x y (xy) pakāpē un atgriež peldošo skaitli.
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)
controller.screen.print(power_result)
# power_result = 8.00000
kvadrātmetrs#
sqrt aprēķina skaitļa kvadrātsakni un atgriež peldošo skaitli.
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)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
pieredze#
exp atgriež e, kas kāpināta x pakāpē (ex), un kā 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)
controller.screen.print(exp_result)
# exp_result = 2.71828
ž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)
controller.screen.print(log_result)
# log_result = 2.00000
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)
controller.screen.print(log10_result)
# log10_result = 3.00000
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)
controller.screen.print(log2_result)
# log2_result = 3.00000
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)
controller.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)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
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)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
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)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# 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)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
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)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp aprēķina x * (2 ** exp), kas ir līdzvērtīgs x * 2exp.
Usage:
math.ldexp(x, exp)
Parametrs |
Apraksts |
|---|---|
|
Bāzes vērtība. |
|
Eksponents. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
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)
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 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)
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 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)
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#
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)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
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)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
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)
controller.screen.print(erf_result)
# erf_result = 0.84270
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)
controller.screen.print(erfc_result)
# erfc_result = 0.15730