Matek#

Bevezetés#

A Math tartalmaz beépített Python függvényeket és a teljes math modult is, amely automatikusan elérhető a VEXcode GO-ban. Ezek az eszközök lehetővé teszik az alapvető aritmetikai műveletektől a haladó trigonometriai, kerekítési és logaritmikus műveletekig mindent.

Ezekkel a függvényekkel és állandókkal kiszámíthatja a robot pozícióit, szögeit, távolságait és egyéb numerikus értékeit. Fokok és radiánok között is válthat, kifejezéseket értékelhet ki, és speciális értékekkel, például végtelennel és NaN-nal dolgozhat.

Az alábbiakban a rendelkezésre álló matematikai függvények, konstansok és segédprogramok listája látható:

Beépített függvények – A Pythonban megtalálható gyakori matematikai eszközök.

  • abs – Egy szám abszolút értékét adja vissza.

  • round – Egy számot megadott számú tizedesjegyre kerekít.

  • min – Visszaadja a bemeneti értékek közül a legkisebbet.

  • max – Visszaadja a bemeneti értékek közül a legnagyobbat.

  • sum – Összeadja egy iterálható objektum összes értékét.

  • divmod – Visszaadja a hányadost és a maradékot egy tuple-ként.

  • pow – Egy számot adott hatványra emel, opcionálisan egy modulussal.

  • int – Egy értéket egész számmá alakít.

  • float – Lebegőpontos számmá alakít egy értéket.

Konstansok – Előre definiált értékek a math modulból.

  • math.pi – A π (pi) állandó.

  • math.tau – A tau (2π) állandó.

  • math.e – Euler-szám, a természetes logaritmus alapja.

Trigonometria – Szögek és oldalak közötti kapcsolatok kiszámítása.

  • math.sin – Egy szög szinuszai radiánban.

  • math.cos – Egy szög koszinusza radiánban.

  • math.tan – Egy szög tangense radiánban.

  • math.atan – Egy radiánban megadott érték arkusz tangense.

  • math.atan2 – Az y/x arkusz tangense radiánban, figyelembe véve a kvadránst.

  • math.asin – Egy radiánban megadott érték arkusz szinuszja.

  • math.acos – Egy radiánban megadott érték arkusz koszinusza.

  • math.degrees – Radiánból fokot vált át.

  • math.radians – Fokokat radiánokká alakít.

Kerekítés és abszolút érték – Pontosság vagy irány beállítása.

  • math.ceil – Felfelé kerekíti a legközelebbi egész számra.

  • math.floor – Lefelé kerekíti a legközelebbi egész számra.

  • math.trunc – Eltávolítja a tizedes részt.

  • math.fabs – Visszaadja az abszolút értéket lebegőpontos számként.

Kitevők és logaritmusok – Hatvány-, gyök- és logaritmusszámítások.

  • math.pow – Egy számot adott hatványra emel.

  • math.sqrt – Visszaadja a négyzetgyököt.

  • math.exp – Kiszámítja az e-t x hatványán.

  • math.log – Számítsa ki x logaritmusát.

  • math.log10 – Kiszámítja az x tízes alapú logaritmusát.

Lebegőpontos műveletek – Lebegőpontos értékek vizsgálata vagy bontása.

  • math.modf – Visszaadja egy lebegőpontos szám tört és egész részét.

  • math.frexp – Egy számot mantisszára és kitevőjére bont.

  • math.fmod – Az osztandó előjelével jelölt maradék.

  • math.copysign – Egy másik előjelű értéket ad vissza.

  • math.ldexp – Kiszámítja x * (2 ** exp).

Beépített függvények#

A Python számos beépített függvényt kínál, amelyek lehetővé teszik matematikai műveletek végrehajtását a projekten belül.

abs#

abs egy szám abszolút értékét adja vissza, eltávolítva a negatív előjeleket.

Usage:
abs(x)

Paraméter

Leírás

x

Egész szám vagy lebegőpontos szám.

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

# abs_result = 10

# Start threads — Do not delete
start_thread(main)

round#

round egy számot megadott számú tizedesjegyre kerekít.

Usage:
round(x, ndigits)

Paraméter

Leírás

x

Egész szám vagy lebegőpontos szám.

ndigits

