Matematik#

Introduktion #

Matematik inkluderar både inbyggda Python-funktioner och den fullständiga math modulen, som automatiskt finns tillgänglig i VEXcode EXP. 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.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.

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

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

# abs_result = 10

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.

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

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

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

# 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 returnerar en tupel som innehåller kvoten och resten av en divisionsoperation.

Usage:
divmod(a, b)

Parameter	Beskrivning
`a`	Utdelningen.
`b`	Divisorn.

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

# divmod_result = (3, 1)

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

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

# pow_result = 8

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.

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

# 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 ger basen för den naturliga logaritmen.

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 #

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.

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

# result = 0.50

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.

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

# result = 0.50

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.

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

# result = 1.00

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.

# 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 beräknar den inversa cosinusen (arcus 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.

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

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

# 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

grader #

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

Usage:
math.degrees(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar en vinkel i radianer.

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

# degrees_result = 180.00

radianer #

radians konverterar en vinkel från grader till radianer som ett flyttal.

Usage:
math.radians(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar en vinkel i grader.

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

# radians_result = 3.14

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.

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

# ceil_result = 4

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.

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

# floor_result = 3

trunk #

trunc tar bort decimaldelen av ett tal utan avrundning.

Usage:
math.trunc(x)

Parameter	Beskrivning
`x`	Ett flyttal som ska avkortas.

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

# trunc_result = 3

fabs #

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

Usage:
math.fabs(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal

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

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.

# 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

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.

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

# power_result = 8.00

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.

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

# square_root = 4.00

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

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

# 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

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.

# 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 returnerar resten av divisionen samtidigt som dividendens tecken (x ) bibehålls.

Usage:
math.fmod(x, y)

Parameter	Beskrivning
`x`	Utdelningen.
`y`	Divisorn.

# 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

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.

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

# copysign_result = 10

ldexp #

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

Usage:
math.ldexp(x, exp)

Parameter	Beskrivning
`x`	Basvärdet.
`exp`	Exponenten.

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

# ldexp_result = 48