Matamaitic#

Réamhrá #

Áirítear leis an matamaitic feidhmeanna Python ionsuite agus an modúl iomlán math , atá ar fáil go huathoibríoch i VEXcode AIM. Ligeann na huirlisí seo duit gach rud a dhéanamh ó uimhríocht bhunúsach go dtí oibríochtaí triantánachta, babhtúcháin agus logartamacha ardleibhéil.

Bain úsáid as na feidhmeanna agus na tairiseacha seo chun suíomhanna, uillinneacha, achair agus luachanna uimhriúla eile a ríomh do do róbat. Is féidir leat tiontú idir céimeanna agus raidiáin freisin, léirithe a mheas, agus oibriú le luachanna speisialta cosúil le héigríoch agus NaN.

Seo thíos liosta de na feidhmeanna matamaitice, na tairiseacha agus na fóntais atá ar fáil:

Feidhmeanna Tógtha Isteach – Uirlisí matamaitice coitianta atá san áireamh le Python.

abs – Tugann sé seo luach absalóideach uimhir ar ais.
round – Slánaíonn uimhir go líon sonraithe de dheachúlacha.
min – Tugann sé seo an luach ionchuir is lú ar ais.
max – Tugann sé seo an luach ionchuir is mó ar ais.
sum – Suimíonn sé na luachanna uile i dtuairisc inathraithe.
divmod – Tugann sé an cóimheas agus an fuílleach ar ais mar thupla.
pow – Ardaíonn sé uimhir go cumhacht, le modúl más féidir.
int – Athraíonn sé luach go slánuimhir.
float – Tiontaíonn sé luach go huimhir snámhphointe.

Tairiseacha – Luachanna réamhshainithe ón modúl math.

math.pi – An tairiseach π (pi).
math.tau – An tairiseach tau (2π).
math.e – Uimhir Euler, bunús an loga nádúrtha.
math.inf – Infhinideacht dhearfach.
math.nan – Ní Uimhir (NaN).

Tríghnéasacht – Ríomh uillinneacha agus caidrimh idir taobhanna.

math.sin – Sín uillinne i raidiáin.
math.cos – Cósíneas uillinne i raidiáin.
math.tan – Tangant uillinne i raidiáin.
math.atan – Arctangant luacha i raidiáin.
math.atan2 – Arctangant y/x i radaíní, agus an ceathrú cuid á chur san áireamh.
math.asin – Arcsín luacha i raidiáin.
math.acos – Arccosín luacha i radaíní.
math.degrees – Tiontaíonn sé raidiáin go céimeanna.
math.radians – Tiontaíonn sé céimeanna go raidiain.

Hipirbholaic – Feidhmeanna ardleibhéil a bhaineann le triantán.

math.sinh – Sín hipearbólach luacha.
math.cosh – Cósín hipearbólach luacha.
math.tanh – Tangant hipearbóileach luacha.
math.asinh – Sín hipearbóileach inbhéartach.
math.acosh – Cósín hipearbóileach inbhéartach.
math.atanh – Tangant hipearbóileach inbhéartach.

Slánú & Luach Absalóideach – Coigeartaigh cruinneas nó treo.

math.ceil – Babhtaíonn suas go dtí an slánuimhir is gaire.
math.floor – Babhtaíonn sé síos go dtí an slánuimhir is gaire.
math.trunc – Baintear an chuid deachúil.
math.fabs – Tugann sé an luach absalóideach ar ais mar shnámhphointe.

Easpónantáin & Logartaim – Ríomhanna cumhachta, fréimhe agus loga.

math.pow – Ardaíonn sé uimhir go cumhacht.
math.sqrt – Tugann sé seo an fhréamh chearnach ar ais.
math.exp – Ríomhann sé e suas go dtí cumhacht x.
math.log – Logartam nádúrtha (bonn e).
math.log10 – Logartam bonn-10.
math.log2 – Logartam bonn-2.
math.factorial – Factorial slánuimhir.
math.expm1 – Toradh níos cruinne le haghaidh e^x - 1.