Opcionális. A tizedesjegyek száma, amelyekre kerekíteni kell. Az alapértelmezett érték 0.

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

# round_int_result = 6

# Start threads — Do not delete
start_thread(main)


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

# round_result = 3.14

# Start threads — Do not delete
start_thread(main)

min#

min a több argumentumból vagy egy iterálható függvényből származó legkisebb értéket adja vissza.

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

Paraméter

Leírás

arg1, arg2, …

Az összehasonlításhoz szükséges számok.

sequence

Számokat tartalmazó lista, tuple vagy más sorozat.

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

# min_result = 1

# Start threads — Do not delete
start_thread(main)


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

# min_list_result = 1

# Start threads — Do not delete
start_thread(main)

max#

max a több argumentum vagy egy iterálható függvény közül a legnagyobb értéket adja vissza.

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

Paraméter

Leírás

arg1, arg2, …

Az összehasonlításhoz szükséges számok.

sequence

Számokat tartalmazó lista, tuple vagy más sorozat.

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

# max_result = 7

# Start threads — Do not delete
start_thread(main)


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

# max_list_result = 25

# Start threads — Do not delete
start_thread(main)

sum#

sum függvény összeadja egy iterálható objektum összes értékét, opcionális kezdőértékkel.

Usage:
sum(sequence, start)

Paraméter

Leírás

sequence

Számokat tartalmazó lista, tuple vagy más sorozat.

start

Opcionális. Az összeghez hozzáadandó érték. Az alapértelmezett érték 0.

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

# sum_result = 15

# Start threads — Do not delete
start_thread(main)


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

# sum_with_start = 16

# Start threads — Do not delete
start_thread(main)

divmod#

divmod egy olyan tuple-t ad vissza, amely egy osztási művelet hányadosát és maradékát tartalmazza.

Usage:
divmod(a, b)

Paraméter

Leírás

a

Az osztalék.

b

Az osztó.

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

# divmod_result = (3, 1)

# Start threads — Do not delete
start_thread(main)

pow#

pow egy számot hatványoz, és opcionálisan modulusműveletet hajt végre.

Usage:
pow(x, y, mod)

Paraméter

Leírás

x

Az alapszám.

y

A kitevő.

mod

Opcionális. Egy modulusérték. Ha meg van adva, (x ** y) % mod értéket ad vissza.

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

# pow_result = 8

# Start threads — Do not delete
start_thread(main)

int#

int függvény egy számot vagy karakterláncot egész számmá alakít. Karakterláncból történő konvertáláskor támogatja az alapkonverziót is.

Usage:
int(x, base)

Paraméter

Leírás

x

Egy szám, karakterlánc vagy más, konvertálandó objektum.

base

Opcionális. Az átváltáshoz használandó számrendszer. Az alapértelmezett érték 10.

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

# Output: 19 coins

# Start threads — Do not delete
start_thread(main)


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

# Output: 110

# Start threads — Do not delete
start_thread(main)

float#

float egy számot vagy karakterláncot lebegőpontos számmá alakít.

Usage:
float(x)

Paraméter

Leírás

x

Egy szám, karakterlánc vagy más, konvertálandó objektum.

 
# 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

Matematikai modul#

A MicroPython math modulja további metódusokat biztosít a gyakori matematikai számítások elvégzéséhez. Ezek a metódusok magukban foglalják a trigonometrikus, logaritmikus és egyéb numerikus műveleteket.

A math modul alapértelmezés szerint importálva van a VEXcode-ban.

Constants#

A konstansok előre definiált értékek, amelyek egy projekt során rögzítettek maradnak. Számításokban felhasználhatók anélkül, hogy bármilyen definíciót vagy értékadást igényelnének.

pi#

pi megadja a π matematikai állandót, a kör kerületének és átmérőjének arányát.

Usage:
math.pi

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

# circle_area = 78.54

# Start threads — Do not delete
start_thread(main)

tau#

tau értéke 2π.

Usage:
math.tau

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

# circumference = 31.42

# Start threads — Do not delete
start_thread(main)

e#

e a természetes logaritmus alapját adja.

Usage:
math.e

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

# e_power = 7.39

# Start threads — Do not delete
start_thread(main)

Trigonometry#

bűn#

