Wiskunde#
Invoering#
De wiskundige module bevat zowel ingebouwde Python-functies als de volledige math module, die automatisch beschikbaar is in VEXcode AIM. Met deze tools kunt u alles uitvoeren, van eenvoudige rekenkundige bewerkingen tot geavanceerde trigonometrie, afronden en logaritmische bewerkingen.
Gebruik deze functies en constanten om posities, hoeken, afstanden en andere numerieke waarden voor je robot te berekenen. Je kunt ook converteren tussen graden en radialen, expressies evalueren en werken met speciale waarden zoals oneindigheid en NaN.
Hieronder vindt u een lijst met beschikbare wiskundige functies, constanten en hulpprogramma’s:
Ingebouwde functies – Veelgebruikte wiskundige hulpmiddelen die standaard in Python zijn opgenomen.
abs– Geeft de absolute waarde van een getal terug.round– Rondt een getal af op een opgegeven aantal decimalen.min– Retourneert de kleinste van de invoerwaarden.max– Retourneert de grootste van de ingevoerde waarden.sum– Telt alle waarden in een iterable op.divmod– Geeft het quotiënt en de rest terug als een tuple.pow– Verheft een getal tot een macht, eventueel met een modulus.int– Converteert een waarde naar een geheel getal.float– Converteert een waarde naar een drijvende-komma getal.
Constanten – Voorgedefinieerde waarden uit de module math.
math.pi– De constante π (pi).math.tau– De constante tau (2π).math.e– Het getal van Euler, grondtal van de natuurlijke logaritme.math.inf– Positieve oneindigheid.math.nan– Geen getal (NaN).
Trigonometrie – Hoeken en de relatie tussen zijden berekenen.
math.sin– Sinus van een hoek in radialen.math.cos– Cosinus van een hoek in radialen.math.tan– Tangens van een hoek in radialen.math.atan– Arctangens van een waarde in radialen.math.atan2– Arctangens van y/x in radialen, rekening houdend met het kwadrant.math.asin– Arcsinus van een waarde in radialen.math.acos– Arccosinus van een waarde in radialen.math.degrees– Zet radialen om in graden.math.radians– Zet graden om in radialen.
Hyperboliek – Geavanceerde functies gerelateerd aan trigonometrie.
math.sinh– Hyperbolische sinus van een waarde.math.cosh– Hyperbolische cosinus van een waarde.math.tanh– Hyperbolische tangens van een waarde.math.asinh– Inverse hyperbolische sinus.math.acosh– Inverse hyperbolische cosinus.math.atanh– Inverse hyperbolische tangens.
Afronding en absolute waarde – Pas de precisie of richting aan.
math.ceil– Rondt af naar het dichtstbijzijnde hele getal.math.floor– Rondt af naar het dichtstbijzijnde hele getal.math.trunc– Verwijdert het decimale gedeelte.math.fabs– Geeft de absolute waarde terug als een float.
Machtsmachten en logaritmen – Macht-, wortel- en logaritme-berekeningen.
math.pow– Verheft een getal tot een macht.math.sqrt– Geeft de vierkantswortel terug.math.exp– Berekent e tot de macht x.math.log– Natuurlijke logaritme (grondtal e).math.log10– Logaritme met grondtal 10.math.log2– Logaritme met grondtal 2.math.factorial– Faculteit van een geheel getal.math.expm1– Nauwkeuriger resultaat voore^x - 1.
Bewerkingen met drijvende-kommawaarden – Drijvende-kommawaarden inspecteren of ontleden.
math.modf– Retourneert het fractionele en gehele deel van een float.math.frexp– Ontbindt een getal in mantissa en exponent.math.fmod– Rest met teken van het deeltal.math.copysign– Geeft een waarde terug met het teken van een andere waarde.math.ldexp– Berekentx * (2 ** exp).
Vergelijking en benadering – Controleer waarden met toleranties of categorieën.
math.isclose– Test of twee waarden ongeveer gelijk zijn.math.isfinite– Controleert of een getal eindig is.math.isinf– Controleert of een getal oneindig is.math.isnan– Controleert of een waarde NaN is.
Fout en gamma – Bijzondere wiskundige functies.
math.gamma– Gammafunctie (gegeneraliseerde faculteit).math.lgamma– Logaritmische gamma.math.erf– Foutfunctie.math.erfc– Complementaire foutfunctie.
Ingebouwde functies#
Python biedt verschillende ingebouwde functies waarmee je wiskundige bewerkingen binnen je project kunt uitvoeren.
abs#
abs geeft de absolute waarde van een getal terug, waarbij elk minteken wordt verwijderd.
Usage:
abs(x)
Parameter |
Beschrijving |
|---|---|
|
Een geheel getal of een decimaal getal. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round op een bepaald aantal decimalen.
Usage:
round(x, ndigits)
Parameter |
Beschrijving |
|---|---|
|
Een geheel getal of een decimaal getal. |
|
Optioneel. Het aantal decimalen waarop afgerond moet worden. De standaardwaarde is 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 retourneert de kleinste waarde uit meerdere argumenten of een iterable.
Usage:
min(arg1, arg2, …) or min(sequence)
Parameter |
Beschrijving |
|---|---|
|
De cijfers ter vergelijking. |
|
Een lijst, tuple of andere reeks die getallen bevat. |
# 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 retourneert de grootste waarde uit meerdere argumenten of een iterable.
Usage:
max(arg1, arg2, …) or max(sequence)
Parameter |
Beschrijving |
|---|---|
|
De cijfers ter vergelijking. |
|
Een lijst, tuple of andere reeks die getallen bevat. |
# 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 telt alle waarden in een iterable op, met een optionele startwaarde.
Usage:
sum(sequence, start)
Parameter |
Beschrijving |
|---|---|
|
Een lijst, tuple of andere reeks die getallen bevat. |
|
Optioneel. Een waarde die bij de som wordt opgeteld. De standaardwaarde is 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 retourneert een tuple met het quotiënt en de rest van een deling.
Usage:
divmod(a, b)
Parameter |
Beschrijving |
|---|---|
|
Het dividend. |
|
De deler. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow verheft een getal tot een macht en voert optioneel een modulo-bewerking uit.
Usage:
pow(x, y, mod)
Parameter |
Beschrijving |
|---|---|
|
Het grondgetal. |
|
De exponent. |
|
Optioneel. Een moduluswaarde. Indien opgegeven, retourneert |
# 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 converteert een getal of tekenreeks naar een geheel getal. Het ondersteunt ook basisconversie bij conversie vanuit een tekenreeks.
Usage:
int(x, base)
Parameter |
Beschrijving |
|---|---|
|
Een getal, tekenreeks of ander object om te converteren. |
|
Optioneel. Het grondtal dat voor de omrekening moet worden gebruikt. Standaard is 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 zet een getal of tekenreeks om in een drijvende-komma getal.
Usage:
float(x)
Parameter |
Beschrijving |
|---|---|
|
Een getal, tekenreeks of ander object om te converteren. |
# 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
Wiskundemodule#
De module math in MicroPython biedt extra methoden voor het uitvoeren van veelvoorkomende wiskundige berekeningen. Deze methoden omvatten trigonometrische, logaritmische en andere numerieke bewerkingen.
De module math wordt standaard geïmporteerd in VEXcode.
Constants#
Constanten zijn vooraf gedefinieerde waarden die tijdens een project vast blijven staan. Ze kunnen in berekeningen worden gebruikt zonder dat ze hoeven te worden gedefinieerd of toegewezen.
pi#
pi geeft de wiskundige constante π, de verhouding tussen de omtrek en de diameter van een cirkel.
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 geeft de waarde van 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 geeft het grondgetal van de natuurlijke logaritme.
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 geeft positieve oneindigheid als een drijvende-kommawaarde.
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 staat voor een speciaal zwevendekommagetal dat staat voor “Not a Number” (NaN).
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#
zonde#
sin berekent de sinus van een hoek in radialen en retourneert een float.
Usage:
math.sin(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt. |
# 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 berekent de cosinus van een hoek in radialen en retourneert een float.
Usage:
math.cos(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
bruinen#
tan berekent de tangens van een hoek in radialen en retourneert een float.
Usage:
math.tan(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt. |
# 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 berekent de inverse tangens (boogtangens) van een getal en retourneert een float die de hoek in radialen weergeeft.
Usage:
math.atan(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal. |
# 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 berekent de hoofdwaarde van de inverse tangens van y/x en retourneert een float die de hoek in radialen weergeeft.
Usage:
math.atan2(y, x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat de y-coördinaat voorstelt. |
|
Een zwevendekommagetal of geheel getal dat de x-coördinaat voorstelt. |
# 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
als#
asin berekent de inverse sinus (arc sinus) van een getal en retourneert een float die de hoek in radialen weergeeft.
Usage:
math.asin(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal tussen -1 en 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 berekent de inverse cosinus (arccosinus) van een getal en retourneert een float die de hoek in radialen weergeeft.
Usage:
math.acos(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal tussen -1 en 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
graden#
degrees zet een hoek om van radialen naar graden.
Usage:
math.degrees(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radialen#
radians zet een hoek om van graden naar radialen.
Usage:
math.radians(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal dat een hoek in graden voorstelt. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh berekent de hyperbolische sinus van x.
Usage:
math.sinh(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
knuppel#
cosh berekent de hyperbolische cosinus van x.
Usage:
math.cosh(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh berekent de hyperbolische tangens van x.
Usage:
math.tanh(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
asinh#
asinh berekent de inverse hyperbolische sinus van x.
Usage:
math.asinh(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
acosh#
acosh berekent de inverse hyperbolische cosinus van x.
Usage:
math.acosh(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal groter dan of gelijk aan 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh berekent de inverse hyperbolische tangens van x.
Usage:
math.atanh(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal tussen -1 en 1 (exclusief). |
# 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#
plafond#
ceil rondt een getal af naar het dichtstbijzijnde hele getal.
Usage:
math.ceil(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of een geheel getal dat naar boven afgerond moet worden. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
vloer#
floor rondt een getal af naar het dichtstbijzijnde hele getal.
Usage:
math.floor(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of een geheel getal dat naar beneden moet worden afgerond. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
afknot#
trunc verwijdert het decimale deel van een getal zonder af te ronden.
Usage:
math.trunc(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal dat moet worden afgekapt. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs retourneert de absolute waarde van een getal als een float.
Usage:
math.fabs(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
kracht#
pow verheft x tot de macht van y en retourneert een drijvende-kommawaarde, zelfs als beide invoerwaarden gehele getallen zijn.
Usage:
math.pow(x, y)
Parameter |
Beschrijving |
|---|---|
|
Een basis van een zwevendekommagetal of een geheel getal. |
|
Een exponent van een zwevendekommagetal of een geheel getal. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
wortel#
sqrt berekent de vierkantswortel van een getal en retourneert een float, zelfs voor perfecte kwadraten.
Usage:
math.sqrt(x)
Parameter |
Beschrijving |
|---|---|
|
Een niet-negatief zwevendekommagetal of geheel getal. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
exp#
exp berekent de macht van een getal en retourneert een drijvende-kommawaarde.
Usage:
math.exp(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of een geheel getal. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
log#
log berekent de natuurlijke logaritme van een getal en retourneert een drijvende-kommawaarde.
Usage:
math.log(x)
Parameter |
Beschrijving |
|---|---|
|
Een positief zwevendekommagetal of geheel getal. |
# 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 berekent de logaritme met grondgetal 10 van een getal en retourneert een drijvende-kommawaarde.
Usage:
math.log10(x)
Parameter |
Beschrijving |
|---|---|
|
Een positief zwevendekommagetal of geheel getal. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
log2 berekent de logaritme met grondgetal 2 van een getal en retourneert een drijvende-kommawaarde, zelfs wanneer x een macht van 2 is.
Usage:
math.log2(x)
Parameter |
Beschrijving |
|---|---|
|
Een positief zwevendekommagetal of geheel getal. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
factorieel#
factorial geeft de faculteit terug van een geheel getal x, wat het product is van alle positieve gehele getallen tot en met x.
Usage:
math.factorial(x)
Parameter |
Beschrijving |
|---|---|
|
Een niet-negatief geheel getal. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 berekent ex - 1, wat nauwkeuriger is voor kleine x.
Usage:
math.expm1(x)
Parameter |
Beschrijving |
|---|---|
|
De exponentwaarde. |
# 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 ontleedt een getal in zijn fractionele en gehele delen en retourneert een tuple (fractional part, integer part), beide als drijvende-kommagetallen.
Usage:
math.modf(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of een geheel getal om te ontbinden. |
# 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 ontleedt een getal in zijn mantissa en exponent en retourneert een tuple (mantissa, exponent), waarbij de mantissa een float is en de exponent een integer.
Usage:
math.frexp(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of een geheel getal om te ontbinden. |
# 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 geeft de rest van de deling terug, waarbij het teken van het deeltal behouden blijft (x).
Usage:
math.fmod(x, y)
Parameter |
Beschrijving |
|---|---|
|
Het dividend. |
|
De deler. |
# 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
auteursrecht#
copysign retourneert x met het teken van y.
Usage:
math.copysign(x, y)
Parameter |
Beschrijving |
|---|---|
|
De waarde die moet worden gewijzigd. |
|
De waarde waarvan het teken gekopieerd zal worden. |
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
robot.screen.print(copysign_result)
# copysign_result = 10.00
ldex#
ldexp berekent x * (2 ** exp), wat gelijk is aan x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parameter |
Beschrijving |
|---|---|
|
De basiswaarde. |
|
De exponent. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
is dichtbij#
isclose controleert of twee getallen binnen een bepaalde tolerantie ongeveer gelijk zijn.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parameter |
Beschrijving |
|---|---|
|
Het eerste getal om te vergelijken. |
|
Het tweede getal om te vergelijken. |
|
Optioneel. Het maximaal toegestane verschil tussen a en b, ten opzichte van hun grootte. De standaardwaarde is 1e-09 (zeer klein). |
|
Optioneel. Een vaste foutmarge, handig bij het vergelijken van getallen die dicht bij nul liggen. De standaardwaarde is 0,0. |
Opmerking: Als zowel rel_tol als abs_tol worden opgegeven, bepaalt de voorwaarde waaraan het eerst wordt voldaan het resultaat.
# 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
is eindig#
isfinite controleert of een getal eindig is. Deze methode retourneert een Booleaanse waarde:
True– Het aantal is eindig.False– Het aantal is oneindig.
Usage:
math.isfinite(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal om te controleren. |
# 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#
isinf controleert of een getal oneindig is. Deze methode retourneert een Booleaanse waarde:
True– Het aantal is oneindig.False– Het aantal is eindig.
Usage:
math.isinf(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal om te controleren. |
# 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#
isnan controleert of een getal NaN (Not a Number) is. Deze methode retourneert een Booleaanse waarde:
True– Het getal is NaN.False– Het getal is een geldig getal.
Usage:
math.isnan(x)
Parameter |
Beschrijving |
|---|---|
|
Een zwevendekommagetal of geheel getal om te controleren. |
# 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 berekent de gammafunctie van x, wat een generalisatie is van de faculteitsfunctie voor reële en complexe getallen. Voor een geheel getal n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parameter |
Beschrijving |
|---|---|
|
Een positief zwevendekommagetal of geheel getal. |
# 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 berekent de natuurlijke logaritme van de gamma functie.
Usage:
math.lgamma(x)
Parameter |
Beschrijving |
|---|---|
|
Een positief zwevendekommagetal of geheel getal. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
robot.screen.print(lgamma_result)
# lgamma_result = 3.18
erf#
erf berekent de foutfunctie van x.
Usage:
math.erf(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc berekent de complementaire foutfunctie van x, die gedefinieerd is als 1 - erf(x).
Usage:
math.erfc(x)
Parameter |
Beschrijving |
|---|---|
|
Een decimaal getal of geheel getal dat de invoerwaarde vertegenwoordigt. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16