Математика#
Введение#
В модуль Math входят как встроенные функции Python, так и полный модуль math , который автоматически доступен в VEXcode AIM. Эти инструменты позволяют выполнять все операции, от базовой арифметики до сложной тригонометрии, округления и логарифмических вычислений.
Используйте эти функции и константы для вычисления положений, углов, расстояний и других числовых значений для вашего робота. Вы также можете преобразовывать градусы в радианы, вычислять выражения и работать со специальными значениями, такими как бесконечность и NaN.
Ниже приведён список доступных математических функций, констант и вспомогательных средств:
Встроенные функции – распространенные математические инструменты, входящие в состав Python.
abs– Возвращает абсолютное значение числа.round– Округляет число до указанного количества десятичных знаков.min– Возвращает наименьшее из входных значений.max– Возвращает наибольшее из входных значений.sum– Суммирует все значения в итерируемом объекте.divmod– Возвращает частное и остаток в виде кортежа.pow– Возводит число в степень, при необходимости с модулем.int– Преобразует значение в целое число.float– Преобразует значение в число с плавающей запятой.
Константы – предопределенные значения из модуля math.
math.pi– Постоянная π (пи).math.tau– Постоянная тау (2π).math.e– число Эйлера, основание натурального логарифма.math.inf– Положительная бесконечность.math.nan– не число (NaN).
Тригонометрия – вычисление углов и соотношений между сторонами.
math.sin– Синус угла в радианах.math.cos– Косинус угла в радианах.math.tan– Тангенс угла в радианах.math.atan– Арктангенс значения в радианах.math.atan2– Арктангенс y/x в радианах, с учетом квадранта.math.asin– Арксинус значения в радианах.math.acos– Арккосинус значения в радианах.math.degrees– Преобразует радианы в градусы.math.radians– Преобразует градусы в радианы.
Гиперболические функции – Расширенные функции, связанные с тригонометрией.
math.sinh– Гиперболический синус значения.math.cosh– Гиперболический косинус значения.math.tanh– Гиперболический тангенс значения.math.asinh– Обратный гиперболический синус.math.acosh– Обратный гиперболический косинус.math.atanh– Обратный гиперболический тангенс.
Округление и абсолютное значение – регулировка точности или направления.
math.ceil– Округляет до ближайшего целого числа.math.floor– Округляет до ближайшего целого числа в меньшую сторону.math.trunc– Удаляет десятичную часть.math.fabs– Возвращает абсолютное значение в виде числа с плавающей запятой.
Степени и логарифмы – вычисления степеней, корней и логарифмов.
math.pow– Возводит число в степень.math.sqrt– Возвращает квадратный корень.math.exp– Вычисляет e в степени x.math.log– Натуральный логарифм (по основанию e).math.log10– Десятичный логарифм.math.log2– Логарифм по основанию 2.math.factorial– Факториал целого числа.math.expm1– Более точный результат дляe^x - 1.
Операции с плавающей запятой – проверка или разложение значений с плавающей запятой.
math.modf– Возвращает дробную и целую части числа с плавающей запятой.math.frexp– Разлагает число на мантиссу и показатель степени.math.fmod– Остаток со знаком делимого.math.copysign– Возвращает значение со знаком другого значения.math.ldexp– Вычисляетx * (2 ** exp).
Сравнение и приближение – Проверка значений с учетом допусков или категорий.
math.isclose– Проверяет, приблизительно ли равны два значения.math.isfinite– Проверяет, является ли число конечным.math.isinf– Проверяет, является ли число бесконечным.math.isnan– Проверяет, является ли значение NaN.
Ошибка и гамма – специальные математические функции.
math.gamma– Гамма-функция (обобщенный факториал).math.lgamma– Логарифмическая гамма.math.erf– Функция ошибок.math.erfc– Дополнительная функция ошибок.
Встроенные функции#
Python предоставляет несколько встроенных функций, позволяющих выполнять математические операции внутри вашего проекта.
abs#
Функция abs возвращает абсолютное значение числа, удаляя все отрицательные знаки.
Usage:
abs(x)
Параметр |
Описание |
|---|---|
|
Целое число или число с плавающей запятой. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round округляет число до указанного количества десятичных знаков.
Usage:
round(x, ndigits)
Параметр |
Описание |
|---|---|
|
Целое число или число с плавающей запятой. |
|
Необязательный параметр. Количество десятичных знаков, до которых следует округлять. По умолчанию — 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 возвращает наименьшее значение из нескольких аргументов или итерируемого объекта.
Usage:
min(arg1, arg2, …) or min(sequence)
Параметр |
Описание |
|---|---|
|
Цифры для сравнения. |
|
Список, кортеж или другая последовательность, содержащая числа. |
# 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 возвращает наибольшее значение из нескольких аргументов или итерируемого объекта.
Usage:
max(arg1, arg2, …) or max(sequence)
Параметр |
Описание |
|---|---|
|
Цифры для сравнения. |
|
Список, кортеж или другая последовательность, содержащая числа. |
# 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 суммирует все значения в итерируемом объекте, с необязательным начальным значением.
Usage:
sum(sequence, start)
Параметр |
Описание |
|---|---|
|
Список, кортеж или другая последовательность, содержащая числа. |
|
Необязательный параметр. Значение, которое нужно добавить к сумме. По умолчанию — 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 возвращает кортеж, содержащий частное и остаток от деления.
Usage:
divmod(a, b)
Параметр |
Описание |
|---|---|
|
Дивиденды. |
|
Делитель. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow возводит число в степень и, при необходимости, выполняет операцию взятия остатка от деления.
Usage:
pow(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 преобразует число или строку в целое число. Также поддерживает преобразование в систему счисления при преобразовании из строки.
Usage:
int(x, base)
Параметр |
Описание |
|---|---|
|
Число, строка или другой объект для преобразования. |
|
Необязательный параметр. Система счисления, используемая для преобразования. По умолчанию — 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 преобразует число или строку в число с плавающей запятой.
Usage:
float(x)
Параметр |
Описание |
|---|---|
|
Число, строка или другой объект для преобразования. |
# 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
Математический модуль#
Модуль math в MicroPython предоставляет дополнительные методы для выполнения распространенных математических вычислений. Эти методы включают тригонометрические, логарифмические и другие числовые операции.
Модуль math импортируется по умолчанию в VEXcode.
Constants#
Константы — это предопределенные значения, которые остаются неизменными на протяжении всего проекта. Их можно использовать в вычислениях без необходимости определения или присваивания каких-либо значений.
пи#
pi дает математическую константу π, отношение длины окружности к ее диаметру.
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 дает значение 2π.
Usage:
math.tau
# Calculate the circumference of a circle with radius
circumference = math.tau * 5
robot.screen.print(circumference)
# circumference = 31.42
е#
e — это основание натурального логарифма.
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 дает положительную бесконечность в виде числа с плавающей запятой.
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).
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#
грех#
Функция sin вычисляет синус угла в радианах и возвращает число с плавающей запятой.
Usage:
math.sin(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее угол в радианах. |
# 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 вычисляет косинус угла в радианах и возвращает число с плавающей запятой.
Usage:
math.cos(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее угол в радианах. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
загар#
Функция tan вычисляет тангенс угла в радианах и возвращает число с плавающей запятой.
Usage:
math.tan(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее угол в радианах. |
# 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 вычисляет арктангенс (арктангенс) числа и возвращает число с плавающей запятой, представляющее угол в радианах.
Usage:
math.atan(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число. |
# 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
атан2#
Функция atan2 вычисляет главное значение арктангенса y/x и возвращает число с плавающей запятой, представляющее угол в радианах.
Usage:
math.atan2(y, x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее координату Y. |
|
Число с плавающей запятой или целое число, представляющее координату 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 вычисляет обратный синус (арксинус) числа и возвращает число с плавающей запятой, представляющее угол в радианах.
Usage:
math.asin(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число от -1 до 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 вычисляет обратный косинус (арккосинус) числа и возвращает число с плавающей запятой, представляющее угол в радианах.
Usage:
math.acos(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число от -1 до 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
градусы#
degrees переводит угол из радиан в градусы.
Usage:
math.degrees(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее угол в радианах. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
радиан#
radians преобразует угол из градусов в радианы.
Usage:
math.radians(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее угол в градусах. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
синх#
sinh вычисляет гиперболический синус x.
Usage:
math.sinh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
шош#
cosh вычисляет гиперболический косинус x.
Usage:
math.cosh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
танх#
tanh вычисляет гиперболический тангенс x.
Usage:
math.tanh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
Асинх#
asinh вычисляет обратный гиперболический синус x.
Usage:
math.asinh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
акош#
acosh вычисляет обратный гиперболический косинус x.
Usage:
math.acosh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, большее или равное 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
атань#
atanh вычисляет обратный гиперболический тангенс x.
Usage:
math.atanh(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой в диапазоне от -1 до 1 (исключая остальные). |
# 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#
потолок#
ceil округляет число до ближайшего целого числа в большую сторону.
Usage:
math.ceil(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, подлежащее округлению в большую сторону. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
пол#
floor округляет число до ближайшего целого числа в меньшую сторону.
Usage:
math.floor(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, подлежащее округлению в меньшую сторону. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
усечение#
trunc удаляет десятичную часть числа без округления.
Usage:
math.trunc(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой, подлежащее усечению. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
фабрики#
Функция fabs возвращает абсолютное значение числа в виде числа с плавающей запятой.
Usage:
math.fabs(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
сила#
Функция pow возводит x в степень y и возвращает число с плавающей запятой, даже если оба входных значения являются целыми числами.
Usage:
math.pow(x, y)
Параметр |
Описание |
|---|---|
|
Основание для чисел с плавающей запятой или целых чисел. |
|
Показатель степени (с плавающей запятой или целое число). |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
кв. рт.#
Функция sqrt вычисляет квадратный корень числа и возвращает число с плавающей запятой, даже для полных квадратов.
Usage:
math.sqrt(x)
Параметр |
Описание |
|---|---|
|
Неотрицательное число с плавающей запятой или целое число. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
эксп#
Функция exp вычисляет экспоненту числа и возвращает число с плавающей запятой.
Usage:
math.exp(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
бревно#
Функция log вычисляет натуральный логарифм числа и возвращает число с плавающей запятой.
Usage:
math.log(x)
Параметр |
Описание |
|---|---|
|
Положительное число с плавающей запятой или целое число. |
# 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 вычисляет десятичный логарифм числа и возвращает число с плавающей запятой.
Usage:
math.log10(x)
Параметр |
Описание |
|---|---|
|
Положительное число с плавающей запятой или целое число. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
Функция log2 вычисляет 2-й логарифм числа и возвращает число с плавающей запятой, даже если x является степенью двойки.
Usage:
math.log2(x)
Параметр |
Описание |
|---|---|
|
Положительное число с плавающей запятой или целое число. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
факториал#
Функция factorial возвращает факториал целого числа x, которое является произведением всех положительных целых чисел до x.
Usage:
math.factorial(x)
Параметр |
Описание |
|---|---|
|
Неотрицательное целое число. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 вычисляет ex - 1, что более точно для малых x.
Usage:
math.expm1(x)
Параметр |
Описание |
|---|---|
|
Значение показателя степени. |
# Compute expm1(1) (e^1 - 1)
expm1_result = math.expm1(1)
robot.screen.print(expm1_result)
# expm1_result = 1.72
Floating Point Operations#
модф#
Функция modf разлагает число на дробную и целую части и возвращает кортеж (fractional part, integer part), обе части представлены в виде чисел с плавающей запятой.
Usage:
math.modf(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число для разложения. |
# 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 разлагает число на мантиссу и показатель степени и возвращает кортеж (mantissa, exponent), где мантисса — число с плавающей запятой, а показатель степени — целое число.
Usage:
math.frexp(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число для разложения. |
# 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 возвращает остаток от деления, сохраняя при этом знак делимого (x).
Usage:
math.fmod(x, y)
Параметр |
Описание |
|---|---|
|
Дивиденды. |
|
Делитель. |
# 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
авторизация#
copysign возвращает x со знаком y.
Usage:
math.copysign(x, y)
Параметр |
Описание |
|---|---|
|
Значение, которое необходимо изменить. |
|
Значение, знак которого будет скопирован. |
# 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 вычисляет x * (2 ** exp), что эквивалентно x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Параметр |
Описание |
|---|---|
|
Базовое значение. |
|
Показатель степени. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
близко#
isclose проверяет, приблизительно ли равны два числа в пределах допустимого отклонения.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Параметр |
Описание |
|---|---|
|
Первое число для сравнения. |
|
Второе число для сравнения. |
|
Необязательный параметр. Максимально допустимая разница между a и b относительно их размеров. Значение по умолчанию — 1e-09 (очень мало). |
|
Необязательный параметр. Фиксированная погрешность, полезная при сравнении чисел, близких к нулю. Значение по умолчанию — 0,0. |
Примечание: Если указаны значения rel_tol и abs_tol , то результат определяется тем условием, которое будет выполнено первым.
# 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
бесконечный#
isfinite проверка конечности числа. Этот метод возвращает логическое значение:
True– Число конечно.False– Число бесконечно.
Usage:
math.isfinite(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число для проверки. |
# 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 проверяет, является ли число бесконечным. Этот метод возвращает логическое значение:
True– Число бесконечно.False– Число конечно.
Usage:
math.isinf(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число для проверки. |
# 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 проверяет, является ли число NaN (не числом). Этот метод возвращает логическое значение:
True– Число равно NaN.False– Число является допустимым.
Usage:
math.isnan(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число для проверки. |
# 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 вычисляет гамма-функцию x, которая обобщает факториальную функцию для действительных и комплексных чисел. Для целого числа n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Параметр |
Описание |
|---|---|
|
Положительное число с плавающей запятой или целое число. |
# 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 вычисляет натуральный логарифм функции gamma.
Usage:
math.lgamma(x)
Параметр |
Описание |
|---|---|
|
Положительное число с плавающей запятой или целое число. |
# Calculate the natural logarithm of the
# gamma function of 5
lgamma_result = math.lgamma(5)
robot.screen.print(lgamma_result)
# lgamma_result = 3.18
erf#
erf вычисляет функцию ошибок x.
Usage:
math.erf(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc вычисляет дополнительную функцию ошибок x, которая определяется как 1 - erf(x).
Usage:
math.erfc(x)
Параметр |
Описание |
|---|---|
|
Число с плавающей запятой или целое число, представляющее входное значение. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16