Matematik#

Introduktion#

Matematik inkluderar både inbyggda Python-funktioner och den fullständiga math modulen, som automatiskt är tillgänglig i VEXcode VR. Dessa verktyg låter dig utföra allt från grundläggande aritmetik till avancerad trigonometri, avrundning och logaritmiska operationer.

Använd dessa funktioner och konstanter för att beräkna positioner, vinklar, avstånd och andra numeriska värden för din robot. Du kan också konvertera mellan grader och radianer, utvärdera uttryck och arbeta med specialvärden som oändlighet och NaN.

Nedan följer en lista över tillgängliga matematiska funktioner, konstanter och verktyg:

Inbyggda funktioner – Vanliga matematiska verktyg som ingår i Python.

  • abs – Returnerar absolutvärdet av ett tal.

  • round – Avrundar ett tal till ett angivet antal decimaler.

  • min – Returnerar det minsta av indatavärdena.

  • max – Returnerar det största av indatavärdena.

  • sum – Adderar alla värden i en iterabel.

  • divmod – Returnerar kvoten och resten som en tupel.

  • pow – Upphöjer ett tal till en potens, eventuellt med en modul.

  • int – Konverterar ett värde till ett heltal.

  • float – Konverterar ett värde till ett flyttal.

Konstanter – Fördefinierade värden från math modulen.

  • math.pi – Konstanten π (pi).

  • math.tau – Konstanten tau (2π).

  • math.e – Eulers tal, basen för den naturliga logaritmen.

Trigonometri – Beräkna vinklar och förhållandet mellan sidor.

  • math.sin – Sinus för en vinkel i radianer.

  • math.cos – Cosinus för en vinkel i radianer.

  • math.tan – Tangenten till en vinkel i radianer.

  • math.atan – Arcustangent av ett värde i radianer.

  • math.atan2 – Arcustangenten till y/x i radianer, med hänsyn till kvadranten.

  • math.asin – Arcussinus av ett värde i radianer.

  • math.acos – Arcus cosinus av ett värde i radianer.

  • math.degrees – Konverterar radianer till grader.

  • math.radians – Omvandlar grader till radianer.

Avrundning och absolutvärde – Justera precision eller riktning.

  • math.ceil – Avrundar uppåt till närmaste heltal.

  • math.floor – Avrundar nedåt till närmaste heltal.

  • math.trunc – Tar bort decimaldelen.

  • math.fabs – Returnerar absolutvärdet som ett flyttal.

Exponenter och logaritmer – Potens-, rot- och logaritmberäkningar.

  • math.pow – Upphöjer ett tal till en potens.

  • math.sqrt – Returnerar kvadratroten.

  • math.exp – Beräknar e upphöjt till x.

  • math.log – Naturlig logaritm (basen e).

Flyttalsoperationer – Inspektera eller dekompilera flyttalvärden.

  • math.modf – Returnerar bråk- och heltalsdelen av ett flyttal.

  • math.frexp – Delar upp ett tal i mantissa och exponent.

  • math.fmod – Resten med tecken på dividenden.

  • math.copysign – Returnerar ett värde med tecknet för ett annat värde.

  • math.ldexp – Beräknar x * (2 ** exp).

Inbyggda funktioner#

Python erbjuder flera inbyggda funktioner som låter dig utföra matematiska operationer i ditt projekt.

abs#

abs returnerar absolutvärdet av ett tal och tar bort alla negativa tecken.

Usage:
abs(x)

Parameter

Beskrivning

x

Ett heltal eller flyttal

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

    # abs_result = 10

# VR threads — Do not delete
vr_thread(main)

round#

round avrundar ett tal till ett angivet antal decimaler.

Usage:
round(x, ndigits)

Parameter

Beskrivning

x

Ett heltal eller flyttal

ndigits

Valfritt. Antalet decimaler att avrunda till. Standardvärdet är 0.

 
def main():
    # Round 5.7 to the nearest integer
    round_int_result = round(5.7)
    brain.print(round_int_result)

    # round_int_result = 6

# VR threads — Do not delete
vr_thread(main)


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

    # round_result = 3.14

# VR threads — Do not delete
vr_thread(main)

min#

min returnerar det minsta värdet från flera argument eller en iterabel värde.

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

Parameter

Beskrivning

arg1, arg2, …

Siffrorna att jämföra.

sequence

En lista, tupel eller annan sekvens som innehåller tal.

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

    # min_result = 1

# VR threads — Do not delete
vr_thread(main)


def main():
    # Get the smallest value from a list
    min_list_result = min([10, 4, 25, 1])
    brain.print(min_list_result)

    # min_list_result = 1

# VR threads — Do not delete
vr_thread(main)

max#

max returnerar det största värdet från flera argument eller en iterabel.

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

Parameter

