Mathe#

Einführung #

Math umfasst sowohl integrierte Python-Funktionen als auch das vollständige math Modul, das in VEXcode GO automatisch verfügbar ist. Mit diesen Werkzeugen können Sie alles von einfacher Arithmetik bis hin zu fortgeschrittener Trigonometrie, Rundung und logarithmischen Operationen durchführen.

Mithilfe dieser Funktionen und Konstanten können Sie Positionen, Winkel, Entfernungen und andere numerische Werte für Ihren Roboter berechnen. Sie können außerdem zwischen Grad und Bogenmaß umrechnen, Ausdrücke auswerten und mit Sonderwerten wie Unendlich und NaN arbeiten.

Nachfolgend finden Sie eine Liste der verfügbaren mathematischen Funktionen, Konstanten und Hilfsprogramme:

Integrierte Funktionen – Gängige mathematische Werkzeuge, die in Python enthalten sind.

abs – Gibt den Absolutwert einer Zahl zurück.
round – Rundet eine Zahl auf eine bestimmte Anzahl von Dezimalstellen.
min – Gibt den kleinsten der Eingabewerte zurück.
max – Gibt den größten der Eingabewerte zurück.
sum – Addiert alle Werte in einem iterierbaren Objekt.
divmod – Gibt den Quotienten und den Rest als Tupel zurück.
pow – Erhöht eine Zahl zu einer Potenz, optional mit Modulo.
int – Wandelt einen Wert in eine ganze Zahl um.
float – Wandelt einen Wert in eine Gleitkommazahl um.

Konstanten – Vordefinierte Werte aus dem Modul math.

math.pi – Die Konstante π (Pi).
math.tau – Die Konstante tau (2π).
math.e – Eulersche Zahl, Basis des natürlichen Logarithmus.

Trigonometrie – Winkel und Beziehungen zwischen Seiten berechnen.

math.sin – Sinus eines Winkels im Bogenmaß.
math.cos – Kosinus eines Winkels im Bogenmaß.
math.tan – Tangens eines Winkels im Bogenmaß.
math.atan – Arkustangens eines Wertes im Bogenmaß.
math.atan2 – Arkustangens von y/x im Bogenmaß, unter Berücksichtigung des Quadranten.
math.asin – Arcussinus eines Wertes im Bogenmaß.
math.acos – Arkuskosinus eines Wertes im Bogenmaß.
math.degrees – Wandelt Radiant in Grad um.
math.radians – Wandelt Grad in Bogenmaß um.

Rundung & Absolutwert – Genauigkeit oder Richtung anpassen.

math.ceil – Rundet auf die nächste ganze Zahl auf.
math.floor – Rundet auf die nächste ganze Zahl ab.
math.trunc – Entfernt den Dezimalteil.
math.fabs – Gibt den Absolutwert als Gleitkommazahl zurück.

Exponenten & Logarithmen – Potenz-, Wurzel- und Logarithmusberechnungen.

math.pow – Potenziert eine Zahl.
math.sqrt – Gibt die Quadratwurzel zurück.
math.exp – Berechnet e hoch x.
math.log – Berechne den Logarithmus von x.
math.log10 – Berechnet den Logarithmus von x zur Basis 10.

Gleitkommaoperationen – Gleitkommawerte prüfen oder zerlegen.

math.modf – Gibt den Bruchteil und den ganzzahligen Anteil einer Gleitkommazahl zurück.
math.frexp – Zerlegt eine Zahl in Mantisse und Exponent.
math.fmod – Rest mit Vorzeichen des Dividenden.
math.copysign – Gibt einen Wert mit dem Vorzeichen eines anderen zurück.
math.ldexp – Berechnet x * (2 ** exp).

Eingebaute Funktionen #

Python bietet mehrere integrierte Funktionen, mit denen Sie mathematische Operationen innerhalb Ihres Projekts durchführen können.

abs #

abs gibt den Absolutwert einer Zahl zurück, wobei das negative Vorzeichen entfernt wird.

Usage:
abs(x)

Parameter	Beschreibung
`x`	Eine ganze Zahl oder eine Gleitkommazahl.

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 rundet eine Zahl auf eine bestimmte Anzahl von Dezimalstellen.

Usage:
round(x, ndigits)

