Toán học#
Giới thiệu#
Math bao gồm cả các hàm Python tích hợp sẵn và mô-đun math đầy đủ, được tự động cài đặt trong VEXcode AIM. Các công cụ này cho phép bạn thực hiện mọi thứ từ phép toán số học cơ bản đến lượng giác nâng cao, làm tròn và các phép toán logarit.
Sử dụng các hàm và hằng số này để tính toán vị trí, góc, khoảng cách và các giá trị số khác cho robot của bạn. Bạn cũng có thể chuyển đổi giữa độ và radian, đánh giá biểu thức và làm việc với các giá trị đặc biệt như vô cực và NaN.
Dưới đây là danh sách các hàm toán học, hằng số và tiện ích có sẵn:
Các hàm tích hợp sẵn – Các công cụ toán học thông dụng được tích hợp sẵn trong Python.
abs– Trả về giá trị tuyệt đối của một số.round– Làm tròn một số đến số chữ số thập phân được chỉ định.min– Trả về giá trị nhỏ nhất trong các giá trị đầu vào.max– Trả về giá trị lớn nhất trong các giá trị đầu vào.sum– Cộng tất cả các giá trị trong một iterable.divmod– Trả về thương và số dư dưới dạng một bộ.pow– Nâng một số lên lũy thừa, tùy chọn với số dư.int– Chuyển đổi một giá trị thành số nguyên.float– Chuyển đổi một giá trị thành số thập phân.
Constants – Predefined values from the math module.
math.pi– Hằng số π (pi).math.tau– Hằng số tau (2π).math.e– Số Euler, cơ số của logarit tự nhiên.math.inf– Vô cực dương.math.nan– Không phải là số (NaN).
Lượng giác – Tính toán các góc và mối quan hệ giữa các cạnh.
math.sin– Sin của một góc tính bằng radian.math.cos– Cosin của một góc tính bằng radian.math.tan– Tangent của một góc tính bằng radian.math.atan– Arctangent của một giá trị tính bằng radian.math.atan2– Arctangent của y/x tính bằng radian, xét theo góc phần tư.math.asin– Arcsin của một giá trị tính bằng radian.math.acos– Arccosin của một giá trị tính bằng radian.math.degrees– Chuyển đổi radian sang độ.math.radians– Chuyển đổi độ sang radian.
Hàm hyperbolic – Các hàm lượng giác nâng cao.
math.sinh– Sin hyperbolic của một giá trị.math.cosh– Cosin hyperbolic của một giá trị.math.tanh– Tangent hyperbolic của một giá trị.math.asinh– Hàm sin hyperbolic nghịch đảo.math.acosh– Cosin hyperbolic nghịch đảo.math.atanh– Hàm tang hyperbolic nghịch đảo.
Làm tròn & Giá trị tuyệt đối – Điều chỉnh độ chính xác hoặc hướng.
math.ceil– Làm tròn lên số nguyên gần nhất.math.floor– Làm tròn xuống số nguyên gần nhất.math.trunc– Loại bỏ phần thập phân.math.fabs– Trả về giá trị tuyệt đối dưới dạng số thực.
Lũy thừa và Logarit – Tính lũy thừa, căn bậc hai và logarit.
math.pow– Nâng một số lên lũy thừa.math.sqrt– Trả về căn bậc hai.math.exp– Tính e mũ x.math.log– Logarit tự nhiên (cơ số e).math.log10– Logarit cơ số 10.math.log2– Logarit cơ số 2.math.factorial– Giai thừa của một số nguyên.math.expm1– Kết quả chính xác hơn choe^x - 1.
Các phép toán số thực dấu phẩy động – Kiểm tra hoặc phân tích giá trị dấu phẩy động.
math.modf– Trả về phần thập phân và phần nguyên của một số thực.math.frexp– Phân tích một số thành phần định trị và số mũ.math.fmod– Phần dư với dấu của số bị chia.math.copysign– Trả về một giá trị có dấu của một giá trị khác.math.ldexp– Tínhx * (2 ** exp).
So sánh & Xấp xỉ – Kiểm tra giá trị với dung sai hoặc phân loại.
math.isclose– Kiểm tra xem hai giá trị có xấp xỉ bằng nhau hay không.math.isfinite– Kiểm tra xem một số có hữu hạn hay không.math.isinf– Kiểm tra xem một số có phải là vô hạn hay không.math.isnan– Kiểm tra xem một giá trị có phải là NaN hay không.
Sai số và Gamma – Các hàm toán học đặc biệt.
math.gamma– Hàm Gamma (giai thừa tổng quát).math.lgamma– Gamma logarit.math.erf– Hàm lỗi.math.erfc– Hàm lỗi bổ sung.
Chức năng tích hợp sẵn#
Python cung cấp một số hàm tích hợp sẵn cho phép bạn thực hiện các phép toán trong dự án của mình.
abs#
abs trả về giá trị tuyệt đối của một số, loại bỏ dấu âm.
Usage:
abs(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số nguyên hoặc số thực. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round làm tròn một số đến số chữ số thập phân được chỉ định.
Usage:
round(x, ndigits)
Tham số |
Sự miêu tả |
|---|---|
|
Một số nguyên hoặc số thực. |
|
Tùy chọn. Số chữ số thập phân cần làm tròn. Mặc định là 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#
Hàm min trả về giá trị nhỏ nhất từ nhiều đối số hoặc một đối tượng có thể lặp lại.
Usage:
min(arg1, arg2, …) or min(sequence)
Tham số |
Sự miêu tả |
|---|---|
|
Các con số để so sánh. |
|
Một danh sách, bộ dữ liệu hoặc chuỗi khác chứa các số. |
# 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#
Hàm max trả về giá trị lớn nhất từ nhiều đối số hoặc một đối tượng có thể lặp lại.
Usage:
max(arg1, arg2, …) or max(sequence)
Tham số |
Sự miêu tả |
|---|---|
|
Các con số để so sánh. |
|
Một danh sách, bộ dữ liệu hoặc chuỗi khác chứa các số. |
# 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 cộng tất cả các giá trị trong một đối tượng có thể lặp lại, với một giá trị bắt đầu tùy chọn.
Usage:
sum(sequence, start)
Tham số |
Sự miêu tả |
|---|---|
|
Một danh sách, bộ dữ liệu hoặc chuỗi khác chứa các số. |
|
Tùy chọn. Giá trị cần cộng vào tổng. Mặc định là 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 trả về một bộ giá trị chứa thương và số dư của phép chia.
Usage:
divmod(a, b)
Tham số |
Sự miêu tả |
|---|---|
|
Cổ tức. |
|
Số chia. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow nâng một số lên lũy thừa và tùy chọn thực hiện phép toán lấy phần dư.
Usage:
pow(x, y, mod)
Tham số |
Sự miêu tả |
|---|---|
|
Số cơ sở. |
|
Số mũ. |
|
Tùy chọn. Giá trị môđun. Nếu được cung cấp, trả về |
# 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#
Hàm int chuyển đổi một số hoặc chuỗi thành số nguyên. Nó cũng hỗ trợ chuyển đổi cơ số khi chuyển đổi từ chuỗi.
Usage:
int(x, base)
Tham số |
Sự miêu tả |
|---|---|
|
Một số, chuỗi ký tự hoặc đối tượng khác cần chuyển đổi. |
|
Tùy chọn. Cơ số số được sử dụng để chuyển đổi. Mặc định là 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#
Hàm float chuyển đổi một số hoặc chuỗi ký tự thành số thập phân.
Usage:
float(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số, chuỗi ký tự hoặc đối tượng khác cần chuyển đổi. |
# 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
Mô-đun Toán học#
Mô-đun math trong MicroPython cung cấp thêm các phương thức để thực hiện các phép tính toán học thông thường. Các phương thức này bao gồm các phép toán lượng giác, logarit và các phép toán số học khác.
Mô-đun math được nhập mặc định trong VEXcode.
Constants#
Hằng số là các giá trị được xác định trước và không thay đổi trong suốt dự án. Chúng có thể được sử dụng trong các phép tính mà không cần định nghĩa hoặc gán giá trị nào.
pi#
pi biểu thị hằng số toán học π, tỉ số giữa chu vi và đường kính của một đường tròn.
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 cho giá trị của 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 cho biết cơ số của logarit tự nhiên.
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
thông tin#
inf cho giá trị vô cực dương dưới dạng số thực.
Usage:
math.inf
# Check if infinity is infinite
inf_value = math.inf
if math.isinf(inf_value):
robot.screen.print("Infinity")
# Prints "Infinity"
bà#
nan biểu thị một số thực đặc biệt có nghĩa là “Không phải là số” (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#
tội lỗi#
Hàm sin tính sin của một góc theo radian và trả về một giá trị float.
Usage:
math.sin(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị góc tính bằng radian. |
# 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#
Hàm cos tính cosin của một góc theo radian và trả về một giá trị float.
Usage:
math.cos(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị góc tính bằng radian. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
robot.screen.print(cosine_result)
# cosine_result = 0.50
rám nắng#
Hàm tan tính tang của một góc theo radian và trả về một giá trị float.
Usage:
math.tan(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị góc tính bằng radian. |
# 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#
Hàm atan tính hàm arctan (arc tangent) của một số và trả về một giá trị float biểu thị góc tính bằng radian.
Usage:
math.atan(x)
Tham số |
Sự miêu tả |
|---|---|
|
Số thực hoặc số nguyên. |
# 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#
Hàm atan2 tính giá trị chính của hàm arctan của y/x và trả về một số thực biểu thị góc tính bằng radian.
Usage:
math.atan2(y, x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị tọa độ y. |
|
Một số thực hoặc số nguyên biểu thị tọa độ 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#
Hàm asin tính toán hàm sin nghịch đảo (arc sin) của một số và trả về một số thực biểu thị góc tính bằng radian.
Usage:
math.asin(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên nằm giữa -1 và 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#
Hàm acos tính toán hàm cosin nghịch đảo (arc cosin) của một số và trả về một giá trị float biểu thị góc tính bằng radian.
Usage:
math.acos(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên nằm giữa -1 và 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
bằng cấp#
degrees chuyển đổi góc từ radian sang độ.
Usage:
math.degrees(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị góc tính bằng radian. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radian#
radians chuyển đổi góc từ độ sang radian.
Usage:
math.radians(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị góc tính bằng độ. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh tính sin hyperbolic của x.
Usage:
math.sinh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
cosh#
cosh tính cosin hyperbolic của x.
Usage:
math.cosh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh tính tang hyperbolic của x.
Usage:
math.tanh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
asinh#
asinh tính nghịch đảo sin hyperbolic của x.
Usage:
math.asinh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
acosh#
acosh tính cosin hyperbolic nghịch đảo của x.
Usage:
math.acosh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên lớn hơn hoặc bằng 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh tính hàm tang hyperbolic nghịch đảo của x.
Usage:
math.atanh(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực nằm giữa -1 và 1 (không bao gồm -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#
trần nhà#
ceil làm tròn số lên đến số nguyên gần nhất.
Usage:
math.ceil(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần được làm tròn lên. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
sàn nhà#
floor làm tròn số xuống số nguyên gần nhất.
Usage:
math.floor(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần được làm tròn xuống. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
trunc#
trunc loại bỏ phần thập phân của một số mà không làm tròn.
Usage:
math.trunc(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực cần được cắt bớt. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
vải#
fabs trả về giá trị tuyệt đối của một số dưới dạng số thực.
Usage:
math.fabs(x)
Tham số |
Sự miêu tả |
|---|---|
|
Số thực hoặc số nguyên. |
# 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#
Hàm pow nâng x lên lũy thừa y và trả về một số thực, ngay cả khi cả hai đầu vào đều là số nguyên.
Usage:
math.pow(x, y)
Tham số |
Sự miêu tả |
|---|---|
|
Cơ số thực hoặc số nguyên. |
|
Số mũ là số thực hoặc số nguyên. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
căn bậc hai#
Hàm sqrt tính căn bậc hai của một số và trả về một số thực, kể cả với các số chính phương.
Usage:
math.sqrt(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên không âm. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
kinh nghiệm#
Hàm exp tính lũy thừa của một số và trả về một số thực.
Usage:
math.exp(x)
Tham số |
Sự miêu tả |
|---|---|
|
Số thực hoặc số nguyên. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
nhật ký#
Hàm log tính logarit tự nhiên của một số và trả về một số thực.
Usage:
math.log(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên dương. |
# 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#
Hàm log10 tính logarit cơ số 10 của một số và trả về một số thực.
Usage:
math.log10(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên dương. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
Hàm log2 tính logarit cơ số 2 của một số và trả về một số thực, ngay cả khi x là lũy thừa của 2.
Usage:
math.log2(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên dương. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
giai thừa#
factorial trả về giai thừa của một số nguyên x, là tích của tất cả các số nguyên dương đến x.
Usage:
math.factorial(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số nguyên không âm. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
expm1#
expm1 tính toán ex - 1, chính xác hơn đối với các số nhỏ x.
Usage:
math.expm1(x)
Tham số |
Sự miêu tả |
|---|---|
|
Giá trị số mũ. |
# 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 phân tích một số thành phần thập phân và phần nguyên và trả về một bộ (fractional part, integer part), cả hai đều là số thực.
Usage:
math.modf(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần phân tích. |
# 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 phân tích một số thành phần định trị và số mũ và trả về một bộ (mantissa, exponent), trong đó định trị là một số thực và số mũ là một số nguyên.
Usage:
math.frexp(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần phân tích. |
# 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 trả về phần dư của phép chia trong khi vẫn giữ nguyên dấu của số bị chia (x).
Usage:
math.fmod(x, y)
Tham số |
Sự miêu tả |
|---|---|
|
Cổ tức. |
|
Số chia. |
# 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#
copysign trả về x với dấu của y.
Usage:
math.copysign(x, y)
Tham số |
Sự miêu tả |
|---|---|
|
Giá trị cần điều chỉnh. |
|
Giá trị có dấu sẽ được sao chép. |
# 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 tính x * (2 ** exp), tương đương với x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Tham số |
Sự miêu tả |
|---|---|
|
Giá trị cơ bản. |
|
Số mũ. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
đóng#
isclose kiểm tra xem hai số có xấp xỉ bằng nhau trong phạm vi dung sai hay không.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Tham số |
Sự miêu tả |
|---|---|
|
Con số đầu tiên cần so sánh. |
|
Con số thứ hai cần so sánh. |
|
Tùy chọn. Sai lệch tối đa cho phép giữa a và b, tính theo kích thước của chúng. Mặc định là 1e-09 (rất nhỏ). |
|
Tùy chọn. Một biên độ sai số cố định, hữu ích khi so sánh các số gần bằng không. Mặc định là 0,0. |
Lưu ý: Nếu cả rel_tol và abs_tol đều được cung cấp, điều kiện nào được đáp ứng trước sẽ quyết định kết quả.
# 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
vô hạn#
isfinite kiểm tra xem một số có hữu hạn hay không. Phương thức này trả về giá trị Boolean:
True– Số lượng là hữu hạn.False– Số lượng là vô hạn.
Usage:
math.isfinite(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần kiểm tra. |
# 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 kiểm tra xem một số có vô hạn hay không. Phương thức này trả về giá trị Boolean:
True– Số lượng là vô hạn.False– Số lượng là hữu hạn.
Usage:
math.isinf(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần kiểm tra. |
# 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 kiểm tra xem một số có phải là NaN (Không phải là số) hay không. Phương thức này trả về giá trị Boolean:
True– Số này là NaN.False– Số này là số hợp lệ.
Usage:
math.isnan(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên cần kiểm tra. |
# 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 tính toán hàm gamma của x, tổng quát hóa hàm giai thừa cho số thực và số phức. Đối với số nguyên n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên dương. |
# Calculate the gamma function of 5 (equivalent to 4!)
gamma_result = math.gamma(5)
robot.screen.print(gamma_result)
# gamma_result = 24.00
gamma#
lgamma tính logarit tự nhiên của hàm gamma.
Usage:
math.lgamma(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên dương. |
# 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 tính toán hàm lỗi của x.
Usage:
math.erf(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc tính toán hàm lỗi bổ sung của x, được định nghĩa là 1 - erf(x).
Usage:
math.erfc(x)
Tham số |
Sự miêu tả |
|---|---|
|
Một số thực hoặc số nguyên biểu thị giá trị đầu vào. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16