Wiskunde#

Invoering #

De wiskundige module bevat zowel ingebouwde Python-functies als de volledige math module, die automatisch beschikbaar is in VEXcode V5. Met deze tools kunt u alles uitvoeren, van eenvoudige rekenkundige bewerkingen tot geavanceerde trigonometrie, afronding 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.e – Het getal van Euler, grondtal van de natuurlijke logaritme.

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.

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 – Bereken de logaritme van x.

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

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
`x`	Een geheel getal of een decimaal getal.

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

# abs_result = 10

round #

round op een bepaald aantal decimalen.

Usage:
round(x, ndigits)

Parameter	Beschrijving
`x`	Een geheel getal of een decimaal getal.
`ndigits`	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)
brain.screen.print(round_int_result)

# round_int_result = 6

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

# 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
`arg1`, `arg2`, …	De cijfers ter vergelijking.
`sequence`	Een lijst, tuple of andere reeks die getallen bevat.

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

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
brain.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
`arg1`, `arg2`, …	De cijfers ter vergelijking.
`sequence`	Een lijst, tuple of andere reeks die getallen bevat.

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

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
brain.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
`sequence`	Een lijst, tuple of andere reeks die getallen bevat.
`start`	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])
brain.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)
brain.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
`a`	Het dividend.
`b`	De deler.

# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
brain.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
`x`	Het grondgetal.
`y`	De exponent.
`mod`	Optioneel. Een moduluswaarde. Indien opgegeven, retourneert `(x ** y) % mod`.

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

# pow_result = 8

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
`x`	Een getal, tekenreeks of ander object om te converteren.
`base`	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)
brain.screen.print("{} coins".format(price_int))

# Output: 19 coins

# Convert a string into an integer to use in calculations
user_input = "55"
user_number = int(user_input)
brain.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
`x`	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
brain.screen.print(circle_area, precision=2)

# circle_area = 78.54

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)
brain.screen.print(e_power, precision=2)

# e_power = 7.39

Trigonometry #

zonde #

sin berekent de sinus van een hoek in radialen en retourneert een float.

Usage:
math.sin(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

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

# result = 0.50

cos #

cos berekent de cosinus van een hoek in radialen en retourneert een float.

Usage:
math.cos(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

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

# result = 0.50

bruinen #

tan berekent de tangens van een hoek in radialen en retourneert een float.

Usage:
math.tan(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

# Calculate the tangent of 
# 45 degrees in radians
result = math.tan(math.radians(45))
brain.screen.print(result)

# result = 1.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
`x`	Een zwevendekommagetal of een geheel getal tussen -1 en 1.

# Calculate the arc sine 
# of 0.5 in degrees
result = math.degrees(math.asin(0.5))
brain.screen.print(result)

# 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
`x`	Een zwevendekommagetal of een geheel getal tussen -1 en 1.

# Calculate the arc cosine 
# of 0.5 in degrees
result = math.degrees(math.acos(0.5))
brain.screen.print(result)

# result = 60.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
`x`	Een zwevendekommagetal of een geheel getal.

# Calculate the arc tangent 
# of 1 in degrees
arc_tan = math.atan(1.0)
result = math.degrees(arc_tan)
brain.screen.print(result)

# 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
`y`	Een zwevendekommagetal of geheel getal dat de y-coördinaat voorstelt.
`x`	Een zwevendekommagetal of geheel getal dat de x-coördinaat voorstelt.

# Calculate the inverse tangent 
# of 1/1 in degrees
atan2 = math.atan2(1.0, 1.0)
result = math.degrees(atan2)
brain.screen.print(result)

# result = 45.00

graden #

degrees zet een hoek om van radialen naar graden en retourneert een float.

Usage:
math.degrees(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

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

# degrees_result = 180.00

radialen #

radians zet een hoek om van graden naar radialen als een zwevendekommagetal.

Usage:
math.radians(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of geheel getal dat een hoek in graden voorstelt.

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

# radians_result = 3.14

Rounding & Absolute Values #

plafond #

ceil rondt een getal af naar het dichtstbijzijnde hele getal.

Usage:
math.ceil(x)

Parameter	Beschrijving
`x`	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)
brain.screen.print(ceil_result)

# ceil_result = 4

vloer #

floor rondt een getal af naar het dichtstbijzijnde hele getal.

Usage:
math.floor(x)

Parameter	Beschrijving
`x`	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)
brain.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
`x`	Een zwevendekommagetal dat moet worden afgekapt.

# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
brain.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
`x`	Een zwevendekommagetal of een geheel getal.

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
brain.screen.print(fabs_result, precision=1)

# fabs_result = 3.7

Exponents & Logarithms #

log #

log berekent de logaritme van een getal en retourneert een drijvende-kommawaarde.

Usage:
math.log(x, base)

Parameter	Beschrijving
`x`	Een positief zwevendekommagetal of geheel getal.
`base`	Optioneel. Het grondtal van de logaritme. Standaard is dit de natuurlijke logaritme.

# Calculate the natural logarithm
# (base e) of 7.389056
log_result = math.log(7.389056)
brain.screen.print(log_result)

# log_result = 2.00

# Calculate the log base 2 of 8
log_result = math.log(8, 2)
brain.screen.print(log_result)

# log_result = 3.00

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
`x`	Een basis van een zwevendekommagetal of een geheel getal.
`y`	Een exponent van een zwevendekommagetal of een geheel getal.

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
brain.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
`x`	Een niet-negatief zwevendekommagetal of geheel getal.

# Calculate the square root of 16
square_root = math.sqrt(16)
brain.screen.print(square_root)

# square_root = 4.00

exp #

exp berekent de macht van een getal en retourneert een drijvende-kommawaarde.

Usage:
math.exp(x)

Parameter	Beschrijving
`x`	Een zwevendekommagetal of een geheel getal.

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

# exp_result = 2.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
`x`	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)
brain.screen.print(fractional_part, precision=2)

brain.screen.print(integer_part)

# fractional_part = 0.14
# integer_part = 3

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
`x`	Een decimaal getal of een geheel getal om te ontbinden.

# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
brain.screen.print(mantissa, precision=2)

brain.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
`x`	Het dividend.
`y`	De deler.

# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
brain.screen.print(fmod_result)

# fmod_result = 1

auteursrecht #

copysign retourneert x met het teken van y.

Usage:
math.copysign(x, y)

Parameter	Beschrijving
`x`	De waarde die moet worden gewijzigd.
`y`	De waarde waarvan het teken gekopieerd zal worden.

# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
brain.screen.print(copysign_result)

# copysign_result = 10

ldex #

ldexp berekent x * (2 ** exp), wat gelijk is aan x * 2^exp.

Usage:
math.ldexp(x, exp)

Parameter	Beschrijving
`x`	De basiswaarde.
`exp`	De exponent.

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

# ldexp_result = 48