Matematik#

Introduktion #

Matematik inkluderar både inbyggda Python-funktioner och den fullständiga math modulen, som automatiskt finns tillgänglig i VEXcode AIM. 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.
math.inf – Positiv oändlighet.
math.nan – Inte ett tal (NaN).

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.

Hyperbolik – Avancerade trigonometriska funktioner.

math.sinh – Hyperbolisk sinus av ett värde.
math.cosh – Hyperbolisk cosinus för ett värde.
math.tanh – Hyperbolisk tangens för ett värde.
math.asinh – Invers hyperbolisk sinus.
math.acosh – Invers hyperbolisk cosinus.
math.atanh – Invers hyperbolisk tangent.

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).
math.log10 – Logaritm med basen 10.
math.log2 – Bas-2-logaritmen.
math.factorial – Faktorial för ett heltal.
math.expm1 – Mer exakt resultat för e^x - 1.

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

Jämförelse och approximation – Kontrollera värden med toleranser eller kategorier.

math.isclose – Testar om två värden är ungefär lika.
math.isfinite – Kontrollerar om ett tal är ändligt.
math.isinf – Kontrollerar om ett tal är oändligt.
math.isnan – Kontrollerar om ett värde är NaN.

Fel och gamma – Speciella matematiska funktioner.

math.gamma – Gammafunktion (generaliserad faktoriell).
math.lgamma – Logaritmisk gamma.
math.erf – Felfunktion.
math.erfc – Komplementär felfunktion.

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)
robot.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)
robot.screen.print(round_int_result)

# round_int_result = 6

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

# 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)
robot.screen.print(min_result)

# min_result = 1

# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
robot.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)
robot.screen.print(max_result)

# max_result = 7

# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
robot.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])
robot.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)
robot.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)
robot.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)
robot.screen.print(pow_result)

# pow_result = 8

# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
robot.screen.print(pow_mod_result)

# pow_mod_result = 6

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)
robot.screen.print(f"{price_int} coins")

# Output: 19 coins

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

# circle_area = 78.54

tau #

tau ger värdet 2π.

Usage:
math.tau

# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)

# circumference = 31.42

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)
robot.screen.print(e_power)

# e_power = 7.39

inf #

inf ger positiv oändlighet som flyttal.

Usage:
math.inf

# Check if infinity is infinite
inf_value = math.inf

if math.isinf(inf_value):
    robot.screen.print("Infinity")

# Prints "Infinity"

nan #

nan representerar ett speciellt flyttal för “Inte ett nummer” (NaN).

Usage:
math.nan

# Check if nan is Not a Number
nan_value = math.nan

if math.isnan(nan_value):
    robot.screen.print("Not a Number")

# Prints "Not a Number"

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
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)

# sine_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
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)

# cosine_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
tangent_result = math.tan(math.radians(45))
robot.screen.print(tangent_result)

# tangent_result = 1.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_tangent_result = math.degrees(math.atan(1.0))
robot.screen.print(arc_tangent_result)

# arc_tangent_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_result = math.degrees(math.atan2(1.0, 1.0))
robot.screen.print(atan2_result)

# atan2_result = 45.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
arc_sine_result = math.degrees(math.asin(0.5))
robot.screen.print(arc_sine_result)

# arc_sine_result = 30.00

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.

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

# arc_cosine_result = 60.00

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.

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

# degrees_result = 180.00

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.

# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)

# radians_result = 3.14

Hyperbolics #

sinh #

sinh beräknar den hyperboliska sinusen för x.

Usage:
math.sinh(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)

# sinh_result = 1.18

kosh #

cosh beräknar den hyperboliska cosinus för x.

Usage:
math.cosh(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)

# cosh_result = 1.54

tanh #

tanh beräknar den hyperboliska tangenten av x.

Usage:
math.tanh(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)

# tanh_result = 0.76

asinh #

asinh beräknar den inversa hyperboliska sinusen av x.

Usage:
math.asinh(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)

# asinh_result = 0.88

akosh #

acosh beräknar den inversa hyperboliska cosinusen av x.

Usage:
math.acosh(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal större än eller lika med 1.

# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)

# acosh_result = 1.32

atanh #

atanh beräknar den inversa hyperboliska tangenten av x.

Usage:
math.atanh(x)

Parameter	Beskrivning
`x`	Ett flyttal mellan -1 och 1 (exklusivt).

# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
robot.screen.print(atanh_result)

# atanh_result = 0.55

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)
robot.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)
robot.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)
robot.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)
robot.screen.print(fabs_result)

# fabs_result = 3.70

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.

# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.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
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)

# sqrt_result = 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)
robot.screen.print(exp_result)

# exp_result = 2.72

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

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

# log_result = 2.00

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

# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)

# log10_result = 3.00

logg2 #

log2 beräknar logaritmen med basen 2 för ett tal och returnerar ett flyttal, även när x är en potens av 2.