Beskrivning

arg1, arg2, …

Siffrorna att jämföra.

sequence

En lista, tupel eller annan sekvens som innehåller tal.

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

    # max_result = 7

# VR threads — Do not delete
vr_thread(main)


def main():
    # Get the largest value from a list
    max_list_result = max([10, 4, 25, 1])
    brain.print(max_list_result)

    # max_list_result = 25

# VR threads — Do not delete
vr_thread(main)

sum#

sum adderar alla värden i en iterabel, med ett valfritt startvärde.

Usage:
sum(sequence, start)

Parameter

Beskrivning

sequence

En lista, tupel eller annan sekvens som innehåller tal.

start

Valfritt. Ett värde att lägga till summan. Standardvärdet är 0.

 
def main():
    # Calculate the sum of a list of numbers
    sum_result = sum([1, 2, 3, 4, 5])
    brain.print(sum_result)

    # sum_result = 15

# VR threads — Do not delete
vr_thread(main)


def main():
    # Calculate the sum of a list with a starting value of 10
    sum_with_start = sum([1, 2, 3], 10)
    brain.print(sum_with_start)

    # sum_with_start = 16

# VR threads — Do not delete
vr_thread(main)

divmod#

divmod returnerar en tupel som innehåller kvoten och resten av en divisionsoperation.

Usage:
divmod(a, b)

Parameter

Beskrivning

a

Utdelningen.

b

Divisorn.

 
def main():
    # Perform integer division and remainder of 10 / 3
    divmod_result = divmod(10, 3)
    brain.print(divmod_result)

    # divmod_result = (3, 1)

# VR threads — Do not delete
vr_thread(main)

pow#

pow upphöjer ett tal till en potens och utför valfritt en modulusoperation.

Usage:
pow(x, y, mod)

Parameter

Beskrivning

x

Basnumret.

y

Exponenten.

mod

Valfritt. Ett modulvärde. Om angivet returneras (x ** y) % mod.

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

    # pow_result = 8

# VR threads — Do not delete
vr_thread(main)

int#

int konverterar ett tal eller en sträng till ett heltal. Den stöder även baskonvertering vid konvertering från en sträng.

Usage:
int(x, base)

Parameter

Beskrivning

x

Ett tal, en sträng eller annat objekt som ska konverteras.

base

Valfritt. Talbasen som ska användas för konvertering. Standardvärdet är 10.

 
def main():
    # Convert a float to an integer to get rid of decimals
    price = 19.99
    price_int = int(price)
    brain.print("{} coins".format(price_int))

    # Output: 19 coins

# VR threads — Do not delete
vr_thread(main)


def main():
    # Convert a string into an integer to use in calculations
    user_input = "55"
    user_number = int(user_input)
    brain.print(user_number * 2)

    # Output: 110

# VR threads — Do not delete
vr_thread(main)

float#

float konverterar ett tal eller en sträng till ett flyttal.

Usage:
float(x)

Parameter

Beskrivning

x

Ett tal, en sträng eller annat objekt som ska konverteras.

 
def main():
    # Convert division result to a float
    num_apples = 6
    num_people = 2
    apples_per_person = float(num_apples) / num_people
    brain.print(apples_per_person)

    # Output: 3.00

# VR threads — Do not delete
vr_thread(main)


def main():
    # Convert a string into a float to use in calculations
    user_input = "23.4"
    user_number = float(user_input)
    brain.print(user_number * 3)

    # Output: 70.20

# VR threads — Do not delete
vr_thread(main)

Matematikmodul#

Modulen math i MicroPython tillhandahåller ytterligare metoder för att utföra vanliga matematiska beräkningar. Dessa metoder inkluderar trigonometriska, logaritmiska och andra numeriska operationer.

Modulen math importeras som standard i VEXcode.

Constants#

Konstanter är fördefinierade värden som förblir fasta under ett projekt. De kan användas i beräkningar utan att kräva någon definition eller tilldelning.

pi#

pi ger den matematiska konstanten π, förhållandet mellan en cirkels omkrets och dess diameter.

Usage:
math.pi

def main():
    # Calculate the area of a circle with radius 5 using pi
    circle_area = math.pi * 5 * 5
    brain.print(circle_area, precision=2)

    # circle_area = 78.54

# VR threads — Do not delete
vr_thread(main)

tau#

tau ger värdet 2π.

Usage:
math.tau

def main():
    # Calculate the circumference of a circle with radius
    circumference = math.tau * 5
    brain.print(circumference, precision=2)

    # circumference = 31.42

# VR threads — Do not delete
vr_thread(main)

e#

e ger basen för den naturliga logaritmen.

Usage:
math.e

def main():
    # Calculate e raised to the power of 2
    e_power = math.pow(math.e, 2)
    brain.print(e_power, precision=2)

    # e_power = 7.39

