Matematik#
Introduktion#
Matematik inkluderar både inbyggda Python-funktioner och den fullständiga math modulen, som automatiskt finns tillgänglig i VEXcode AIR. 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 VEX AIR Drone Controller. Du kan också konvertera mellan grader och radianer, utvärdera uttryck och arbeta med specialvärden som oändlighet och NaN.
Obs! Om inget annat uttryckligen anges är alla returvärden flyttal formaterade till exakt fem decimaler. Värden med fler än fem decimaler avrundas, och värden med färre än fem decimaler utökas med nollor så att exakt fem decimaler alltid visas.
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.asin– Arcussinus av ett värde i radianer.math.acos– Arcus cosinus av ett värde 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.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öre^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.math.ldexp– Beräknarx * (2 ** exp).
Jämförelse och approximation – Kontrollera värden med toleranser eller kategorier.
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 |
|---|---|
|
Ett heltal eller flyttal |
# Get the absolute value of -10
abs_result = abs(-10)
controller.screen.print(abs_result)
# abs_result = 10
round#
round returnerar ett avrundat tal till ett angivet antal decimaler som ett heltal.
Usage:
round(x, ndigits)
Parameter |
Beskrivning |
|---|---|
|
Ett heltal eller flyttal |
|
Valfritt. Styr hur många decimaler som ska avrundas till (mellan 0 och 5). Standardvärdet är 0. När den här parametern används returnerar |
# Round 5.7 to the nearest integer
round_int_result = round(5.7)
controller.screen.print(round_int_result)
# round_int_result = 6
# Round 3.14159 to 2 decimal places
round_result = round(3.14159, 2)
controller.screen.print(round_result)
# round_result = 3.14000
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 |
|---|---|
|
Siffrorna att jämföra. |
|
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)
controller.screen.print(min_result)
# min_result = 1
# Get the smallest value from a list
min_list_result = min([10, 4, 25, 1])
controller.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 |
|---|---|
|
Siffrorna att jämföra. |
|
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)
controller.screen.print(max_result)
# max_result = 7
# Get the largest value from a list
max_list_result = max([10, 4, 25, 1])
controller.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 |
|---|---|
|
En lista, tupel eller annan sekvens som innehåller tal. |
|
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])
controller.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)
controller.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 |
|---|---|
|
Utdelningen. |
|
Divisorn. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow returnerar ett tal upphöjt till en potens och utför eventuellt en modulusoperation som ett heltal.
Usage:
pow(x, y, mod)
Parameter |
Beskrivning |
|---|---|
|
Basnumret. |
|
Exponenten. |
|
Valfritt. Ett modulvärde. Om angivet returneras |
# Calculate 2 raised to the power of 3
pow_result = pow(2, 3)
controller.screen.print(pow_result)
# pow_result = 8
# Calculate (5 ** 3) % 7
pow_mod_result = pow(5, 3, 7)
controller.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 |
|---|---|
|
Ett tal, en sträng eller annat objekt som ska konverteras. |
|
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)
controller.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)
controller.screen.print(user_number * 2)
# Output: 110
float#
float konverterar ett tal eller en sträng till ett flyttal.
Usage:
float(x)
Parameter |
Beskrivning |
|---|---|
|
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
controller.screen.print(apples_per_person)
# Output: 3.00000
# Convert a string into a float to use in calculations
user_input = "23.4"
user_number = float(user_input)
controller.screen.print(user_number * 3)
# Output: 70.20000
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
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau ger värdet 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
controller.screen.print(circumference)
# circumference = 31.41593
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)
controller.screen.print(e_power)
# e_power = 7.38906
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):
controller.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):
controller.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 |
|---|---|
|
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))
controller.screen.print(sine_result)
# sine_result = 0.50000
för#
cos beräknar cosinus för en vinkel i radianer och returnerar ett flyttal.
Usage:
math.cos(x)
Parameter |
Beskrivning |
|---|---|
|
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))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
solbränna#
tan beräknar tangenten till en vinkel i radianer och returnerar ett flyttal.
Usage:
math.tan(x)
Parameter |
Beskrivning |
|---|---|
|
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))
controller.screen.print(tangent_result)
# tangent_result = 1.00000
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 |
|---|---|
|
Ett flyttal eller heltal mellan -1 och 1. |
# Calculate the arc sine of 0.5 in radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
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 |
|---|---|
|
Ett flyttal eller heltal mellan -1 och 1. |
# Calculate the arc cosine of 0.5 in radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
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 |
|---|---|
|
Ett flyttal eller heltal |
# Calculate the arc tangent of 1 in radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
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 |
|---|---|
|
Ett flyttal eller heltal som representerar y-koordinaten. |
|
Ett flyttal eller heltal som representerar x-koordinaten. |
# Calculate the inverse tangent of (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
grader#
degrees omvandlar en vinkel från radianer till grader.
Usage:
math.degrees(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar en vinkel i radianer. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
radianer#
radians omvandlar en vinkel från grader till radianer.
Usage:
math.radians(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar en vinkel i grader. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
controller.screen.print(radians_result)
# radians_result = 3.14159
Hyperbolics#
sinh#
sinh beräknar den hyperboliska sinusen för x.
Usage:
math.sinh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
kosh#
cosh beräknar den hyperboliska cosinus för x.
Usage:
math.cosh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
tanh#
tanh beräknar den hyperboliska tangenten av x.
Usage:
math.tanh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
asinh#
asinh beräknar den inversa hyperboliska sinusen av x.
Usage:
math.asinh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
akosh#
acosh beräknar den inversa hyperboliska cosinusen av x.
Usage:
math.acosh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal större än eller lika med 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
atanh#
atanh beräknar den inversa hyperboliska tangenten av x.
Usage:
math.atanh(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal mellan -1 och 1 (exklusivt). |
# Calculate the inverse hyperbolic tangent of 0.5
atanh_result = math.atanh(0.5)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
Rounding & Absolute Values#
tak#
ceil avrundar ett tal uppåt till närmaste heltal.
Usage:
math.ceil(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som ska avrundas uppåt. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
controller.screen.print(ceil_result)
# ceil_result = 4
golv#
floor avrundar ett tal nedåt till närmaste heltal.
Usage:
math.floor(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som ska avrundas nedåt. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
controller.screen.print(floor_result)
# floor_result = 3
trunk#
trunc tar bort decimaldelen av ett tal utan avrundning.
Usage:
math.trunc(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal som ska avkortas. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
controller.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs returnerar absolutvärdet av ett tal som ett flyttal.
Usage:
math.fabs(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
pulver#
pow upphöjer x upphöjt till potensen y (xy) och returnerar ett flyttal.
Usage:
math.pow(x, y)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal. |
|
En flyttals- eller heltalsexponent. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
controller.screen.print(power_result)
# power_result = 8.00000
kvadrat#
sqrt beräknar kvadratroten ur ett tal och returnerar ett flyttal.
Usage:
math.sqrt(x)
Parameter |
Beskrivning |
|---|---|
|
Ett icke-negativt flyttal eller heltal. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
exp#
exp returnerar e upphöjt till potensen x (ex) och som ett flyttal.
Usage:
math.exp(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
controller.screen.print(exp_result)
# exp_result = 2.71828
logga#
log beräknar den naturliga logaritmen för ett tal och returnerar ett flyttal.
Usage:
math.log(x)
Parameter |
Beskrivning |
|---|---|
|
Ett positivt flyttal eller heltal |
# Calculate the natural logarithm (base e) of 7.389056
log_result = math.log(7.389056)
controller.screen.print(log_result)
# log_result = 2.00000
logg10#
log10 beräknar 10-baslogaritmen för ett tal och returnerar ett flyttal.
Usage:
math.log10(x)
Parameter |
Beskrivning |
|---|---|
|
Ett positivt flyttal eller heltal |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
controller.screen.print(log10_result)
# log10_result = 3.00000
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 |
|---|---|
|
Ett positivt flyttal eller heltal |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
controller.screen.print(log2_result)
# log2_result = 3.00000
faktorial#
factorial returnerar faktorialen av ett heltal x, vilket är produkten av alla positiva heltal upp till x.
Usage:
math.factorial(x)
Parameter |
Beskrivning |
|---|---|
|
Ett icke-negativt heltal. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
controller.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 beräknar ex - 1, vilket är mer exakt för små x.
Usage:
math.expm1(x)
Parameter |
Beskrivning |
|---|---|
|
Exponentvärdet. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
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 |
|---|---|
|
Ett flyttal eller heltal att dekomponera. |
# Decompose 3.14159 into fractional and integer parts
fractional_part, integer_part = math.modf(3.14159)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
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 |
|---|---|
|
Ett flyttal eller heltal att dekomponera. |
# Decompose 16 into its mantissa and exponent
mantissa, exponent = math.frexp(16)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# exponent = 5
fmod#
fmod returnerar resten av divisionen samtidigt som dividendens tecken (x) bibehålls.
Usage:
math.fmod(x, y)
Parameter |
Beskrivning |
|---|---|
|
Utdelningen. |
|
Divisorn. |
# Calculate remainder of 10 / 3
# that preserves the sign of 10
fmod_result = math.fmod(10, 3)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
kopieringssignering#
copysign returnerar x med tecknet y.
Usage:
math.copysign(x, y)
Parameter |
Beskrivning |
|---|---|
|
Värdet som ska ändras. |
|
Det värde vars tecken ska kopieras. |
# Return -10 with the sign of 3 (positive)
copysign_result = math.copysign(-10, 3)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp beräknar x * (2 ** exp), vilket motsvarar x * 2exp.
Usage:
math.ldexp(x, exp)
Parameter |
Beskrivning |
|---|---|
|
Basvärdet. |
|
Exponenten. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
ä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 |
|---|---|
|
Ett flyttal eller heltal att kontrollera. |
# Check if 42 is a finite number (returns True)
is_finite_true = math.isfinite(42)
controller.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)
controller.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 |
|---|---|
|
Ett flyttal eller heltal att kontrollera. |
# Check if infinity is an infinite number (returns True)
is_inf_true = math.isinf(math.inf)
controller.screen.print(is_inf_true)
# is_inf_true = True
# Check if 42 is an infinite number (returns False)
is_inf_false = math.isinf(42)
controller.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 |
|---|---|
|
Ett flyttal eller heltal att kontrollera. |
# Check if NaN (Not a Number) is NaN (returns True)
is_nan_true = math.isnan(math.nan)
controller.screen.print(is_nan_true)
# is_nan_true = True
# Check if 42 is NaN (returns False)
is_nan_false = math.isnan(42)
controller.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 |
|---|---|
|
Ett positivt flyttal eller heltal |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
lgamma#
lgamma beräknar den naturliga logaritmen för gamma -funktionen.
Usage:
math.lgamma(x)
Parameter |
Beskrivning |
|---|---|
|
Ett positivt flyttal eller heltal |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
tomt#
erf beräknar felfunktionen för x.
Usage:
math.erf(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the error function of 1
erf_result = math.erf(1)
controller.screen.print(erf_result)
# erf_result = 0.84270
erfc#
erfc beräknar den komplementära felfunktionen för x, vilken definieras som 1 - erf(x).
Usage:
math.erfc(x)
Parameter |
Beskrivning |
|---|---|
|
Ett flyttal eller heltal som representerar inmatningsvärdet. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
controller.screen.print(erfc_result)
# erfc_result = 0.15730