Matematika#
Perkenalan#
Fitur matematika mencakup fungsi bawaan Python dan modul math lengkap, yang secara otomatis tersedia di VEXcode AIM. Alat-alat ini memungkinkan Anda untuk melakukan segala hal mulai dari aritmatika dasar hingga trigonometri tingkat lanjut, pembulatan, dan operasi logaritma.
Gunakan fungsi dan konstanta ini untuk menghitung posisi, sudut, jarak, dan nilai numerik lainnya untuk robot Anda. Anda juga dapat mengkonversi antara derajat dan radian, mengevaluasi ekspresi, dan bekerja dengan nilai khusus seperti tak terhingga dan NaN.
Berikut adalah daftar fungsi matematika, konstanta, dan utilitas yang tersedia:
Fungsi Bawaan – Alat matematika umum yang disertakan dalam Python.
abs– Mengembalikan nilai absolut dari suatu angka.round– Membulatkan angka ke sejumlah tempat desimal yang ditentukan.min– Mengembalikan nilai terkecil dari nilai input.max– Mengembalikan nilai terbesar dari nilai input.sum– Menjumlahkan semua nilai dalam iterable.divmod– Mengembalikan hasil bagi dan sisa sebagai tuple.pow– Memangkatkan suatu angka, opsional dengan modulus.int– Mengonversi nilai menjadi bilangan bulat.float– Mengonversi nilai menjadi bilangan floating-point.
Konstanta – Nilai yang telah ditentukan sebelumnya dari modul math.
math.pi– Konstanta π (pi).math.tau– Konstanta tau (2π).math.e– Bilangan Euler, basis logaritma natural.math.inf– Tak terhingga positif.math.nan– Bukan Angka (NaN).
Trigonometri – Menghitung sudut dan hubungan antar sisi.
math.sin– Sinus suatu sudut dalam radian.math.cos– Kosinus sudut dalam radian.math.tan– Tangen sudut dalam radian.math.atan– Arctangen dari suatu nilai dalam radian.math.atan2– Arctangen y/x dalam radian, dengan mempertimbangkan kuadran.math.asin– Arcsin dari suatu nilai dalam radian.math.acos– Arccosine dari suatu nilai dalam radian.math.degrees– Mengonversi radian ke derajat.math.radians– Mengonversi derajat ke radian.
Hiperbolisme – Fungsi-fungsi tingkat lanjut terkait trigonometri.
math.sinh– Sinus hiperbolik dari suatu nilai.math.cosh– Kosinus hiperbolik dari suatu nilai.math.tanh– Tangen hiperbolik dari suatu nilai.math.asinh– Sinus hiperbolik invers.math.acosh– Kosinus hiperbolik invers.math.atanh– Tangen hiperbolik invers.
Pembulatan & Nilai Mutlak – Sesuaikan presisi atau arah.
math.ceil– Membulatkan ke bilangan bulat terdekat.math.floor– Membulatkan ke bawah ke bilangan bulat terdekat.math.trunc– Menghapus bagian desimal.math.fabs– Mengembalikan nilai absolut sebagai float.
Eksponen & Logaritma – Perhitungan pangkat, akar, dan logaritma.
math.pow– Memangkatkan suatu angka.math.sqrt– Mengembalikan akar kuadrat.math.exp– Menghitung e pangkat x.math.log– Logaritma natural (basis e).math.log10– Logaritma basis 10.math.log2– Logaritma basis 2.math.factorial– Faktorial dari sebuah bilangan bulat.math.expm1– Hasil yang lebih akurat untuke^x - 1.
Operasi Bilangan Titik Mengambang – Memeriksa atau menguraikan nilai bilangan titik mengambang.
math.modf– Mengembalikan bagian pecahan dan bilangan bulat dari sebuah float.math.frexp– Menguraikan sebuah angka menjadi mantissa dan eksponen.math.fmod– Sisa dengan tanda dividen.math.copysign– Mengembalikan nilai dengan tanda yang lain.math.ldexp– Menghitungx * (2 ** exp).
Perbandingan & Perkiraan – Periksa nilai dengan toleransi atau kategori.
math.isclose– Menguji apakah dua nilai kira-kira sama.math.isfinite– Memeriksa apakah suatu angka bersifat terbatas.math.isinf– Memeriksa apakah suatu angka adalah tak terhingga.math.isnan– Memeriksa apakah suatu nilai adalah NaN.
Kesalahan & Gamma – Fungsi matematika khusus.
math.gamma– Fungsi Gamma (faktorial umum).math.lgamma– Gamma logaritmik.math.erf– Fungsi kesalahan.math.erfc– Fungsi kesalahan komplementer.
Fungsi Bawaan#
Python menyediakan beberapa fungsi bawaan yang memungkinkan Anda melakukan operasi matematika di dalam proyek Anda.
abs#
abs mengembalikan nilai absolut dari suatu angka, dengan menghilangkan tanda negatif.
Usage:
abs(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan bulat atau bilangan pecahan. |
# Get the absolute value of -10
abs_result = abs(-10)
robot.screen.print(abs_result)
# abs_result = 10
round#
round membulatkan angka ke sejumlah tempat desimal yang ditentukan.
Usage:
round(x, ndigits)
Parameter |
Keterangan |
|---|---|
|
Bilangan bulat atau bilangan pecahan. |
|
Opsional. Jumlah tempat desimal yang akan dibulatkan. Nilai default adalah 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 mengembalikan nilai terkecil dari beberapa argumen atau sebuah iterable.
Usage:
min(arg1, arg2, …) or min(sequence)
Parameter |
Keterangan |
|---|---|
|
Angka-angka untuk perbandingan. |
|
Daftar, tuple, atau urutan lain yang berisi angka. |
# 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 mengembalikan nilai terbesar dari beberapa argumen atau sebuah iterable.
Usage:
max(arg1, arg2, …) or max(sequence)
Parameter |
Keterangan |
|---|---|
|
Angka-angka untuk perbandingan. |
|
Daftar, tuple, atau urutan lain yang berisi angka. |
# 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 menjumlahkan semua nilai dalam sebuah iterable, dengan nilai awal opsional.
Usage:
sum(sequence, start)
Parameter |
Keterangan |
|---|---|
|
Daftar, tuple, atau urutan lain yang berisi angka. |
|
Opsional. Nilai yang akan ditambahkan ke jumlah total. Nilai default adalah 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 mengembalikan tuple yang berisi hasil bagi dan sisa dari operasi pembagian.
Usage:
divmod(a, b)
Parameter |
Keterangan |
|---|---|
|
Dividen. |
|
Pembagi. |
# Perform integer division and remainder of 10 / 3
divmod_result = divmod(10, 3)
robot.screen.print(divmod_result)
# divmod_result = (3, 1)
pow#
pow memangkatkan suatu angka dan secara opsional melakukan operasi modulus.
Usage:
pow(x, y, mod)
Parameter |
Keterangan |
|---|---|
|
Angka dasar. |
|
Eksponen. |
|
Opsional. Nilai modulus. Jika diberikan, mengembalikan |
# 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 mengkonversi angka atau string menjadi bilangan bulat. Fungsi ini juga mendukung konversi basis saat mengkonversi dari string.
Usage:
int(x, base)
Parameter |
Keterangan |
|---|---|
|
Angka, string, atau objek lain yang akan dikonversi. |
|
Opsional. Basis angka yang digunakan untuk konversi. Nilai default adalah 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 mengubah angka atau string menjadi bilangan floating-point.
Usage:
float(x)
Parameter |
Keterangan |
|---|---|
|
Angka, string, atau objek lain yang akan dikonversi. |
# 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
Modul Matematika#
Modul math di MicroPython menyediakan metode tambahan untuk melakukan perhitungan matematika umum. Metode-metode ini meliputi operasi trigonometri, logaritma, dan operasi numerik lainnya.
Modul math diimpor secara default di VEXcode.
Constants#
Konstanta adalah nilai yang telah ditentukan sebelumnya dan tetap konstan selama proyek berlangsung. Konstanta dapat digunakan dalam perhitungan tanpa memerlukan definisi atau penugasan apa pun.
pi#
pi memberikan konstanta matematika π, yaitu perbandingan antara keliling lingkaran dan diameternya.
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 memberikan nilai 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 memberikan basis logaritma natural.
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
informasi#
inf memberikan nilai tak terhingga positif sebagai bilangan floating point.
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 mewakili angka float khusus untuk “Bukan Angka” (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#
dosa#
sin menghitung sinus suatu sudut dalam radian dan mengembalikan nilai float.
Usage:
math.sin(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang mewakili sudut dalam 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
karena#
cos menghitung kosinus suatu sudut dalam radian dan mengembalikan nilai float.
Usage:
math.cos(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang mewakili sudut dalam 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
cokelat muda#
tan menghitung tangen suatu sudut dalam radian dan mengembalikan nilai float.
Usage:
math.tan(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang mewakili sudut dalam 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#
atan menghitung invers tangen (arc tangen) dari suatu angka dan mengembalikan nilai float yang mewakili sudut dalam radian.
Usage:
math.atan(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat. |
# 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 menghitung nilai utama dari invers tangen y/x dan mengembalikan nilai float yang mewakili sudut dalam radian.
Usage:
math.atan2(y, x)
Parameter |
Keterangan |
|---|---|
|
Bilangan floating point atau integer yang mewakili koordinat y. |
|
Bilangan floating point atau integer yang mewakili koordinat 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 menghitung invers sinus (arc sinus) dari suatu angka dan mengembalikan nilai float yang mewakili sudut dalam radian.
Usage:
math.asin(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat antara -1 dan 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 menghitung kosinus invers (arc cosine) dari suatu angka dan mengembalikan nilai float yang mewakili sudut dalam radian.
Usage:
math.acos(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat antara -1 dan 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
derajat#
degrees mengubah sudut dari radian ke derajat.
Usage:
math.degrees(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang mewakili sudut dalam radian. |
# Convert pi radians to degrees
degrees_result = math.degrees(math.pi)
robot.screen.print(degrees_result)
# degrees_result = 180.00
radian#
radians mengubah sudut dari derajat ke radian.
Usage:
math.radians(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang mewakili sudut dalam derajat. |
# Convert 180 degrees to radians
radians_result = math.radians(180)
robot.screen.print(radians_result)
# radians_result = 3.14
Hyperbolics#
sinh#
sinh menghitung sinus hiperbolik dari x.
Usage:
math.sinh(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the hyperbolic sine of 1
sinh_result = math.sinh(1)
robot.screen.print(sinh_result)
# sinh_result = 1.18
tongkat pendek#
cosh menghitung kosinus hiperbolik dari x.
Usage:
math.cosh(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the hyperbolic cosine of 1
cosh_result = math.cosh(1)
robot.screen.print(cosh_result)
# cosh_result = 1.54
tanh#
tanh menghitung tangen hiperbolik dari x.
Usage:
math.tanh(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the hyperbolic tangent of 1
tanh_result = math.tanh(1)
robot.screen.print(tanh_result)
# tanh_result = 0.76
asinh#
asinh menghitung invers sinus hiperbolik dari x.
Usage:
math.asinh(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the inverse hyperbolic sine of 1
asinh_result = math.asinh(1)
robot.screen.print(asinh_result)
# asinh_result = 0.88
acosh#
acosh menghitung kosinus hiperbolik invers dari x.
Usage:
math.acosh(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan floating point atau bilangan bulat yang lebih besar dari atau sama dengan 1. |
# Calculate the inverse hyperbolic cosine of 2
acosh_result = math.acosh(2)
robot.screen.print(acosh_result)
# acosh_result = 1.32
atanh#
atanh menghitung invers tangen hiperbolik dari x.
Usage:
math.atanh(x)
Parameter |
Keterangan |
|---|---|
|
Nilai mengambang antara -1 dan 1 (eksklusif). |
# 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#
langit-langit#
ceil membulatkan angka ke atas ke bilangan bulat terdekat.
Usage:
math.ceil(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang akan dibulatkan ke atas. |
# Round 3.7 up to the nearest integer
ceil_result = math.ceil(3.7)
robot.screen.print(ceil_result)
# ceil_result = 4
lantai#
floor membulatkan angka ke bawah ke bilangan bulat terdekat.
Usage:
math.floor(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang akan dibulatkan ke bawah. |
# Round 3.7 down to the nearest integer
floor_result = math.floor(3.7)
robot.screen.print(floor_result)
# floor_result = 3
memotong#
trunc menghilangkan bagian desimal dari suatu angka tanpa pembulatan.
Usage:
math.trunc(x)
Parameter |
Keterangan |
|---|---|
|
Angka desimal yang akan dipotong. |
# Remove the decimal part of 3.7
trunc_result = math.trunc(3.7)
robot.screen.print(trunc_result)
# trunc_result = 3
fabs#
fabs mengembalikan nilai absolut suatu angka sebagai bilangan float.
Usage:
math.fabs(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat. |
# Get the absolute value of -3.7
fabs_result = math.fabs(-3.7)
robot.screen.print(fabs_result)
# fabs_result = 3.70
Exponents & Logarithms#
daya#
pow memangkatkan x dengan y dan mengembalikan nilai float, bahkan jika kedua inputnya adalah bilangan bulat.
Usage:
math.pow(x, y)
Parameter |
Keterangan |
|---|---|
|
Basis bilangan pecahan atau bilangan bulat. |
|
Eksponen berupa bilangan pecahan atau bilangan bulat. |
# Calculate 2 raised to the power of 3
power_result = math.pow(2, 3)
robot.screen.print(power_result)
# power_result = 8.00
akar kuadrat#
sqrt menghitung akar kuadrat dari suatu angka dan mengembalikan nilai float, bahkan untuk bilangan kuadrat sempurna.
Usage:
math.sqrt(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan floating point atau integer non-negatif. |
# Calculate the square root of 16
sqrt_result = math.sqrt(16)
robot.screen.print(sqrt_result)
# sqrt_result = 4.00
pengalaman#
exp menghitung eksponen dari suatu angka dan mengembalikan nilai float.
Usage:
math.exp(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat. |
# Calculate e raised to the power of 1
exp_result = math.exp(1)
robot.screen.print(exp_result)
# exp_result = 2.72
catatan#
log menghitung logaritma natural dari suatu angka dan mengembalikan nilai float.
Usage:
math.log(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat positif. |
# 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 menghitung logaritma basis 10 dari suatu angka dan mengembalikan nilai float.
Usage:
math.log10(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat positif. |
# Calculate the base-10 logarithm of 1000
log10_result = math.log10(1000)
robot.screen.print(log10_result)
# log10_result = 3.00
log2#
log2 menghitung logaritma basis 2 dari suatu angka dan mengembalikan nilai float, bahkan ketika x adalah pangkat 2.
Usage:
math.log2(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat positif. |
# Calculate the base-2 logarithm of 8
log2_result = math.log2(8)
robot.screen.print(log2_result)
# log2_result = 3.00
faktorial#
factorial mengembalikan faktorial dari bilangan bulat x, yang merupakan hasil perkalian semua bilangan bulat positif hingga x.
Usage:
math.factorial(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan bulat non-negatif. |
# Calculate 5 factorial (5!)
factorial_result = math.factorial(5)
robot.screen.print(factorial_result)
# factorial_result = 120
percobaan1#
expm1 menghitung ex - 1, yang lebih akurat untuk x yang kecil.
Usage:
math.expm1(x)
Parameter |
Keterangan |
|---|---|
|
Nilai eksponen. |
# 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 menguraikan sebuah angka menjadi bagian pecahan dan bagian bilangan bulatnya dan mengembalikan sebuah tuple (fractional part, integer part), keduanya berupa bilangan float.
Usage:
math.modf(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang akan diuraikan. |
# 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 menguraikan sebuah angka menjadi mantissa dan eksponennya dan mengembalikan sebuah tuple (mantissa, exponent), di mana mantissa adalah bilangan float dan eksponen adalah bilangan bulat.
Usage:
math.frexp(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat yang akan diuraikan. |
# 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 mengembalikan sisa pembagian sambil mempertahankan tanda dividen (x).
Usage:
math.fmod(x, y)
Parameter |
Keterangan |
|---|---|
|
Dividen. |
|
Pembagi. |
# 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
tanda tangan hak cipta#
copysign mengembalikan x dengan tanda y.
Usage:
math.copysign(x, y)
Parameter |
Keterangan |
|---|---|
|
Nilai yang akan dimodifikasi. |
|
Nilai yang tandanya akan disalin. |
# 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 menghitung x * (2 ** exp), yang setara dengan x * 2exp{code}.
Usage:
math.ldexp(x, exp)
Parameter |
Keterangan |
|---|---|
|
Nilai dasar. |
|
Eksponen. |
# Compute 3 * (2 ** 4)
ldexp_result = math.ldexp(3, 4)
robot.screen.print(ldexp_result)
# ldexp_result = 48.00
Comparison & Approximation#
dekat#
isclose memeriksa apakah dua angka hampir sama dalam batas toleransi.
Usage:
math.isclose(a, b, rel_tol, abs_tol)
Parameter |
Keterangan |
|---|---|
|
Angka pertama yang akan dibandingkan. |
|
Angka kedua untuk dibandingkan. |
|
Opsional. Perbedaan maksimum yang diperbolehkan antara a dan b, relatif terhadap ukurannya. Nilai default adalah 1e-09 (sangat kecil). |
|
Opsional. Margin kesalahan tetap, berguna saat membandingkan angka yang mendekati nol. Nilai default adalah 0,0. |
Catatan: Jika rel_tol dan abs_tol sama-sama diberikan, kondisi mana pun yang terpenuhi terlebih dahulu akan menentukan hasilnya.
# 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
tak terbatas#
isfinite memeriksa apakah suatu angka terbatas. Metode ini mengembalikan nilai Boolean:
True– Angka tersebut terbatas.False– Angkanya tak terbatas.
Usage:
math.isfinite(x)
Parameter |
Keterangan |
|---|---|
|
Angka desimal atau bilangan bulat yang akan diperiksa. |
# 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 memeriksa apakah suatu angka tak terhingga. Metode ini mengembalikan nilai Boolean:
True– Angkanya tak terbatas.False– Jumlahnya terbatas.
Usage:
math.isinf(x)
Parameter |
Keterangan |
|---|---|
|
Angka desimal atau bilangan bulat yang akan diperiksa. |
# 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 memeriksa apakah suatu angka adalah NaN (Bukan Angka). Metode ini mengembalikan nilai Boolean:
True– Angkanya adalah NaN.False– Angka tersebut adalah angka yang valid.
Usage:
math.isnan(x)
Parameter |
Keterangan |
|---|---|
|
Angka desimal atau bilangan bulat yang akan diperiksa. |
# 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 menghitung fungsi gamma dari x, yang menggeneralisasi fungsi faktorial untuk bilangan real dan kompleks. Untuk bilangan bulat n, gamma(n) = (n-1)!.
Usage:
math.gamma(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat positif. |
# 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 menghitung logaritma natural dari fungsi gamma.
Usage:
math.lgamma(x)
Parameter |
Keterangan |
|---|---|
|
Bilangan desimal atau bilangan bulat positif. |
# 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 menghitung fungsi kesalahan dari x.
Usage:
math.erf(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the error function of 1
erf_result = math.erf(1)
robot.screen.print(erf_result)
# erf_result = 0.84
erfc#
erfc menghitung fungsi kesalahan komplementer dari x, yang didefinisikan sebagai 1 - erf(x).
Usage:
math.erfc(x)
Parameter |
Keterangan |
|---|---|
|
Nilai berupa angka desimal atau bilangan bulat yang mewakili nilai masukan. |
# Calculate the complementary error function of 1
erfc_result = math.erfc(1)
robot.screen.print(erfc_result)
# erfc_result = 0.16