Oibríochtaí Pointe Snámha – Luachanna snámha a iniúchadh nó a dhíghrádú.

math.modf – Tugann sé seo codanna codánacha agus slánuimhir snámhphointe ar ais.
math.frexp – Déanann sé uimhir a dhíscaoileadh ina mantissa agus ina heaspónant.
math.fmod – An chuid eile le comhartha na díbhinne.
math.copysign – Tugann sé luach ar ais le comhartha luach eile.
math.ldexp – Ríomhann x * (2 ** exp).

Comparáid & Measúnú – Seiceáil luachanna le lamháltais nó catagóirí.

math.isclose – Déanann tástáil an bhfuil dhá luach cothrom go garbh.
math.isfinite – Seiceálann sé an bhfuil uimhir críochta.
math.isinf – Seiceálann sé an bhfuil uimhir gan teorainn.
math.isnan – Seiceálann sé an bhfuil luach NaN.

Earráid & Gáma – Feidhmeanna matamaiticiúla speisialta.

math.gamma – Feidhm gama (fachtóir ginearálaithe).
math.lgamma – Gáma logartamach.
math.erf – Feidhm earráide.
math.erfc – Feidhm earráide chomhlántach.

Feidhmeanna Tógtha Isteach #

Cuireann Python roinnt feidhmeanna ionsuite ar fáil a ligeann duit oibríochtaí matamaiticiúla a dhéanamh laistigh de do thionscadal.

abs #

Tugann abs luach absalóideach uimhreach ar ais, ag baint aon chomhartha diúltach.

Usage:
abs(x)

Paraiméadar	Cur síos
`x`	Slánuimhir nó snámhuimhir.

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

# abs_result = 10

round #

Slánaíonn round uimhir go dtí líon sonraithe ionad deachúlacha.

Usage:
round(x, ndigits)

Paraiméadar	Cur síos
`x`	Slánuimhir nó snámhuimhir.
`ndigits`	Roghnach. Líon na n-áiteanna deachúlacha le babhtú chucu. Is é 0 an réamhshocrú.

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

Tugann min an luach is lú ar ais ó il-argóintí nó ó athrá.

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

Paraiméadar	Cur síos
`arg1`, `arg2`, …	Na huimhreacha le comparáid a dhéanamh.
`sequence`	Liosta, tuple, nó seicheamh eile ina bhfuil uimhreacha.

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

Tugann max an luach is mó ó il-argóintí nó ó athrá argóint ar ais.

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

Paraiméadar	Cur síos
`arg1`, `arg2`, …	Na huimhreacha le comparáid a dhéanamh.
`sequence`	Liosta, tuple, nó seicheamh eile ina bhfuil uimhreacha.

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

Cuireann sum na luachanna uile in athrá le chéile, le luach tosaigh roghnach.

Usage:
sum(sequence, start)

Paraiméadar	Cur síos
`sequence`	Liosta, tuple, nó seicheamh eile ina bhfuil uimhreacha.
`start`	Roghnach. Luach le cur leis an tsuim. Is é 0 an réamhshocrú.

# 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 tuple ar ais ina bhfuil an cóimheas agus an fuíoll d’oibríocht roinnte.

Usage:
divmod(a, b)

Paraiméadar	Cur síos
`a`	An díbhinn.
`b`	An roinnteoir.

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

# divmod_result = (3, 1)

pow #

Ardaíonn pow uimhir go cumhacht agus déanann sé oibríocht modúlais más mian leat.

Usage:
pow(x, y, mod)

Paraiméadar	Cur síos
`x`	An uimhir bhunúsach.
`y`	An t-easpónant.
`mod`	Roghnach. Luach modúil. Má sholáthraítear é, tugann sé `(x ** y) % mod` ar ais.

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

