Matematiikka#

Johdanto#

Math sisältää sekä sisäänrakennettuja Python-funktioita että täyden math -moduulin, joka on automaattisesti saatavilla VEXcode VR: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.

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.

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).

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 – Laskee x * (2 ** exp).

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

x

Kokonaisluku tai liukuluku.

 
def main():
    # Get the absolute value of -10
    abs_result = abs(-10)
    brain.print(abs_result)

    # abs_result = 10

# VR threads — Do not delete
vr_thread(main)

round#

round pyöristää luvun tiettyyn desimaalien määrään.

Usage:
round(x, ndigits)

Parametri

Kuvaus

x

Kokonaisluku tai liukuluku.

ndigits

Valinnainen. Desimaalien määrä, johon pyöristetään. Oletusarvo on 0.

 
def main():
    # Round 5.7 to the nearest integer
    round_int_result = round(5.7)
    brain.print(round_int_result)

    # round_int_result = 6

# VR threads — Do not delete
vr_thread(main)


def main():
    # Round 3.14159 to 2 decimal places
    round_result = round(3.14159, 2)
    brain.print(round_result, precision=2)

    # round_result = 3.14

# VR threads — Do not delete
vr_thread(main)

min#

min palauttaa pienimmän arvon useista argumenteista tai iteroitavasta joukosta.

Usage:
min(arg1, arg2, …) or min(sequence)

Parametri

Kuvaus

arg1, arg2, …

Vertailun arvoiset luvut.

sequence

Lista, tuple tai muu numeroita sisältävä sekvenssi.

 
def main():
    # Get the smallest number from 3, 7, and 1
    min_result = min(3, 7, 1)
    brain.print(min_result)

    # min_result = 1

# VR threads — Do not delete
vr_thread(main)


def main():
    # Get the smallest value from a list
    min_list_result = min([10, 4, 25, 1])
    brain.print(min_list_result)

    # min_list_result = 1

# VR threads — Do not delete
vr_thread(main)

max#

max palauttaa suurimman arvon useista argumenteista tai iteroitavasta joukosta.

Usage:
max(arg1, arg2, …) or max(sequence)

Parametri

Kuvaus

arg1, arg2, …

Vertailun arvoiset luvut.

sequence

Lista, tuple tai muu numeroita sisältävä sekvenssi.

 
def main():
    # Get the largest number from 3, 7, and 1
    max_result = max(3, 7, 1)
    brain.print(max_result)

    # max_result = 7

# VR threads — Do not delete
vr_thread(main)


def main():
    # Get the largest value from a list
    max_list_result = max([10, 4, 25, 1])
    brain.print(max_list_result)

    # max_list_result = 25

# VR threads — Do not delete
vr_thread(main)

sum#

sum laskee yhteen kaikki iteroitavan objektin arvot ja antaa valinnaisen aloitusarvon.

Usage:
sum(sequence, start)

Parametri

Kuvaus

sequence

Lista, tuple tai muu numeroita sisältävä sekvenssi.

start

Valinnainen. Summaan lisättävä arvo. Oletusarvo on 0.

 
def main():
    # Calculate the sum of a list of numbers
    sum_result = sum([1, 2, 3, 4, 5])
    brain.print(sum_result)

    # sum_result = 15

# VR threads — Do not delete
vr_thread(main)


def main():
    # Calculate the sum of a list with a starting value of 10
    sum_with_start = sum([1, 2, 3], 10)
    brain.print(sum_with_start)

    # sum_with_start = 16

# VR threads — Do not delete
vr_thread(main)

divmod#

divmod palauttaa tuplen, joka sisältää jakolaskun osamäärän ja jakojäännöksen.

Usage:
divmod(a, b)

Parametri

Kuvaus

a

Osinko.

b

Jakaja.

 
def main():
    # Perform integer division and remainder of 10 / 3
    divmod_result = divmod(10, 3)
    brain.print(divmod_result)

    # divmod_result = (3, 1)

# VR threads — Do not delete
vr_thread(main)

pow#

pow korottaa luvun potenssiin ja suorittaa valinnaisesti modulo-operaation.