sin függvény egy szög szinuszát számítja ki radiánban, és lebegőpontos értéket ad vissza.

Usage:
math.sin(x)

Paraméter

Leírás

x

Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám.

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

# result = 0.50

# Start threads — Do not delete
start_thread(main)

kötözősaláta#

cos függvény egy szög koszinuszát számítja ki radiánban, és egy lebegőpontos értéket ad vissza.

Usage:
math.cos(x)

Paraméter

Leírás

x

Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám.

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

# result = 0.50

# Start threads — Do not delete
start_thread(main)

cserszínű#

tan függvény egy szög tangensét számítja ki radiánban, és egész számot ad vissza.

Usage:
math.tan(x)

Paraméter

Leírás

x

Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám.

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

# result = 1

# Start threads — Do not delete
start_thread(main)

szamár#

asin függvény kiszámítja egy szám inverz szinuszát (arc szinuszát), és egy egész számot ad vissza, amely a szöget jelenti radiánban.

Usage:
math.asin(x)

Paraméter

Leírás

x

Egy -1 és 1 közötti lebegőpontos szám vagy egész szám.

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

# result = 30

# Start threads — Do not delete
start_thread(main)

ákosok#

acos függvény kiszámítja egy szám inverz koszinuszát (arkus koszinuszát), és egy egész számot ad vissza, amely a szöget jelenti radiánban.

Usage:
math.acos(x)

Paraméter

Leírás

x

Egy -1 és 1 közötti lebegőpontos szám vagy egész szám.

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

# result = 60

# Start threads — Do not delete
start_thread(main)

Atán#

atan függvény kiszámítja egy szám inverz tangensét (arkus tangenst), és egy egész számot ad vissza, amely a szöget jelenti radiánban.

Usage:
math.atan(x)

Paraméter

Leírás

x

Egy lebegőpontos szám vagy egész szám.

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

# result = 45

# Start threads — Do not delete
start_thread(main)

atan2#

atan2 függvény kiszámítja az y/x függvény inverz tangensének főértékét, és egy lebegőpontos számot ad vissza, amely a szöget jelenti radiánban.

Usage:
math.atan2(y, x)

Paraméter

Leírás

y

Egy lebegőpontos szám vagy egész szám, amely az y koordinátát jelöli.

x

Az x koordinátát reprezentáló lebegőpontos szám vagy egész szám.

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

# result = 45

# Start threads — Do not delete
start_thread(main)

fok#

degrees egy szöget radiánból fokokba konvertál, és egész számot ad vissza.

Usage:
math.degrees(x)

Paraméter

Leírás

x

Egy radiánban megadott szöget ábrázoló lebegőpontos vagy egész szám.

 
def main():
    # Convert pi radians to degrees
    degrees_result = math.degrees(math.pi)
    console.print(degrees_result)

# degrees_result = 180

# Start threads — Do not delete
start_thread(main)

radián#

radians egy szöget fokból radiánba konvertál.

Usage:
math.radians(x)

Paraméter

Leírás

x

Egy lebegőpontos szám vagy egész szám, amely egy szöget ábrázol fokban.

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

# radians_result = 3.14

# Start threads — Do not delete
start_thread(main)

Rounding & Absolute Values#

mennyezet#

ceil függvény egy számot felfelé kerekít a legközelebbi egész számra.

Usage:
math.ceil(x)

Paraméter

Leírás

x

Felfelé kerekítendő lebegőpontos szám vagy egész szám.

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

# ceil_result = 4

# Start threads — Do not delete
start_thread(main)

emelet#

floor függvény egy számot lefelé kerekít a legközelebbi egész számra.

Usage:
math.floor(x)

Paraméter

Leírás

x

Lefelé kerekítendő lebegőpontos szám vagy egész szám.

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

# floor_result = 3

# Start threads — Do not delete
start_thread(main)

csonk#

trunc parancs kerekítés nélkül eltávolítja a szám tizedes részét.

Usage:
math.trunc(x)

Paraméter

Leírás

x

Egy csonkolandó úszótest.

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

# trunc_result = 3

# Start threads — Do not delete
start_thread(main)

fabrikáltak#

fabs Egy szám abszolút értékét adja vissza lebegőpontos számként.

Usage:
math.fabs(x)

