Matematiikka#
Johdanto#
Math sisältää sekä sisäänrakennettuja Python-funktioita että täyden math -moduulin, joka on automaattisesti saatavilla VEXcode AIRissa. Näiden työkalujen avulla voit suorittaa kaikkea perusaritmetiikasta edistyneeseen trigonometriaan, pyöristämiseen ja logaritmisiin operaatioihin.
Käytä näitä funktioita ja vakioita laskeaksesi sijainteja, kulmia, etäisyyksiä ja muita numeerisia arvoja VEX AIR -drone-ohjaimelle. Voit myös muuntaa asteita radiaaneiksi ja päinvastoin, laskea lausekkeita ja työskennellä erikoisarvojen, kuten äärettömyyden ja NaN:n, kanssa.
Huomautus: Ellei toisin mainita, kaikki palautusarvot ovat liukulukuja ja muotoillaan täsmälleen viiden desimaalin tarkkuudella. Yli viiden desimaalin tarkkuudella olevat arvot pyöristetään ja alle viiden desimaalin tarkkuudella olevat arvot laajennetaan nollilla, jotta näytettäisiin aina täsmälleen viisi desimaalia.
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.asin– Radiaaneina annetun arvon arcussini.math.acos– Radiaaneina annetun arvon arkuskosini.math.atan– Radiaaneina annetun arvon arcustangentti.math.atan2– y/x:n arcustangentti radiaaneina ottaen huomioon kvadrantin.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.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– Täydentävä 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)
controller.screen.print(abs_result)
# abs_result = 10
round#
round palauttaa pyöristetyn luvun kokonaislukuna määritettyyn desimaalien määrään.
Usage:
round(x, ndigits)
Parametri |
Kuvaus |
|---|---|
|
Kokonaisluku tai liukuluku. |
|
Valinnainen. Määrittää, kuinka moneen desimaaliin pyöristetään (välillä 0–5). Oletusarvo on 0. Kun tätä parametria käytetään, |
# 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 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)
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 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)
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 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])
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 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)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow palauttaa luvun korotettuna potenssiin ja suorittaa valinnaisesti modulo-operaation kokonaislukuna.
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)
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 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)
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 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
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
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
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau antaa arvon 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 antaa luonnollisen logaritmin kantaluvun.
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
tiedot#
inf antaa positiivisen äärettömyyden liukulukuna.
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 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):
controller.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 |
|---|---|
|
Liukuluku tai kokonaisluku, joka edustaa kulmaa yksiköissä radiaanit. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
koska#
cos laskee kulman kosinin radiaaneina ja palauttaa liukulukun.
Usage:
math.cos(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, joka edustaa kulmaa yksiköissä radiaanit. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
rusketus#
tan laskee kulman tangentin radiaaneina ja palauttaa liukulukun.
Usage:
math.tan(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku, joka edustaa kulmaa yksiköissä radiaanit. |
# Calculate the tangent of 45 degrees in radians
tangent_result = math.tan(math.radians(45))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
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 radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
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 radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
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 radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
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 (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
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)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
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)
controller.screen.print(radians_result)
# radians_result = 3.14159
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)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
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)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
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)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
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)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
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)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
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)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
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)
controller.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)
controller.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)
controller.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)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
puuteri#
pow korottaa x potenssiin y (xy) ja palauttaa liukuluvun.
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)
controller.screen.print(power_result)
# power_result = 8.00000
neliömäärä#
sqrt laskee luvun neliöjuuren ja palauttaa liukulukuarvon.
Usage:
math.sqrt(x)
Parametri |
Kuvaus |
|---|---|
|
Ei-negatiivinen liukuluku tai kokonaisluku. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
kokemus#
exp palauttaa luvun e korotettuna potenssiin x (ex) ja liukulukuna.
Usage:
math.exp(x)
Parametri |
Kuvaus |
|---|---|
|
Liukuluku tai kokonaisluku. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
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)
controller.screen.print(log_result)
# log_result = 2.00000
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)
controller.screen.print(log10_result)
# log10_result = 3.00000
log2#
log2 laskee luvun kaksikantaisen logaritmin ja palauttaa liukulukuarvon, vaikka x olisi 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)
controller.screen.print(log2_result)
# log2_result = 3.00000
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)
controller.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)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
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)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
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)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# 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)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
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)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp laskee x * (2 ** exp), joka on yhtä kuin x * 2exp.
Usage:
math.ldexp(x, exp)
Parametri |
Kuvaus |
|---|---|
|
Perusarvo. |
|
Eksponentti. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
ää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)
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 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)
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 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)
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 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)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
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)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
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)
controller.screen.print(erf_result)
# erf_result = 0.84270
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)
controller.screen.print(erfc_result)
# erfc_result = 0.15730