Déanann int uimhir nó teaghrán a thiontú ina slánuimhir. Tacaíonn sé le tiontú bunús freisin agus teaghrán á thiontú.

Usage:
int(x, base)

Paraiméadar	Cur síos
`x`	Uimhir, teaghrán, nó réad eile le tiontú.
`base`	Roghnach. An bonn uimhreach le húsáid le haghaidh tiontaithe. Is é 10 an réamhshocrú.

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

Athraíonn float uimhir nó teaghrán ina huimhir snámhphointe.

Usage:
float(x)

Paraiméadar	Cur síos
`x`	Uimhir, teaghrán, nó réad eile le tiontú.

# 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

Modúl Matamaitice #

Cuireann an modúl math i MicroPython modhanna breise ar fáil chun ríomhanna matamaiticiúla coitianta a dhéanamh. Áirítear leis na modhanna seo oibríochtaí trigonometric, logartamach, agus uimhriúla eile.

Déantar an modúl math a allmhairiú de réir réamhshocraithe i VEXcode.

Constants #

Is luachanna réamhshainithe iad tairiseacha a fhanann seasta le linn tionscadail. Is féidir iad a úsáid i ríomhanna gan aon sainmhíniú ná sannadh a bheith ag teastáil.

pi #

Tugann pi an tairiseach matamaiticiúil π, an cóimheas idir imlíne ciorcail agus a thrastomhas.

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

tao #

Tugann tau luach 2π.

Usage:
math.tau

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

# circumference = 31.42

e #

Tugann e bonn an logartaim nádúrtha.

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 #

Tugann inf éigríoch dhearfach mar shnámhphointe.

Usage:
math.inf

# Check if infinity is infinite
inf_value = math.inf

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

# Prints "Infinity"

nana #

