Mathe#

Einführung #

Math umfasst sowohl integrierte Python-Funktionen als auch das vollständige math Modul, das in VEXcode AIM 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.
math.inf – Positive Unendlichkeit.
math.nan – Keine Zahl (NaN).

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.

Hyperbolische Funktionen – Fortgeschrittene trigonometrische Funktionen.

math.sinh – Hyperbolischer Sinus eines Wertes.
math.cosh – Hyperbolischer Kosinus eines Wertes.
math.tanh – Hyperbolischer Tangens eines Wertes.
math.asinh – Inverse hyperbolische Sinusfunktion.
math.acosh – Inverse hyperbolische Kosinusfunktion.
math.atanh – Inverse hyperbolische Tangensfunktion.

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 – Natürlicher Logarithmus (Basis e).
math.log10 – Logarithmus zur Basis 10.
math.log2 – Logarithmus zur Basis 2.
math.factorial – Fakultät einer ganzen Zahl.
math.expm1 – Genaueres Ergebnis für e^x - 1.

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

Vergleich & Annäherung – Werte mit Toleranzen oder Kategorien prüfen.

math.isclose – Testet, ob zwei Werte annähernd gleich sind.
math.isfinite – Prüft, ob eine Zahl endlich ist.
math.isinf – Prüft, ob eine Zahl unendlich ist.
math.isnan – Prüft, ob ein Wert NaN ist.

Fehler- und Gammafunktion – Spezielle mathematische Funktionen.

math.gamma – Gammafunktion (verallgemeinerte Fakultät).
math.lgamma – Logarithmisches Gamma.
math.erf – Fehlerfunktion.
math.erfc – Komplementäre Fehlerfunktion.

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.

# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)

# abs_result = 10

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.

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

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

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

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

# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)

# divmod_result = (3, 1)

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.

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

# 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 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

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

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

inf #

inf ergibt positive Unendlichkeit als Gleitkommazahl.

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 stellt einen speziellen Gleitkommawert für “Not a Number” (NaN) dar.

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 #

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.

# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)

# sine_result = 0.50

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.

# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)

# cosine_result = 0.50

bräunen #

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

Usage:
math.tan(x)

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

# 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 berechnet den Arkustangens (arc tangent) einer Zahl und gibt eine Gleitkommazahl zurück, die den Winkel im Bogenmaß darstellt.

Usage:
math.atan(x)

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

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

# 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

asin #

asin berechnet den Arkussinus (Arc Sinus) einer Zahl und gibt eine Gleitkommazahl 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.

# 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 berechnet den Arkuskosinus (Arccosinus) einer Zahl und gibt eine Gleitkommazahl 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.

# 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

Abschlüsse #

degrees wandelt einen Winkel von Radiant in Grad um.

Usage:
math.degrees(x)

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

# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)

# degrees_result = 180.00

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.

# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)

# radians_result = 3.14

Hyperbolics #

Sinh #

sinh berechnet den hyperbolischen Sinus von x.

Usage:
math.sinh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)

# sinh_result = 1.18

Schlagstock #

cosh berechnet den hyperbolischen Kosinus von x.

Usage:
math.cosh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)

# cosh_result = 1.54

tanh #

tanh berechnet den hyperbolischen Tangens von x.

Usage:
math.tanh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)

# tanh_result = 0.76

Asinh #

asinh berechnet den inversen hyperbolischen Sinus von x.

Usage:
math.asinh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)

# asinh_result = 0.88

acosh #

acosh berechnet den inversen hyperbolischen Kosinus von x.

Usage:
math.acosh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine ganze Zahl größer oder gleich 1.

# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)

# acosh_result = 1.32

atanh #

atanh berechnet den inversen hyperbolischen Tangens von x.

Usage:
math.atanh(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl zwischen -1 und 1 (exklusiv).

# 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 #

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.

# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)

# ceil_result = 4

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.

# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)

# floor_result = 3

abschneiden #

trunc entfernt den Dezimalteil einer Zahl ohne Rundung.

Usage:
math.trunc(x)

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

# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)

# trunc_result = 3

Fabriken #

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

Usage:
math.fabs(x)

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

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)