Paraméter

Leírás

x

Egy lebegőpontos szám vagy egész szám.

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

# fabs_result = 3.7

# Start threads — Do not delete
start_thread(main)

Exponents & Logarithms#

napló#

log függvény egy szám logaritmusát számítja ki, és lebegőpontos értéket ad vissza.

Usage:
math.log(x, base)

Paraméter

Leírás

x

Pozitív lebegőpontos szám vagy egész szám.

base

Opcionális. A használandó logaritmus alap. Alapértelmezés szerint ez a természetes logaritmus.

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

# log_result = 2

# Start threads — Do not delete
start_thread(main)


def main():
    # Calculate the log base 2 of 8
    log_result = math.log(8, 2)
    console.print(log_result)

# log_result = 3

# Start threads — Do not delete
start_thread(main)

log10#

log10 egy szám 10-es alapú logaritmusát számítja ki, és lebegőpontos értéket ad vissza.

Usage:
math.log10(x)

Paraméter

Leírás

x

Pozitív lebegőpontos szám vagy egész szám.

 
def main():
    # Calculate the base-10 logarithm of 100
    log10_result = math.log10(100)
    console.print(log10_result)

# log10_result = 2

# Start threads — Do not delete
start_thread(main)

hadifogoly#

pow függvény x értékét y hatványára emeli, és lebegőpontos számot ad vissza, még akkor is, ha mindkét bemenet egész szám.

Usage:
math.pow(x, y)

Paraméter

Leírás

x

Lebegőpontos vagy egész alapú szám.

y

Egy lebegőpontos vagy egész kitevőjű.

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

    # power_result = 8

# Start threads — Do not delete
start_thread(main)

négyzetméter#

sqrt függvény kiszámítja egy szám négyzetgyökét, és lebegőpontos számot ad vissza, még tökéletes négyzetszámok esetén is.

Usage:
math.sqrt(x)

Paraméter

Leírás

x

Nemnegatív lebegőpontos szám vagy egész szám.

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

# power_result = 8

# Start threads — Do not delete
start_thread(main)

tapasztalat#

exp Kiszámítja egy szám exponenciálisát és lebegőpontos számot ad vissza.

Usage:
math.exp(x)

Paraméter

Leírás

x

Egy lebegőpontos szám vagy egész szám.

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

# exp_result = 2.72

# Start threads — Do not delete
start_thread(main)

Floating Point Operations#

modf#

modf függvény egy számot tört és egész részeire bont, és egy tuple-t ad vissza (fractional part, integer part), mindkettőt lebegőpontos számként.

Usage:
math.modf(x)

Paraméter

Leírás

x

Egy felbontandó lebegőpontos szám vagy egész szám.

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

# fractional_part = 0.14
# integer_part = 3

# Start threads — Do not delete
start_thread(main)

frexp#

frexp függvény egy számot mantisszára és kitevőjére bont, és egy tuple-t ad vissza (mantissa, exponent), ahol a mantissza egy lebegőpontos szám, a kitevő pedig egy egész szám.

Usage:
math.frexp(x)

Paraméter

Leírás

x

Egy felbontandó lebegőpontos szám vagy egész szám.

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

# mantissa = 0.50
# exponent = 5

# Start threads — Do not delete
start_thread(main)

fmod#

fmod függvény visszaadja az osztás maradékát, miközben megtartja az osztandó előjelét (x).

Usage:
math.fmod(x, y)

Paraméter

Leírás

x

Az osztalék.

y

Az osztó.

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

# fmod_result = 1

# Start threads — Do not delete
start_thread(main)

szerzői aláírás#

copysign függvény x értékét adja vissza y előjellel.

Usage:
math.copysign(x, y)

Paraméter

Leírás

x

A módosítandó érték.

y

Az az érték, amelynek az előjelét másolni fogják.

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

# copysign_result = 10

# Start threads — Do not delete
start_thread(main)

ldexp#

ldexp kiszámítja x * (2 ** exp), ami egyenértékű x * 2exp képlettel.

Usage:
math.ldexp(x, exp)

Paraméter

Leírás

x

Az alapérték.

exp

A kitevő.

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

# ldexp_result = 48

# Start threads — Do not delete
start_thread(main)
On this page