Parameter	Beschreibung
`x`	Eine ganze Zahl oder eine Gleitkommazahl.
`ndigits`	Optional. Die Anzahl der Dezimalstellen, auf die gerundet werden soll. Standardwert ist 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 gibt den kleinsten Wert aus mehreren Argumenten oder einem iterierbaren Objekt zurück.

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

Parameter	Beschreibung
`arg1`, `arg2`, …	Die Zahlen zum Vergleich.
`sequence`	Eine Liste, ein Tupel oder eine andere Sequenz, die Zahlen enthält.

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 gibt den größten Wert aus mehreren Argumenten oder einem iterierbaren Objekt zurück.

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

Parameter	Beschreibung
`arg1`, `arg2`, …	Die Zahlen zum Vergleich.
`sequence`	Eine Liste, ein Tupel oder eine andere Sequenz, die Zahlen enthält.

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 addiert alle Werte in einem iterierbaren Objekt, wobei ein Startwert optional ist.

Usage:
sum(sequence, start)

Parameter	Beschreibung
`sequence`	Eine Liste, ein Tupel oder eine andere Sequenz, die Zahlen enthält.
`start`	Optional. Ein Wert, der zur Summe addiert wird. Standardwert ist 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 gibt ein Tupel zurück, das den Quotienten und den Rest einer Divisionsoperation enthält.

Usage:
divmod(a, b)

Parameter	Beschreibung
`a`	Die Dividende.
`b`	Der Divisor.

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 potenziert eine Zahl und führt optional eine Modulo-Operation durch.

Usage:
pow(x, y, mod)

Parameter	Beschreibung
`x`	Die Basiszahl.
`y`	Der Exponent.
`mod`	Optional. Ein Modulo-Wert. Falls angegeben, wird `(x ** y) % mod` zurückgegeben.

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 wandelt eine Zahl oder Zeichenkette in eine ganze Zahl um. Es unterstützt auch die Basisumwandlung bei der Umwandlung von einer Zeichenkette.

Usage:
int(x, base)

Parameter	Beschreibung
`x`	Eine Zahl, eine Zeichenkette oder ein anderes Objekt, das konvertiert werden soll.
`base`	Optional. Die für die Umrechnung zu verwendende Zahlenbasis. Standardwert ist 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 wandelt eine Zahl oder Zeichenkette in eine Gleitkommazahl um.

Usage:
float(x)

Parameter	Beschreibung
`x`	Eine Zahl, eine Zeichenkette oder ein anderes Objekt, das konvertiert werden soll.

# 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

Mathematikmodul #

Das Modul math in MicroPython bietet zusätzliche Methoden zur Durchführung gängiger mathematischer Berechnungen. Zu diesen Methoden gehören trigonometrische, logarithmische und andere numerische Operationen.

Das Modul math wird standardmäßig in VEXcode importiert.

Constants #

Konstanten sind vordefinierte Werte, die während eines Projekts unverändert bleiben. Sie können in Berechnungen verwendet werden, ohne dass eine Definition oder Zuweisung erforderlich ist.

Pi #

pi ergibt die mathematische Konstante π, das Verhältnis des Umfangs eines Kreises zu seinem Durchmesser.

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 ergibt den Wert von 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 gibt die Basis des natürlichen Logarithmus an.

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 #

Sünde #

sin berechnet den Sinus eines Winkels im Bogenmaß und gibt eine Gleitkommazahl zurück.

Usage:
math.sin(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die einen Winkel im Bogenmaß darstellt.

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)

cos #

cos berechnet den Kosinus eines Winkels im Bogenmaß und gibt eine Gleitkommazahl zurück.

Usage:
math.cos(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die einen Winkel im Bogenmaß darstellt.

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)

bräunen #

tan berechnet den Tangens eines Winkels im Bogenmaß und gibt eine ganze Zahl zurück.

Usage:
math.tan(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die einen Winkel im Bogenmaß darstellt.

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)

asin #

asin berechnet den Arkussinus (Arc Sinus) einer Zahl und gibt eine ganze Zahl zurück, die den Winkel im Bogenmaß darstellt.

Usage:
math.asin(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl zwischen -1 und 1.

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)

acos #

acos berechnet den Arkuskosinus (Arccosinus) einer Zahl und gibt eine ganze Zahl zurück, die den Winkel im Bogenmaß darstellt.

Usage:
math.acos(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl zwischen -1 und 1.

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)

atan #