# fabs_result = 3.70

Exponents & Logarithms #

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.

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)

# power_result = 8.00

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.

# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)

# sqrt_result = 4.00

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.

# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)

# exp_result = 2.72

Protokoll #

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

Usage:
math.log(x)

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

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

# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)

# log10_result = 3.00

log2 #

log2 berechnet den Logarithmus einer Zahl zur Basis 2 und gibt eine Gleitkommazahl zurück, selbst wenn x eine Zweierpotenz ist.

Usage:
math.log2(x)

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

# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)

# log2_result = 3.00

Fakultät #

factorial gibt die Fakultät einer ganzen Zahl xzurück, die das Produkt aller positiven ganzen Zahlen bis x ist.

Usage:
math.factorial(x)

Parameter	Beschreibung
`x`	Eine nichtnegative ganze Zahl.

# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)

# factorial_result = 120

expm1 #

expm1 berechnet e^x - 1, was für kleine x genauer ist.

Usage:
math.expm1(x)

Parameter	Beschreibung
`x`	Der Exponentenwert.

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

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

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

# 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

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.

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

Usage:
math.ldexp(x, exp)

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

# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)

# ldexp_result = 48.00

Comparison & Approximation #

ist geschlossen #

isclose prüft, ob zwei Zahlen innerhalb einer Toleranz annähernd gleich sind.

Usage:
math.isclose(a, b, rel_tol, abs_tol)

Parameter	Beschreibung
`a`	Die erste Zahl zum Vergleichen.
`b`	Die zweite Zahl zum Vergleichen.
`rel_tol`	Optional. Die maximal zulässige Differenz zwischen a und b, bezogen auf ihre Größe. Standardwert: 1e-09 (sehr klein).
`abs_tol`	Optional. Eine feste Fehlertoleranz, die beim Vergleich von Zahlen nahe Null hilfreich ist. Standardwert: 0,0.

Hinweis: Wenn sowohl rel_tol als auch abs_tol angegeben werden, bestimmt die zuerst erfüllte Bedingung das Ergebnis.

# 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

ist endlich #

isfinite prüft, ob eine Zahl endlich ist. Diese Methode gibt einen booleschen Wert zurück:

True – Die Zahl ist endlich.
False – Die Zahl ist unendlich.

Usage:
math.isfinite(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die überprüft werden soll.

# 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 #

Die Methode isinf prüft, ob eine Zahl unendlich ist. Diese Methode gibt einen booleschen Wert zurück:

True – Die Zahl ist unendlich.
False – Die Zahl ist endlich.

Usage:
math.isinf(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die überprüft werden soll.

# 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 #

Die Methode isnan prüft, ob eine Zahl NaN (Not a Number) ist. Diese Methode gibt einen booleschen Wert zurück.

True – Die Zahl ist NaN.
False – Die Zahl ist eine gültige Zahl.

Usage:
math.isnan(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die überprüft werden soll.

# 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 berechnet die Gammafunktion von x, welche die Fakultätsfunktion für reelle und komplexe Zahlen verallgemeinert. Für eine ganze Zahl n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

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

# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)

# gamma_result = 24.00

lgamma #

lgamma berechnet den natürlichen Logarithmus der gamma Funktion.

Usage:
math.lgamma(x)

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

# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
robot.screen.print(lgamma_result)

# lgamma_result = 3.18

Grundstück #

erf berechnet die Fehlerfunktion von x.

Usage:
math.erf(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)

# erf_result = 0.84

erfc #

erfc berechnet die komplementäre Fehlerfunktion von x, die wie folgt definiert ist: 1 - erf(x).

Usage:
math.erfc(x)

Parameter	Beschreibung
`x`	Eine Gleitkommazahl oder eine Ganzzahl, die den Eingabewert darstellt.

# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)

# erfc_result = 0.16