Matematiikka#
Johdanto#
Math sisältää sekä sisäänrakennettuja Python-funktioita että täyden math -moduulin, joka on automaattisesti saatavilla VEXcode AIM:ssä. Näiden työkalujen avulla voit suorittaa kaikkea perusaritmetiikasta edistyneeseen trigonometriaan, pyöristämiseen ja logaritmisiin operaatioihin.
Käytä näitä funktioita ja vakioita robottisi sijaintien, kulmien, etäisyyksien ja muiden numeeristen arvojen laskemiseen. Voit myös muuntaa asteita radiaaneiksi ja päinvastoin, laskea lausekkeita ja työskennellä erikoisarvojen, kuten äärettömyyden ja NaN:n, kanssa.
Alla on luettelo käytettävissä olevista matemaattisista funktioista, vakioista ja apuohjelmista:
Sisäänrakennetut funktiot – Yleisiä Pythonin mukana tulevia matemaattisia työkaluja.
abs– Palauttaa luvun itseisarvon.round– Pyöristää luvun määritettyyn desimaalien määrään.min– Palauttaa pienimmän syötearvoista.max– Palauttaa syötetyistä arvoista suurimman.sum– Laskee yhteen kaikki iteroitavan yksikön arvot.divmod– Palauttaa osamäärän ja jakojäännöksen tuplena.pow– Korottaa luvun potenssiin, valinnaisesti jakauman kanssa.int– Muuntaa arvon kokonaisluvuksi.float– Muuntaa arvon liukulukuksi.
Vakiot – math -moduulin ennalta määritetyt arvot.
math.pi– Vakio π (pii).math.tau– Vakio tau(2π).math.e– Eulerin luku, luonnollisen logaritmin kantaluku.math.inf– Positiivinen ääretön.math.nan– Ei numero (NaN).
Trigonometria – Laske kulmia ja sivujen välisiä suhteita.
math.sin– Kulman sini radiaaneina.math.cos– Kulman kosini radiaaneina.math.tan– Kulman tangentti radiaaneina.math.atan– Radiaaneina annetun arvon arcustangentti.math.atan2– y/x:n arcustangentti radiaaneina ottaen huomioon kvadrantin.math.asin– Radiaaneina annetun arvon arcussini.math.acos– Radiaaneina annetun arvon arkuskosini.math.degrees– Muuntaa radiaanit asteiksi.math.radians– Muuntaa asteet radiaaneiksi.
Hyperboliset jakaumat – Edistyneet trigonometriaan liittyvät funktiot.
math.sinh– Arvon hyperbolinen sini.math.cosh– Arvon hyperbolinen kosini.math.tanh– Arvon hyperbolinen tangentti.math.asinh– Käänteinen hyperbolinen sini.math.acosh– Käänteinen hyperbolinen kosini.math.atanh– Käänteinen hyperbolinen tangentti.
Pyöristäminen ja itseisarvo – Säädä tarkkuutta tai suuntaa.
math.ceil– Pyöristää ylöspäin lähimpään kokonaislukuun.math.floor– Pyöristää alaspäin lähimpään kokonaislukuun.math.trunc– Poistaa desimaaliosan.math.fabs– Palauttaa itseisarvon liukulukuna.
Eksponentit ja logaritmit – Potenssi-, juuri- ja logaritmilaskutoimitukset.
math.pow– Korottaa luvun potenssiin.math.sqrt– Palauttaa neliöjuuren.math.exp– Laskee e:n potenssiin x.math.log– Luonnollinen logaritmi (kantaluku e).math.log10– Kymmenkantainen logaritmi.math.log2– 2-kantainen logaritmi.math.factorial– Kokonaisluvun kertoma.math.expm1– Tarkempi tulos funktiollee^x - 1.
Liukulukuoperaatiot – Tarkista tai jaa liukulukujen arvot.
math.modf– Palauttaa liukulukun murto- ja kokonaislukuosan.math.frexp– Jakaa luvun mantissaksi ja eksponentiksi.math.fmod– Jaettavan etumerkillä varustettu jakojäännös.math.copysign– Palauttaa arvon, jonka etumerkki on jokin toinen.math.ldexp– Laskeex * (2 ** exp).
Vertailu ja approksimaatio – Tarkista arvot toleranssien tai luokkien avulla.
math.isclose– Testaa, ovatko kaksi arvoa suunnilleen yhtä suuret.math.isfinite– Tarkistaa, onko luku äärellinen.math.isinf– Tarkistaa, onko luku ääretön.math.isnan– Tarkistaa, onko arvo NaN.
Virhe ja gamma – Erikoismatemaattiset funktiot.
math.gamma– Gammafunktio (yleistetty kertoma).math.lgamma– Logaritminen gamma.math.erf– Virhefunktio.math.erfc– Komplementaarinen virhefunktio.
Sisäänrakennetut funktiot#
Python tarjoaa useita sisäänrakennettuja funktioita, joiden avulla voit suorittaa matemaattisia laskutoimituksia projektisi sisällä.
abs#
abs palauttaa luvun itseisarvon poistaen kaikki negatiiviset etumerkit.
Usage:
abs(x)
Parametri |
Kuvaus |
|---|---|
|
Kokonaisluku tai liukuluku. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round pyöristää luvun tiettyyn desimaalien määrään.
Usage:
round(x, ndigits)
Parametri |
Kuvaus |
|---|---|
|
Kokonaisluku tai liukuluku. |
|
Valinnainen. Desimaalien määrä, johon pyöristetään. Oletusarvo on 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 palauttaa pienimmän arvon useista argumenteista tai iteroitavasta joukosta.
Usage:
min(arg1, arg2, …) or min(sequence)
Parametri |
Kuvaus |
|---|---|
|
Vertailun arvoiset luvut. |
|
Lista, tuple tai muu numeroita sisältävä sekvenssi. |
# 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 palauttaa suurimman arvon useista argumenteista tai iteroitavasta joukosta.
Usage:
max(arg1, arg2, …) or max(sequence)
Parametri |
Kuvaus |
|---|---|
|
Vertailun arvoiset luvut. |
|
Lista, tuple tai muu numeroita sisältävä sekvenssi. |
# 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 laskee yhteen kaikki iteroitavan objektin arvot ja antaa valinnaisen aloitusarvon.
Usage:
sum(sequence, start)
Parametri |
Kuvaus |
|---|---|
|
Lista, tuple tai muu numeroita sisältävä sekvenssi. |
|
Valinnainen. Summaan lisättävä arvo. Oletusarvo on 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 palauttaa tuplen, joka sisältää jakolaskun osamäärän ja jakojäännöksen.
Usage:
divmod(a, b)
Parametri |
Kuvaus |
|---|---|
|
Osinko. |
|
Jakaja. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow korottaa luvun potenssiin ja suorittaa valinnaisesti modulo-operaation.
Usage:
pow(x, y, mod)
Parametri |
Kuvaus |
|---|---|
|
Perusnumero. |
|
Eksponentti. |
|
Valinnainen. Moduulin arvo. Jos annettu, palauttaa arvon |
# 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 muuntaa luvun tai merkkijonon kokonaisluvuksi. Se tukee myös kantalukumuunnosta merkkijonosta muunnettaessa.
Usage:
int(x, base)
Parametri |
Kuvaus |
|---|---|
|
Muunnettava numero, merkkijono tai muu objekti. |
|
Valinnainen. Muunnoksessa käytettävä lukukanta. Oletusarvo on 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 muuntaa luvun tai merkkijonon liukulukuksi.
Usage:
float(x)
Parametri |
Kuvaus |
|---|---|
|
Muunnettava numero, merkkijono tai muu objekti. |
# 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
Matematiikkamoduuli#
MicroPythonin math -moduuli tarjoaa lisämenetelmiä yleisten matemaattisten laskutoimitusten suorittamiseen. Näitä menetelmiä ovat trigonometriset, logaritmiset ja muut numeeriset operaatiot.
math -moduuli tuodaan oletusarvoisesti VEXcodeen.
Constants#
Vakiot ovat ennalta määritettyjä arvoja, jotka pysyvät kiinteinä projektin aikana. Niitä voidaan käyttää laskutoimituksissa ilman erillistä määrittelyä tai kohdistamista.
pii#
pi antaa matemaattisen vakion π, ympyrän kehän ja sen halkaisijan suhteen.
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 antaa arvon 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 antaa luonnollisen logaritmin kantaluvun.
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
tiedot#
inf antaa positiivisen äärettömyyden liukulukuna.
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 edustaa erityistä liukulukua “Not a Number” (NaN) -argumentille.
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#
synti#
sin laskee kulman sinin radiaaneina ja palauttaa liukulukun.
Usage:
math.sin(x)
Parametri |
Kuvaus |
|---|---|
|
Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)
# sine_result = 0.50
koska#
cos laskee kulman kosinin radiaaneina ja palauttaa liukulukun.
Usage:
math.cos(x)
Parametri |
Kuvaus |
|---|---|
|
Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
rusketus#
tan laskee kulman tangentin radiaaneina ja palauttaa liukulukun.
Usage:
math.tan(x)
Parametri |
Kuvaus |
|---|---|
|
Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
robot.screen.print(tangent_result)
# tangent_result = 1.00
atan#
atan laskee luvun käänteistangentin (arkustangentin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.
Usage:
math.atan(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku. |
# 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 laskee y/x-funktion käänteistangentin pääarvon ja palauttaa liukulukun, joka edustaa kulmaa radiaaneina.
Usage:
math.atan2(y, x)
Parametri |
Kuvaus |
|---|---|
|
Y-koordinaattia edustava liukuluku tai kokonaisluku. |
|
Liukuluku tai kokonaisluku, joka edustaa x-koordinaattia. |
# 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
aasi#
asin laskee luvun käänteisen sinin (arkussinin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.
Usage:
math.asin(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku väliltä -1 ja 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
acos#
acos laskee luvun käänteisen kosinin (arkuskosinin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.
Usage:
math.acos(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku väliltä -1 ja 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
astetta#
degrees muuntaa kulman radiaaneista asteiksi.
Usage:
math.degrees(x)
Parametri |
Kuvaus |
|---|---|
|
Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radiaanit#
radians muuntaa kulman asteista radiaaneiksi.
Usage:
math.radians(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, joka edustaa kulmaa asteina. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh laskee luvun x hyperbolisen sinin.
Usage:
math.sinh(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
cosh#
cosh laskee luvun x hyperbolisen kosinin.
Usage:
math.cosh(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh laskee luvun x hyperbolisen tangentin.
Usage:
math.tanh(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
asinh#
asinh laskee luvun x käänteisen hyperbolisen sinin.
Usage:
math.asinh(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
acosh#
acosh laskee lausekkeen x käänteisen hyperbolisen kosinin.
Usage:
math.acosh(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, joka on suurempi tai yhtä suuri kuin 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh laskee luvun x käänteisen hyperbolisen tangentin.
Usage:
math.atanh(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku välillä -1 ja 1 (poissulkeva). |
# 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#
katto#
ceil pyöristää luvun ylöspäin lähimpään kokonaislukuun.
Usage:
math.ceil(x)
Parametri |
Kuvaus |
|---|---|
|
Ylöspäin pyöristettävä liukuluku tai kokonaisluku. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
lattia#
floor pyöristää luvun alaspäin lähimpään kokonaislukuun.
Usage:
math.floor(x)
Parametri |
Kuvaus |
|---|---|
|
Alaspäin pyöristettävä liukuluku tai kokonaisluku. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
katkaisu#
trunc poistaa luvun desimaaliosan pyöristämättä.
Usage:
math.trunc(x)
Parametri |
Kuvaus |
|---|---|
|
Katkaistava liukuluku. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
keksintöjä#
fabs palauttaa luvun itseisarvon liukulukuna.
Usage:
math.fabs(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
puuteri#
pow korottaa x:n potenssiin y ja palauttaa liukulukuarvon, vaikka molemmat syötteet olisivat kokonaislukuja.
Usage:
math.pow(x, y)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku- tai kokonaislukukanta. |
|
Liukuluku- tai kokonaislukueksponentti. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
neliömäärä#
sqrt laskee luvun neliöjuuren ja palauttaa liukulukuarvon, myös täydellisten neliöiden tapauksessa.
Usage:
math.sqrt(x)
Parametri |
Kuvaus |
|---|---|
|
Ei-negatiivinen liukuluku tai kokonaisluku. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
kokemus#
exp laskee luvun eksponentin ja palauttaa liukulukun.
Usage:
math.exp(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
tukki#
log laskee luvun luonnollisen logaritmin ja palauttaa liukulukun.
Usage:
math.log(x)
Parametri |
Kuvaus |
|---|---|
|
Positiivinen liukuluku tai kokonaisluku. |
# 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 laskee luvun kymmenkantaisen logaritmin ja palauttaa liukulukuarvon.
Usage:
math.log10(x)
Parametri |
Kuvaus |
|---|---|
|
Positiivinen liukuluku tai kokonaisluku. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
log2 laskee luvun kaksikantaisen logaritmin ja palauttaa liukulukuarvon, vaikka x olisikin luvun 2 potenssi.
Usage:
math.log2(x)
Parametri |
Kuvaus |
|---|---|
|
Positiivinen liukuluku tai kokonaisluku. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
kertoma#
factorial palauttaa kokonaisluvun xkertoman, joka on kaikkien positiivisten kokonaislukujen tulo lukuun x asti.
Usage:
math.factorial(x)
Parametri |
Kuvaus |
|---|---|
|
Ei-negatiivinen kokonaisluku. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 laskee ex - 1, mikä on tarkempi pienille x -funktioille.
Usage:
math.expm1(x)
Parametri |
Kuvaus |
|---|---|
|
Eksponentin arvo. |
# 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 purkaa luvun murto- ja kokonaislukuosiin ja palauttaa tuplen (fractional part, integer part), molemmat liukulukuina.
Usage:
math.modf(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, jota hajotella. |
# 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 purkaa luvun mantissaan ja eksponenttiinsa ja palauttaa tuplen (mantissa, exponent), jossa mantissa on liukuluku ja eksponentti on kokonaisluku.
Usage:
math.frexp(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, jota hajotella. |
# 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 palauttaa jakolaskun jakojäännösten säilyttäen jaettavan etumerkin (x).
Usage:
math.fmod(x, y)
Parametri |
Kuvaus |
|---|---|
|
Osinko. |
|
Jakaja. |
# 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
copysigneeraus#
copysign palauttaa x:n, jonka etumerkki on y.
Usage:
math.copysign(x, y)
Parametri |
Kuvaus |
|---|---|
|
Muokattava arvo. |
|
Arvo, jonka etumerkki kopioidaan. |
# 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 laskee x * (2 ** exp), joka on yhtä kuin x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parametri |
Kuvaus |
|---|---|
|
Perusarvo. |
|
Eksponentti. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
on lähellä#
isclose tarkistaa, ovatko kaksi lukua suunnilleen yhtä suuret toleranssin rajoissa.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parametri |
Kuvaus |
|---|---|
|
Ensimmäinen vertailuun käytettävä numero. |
|
Toinen vertailun arvoinen luku. |
|
Valinnainen. Suurin sallittu ero a:n ja b:n välillä suhteessa niiden kokoon. Oletusarvo on 1e-09 (hyvin pieni). |
|
Valinnainen. Kiinteä virhemarginaali, hyödyllinen verrattaessa lähellä nollaa olevia lukuja. Oletusarvo on 0,0. |
Huomautus: Jos sekä rel_tol että abs_tol annetaan, tulos määräytyy siitä, kumpi ehto täyttyy ensin.
# 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
ääretön#
isfinite tarkistaa, onko luku äärellinen. Tämä metodi palauttaa loogisen arvon:
True– Luku on äärellinen.False– Luku on ääretön.
Usage:
math.isfinite(x)
Parametri |
Kuvaus |
|---|---|
|
Tarkistettava liukuluku tai kokonaisluku. |
# 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 tarkistaa, onko luku ääretön. Tämä metodi palauttaa totuusarvon:
True– Luku on ääretön.False– Luku on äärellinen.
Usage:
math.isinf(x)
Parametri |
Kuvaus |
|---|---|
|
Tarkistettava liukuluku tai kokonaisluku. |
# 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 tarkistaa, onko luku NaN (ei luku). Tämä metodi palauttaa totuusarvon:
True– Luku on NaN.False– Numero on kelvollinen numero.
Usage:
math.isnan(x)
Parametri |
Kuvaus |
|---|---|
|
Tarkistettava liukuluku tai kokonaisluku. |
# 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 laskee luvun xgammafunktion, joka yleistää kertomafunktion reaaliluvuille ja kompleksiluvuille. Kokonaisluvulle n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parametri |
Kuvaus |
|---|---|
|
Positiivinen liukuluku tai kokonaisluku. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)
# gamma_result = 24.00
gamma#
lgamma laskee gamma -funktion luonnollisen logaritmin.
Usage:
math.lgamma(x)
Parametri |
Kuvaus |
|---|---|
|
Positiivinen liukuluku tai kokonaisluku. |
# 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 laskee x :n virhefunktion.
Usage:
math.erf(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc laskee x:n komplementaarisen virhefunktion, joka on määritelty muodossa 1 - erf(x).
Usage:
math.erfc(x)
Parametri |
Kuvaus |
|---|---|
|
Syötearvoa edustava liukuluku tai kokonaisluku. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16