Usage:
pow(x, y, mod)

Parametri

Kuvaus

x

Perusnumero.

y

Eksponentti.

mod

Valinnainen. Moduulin arvo. Jos annettu, palauttaa arvon (x ** y) % mod.

 
def main():
    # Calculate 2 raised to the power of 3
    pow_result = pow(2, 3)
    brain.print(pow_result)

    # pow_result = 8

# VR threads — Do not delete
vr_thread(main)

int#

int muuntaa luvun tai merkkijonon kokonaisluvuksi. Se tukee myös kantalukumuunnosta merkkijonosta muunnettaessa.

Usage:
int(x, base)

Parametri

Kuvaus

x

Muunnettava numero, merkkijono tai muu objekti.

base

Valinnainen. Muunnoksessa käytettävä lukukanta. Oletusarvo on 10.

 
def main():
    # Convert a float to an integer to get rid of decimals
    price = 19.99
    price_int = int(price)
    brain.print("{} coins".format(price_int))

    # Output: 19 coins

# VR threads — Do not delete
vr_thread(main)


def main():
    # Convert a string into an integer to use in calculations
    user_input = "55"
    user_number = int(user_input)
    brain.print(user_number * 2)

    # Output: 110

# VR threads — Do not delete
vr_thread(main)

float#

float muuntaa luvun tai merkkijonon liukulukuksi.

Usage:
float(x)

Parametri

Kuvaus

x

Muunnettava numero, merkkijono tai muu objekti.

 
def main():
    # Convert division result to a float
    num_apples = 6
    num_people = 2
    apples_per_person = float(num_apples) / num_people
    brain.print(apples_per_person)

    # Output: 3.00

# VR threads — Do not delete
vr_thread(main)


def main():
    # Convert a string into a float to use in calculations
    user_input = "23.4"
    user_number = float(user_input)
    brain.print(user_number * 3)

    # Output: 70.20

# VR threads — Do not delete
vr_thread(main)

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

def main():
    # Calculate the area of a circle with radius 5 using pi
    circle_area = math.pi * 5 * 5
    brain.print(circle_area, precision=2)

    # circle_area = 78.54

# VR threads — Do not delete
vr_thread(main)

tau#

tau antaa arvon 2π.

Usage:
math.tau

def main():
    # Calculate the circumference of a circle with radius
    circumference = math.tau * 5
    brain.print(circumference, precision=2)

    # circumference = 31.42

# VR threads — Do not delete
vr_thread(main)

e#

e antaa luonnollisen logaritmin kantaluvun.

Usage:
math.e

def main():
    # Calculate e raised to the power of 2
    e_power = math.pow(math.e, 2)
    brain.print(e_power, precision=2)

    # e_power = 7.39

# VR threads — Do not delete
vr_thread(main)

Trigonometry#

synti#

sin laskee kulman sinin radiaaneina ja palauttaa liukulukun.

Usage:
math.sin(x)

Parametri

Kuvaus

x

Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku.

 
def main():
    # Calculate the sine of 
    # 30 degrees in radians
    result = math.sin(math.radians(30))
    brain.print(result, precision=2)

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

koska#

cos laskee kulman kosinin radiaaneina ja palauttaa liukulukun.

Usage:
math.cos(x)

Parametri

Kuvaus

x

Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku.

 
def main():
    # Calculate the cosine of 
    # 60 degrees in radians
    result = math.cos(math.radians(60))
    brain.print(result, precision=2)

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

rusketus#

tan laskee kulman tangentin radiaaneina ja palauttaa liukulukun.

Usage:
math.tan(x)

Parametri

Kuvaus

x

Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku.

 
def main():
    # Calculate the tangent of 
    # 45 degrees in radians
    result = math.tan(math.radians(45))
    brain.print(result, precision=2)

    # result = 1.00

# VR threads — Do not delete
vr_thread(main)

atan#