# VR threads — Do not delete
vr_thread(main)

Trigonometry#

synd#

sin beräknar sinus för en vinkel i radianer och returnerar ett flyttal.

Usage:
math.sin(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som representerar en vinkel i radianer.

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

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

för#

cos beräknar cosinus för en vinkel i radianer och returnerar ett flyttal.

Usage:
math.cos(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som representerar en vinkel i radianer.

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

    # result = 0.50

# VR threads — Do not delete
vr_thread(main)

solbränna#

tan beräknar tangenten till en vinkel i radianer och returnerar ett flyttal.

Usage:
math.tan(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som representerar en vinkel i radianer.

 
def main():
    # Calculate the tangent of 
    # 45 degrees in radians
    result = math.tan(math.radians(45))
    brain.print(result, precision=2)

    # result = 1.00

# VR threads — Do not delete
vr_thread(main)

atan#

atan beräknar den inversa tangenten (bågtangenten) för ett tal och returnerar ett flyttal som representerar vinkeln i radianer.

Usage:
math.atan(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal

 
def main():
    # Calculate the arc tangent 
    # of 1 in degrees
    arc_tan = math.atan(1.0)
    result = math.degrees(arc_tan)
    brain.print(result, precision=2)

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

atan2#

atan2 beräknar huvudvärdet för den inversa tangenten till y/x och returnerar ett flyttal som representerar vinkeln i radianer.

Usage:
math.atan2(y, x)

Parameter

Beskrivning

y

Ett flyttal eller heltal som representerar y-koordinaten.

x

Ett flyttal eller heltal som representerar x-koordinaten.

 
def main():
    # Calculate the inverse tangent 
    # of 1/1 in degrees
    atan2 = math.atan2(1.0, 1.0)
    result = math.degrees(atan2)
    brain.print(result, precision=2)

    # result = 45.00

# VR threads — Do not delete
vr_thread(main)

asin#

asin beräknar den inversa sinusen (arcus sinus) för ett tal och returnerar ett flyttal som representerar vinkeln i radianer.

Usage:
math.asin(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal mellan -1 och 1.

 
def main():
    # Calculate the arc sine 
    # of 0.5 in degrees
    result = math.degrees(math.asin(0.5))
    brain.print(result, precision=2)

    # result = 30.00

# VR threads — Do not delete
vr_thread(main)

acos#

acos beräknar den inversa cosinusen (arc-cosinus) för ett tal och returnerar ett flyttal som representerar vinkeln i radianer.

Usage:
math.acos(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal mellan -1 och 1.

 
def main():
    # Calculate the arc cosine 
    # of 0.5 in degrees
    result = math.degrees(math.acos(0.5))
    brain.print(result, precision=2)

    # result = 60.00

# VR threads — Do not delete
vr_thread(main)

grader#

degrees omvandlar en vinkel från radianer till grader.

Usage:
math.degrees(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som representerar en vinkel i radianer.

 
def main():
    # Convert pi radians to degrees
    degrees_result = math.degrees(math.pi)
    brain.print(degrees_result, precision=2)

    # degrees_result = 180.00

# VR threads — Do not delete
vr_thread(main)

radianer#

radians omvandlar en vinkel från grader till radianer.

Usage:
math.radians(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som representerar en vinkel i grader.

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

    # radians_result = 3.14

# VR threads — Do not delete
vr_thread(main)

Rounding & Absolute Values#

tak#

ceil avrundar ett tal uppåt till närmaste heltal.

Usage:
math.ceil(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som ska avrundas uppåt.

 
def main():
    # Round 3.7 up to the nearest integer
    ceil_result = math.ceil(3.7)
    brain.print(ceil_result)

    # ceil_result = 4

# VR threads — Do not delete
vr_thread(main)

golv#

floor avrundar ett tal nedåt till närmaste heltal.

Usage:
math.floor(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal som ska avrundas nedåt.

 
def main():
    # Round 3.7 down to the nearest integer
    floor_result = math.floor(3.7)
    brain.print(floor_result)

    # floor_result = 3

# VR threads — Do not delete
vr_thread(main)

trunk#

trunc tar bort decimaldelen av ett tal utan avrundning.

Usage:
math.trunc(x)

Parameter

Beskrivning

x

Ett flyttal som ska avkortas.

 
def main():
    # Remove the decimal part of 3.7
    trunc_result = math.trunc(3.7)
    brain.print(trunc_result)

    # trunc_result = 3

# VR threads — Do not delete
vr_thread(main)

fabs#

fabs returnerar absolutvärdet av ett tal som ett flyttal.

Usage:
math.fabs(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal

 
def main():
    # Get the absolute value of -3.7
    fabs_result = math.fabs(-3.7)
    brain.print(fabs_result, precision=2)

    # fabs_result = 3.70

# VR threads — Do not delete
vr_thread(main)

Exponents & Logarithms#

pulver#

pow upphöjer x upphöjt till y och returnerar ett flyttal, även om båda ingångarna är heltal.

Usage:
math.pow(x, y)

Parameter

Beskrivning

x

Ett flyttal eller heltal.

y

En flyttals- eller heltalsexponent.

 
def main():
    # Calculate 2 raised to the power of 3
    power_result = math.pow(2, 3)
    brain.print(power_result, precision=2)

    # power_result = 8.00

# VR threads — Do not delete
vr_thread(main)

kvadrat#

sqrt beräknar kvadratroten ur ett tal och returnerar ett flyttal, även för perfekta kvadrater.

Usage:
math.sqrt(x)

Parameter

Beskrivning

x

Ett icke-negativt flyttal eller heltal.

 
def main():
    # Calculate the square root of 16
    sqrt_result = math.sqrt(16)
    brain.print(sqrt_result, precision=2)

    # sqrt_result = 4.00

# VR threads — Do not delete
vr_thread(main)

exp#

exp beräknar exponentialvärdet för ett tal och returnerar ett flyttal.

Usage:
math.exp(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal

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

    # exp_result = 2.72

# VR threads — Do not delete
vr_thread(main)

logga#

log beräknar den naturliga logaritmen för ett tal och returnerar ett flyttal.

Usage:
math.log(x)

Parameter

Beskrivning

x

Ett positivt flyttal eller heltal

 
def main():
    # Calculate the natural logarithm
    # (base e) of 7.389056
    log_result = math.log(7.389056)
    brain.print(log_result, precision=2)

    # log_result = 2.00

# VR threads — Do not delete
vr_thread(main)

logg10#

log10 beräknar logaritmen med basen 10 för ett tal och returnerar ett flyttal.

Usage:
math.log10(x)

Parameter

Beskrivning

x

Ett positivt flyttal eller heltal

 
def main():
    # Calculate the log10 of 100
    log_result = math.log10(100)
    brain.print(log_result)

    # log_result = 2

# VR threads — Do not delete
vr_thread(main)

Floating Point Operations#

modf#

modf uppdelar ett tal i dess bråk- och heltalsdelar och returnerar en tupel (fractional part, integer part), båda som flyttal.

Usage:
math.modf(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal att dekomponera.

 
def main():
    # Decompose 3.14159 into fractional and integer parts
    fractional_part, integer_part = math.modf(3.14159)
    brain.print(fractional_part, precision=2)
    brain.new_line()
    brain.print(integer_part, precision=2)

    # fractional_part = 0.14
    # integer_part = 3.00

# VR threads — Do not delete
vr_thread(main)

frex#

frexp sönderdelar ett tal i dess mantissa och exponent och returnerar en tupel (mantissa, exponent), där mantissan är ett flyttal och exponenten är ett heltal.

Usage:
math.frexp(x)

Parameter

Beskrivning

x

Ett flyttal eller heltal att dekomponera.

 
def main():
    # Decompose 16 into its mantissa and exponent
    mantissa, exponent = math.frexp(16)
    brain.print(mantissa, precision=2)
    brain.new_line()
    brain.print(exponent)

    # mantissa = 0.50
    # exponent = 5

# VR threads — Do not delete
vr_thread(main)

fmod#

fmod returnerar resten av divisionen samtidigt som dividendens tecken (x) bibehålls.

Usage:
math.fmod(x, y)

Parameter

Beskrivning

x

Utdelningen.

y

Divisorn.

 
def main():
    # Calculate remainder of 10 / 3
    # that preserves the sign of 10
    fmod_result = math.fmod(10, 3)
    brain.print(fmod_result, precision=2)

    # fmod_result = 1.00

# VR threads — Do not delete
vr_thread(main)

kopieringssignering#

copysign returnerar x med tecknet y.

Usage:
math.copysign(x, y)

Parameter

Beskrivning

x

Värdet som ska ändras.

y

Det värde vars tecken ska kopieras.

 
def main():
    # Return -10 with the sign of 3 (positive)
    copysign_result = math.copysign(-10, 3)
    brain.print(copysign_result, precision=2)

    # copysign_result = 10.00

# VR threads — Do not delete
vr_thread(main)

ldexp#

ldexp beräknar x * (2 ** exp), vilket motsvarar x * 2exp{code}.

Usage:
math.ldexp(x, exp)

Parameter

Beskrivning

x

Basvärdet.

exp

Exponenten.

 
def main():
    # Compute 3 * (2 ** 4)
    ldexp_result = math.ldexp(3, 4)
    brain.print(ldexp_result, precision=2)

    # ldexp_result = 48.00

# VR threads — Do not delete
vr_thread(main)
On this page