Seasann nan do shnámhphointe speisialta do “Ní Uimhir” (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 #

peaca #

Ríomhann sin sine uillinne i raidiain agus tugann sé snámhphointe ar ais.

Usage:
math.sin(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn uillinn i radiáin.

# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
robot.screen.print(sine_result)

# sine_result = 0.50

cos #

Ríomhann cos cosíneas uillinne i raidiain agus tugann sé snámhphointe ar ais.

Usage:
math.cos(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn uillinn i radiáin.

# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)

# cosine_result = 0.50

donn #

Ríomhann tan tadhlaí uillinne i raidiain agus tugann sé snámhphointe ar ais.

Usage:
math.tan(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn uillinn i radiáin.

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

# tangent_result = 1.00

atán #

Ríomhann atan tadhlaí inbhéartach (tadhlaí stua) uimhreach agus tugann sé snámhphointe ar ais a léiríonn an uillinn i raidiain.

Usage:
math.atan(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir.

# 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 ríomhann sé príomhluach an tadhlaí inbhéartaigh de y/x agus tugann sé snámhphointe ar ais a léiríonn an uillinn i raidiain.

Usage:
math.atan2(y, x)

Paraiméadar	Cur síos
`y`	Snámhphointe nó slánuimhir a léiríonn an comhordanáid y.
`x`	Snámhphointe nó slánuimhir a léiríonn an chomhordanáid x.

# 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 ríomhann sé an sine inbhéartach (sine stua) d’uimhir agus tugann sé snámhphointe ar ais a léiríonn an uillinn i raidiain.

Usage:
math.asin(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir idir -1 agus 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 ríomhann an cosíneas inbhéartach (cosíneas stua) d’uimhir agus tugann sé snámhphointe ar ais a léiríonn an uillinn i raidiain.

Usage:
math.acos(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir idir -1 agus 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

céimeanna #

degrees uillinn ó raidiain go céimeanna.

Usage:
math.degrees(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn uillinn i radiáin.

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

# degrees_result = 180.00

raidiáin #

radians uillinn a thiontú ó chéimeanna go raidiain.

Usage:
math.radians(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn uillinn i gcéimeanna.

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

# radians_result = 3.14

Hyperbolics #

sin #

sinh ríomhann an sine hipearbóileach de x.

Usage:
math.sinh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# sinh_result = 1.18

cócó #

Ríomhann cosh an cosíneas hipearbóileach de x.

Usage:
math.cosh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# cosh_result = 1.54

tanh #

Ríomhann tanh an tadhlaí hipearbóileach de x.

Usage:
math.tanh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# tanh_result = 0.76

asinh #

Ríomhann asinh an sine hipearbóileach inbhéartach de x.

Usage:
math.asinh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# asinh_result = 0.88

acosh #

acosh ríomhann an cósíneas hipearbóileach inbhéartach de x.

Usage:
math.acosh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir atá níos mó ná 1 nó cothrom leis.

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

# acosh_result = 1.32

atanh #

Ríomhann atanh an tadhlaí hipearbóileach inbhéartach de x.

Usage:
math.atanh(x)

Paraiméadar	Cur síos
`x`	Snámhphointe idir -1 agus 1 (eisiach).

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

uasteorainn #

Slánaíonn ceil uimhir suas go dtí an slánuimhir is gaire.

Usage:
math.ceil(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le bailiú suas.

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

# ceil_result = 4

urlár #

Slánaíonn floor uimhir síos go dtí an slánuimhir is gaire.

Usage:
math.floor(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le slánú síos.

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

# floor_result = 3

trunc #

Baintear an chuid deachúil d’uimhir trunc gan í a shlánú.

Usage:
math.trunc(x)

Paraiméadar	Cur síos
`x`	Snámhphointe le giorraithe.

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

# trunc_result = 3

fabs #

fabs tugann sé luach absalóideach uimhreach ar ais mar shnámhphointe.

Usage:
math.fabs(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir.

# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)

# fabs_result = 3.70

Exponents & Logarithms #

púdar #

Ardaíonn pow x go dtí cumhacht y agus tugann sé snámhphointe ar ais, fiú más slánuimhreacha iad an dá ionchur.

Usage:
math.pow(x, y)

Paraiméadar	Cur síos
`x`	Bonn snámhphointe nó slánuimhir.
`y`	Easpónant snámhphointe nó slánuimhir.

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

# power_result = 8.00

cearnógach #

Ríomhann sqrt fréamh chearnach uimhreach agus tugann sé snámhphointe ar ais, fiú i gcás cearnóga foirfe.

Usage:
math.sqrt(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir neamh-dhiúltach.

# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)

# sqrt_result = 4.00

taithí #

exp ríomhann easpónantúil uimhir agus tugann snámhphointe ar ais.

Usage:
math.exp(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir.

# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)

# exp_result = 2.72

logáil #

Ríomhann log logartam nádúrtha uimhreach agus tugann sé snámhphointe ar ais.

Usage:
math.log(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir dhearfach.

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

# log_result = 2.00

log10 #

log10 logartam bonn-10 uimhir agus tugann sé snámhphointe ar ais.

Usage:
math.log10(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir dhearfach.

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

# log10_result = 3.00

log2 #

Ríomhann log2 logartam bonn-2 uimhir agus tugann sé snámhphointe ar ais, fiú nuair is cumhacht de 2 é x.

Usage:
math.log2(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir dhearfach.

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

# log2_result = 3.00

fachtóir #

Tugann factorial fachtóiriúil slánuimhir xar ais, arb é toradh na slánuimhreacha dearfacha uile suas go dtí x é.

Usage:
math.factorial(x)

Paraiméadar	Cur síos
`x`	Slánuimhir neamh-dhiúltach.

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

# factorial_result = 120

taithí1 #

Ríomhann expm1 e^x - 1, atá níos cruinne do x beag.

Usage:
math.expm1(x)

Paraiméadar	Cur síos
`x`	An luach easpónant.

# 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 uimhir a dhíscaoileadh ina codanna codánacha agus slánuimhreacha agus tugann sé tuple (fractional part, integer part)ar ais, an dá cheann mar shnámhphointí.

Usage:
math.modf(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le dí-chomhdhlúthú.

# 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

frexp #

frexp déanann uimhir a dhíscaoileadh ina mantissa agus ina heaspónant agus tugann sé tuple (mantissa, exponent)ar ais, áit a bhfuil an mantissa ina snámhphointe agus an t-easpónant ina shlánuimhir.

Usage:
math.frexp(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le dí-chomhdhlúthú.

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

Tugann fmod fuílleach na roinnte ar ais agus comhartha na díbhinne á choinneáil (x).

Usage:
math.fmod(x, y)

Paraiméadar	Cur síos
`x`	An díbhinn.
`y`	An roinnteoir.

# 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

cóipshíniú #

Tugann copysign x ar ais leis an gcomhartha y.

Usage:
math.copysign(x, y)

Paraiméadar	Cur síos
`x`	An luach atá le modhnú.
`y`	An luach a mbeidh a chomhartha cóipeáilte.

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

# copysign_result = 10.00

ldexp #

Ríomhann ldexp x * (2 ** exp), atá coibhéiseach le x * 2^exp{code}.

Usage:
math.ldexp(x, exp)

Paraiméadar	Cur síos
`x`	An luach bonn.
`exp`	An t-easpónant.

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

# ldexp_result = 48.00

Comparison & Approximation #

isdúnta #

isclose seiceálann an bhfuil dhá uimhir cothrom go garbh laistigh de lamháltas.

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

Paraiméadar	Cur síos
`a`	An chéad uimhir le comparáid.
`b`	An dara huimhir le comparáid.
`rel_tol`	Roghnach. An difríocht uasta a cheadaítear idir a agus b, i gcoibhneas lena méid. Is é 1e-09 (an-bheag) an réamhshocrú.
`abs_tol`	Roghnach. Corrlach earráide seasta, úsáideach agus uimhreacha gar do náid á gcomparáid. Is é 0.0 an réamhshocrú.

Nóta: Má chuirtear rel_tol agus abs_tol ar fáil, is é an coinníoll a chomhlíontar ar dtús a chinnfidh an toradh.

# 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

neamhchríochnaithe #

isfinite seiceálann an bhfuil uimhir chríochta. Tugann an modh seo luach Booleanach ar ais:

True – Tá an uimhir teoranta.
False – Tá an uimhir gan teorainn.

Usage:
math.isfinite(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le seiceáil.

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

Seiceálann isinf an bhfuil uimhir gan teorainn. Tugann an modh seo luach Booleánach ar ais:

True – Tá an uimhir gan teorainn.
False – Tá an uimhir teoranta.

Usage:
math.isinf(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le seiceáil.

# 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

isnán #

Seiceálann isnan an bhfuil uimhir NaN (Ní Uimhir). Tugann an modh seo luach Booleánach ar ais:

True – Is é NaN an uimhir.
False – Is uimhir bhailí í an uimhir.

Usage:
math.isnan(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir le seiceáil.

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

gáma #

Ríomhann gamma feidhm gamma x, rud a ghinearálann an fheidhm fachtóiriúil do réaduimhreacha agus uimhreacha casta. I gcás slánuimhir n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir dhearfach.

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

# gamma_result = 24.00

lgamma #

Ríomhann lgamma logartam nádúrtha na feidhme gamma.

Usage:
math.lgamma(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir dhearfach.

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

# lgamma_result = 3.18

talamh #

Ríomhann erf feidhm earráide x.

Usage:
math.erf(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# erf_result = 0.84

erfc #

Ríomhann erfc feidhm earráide chomhlántach x, atá sainmhínithe mar 1 - erf(x).

Usage:
math.erfc(x)

Paraiméadar	Cur síos
`x`	Snámhphointe nó slánuimhir a léiríonn an luach ionchuir.

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

# erfc_result = 0.16