atan laskee luvun käänteistangentin (arkustangentin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.

Usage:
math.atan(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku.

 
def main():
    # Calculate the arc tangent 
    # of 1 in degrees
    arc_tan = math.atan(1.0)
    result = math.degrees(arc_tan)
    brain.print(result, precision=2)

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

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

Y-koordinaattia edustava liukuluku tai kokonaisluku.

x

Liukuluku tai kokonaisluku, joka edustaa x-koordinaattia.

 
def main():
    # Calculate the inverse tangent 
    # of 1/1 in degrees
    atan2 = math.atan2(1.0, 1.0)
    result = math.degrees(atan2)
    brain.print(result, precision=2)

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

aasi#

asin laskee luvun käänteisen sinin (arkussinin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.

Usage:
math.asin(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku väliltä -1 ja 1.

 
def main():
    # Calculate the arc sine 
    # of 0.5 in degrees
    result = math.degrees(math.asin(0.5))
    brain.print(result, precision=2)

    # result = 30.00

# VR threads — Do not delete
vr_thread(main)

acos#

acos laskee luvun käänteisen kosinin (arkuskosinin) ja palauttaa liukulukuarvon, joka edustaa kulmaa radiaaneina.

Usage:
math.acos(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku väliltä -1 ja 1.

 
def main():
    # Calculate the arc cosine 
    # of 0.5 in degrees
    result = math.degrees(math.acos(0.5))
    brain.print(result, precision=2)

    # result = 60.00

# VR threads — Do not delete
vr_thread(main)

astetta#

degrees muuntaa kulman radiaaneista asteiksi.

Usage:
math.degrees(x)

Parametri

Kuvaus

x

Radiaaneina ilmaistua kulmaa edustava liukuluku tai kokonaisluku.

 
def main():
    # Convert pi radians to degrees
    degrees_result = math.degrees(math.pi)
    brain.print(degrees_result, precision=2)

    # degrees_result = 180.00

# VR threads — Do not delete
vr_thread(main)

radiaanit#

radians muuntaa kulman asteista radiaaneiksi.

Usage:
math.radians(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku, joka edustaa kulmaa asteina.

 
def main():
    # Convert 180 degrees to radians
    radians_result = math.radians(180)
    brain.print(radians_result, precision=2)

    # radians_result = 3.14

# VR threads — Do not delete
vr_thread(main)

Rounding & Absolute Values#

katto#

ceil pyöristää luvun ylöspäin lähimpään kokonaislukuun.

Usage:
math.ceil(x)

Parametri

Kuvaus

x

Ylöspäin pyöristettävä liukuluku tai kokonaisluku.

 
def main():
    # Round 3.7 up to the nearest integer
    ceil_result = math.ceil(3.7)
    brain.print(ceil_result)

    # ceil_result = 4

# VR threads — Do not delete
vr_thread(main)

lattia#

floor pyöristää luvun alaspäin lähimpään kokonaislukuun.

Usage:
math.floor(x)

Parametri

Kuvaus

x

Alaspäin pyöristettävä liukuluku tai kokonaisluku.

 
def main():
    # Round 3.7 down to the nearest integer
    floor_result = math.floor(3.7)
    brain.print(floor_result)

    # floor_result = 3

# VR threads — Do not delete
vr_thread(main)

katkaisu#

trunc poistaa luvun desimaaliosan pyöristämättä.

Usage:
math.trunc(x)

Parametri

Kuvaus

x

Katkaistava liukuluku.

 
def main():
    # Remove the decimal part of 3.7
    trunc_result = math.trunc(3.7)
    brain.print(trunc_result)

    # trunc_result = 3

# VR threads — Do not delete
vr_thread(main)

keksintöjä#

fabs palauttaa luvun itseisarvon liukulukuna.

Usage:
math.fabs(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku.

 
def main():
    # Get the absolute value of -3.7
    fabs_result = math.fabs(-3.7)
    brain.print(fabs_result, precision=2)

    # fabs_result = 3.70

# VR threads — Do not delete
vr_thread(main)

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

x

Liukuluku- tai kokonaislukukanta.

y

Liukuluku- tai kokonaislukueksponentti.

 
def main():
    # Calculate 2 raised to the power of 3
    power_result = math.pow(2, 3)
    brain.print(power_result, precision=2)

    # power_result = 8.00

# VR threads — Do not delete
vr_thread(main)

neliömäärä#

sqrt laskee luvun neliöjuuren ja palauttaa liukulukuarvon, myös täydellisten neliöiden tapauksessa.

Usage:
math.sqrt(x)

Parametri

Kuvaus

x

Ei-negatiivinen liukuluku tai kokonaisluku.

 
def main():
    # Calculate the square root of 16
    sqrt_result = math.sqrt(16)
    brain.print(sqrt_result, precision=2)

    # sqrt_result = 4.00

# VR threads — Do not delete
vr_thread(main)

kokemus#

exp laskee luvun eksponentin ja palauttaa liukulukun.

Usage:
math.exp(x)

Parametri

Kuvaus

x

Liukuluku tai kokonaisluku.

 
def main():
    # Calculate e raised to the power of 1
    exp_result = math.exp(1)
    brain.print(exp_result, precision=2)

    # exp_result = 2.72

# VR threads — Do not delete
vr_thread(main)

tukki#

log laskee luvun luonnollisen logaritmin ja palauttaa liukulukun.

Usage:
math.log(x)

Parametri

Kuvaus

x

Positiivinen liukuluku tai kokonaisluku.

 
def main():
    # Calculate the natural logarithm
    # (base e) of 7.389056
    log_result = math.log(7.389056)
    brain.print(log_result, precision=2)

    # log_result = 2.00

# VR threads — Do not delete
vr_thread(main)

log10#

log10 laskee luvun kymmenkantaisen logaritmin ja palauttaa liukulukuarvon.

Usage:
math.log10(x)

Parametri

Kuvaus

x

Positiivinen liukuluku tai kokonaisluku.

 
def main():
    # Calculate the log10 of 100
    log_result = math.log10(100)
    brain.print(log_result)

    # log_result = 2

# VR threads — Do not delete
vr_thread(main)

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

x

Liukuluku tai kokonaisluku, jota hajotella.

 
def main():
    # Decompose 3.14159 into fractional and integer parts
    fractional_part, integer_part = math.modf(3.14159)
    brain.print(fractional_part, precision=2)
    brain.new_line()
    brain.print(integer_part, precision=2)

    # fractional_part = 0.14
    # integer_part = 3.00

# VR threads — Do not delete
vr_thread(main)

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

x

Liukuluku tai kokonaisluku, jota hajotella.

 
def main():
    # Decompose 16 into its mantissa and exponent
    mantissa, exponent = math.frexp(16)
    brain.print(mantissa, precision=2)
    brain.new_line()
    brain.print(exponent)

    # mantissa = 0.50
    # exponent = 5

# VR threads — Do not delete
vr_thread(main)

fmod#

fmod palauttaa jakolaskun jakojäännösten säilyttäen jaettavan etumerkin (x).

Usage:
math.fmod(x, y)

Parametri

Kuvaus

x

Osinko.

y

Jakaja.

 
def main():
    # Calculate remainder of 10 / 3
    # that preserves the sign of 10
    fmod_result = math.fmod(10, 3)
    brain.print(fmod_result, precision=2)

    # fmod_result = 1.00

# VR threads — Do not delete
vr_thread(main)

copysigneeraus#

copysign palauttaa x:n, jonka etumerkki on y.

Usage:
math.copysign(x, y)

Parametri

Kuvaus

x

Muokattava arvo.

y

Arvo, jonka etumerkki kopioidaan.

 
def main():
    # Return -10 with the sign of 3 (positive)
    copysign_result = math.copysign(-10, 3)
    brain.print(copysign_result, precision=2)

    # copysign_result = 10.00

# VR threads — Do not delete
vr_thread(main)

ldexp#

ldexp laskee x * (2 ** exp), joka on yhtä kuin x * 2exp{code}.

Usage:
math.ldexp(x, exp)

Parametri

Kuvaus

x

Perusarvo.

exp

Eksponentti.

 
def main():
    # Compute 3 * (2 ** 4)
    ldexp_result = math.ldexp(3, 4)
    brain.print(ldexp_result, precision=2)

    # ldexp_result = 48.00

# VR threads — Do not delete
vr_thread(main)
On this page