Usage:
math.log2(x)

Parameter	Beskrivning
`x`	Ett positivt flyttal eller heltal

# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)

# log2_result = 3.00

faktorial #

factorial returnerar faktorialen av ett heltal x, vilket är produkten av alla positiva heltal upp till x.

Usage:
math.factorial(x)

Parameter	Beskrivning
`x`	Ett icke-negativt heltal.

# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)

# factorial_result = 120

expm1 #

expm1 beräknar e^x - 1, vilket är mer exakt för små x.

Usage:
math.expm1(x)

Parameter	Beskrivning
`x`	Exponentvärdet.

# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
robot.screen.print(expm1_result)

# expm1_result = 1.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)
robot.screen.print(fractional_part)
robot.screen.next_row()
robot.screen.print(integer_part)

# fractional_part = 0.14
# integer_part = 3.00

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)
robot.screen.print(mantissa)
robot.screen.next_row()
robot.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)
robot.screen.print(fmod_result)

# fmod_result = 1.00

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)
robot.screen.print(copysign_result)

# copysign_result = 10.00

ldexp #

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

Usage:
math.ldexp(x, exp)

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

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

# ldexp_result = 48.00

Comparison & Approximation #

är nära #

isclose kontrollerar om två tal är ungefär lika inom en tolerans.

Usage:
math.isclose(a, b, rel_tol, abs_tol)

Parameter	Beskrivning
`a`	Det första numret att jämföra.
`b`	Det andra numret att jämföra.
`rel_tol`	Valfritt. Den maximalt tillåtna skillnaden mellan a och b, i förhållande till deras storlek. Standardvärdet är 1e-09 (mycket liten).
`abs_tol`	Valfritt. En fast felmarginal, användbar vid jämförelse av tal nära noll. Standardvärdet är 0,0.

Obs: Om både rel_tol och abs_tol anges, avgör det villkor som uppfylls först resultatet.

# Check if 1.000000001 and 1.0 are close
# within the default tolerance
isclose_result = math.isclose(1.000000001, 1.0)
robot.screen.print(isclose_result)

# isclose_result = True

# Check if 0.0000001 and 0.0 are close
# using absolute tolerance
isclose_result = math.isclose(0.0000001, 0.0, abs_tol=1e-07)
robot.screen.print(isclose_result)

# isclose_result = True

# Check if 1000000.0 and 1000000.1 are close
# with a stricter tolerance
isclose_result = math.isclose(1000000.0, 1000000.1, rel_tol=1e-10)
robot.screen.print(isclose_result)

# isclose_result = False

är oändlig #

isfinite kontrollerar om ett tal är ändligt. Denna metod returnerar ett booleskt värde:

True – Talet är ändligt.
False – Talet är oändligt.

Usage:
math.isfinite(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal att kontrollera.

# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
robot.screen.print(is_finite_true)

# is_finite_true = True

# Check if infinity is a finite number (returns False)
is_finite_false = math.isfinite(math.inf)
robot.screen.print(is_finite_false)

# is_finite_false = False

isinf #

isinf kontrollerar om ett tal är oändligt. Denna metod returnerar ett booleskt värde:

True – Talet är oändligt.
False – Talet är ändligt.

Usage:
math.isinf(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal att kontrollera.

# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
robot.screen.print(is_inf_true)

# is_inf_true = True

# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
robot.screen.print(is_inf_false)

# is_inf_false = False

isnan #

isnan kontrollerar om ett tal är NaN (Inte ett tal). Denna metod returnerar ett booleskt värde:

True – Talet är NaN.
False – Numret är ett giltigt nummer.

Usage:
math.isnan(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal att kontrollera.

# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
robot.screen.print(is_nan_true)

# is_nan_true = True

# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
robot.screen.print(is_nan_false)

# is_nan_false = False

Error and Gamma Calculations #

gamma #

gamma beräknar gammafunktionen för x, vilket generaliserar faktorfunktionen för reella och komplexa tal. För ett heltal n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

Parameter	Beskrivning
`x`	Ett positivt flyttal eller heltal

# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)

# gamma_result = 24.00

lgamma #

lgamma beräknar den naturliga logaritmen för gamma -funktionen.

Usage:
math.lgamma(x)

Parameter	Beskrivning
`x`	Ett positivt flyttal eller heltal

# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
robot.screen.print(lgamma_result)

# lgamma_result = 3.18

tomt #

erf beräknar felfunktionen för x.

Usage:
math.erf(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)

# erf_result = 0.84

erfc #

erfc beräknar den komplementära felfunktionen för x, vilken definieras som 1 - erf(x).

Usage:
math.erfc(x)

Parameter	Beskrivning
`x`	Ett flyttal eller heltal som representerar inmatningsvärdet.

# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)

# erfc_result = 0.16