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ó sẵn trong VEXcode AIR. 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 bộ điều khiển máy bay không người lái VEX AIR. 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.
Lưu ý: Trừ khi có ghi chú khác, tất cả các giá trị trả về đều là số thực được định dạng chính xác đến năm chữ số thập phân. Các giá trị có nhiều hơn năm chữ số thập phân sẽ được làm tròn, và các giá trị có ít hơn năm chữ số thập phân sẽ được bổ sung thêm số 0 để luôn hiển thị chính xác năm chữ số thập phân.
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.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.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.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.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)
controller.screen.print(abs_result)
# abs_result = 10
round#
Hàm round trả về một số được làm tròn đến số chữ số thập phân được chỉ định dưới dạng số nguyên.
Usage:
round(x, ndigits)
Tham số |
Sự miêu tả |
|---|---|
|
Một số nguyên hoặc số thực. |
|
Tùy chọn. Điều khiển số chữ số thập phân được làm tròn (từ 0 đến 5). Mặc định là 0. Khi tham số này được sử dụng, |
# 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#
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)
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#
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)
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 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])
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 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)
controller.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow trả về một số được nâng lên lũy thừa và tùy chọn thực hiện phép toán lấy dư dưới dạng số nguyên.
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)
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 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)
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 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
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
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
controller.screen.print(circle_area)
# circle_area = 78.53982
tau#
tau cho giá trị của 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 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)
controller.screen.print(e_power)
# e_power = 7.38906
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):
controller.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):
controller.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ị một góc tính bằng radian. |
# Calculate the sine of 30 degrees in radians
sine_result = math.sin(math.radians(30))
controller.screen.print(sine_result)
# sine_result = 0.50000
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ị một góc tính bằng radian. |
# Calculate the cosine of 60 degrees in radians
cosine_result = math.cos(math.radians(60))
controller.screen.print(cosine_result)
# cosine_result = 0.50000
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ị một góc tính bằng radian. |
# 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#
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 radians
arc_sine_result = math.asin(0.5)
controller.screen.print(arc_sine_result)
# arc_sine_result = 0.52360
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 radians
arc_cosine_result = math.acos(0.5)
controller.screen.print(arc_cosine_result)
# arc_cosine_result = 1.04720
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 radians
arc_tangent_result = math.atan(1)
controller.screen.print(arc_tangent_result)
# arc_tangent_result = 0.78540
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 (4, 3) in radians
atan2_result = math.atan2(3, 4)
controller.screen.print(atan2_result)
# atan2_result = 0.64350
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)
controller.screen.print(degrees_result)
# degrees_result = 180.00000
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)
controller.screen.print(radians_result)
# radians_result = 3.14159
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)
controller.screen.print(sinh_result)
# sinh_result = 1.7520
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)
controller.screen.print(cosh_result)
# cosh_result = 1.54308
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)
controller.screen.print(tanh_result)
# tanh_result = 0.76159
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)
controller.screen.print(asinh_result)
# asinh_result = 0.88137
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)
controller.screen.print(acosh_result)
# acosh_result = 1.31696
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)
controller.screen.print(atanh_result)
# atanh_result = 0.54931
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)
controller.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)
controller.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)
controller.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)
controller.screen.print(fabs_result)
# fabs_result = 3.70000
Exponents & Logarithms#
pow#
pow nâng x lên lũy thừa y (xy) và trả về một số thực.
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)
controller.screen.print(power_result)
# power_result = 8.00000
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.
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)
controller.screen.print(sqrt_result)
# sqrt_result = 4.00000
kinh nghiệm#
exp trả về e được nâng lên lũy thừa x (ex) và dưới dạng 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)
controller.screen.print(exp_result)
# exp_result = 2.71828
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)
controller.screen.print(log_result)
# log_result = 2.00000
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)
controller.screen.print(log10_result)
# log10_result = 3.00000
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)
controller.screen.print(log2_result)
# log2_result = 3.00000
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)
controller.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)
controller.screen.print(expm1_result)
# expm1_result = 1.71828
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)
controller.screen.print(fractional_part)
controller.screen.next_row()
controller.screen.print(integer_part)
# fractional_part = 0.14159
# integer_part = 3.00000
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)
controller.screen.print(mantissa)
controller.screen.next_row()
controller.screen.print(exponent)
# mantissa = 0.50000
# 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)
controller.screen.print(fmod_result)
# fmod_result = 1.00000
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)
controller.screen.print(copysign_result)
# copysign_result = 10.00000
ldexp#
ldexp tính x * (2 ** exp), tương đương với x * 2exp.
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)
controller.screen.print(ldexp_result)
# ldexp_result = 48.00000
Comparison & Approximation#
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)
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 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)
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 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)
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 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)
controller.screen.print(gamma_result)
# gamma_result = 24.00000
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)
controller.screen.print(lgamma_result)
# lgamma_result = 3.17805
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)
controller.screen.print(erf_result)
# erf_result = 0.84270
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)
controller.screen.print(erfc_result)
# erfc_result = 0.15730