Wiskunde#

Invoering#

De wiskundige module bevat zowel ingebouwde Python-functies als de volledige math module, die automatisch beschikbaar is in VEXcode GO. 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.

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.

  • math.log10 – Berekent de logaritme met grondtal 10 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.

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

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

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

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

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

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

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

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

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 geeft de waarde van 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 geeft het grondgetal van de natuurlijke logaritme.

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#

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.

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

 
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)

bruinen#

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

Usage:
math.tan(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

 
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)

als#

asin berekent de inverse sinus (arc sinus) van een getal en retourneert een geheel getal dat de hoek in radialen weergeeft.

Usage:
math.asin(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of een geheel getal tussen -1 en 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 berekent de inverse cosinus (arccosinus) van een getal en retourneert een geheel getal dat de hoek in radialen weergeeft.

Usage:
math.acos(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of een geheel getal tussen -1 en 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 berekent de inverse tangens (boogtangens) van een getal en retourneert een geheel getal dat de hoek in radialen weergeeft.

Usage:
math.atan(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of een geheel getal.

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

 
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)

graden#

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

Usage:
math.degrees(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of geheel getal dat een hoek in radialen voorstelt.

 
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)

radialen#

radians zet een hoek om van graden naar radialen.

Usage:
math.radians(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of geheel getal dat een hoek in graden voorstelt.

 
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#

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.

 
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)

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.

 
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)

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.

 
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)

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.

 
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#

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.

 
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 berekent de logaritme met grondgetal 10 van een getal en retourneert een drijvende-kommawaarde.

Usage:
math.log10(x)

Parameter

Beschrijving

x

Een positief zwevendekommagetal of geheel getal.

 
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)

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.

 
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)

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.

 
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 berekent de macht van een getal en retourneert een drijvende-kommawaarde.

Usage:
math.exp(x)

Parameter

Beschrijving

x

Een zwevendekommagetal of een geheel getal.

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

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

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

 
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)

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.

 
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)

ldex#

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

Usage:
math.ldexp(x, exp)

Parameter

Beschrijving

x

De basiswaarde.

exp

De 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)
On this page