Matematik#

Introduktion#

Matematik inkluderar både inbyggda Python-funktioner och den fullständiga math modulen, som automatiskt är tillgänglig i VEXcode GO. 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 – Beräkna logaritmen till x.

  • math.log10 – Beräknar logaritmen av x med basen 10.

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.

  • 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)
    console.print(abs_result)

# abs_result = 10

# Start threads — Do not delete
start_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)
    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 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)
    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 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)
    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 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])
    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 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)
    console.print(divmod_result)

# divmod_result = (3, 1)

# Start threads — Do not delete
start_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)
    console.print(pow_result)

# pow_result = 8

# Start threads — Do not delete
start_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)
    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 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.

 
# 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

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
    console.print(circle_area, precision=2)

# circle_area = 78.54

# Start threads — Do not delete
start_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
    console.print(circumference, precision=2)

# circumference = 31.42

# Start threads — Do not delete
start_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)
    console.print(e_power, precision=2)

# e_power = 7.39

# Start threads — Do not delete
start_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))
    console.print(result, precision=2)

# result = 0.50

# Start threads — Do not delete
start_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))
    console.print(result, precision=2)

# result = 0.50

# Start threads — Do not delete
start_thread(main)

solbränna#

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

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))
    console.print(result)

# result = 1

# Start threads — Do not delete
start_thread(main)

asin#

asin beräknar invers sinus (arcus sinus) för ett tal och returnerar ett heltal 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))
    console.print(result)

# result = 30

# Start threads — Do not delete
start_thread(main)

acos#

acos beräknar den inversa cosinusen (arc-cosinus) för ett tal och returnerar ett heltal 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))
    console.print(result)

# result = 60

# Start threads — Do not delete
start_thread(main)

atan#

atan beräknar den inversa tangenten (bågtangenten) för ett tal och returnerar ett heltal 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)
    console.print(result)

# result = 45

# Start threads — Do not delete
start_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)
    console.print(result)

# result = 45

# Start threads — Do not delete
start_thread(main)

grader#

degrees konverterar en vinkel från radianer till grader och returnerar ett heltal.

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)
    console.print(degrees_result)

# degrees_result = 180

# Start threads — Do not delete
start_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)
    console.print(radians_result, precision=2)

# radians_result = 3.14

# Start threads — Do not delete
start_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)
    console.print(ceil_result)

# ceil_result = 4

# Start threads — Do not delete
start_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)
    console.print(floor_result)

# floor_result = 3

# Start threads — Do not delete
start_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)
    console.print(trunc_result)

# trunc_result = 3

# Start threads — Do not delete
start_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)
    console.print(fabs_result, precision=1)

# fabs_result = 3.7

# Start threads — Do not delete
start_thread(main)

Exponents & Logarithms#

logga#

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

Usage:
math.log(x, base)

Parameter

Beskrivning

x

Ett positivt flyttal eller heltal

base

Valfritt. Logaritmbasen som ska användas. Som standard är detta den naturliga logaritmen.

 
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)

logg10#

log10 beräknar 10-baslogaritmen för ett tal och returnerar ett flyttal.

Usage:
math.log10(x)

Parameter

Beskrivning

x

Ett positivt flyttal eller heltal

 
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)

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)
    console.print(power_result)

    # power_result = 8

# Start threads — Do not delete
start_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 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 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)
    console.print(exp_result, precision=2)

# exp_result = 2.72

# Start threads — Do not delete
start_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)
    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)

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)
    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 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)
    console.print(fmod_result)

# fmod_result = 1

# Start threads — Do not delete
start_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)
    console.print(copysign_result)

# copysign_result = 10

# Start threads — Do not delete
start_thread(main)

ldexp#

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

Usage:
math.ldexp(x, exp)

Parameter

Beskrivning

x

Basvärdet.

exp

Exponenten.

 
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