atan berechnet den Arkustangens (arc tangent) einer Zahl und gibt eine ganze Zahl zurück, die den Winkel im Bogenmaß darstellt.

Usage:
math.atan(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl.

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 berechnet den Hauptwert des Arkustangens von y/x und gibt eine Gleitkommazahl zurück, die den Winkel im Bogenmaß darstellt.

Usage:
math.atan2(y, x)

Parameter	Beschreibung
`y`	Eine Gleitkommazahl oder eine ganze Zahl, die die y-Koordinate darstellt.
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die die x-Koordinate darstellt.

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)

Abschlüsse #

degrees wandelt einen Winkel von Radiant in Grad um und gibt eine ganze Zahl zurück.

Usage:
math.degrees(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die einen Winkel im Bogenmaß darstellt.

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)

Radiant #

radians wandelt einen Winkel von Grad in Radiant um.

Usage:
math.radians(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die einen Winkel in Grad darstellt.

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 #

Decke #

ceil rundet eine Zahl auf die nächste ganze Zahl auf.

Usage:
math.ceil(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die aufgerundet werden soll.

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)

Boden #

floor rundet eine Zahl auf die nächste ganze Zahl ab.

Usage:
math.floor(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die abgerundet werden soll.

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)

abschneiden #

trunc entfernt den Dezimalteil einer Zahl ohne Rundung.

Usage:
math.trunc(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl, die abgeschnitten werden soll.

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)

Fabriken #

fabs gibt den Absolutwert einer Zahl als Gleitkommazahl zurück.

Usage:
math.fabs(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl.

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 #

Protokoll #

log berechnet den Logarithmus einer Zahl und gibt eine Gleitkommazahl zurück.

Usage:
math.log(x, base)

Parameter	Beschreibung
`x`	Eine positive Gleitkommazahl oder eine ganze Zahl.
`base`	Optional. Die zu verwendende Basis des Logarithmus. Standardmäßig ist dies der natürliche Logarithmus.

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 berechnet den Logarithmus einer Zahl zur Basis 10 und gibt eine Gleitkommazahl zurück.

Usage:
math.log10(x)

Parameter	Beschreibung
`x`	Eine positive Gleitkommazahl oder eine ganze Zahl.

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)

Pow #

pow potenziert x mit y und gibt eine Gleitkommazahl zurück, selbst wenn beide Eingaben ganze Zahlen sind.

Usage:
math.pow(x, y)

Parameter	Beschreibung
`x`	Eine Gleitkomma- oder Ganzzahlbasis.
`y`	Ein Gleitkomma- oder Ganzzahlexponent.

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)

Quadrat #

sqrt berechnet die Quadratwurzel einer Zahl und gibt eine Gleitkommazahl zurück, auch bei perfekten Quadratzahlen.

Usage:
math.sqrt(x)

Parameter	Beschreibung
`x`	Eine nicht-negative Gleitkommazahl oder ganze Zahl.

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)

exp #

exp berechnet die Exponentialfunktion einer Zahl und gibt eine Gleitkommazahl zurück.

Usage:
math.exp(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl.

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 zerlegt eine Zahl in ihren Bruchteil und ihren ganzzahligen Anteil und gibt ein Tupel (fractional part, integer part)zurück, beide als Gleitkommazahlen.

Usage:
math.modf(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die zerlegt werden soll.

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 zerlegt eine Zahl in ihre Mantisse und ihren Exponenten und gibt ein Tupel (mantissa, exponent)zurück, wobei die Mantisse eine Gleitkommazahl und der Exponent eine ganze Zahl ist.

Usage:
math.frexp(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl, die zerlegt werden soll.

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 gibt den Rest der Division zurück, wobei das Vorzeichen des Dividenden beibehalten wird (x).

Usage:
math.fmod(x, y)

Parameter	Beschreibung
`x`	Die Dividende.
`y`	Der Divisor.

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)

Kopiersignatur #

copysign gibt x mit dem Vorzeichen von y zurück.

Usage:
math.copysign(x, y)

Parameter	Beschreibung
`x`	Der zu ändernde Wert.
`y`	Der Wert, dessen Vorzeichen kopiert wird.

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 berechnet x * (2 ** exp), was äquivalent zu x * 2^exp ist.

Usage:
math.ldexp(x, exp)

Parameter	Beschreibung
`x`	Der Basiswert.
`exp`	Der Exponent.

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)