Matematik#

giriiş #

Matematik modülü, hem Python’ın yerleşik fonksiyonlarını hem de VEXcode AIM’de otomatik olarak kullanılabilen tam math modülünü içerir. Bu araçlar, temel aritmetikten gelişmiş trigonometriye, yuvarlamaya ve logaritmik işlemlere kadar her şeyi gerçekleştirmenizi sağlar.

Robotunuzun konumlarını, açılarını, mesafelerini ve diğer sayısal değerlerini hesaplamak için bu fonksiyonları ve sabitleri kullanın. Ayrıca derece ve radyan arasında dönüşüm yapabilir, ifadeleri değerlendirebilir ve sonsuzluk ve NaN gibi özel değerlerle çalışabilirsiniz.

Aşağıda mevcut matematiksel fonksiyonlar, sabitler ve yardımcı programların bir listesi bulunmaktadır:

Yerleşik Fonksiyonlar – Python ile birlikte gelen yaygın matematik araçları.

abs – Bir sayının mutlak değerini döndürür.
round – Bir sayıyı belirtilen sayıda ondalık basamağa yuvarlar.
min – Giriş değerlerinin en küçüğünü döndürür.
max – Girdi değerlerinin en büyüğünü döndürür.
sum – Yinelenebilir bir nesnedeki tüm değerleri toplar.
divmod – Bölümü ve kalanı bir demet olarak döndürür.
pow – Bir sayıyı, isteğe bağlı olarak modül ile birlikte bir kuvvete yükseltir.
int – Bir değeri tam sayıya dönüştürür.
float – Bir değeri ondalıklı sayıya dönüştürür.

Sabitler – math modülünden önceden tanımlanmış değerler.

math.pi – Sabit π (pi).
math.tau – Sabit tau (2π).
math.e – Euler sayısı, doğal logaritmanın tabanı.
math.inf – Pozitif sonsuzluk.
math.nan – Sayı Değil (NaN).

Trigonometri – Açıları ve kenarlar arasındaki ilişkileri hesaplayın.

math.sin – Radyan cinsinden bir açının sinüsü.
math.cos – Radyan cinsinden bir açının kosinüsü.
math.tan – Radyan cinsinden bir açının tanjantı.
math.atan – Radyan cinsinden bir değerin arktanjantı.
math.atan2 – Çeyrek bölgeyi dikkate alarak y/x’in radyan cinsinden arktanjantı.
math.asin – Radyan cinsinden bir değerin arksinüsü.
math.acos – Radyan cinsinden bir değerin arkkosinüsü.
math.degrees – Radyanları dereceye dönüştürür.
math.radians – Dereceleri radyanlara dönüştürür.

Hyperbolics – Gelişmiş trigonometri ile ilgili fonksiyonlar.

math.sinh – Bir değerin hiperbolik sinüsü.
math.cosh – Bir değerin hiperbolik kosinüsü.
math.tanh – Bir değerin hiperbolik tanjantı.
math.asinh – Ters hiperbolik sinüs.
math.acosh – Ters hiperbolik kosinüs.
math.atanh – Ters hiperbolik tanjant.

Yuvarlama ve Mutlak Değer – Hassasiyeti veya yönü ayarlayın.

math.ceil – En yakın tam sayıya yuvarlar.
math.floor – En yakın tam sayıya yuvarlar.
math.trunc – Ondalık kısmı kaldırır.
math.fabs – Mutlak değeri ondalık sayı olarak döndürür.

Üslü Sayılar ve Logaritma – Kuvvet, kök ve logaritma hesaplamaları.

math.pow – Bir sayıyı bir kuvvete yükseltir.
math.sqrt – Karekökünü döndürür.
math.exp – e’nin x kuvvetini hesaplar.
math.log – Doğal logaritma (e tabanı).
math.log10 – 10 Tabanlı logaritma.
math.log2 – Taban-2 logaritması.
math.factorial – Bir tamsayının faktöriyeli.
math.expm1 – e^x - 1 için daha doğru sonuç.

Kayan Nokta İşlemleri – Kayan noktalı sayıları inceleyin veya ayrıştırın.

math.modf – Bir ondalık sayının kesirli ve tam sayı kısımlarını döndürür.
math.frexp – Bir sayıyı mantis ve üsse ayırır.
math.fmod – Bölünenin işaretiyle kalan.
math.copysign – Başka bir değerin işaretiyle bir değer döndürür.
math.ldexp – x * (2 ** exp) hesaplar.

Karşılaştırma ve Yaklaşım – Değerleri toleranslar veya kategorilerle kontrol edin.

math.isclose – İki değerin yaklaşık olarak eşit olup olmadığını test eder.
math.isfinite – Bir sayının sonlu olup olmadığını kontrol eder.
math.isinf – Bir sayının sonsuz olup olmadığını kontrol eder.
math.isnan – Bir değerin NaN olup olmadığını kontrol eder.

Hata ve Gama – Özel matematiksel fonksiyonlar.

math.gamma – Gama fonksiyonu (genelleştirilmiş faktöriyel).
math.lgamma – Logaritmik gama.
math.erf – Hata fonksiyonu.
math.erfc – Tamamlayıcı hata fonksiyonu.

Dahili Fonksiyonlar #

Python, projeniz içinde matematiksel işlemler gerçekleştirmenize olanak tanıyan çeşitli yerleşik fonksiyonlar sunar.

abs #

abs bir sayının mutlak değerini, negatif işareti kaldırarak döndürür.

Usage:
abs(x)

Parametre	Tanım
`x`	Bir tamsayı veya ondalık sayı.

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

# abs_result = 10

round #

round tur, bir sayıyı belirtilen sayıda ondalık basamağa yuvarlar.

Usage:
round(x, ndigits)

Parametre	Tanım
`x`	Bir tamsayı veya ondalık sayı.
`ndigits`	İsteğe bağlı. Yuvarlama için ondalık basamak sayısı. Varsayılan değer 0’dır.

# 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 birden fazla argümandan veya yinelenebilir bir nesneden en küçük değeri döndürür.

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

Parametre	Tanım
`arg1`, `arg2`, …	Karşılaştırılacak sayılar.
`sequence`	Sayılar içeren bir liste, demet veya başka bir dizi.

# 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 birden fazla argümandan veya yinelenebilir bir nesneden en büyük değeri döndürür.

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

Parametre	Tanım
`arg1`, `arg2`, …	Karşılaştırılacak sayılar.
`sequence`	Sayılar içeren bir liste, demet veya başka bir dizi.

# 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 isteğe bağlı bir başlangıç değeriyle, yinelenebilir bir nesnedeki tüm değerleri toplar.

Usage:
sum(sequence, start)

Parametre	Tanım
`sequence`	Sayılar içeren bir liste, demet veya başka bir dizi.
`start`	İsteğe bağlı. Toplama eklenecek değer. Varsayılan değer 0’dır.

# 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 bir bölme işleminin bölümünü ve kalanını içeren bir demet döndürür.

Usage:
divmod(a, b)

Parametre	Tanım
`a`	Temettü.
`b`	Bölücü.

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

# divmod_result = (3, 1)

pow #

pow bir sayıyı bir kuvvete yükseltir ve isteğe bağlı olarak modül işlemi gerçekleştirir.

Usage:
pow(x, y, mod)

Parametre	Tanım
`x`	Taban sayısı.
`y`	Üs.
`mod`	İsteğe bağlı. Bir modül değeri. Sağlanırsa, `(x ** y) % mod` değerini döndürür.

# 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 , bir sayıyı veya dizeyi tamsayıya dönüştürür. Ayrıca, dizeden dönüştürme yaparken taban dönüştürmeyi de destekler.

Usage:
int(x, base)

Parametre	Tanım
`x`	Dönüştürülecek sayı, dize veya başka bir nesne.
`base`	İsteğe bağlı. Dönüştürme için kullanılacak sayı tabanı. Varsayılan değer 10’dur.

# 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 , bir sayıyı veya dizeyi ondalıklı sayıya dönüştürür.

Usage:
float(x)

Parametre	Tanım
`x`	Dönüştürülecek sayı, dize veya başka bir nesne.

# 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

Matematik Modülü #

MicroPython’daki math modülü, yaygın matematiksel hesaplamaları gerçekleştirmek için ek yöntemler sunar. Bu yöntemler arasında trigonometrik, logaritmik ve diğer sayısal işlemler bulunur.

VEXcode’da math modülü varsayılan olarak içe aktarılır.

Constants #

Sabitler, bir proje boyunca sabit kalan önceden tanımlanmış değerlerdir. Herhangi bir tanımlama veya atama gerektirmeden hesaplamalarda kullanılabilirler.

pi #

pi , bir dairenin çevresinin çapına oranını veren matematiksel sabit π’yi verir.

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 ifadesi 2π değerini verir.

Usage:
math.tau

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

# circumference = 31.42

e #

e doğal logaritmanın tabanını verir.

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

bilgi #

inf ifadesi, kayan noktalı sayı olarak pozitif sonsuzluk verir.

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 “Sayı Değil” (NaN) için özel bir ondalık sayıyı temsil eder.

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 #

günah #

sin , radyan cinsinden bir açının sinüsünü hesaplar ve ondalık sayı döndürür.

Usage:
math.sin(x)

Parametre	Tanım
`x`	Radyan cinsinden açıyı temsil eden ondalık sayı veya tam sayı.

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

cos , radyan cinsinden bir açının kosinüsünü hesaplar ve ondalık sayı döndürür.

Usage:
math.cos(x)

Parametre	Tanım
`x`	Radyan cinsinden açıyı temsil eden ondalık sayı veya tam sayı.

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

# cosine_result = 0.50

bronz #

tan , radyan cinsinden bir açının tanjantını hesaplar ve ondalık sayı döndürür.

Usage:
math.tan(x)

Parametre	Tanım
`x`	Radyan cinsinden açıyı temsil eden ondalık sayı veya tam sayı.

# 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 bir sayının ters tanjantını (arktanjantını) hesaplar ve radyan cinsinden açıyı temsil eden bir ondalık sayı döndürür.

Usage:
math.atan(x)

Parametre	Tanım
`x`	Ondalık sayı veya tam sayı.

# 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 y/x’in ters tanjantının esas değerini hesaplar ve radyan cinsinden açıyı temsil eden bir ondalık sayı döndürür.

Usage:
math.atan2(y, x)

Parametre	Tanım
`y`	Y koordinatını temsil eden ondalık sayı veya tam sayı.
`x`	X koordinatını temsil eden ondalık sayı veya tam sayı.

# 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 bir sayının ters sinüsünü (ark sinüsünü) hesaplar ve radyan cinsinden açıyı temsil eden bir ondalık sayı döndürür.

Usage:
math.asin(x)

Parametre	Tanım
`x`	-1 ile 1 arasında bir ondalık sayı veya tam sayı.

# 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 bir sayının ters kosinüsünü (ark kosinüsünü) hesaplar ve radyan cinsinden açıyı temsil eden bir ondalık sayı döndürür.

Usage:
math.acos(x)

Parametre	Tanım
`x`	-1 ile 1 arasında bir ondalık sayı veya tam sayı.

# 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

dereceler #

degrees , bir açıyı radyan cinsinden dereceye dönüştürür.

Usage:
math.degrees(x)

Parametre	Tanım
`x`	Radyan cinsinden açıyı temsil eden ondalık sayı veya tam sayı.

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

# degrees_result = 180.00

radyanlar #

radians bir açıyı dereceden radyana dönüştürür.

Usage:
math.radians(x)

Parametre	Tanım
`x`	Açı değerini derece cinsinden temsil eden ondalık sayı veya tam sayı.

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

# radians_result = 3.14

Hyperbolics #

sinh #

sinh x hiperbolik sinüsünü hesaplar.

Usage:
math.sinh(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# sinh_result = 1.18

koç #

cosh x hiperbolik kosinüsünü hesaplar.

Usage:
math.cosh(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# cosh_result = 1.54

tanh #

tanh x hiperbolik tanjantını hesaplar.

Usage:
math.tanh(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# tanh_result = 0.76

asinh #

asinh x ters hiperbolik sinüsünü hesaplar.

Usage:
math.asinh(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# asinh_result = 0.88

acosh #

acosh x ters hiperbolik kosinüsünü hesaplar.

Usage:
math.acosh(x)

Parametre	Tanım
`x`	1’den büyük veya 1’e eşit bir ondalık sayı veya tam sayı.

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

# acosh_result = 1.32

atanh #

atanh x ters hiperbolik tanjantını hesaplar.

Usage:
math.atanh(x)

Parametre	Tanım
`x`	-1 ile 1 arasında (1 hariç) ondalık sayı.

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

tavan #

ceil bir sayıyı en yakın tam sayıya yuvarlar.

Usage:
math.ceil(x)

Parametre	Tanım
`x`	Yukarı yuvarlanacak ondalık sayı veya tam sayı.

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

# ceil_result = 4

zemin #

floor basamak, bir sayıyı en yakın tam sayıya yuvarlar.

Usage:
math.floor(x)

Parametre	Tanım
`x`	Aşağı yuvarlanacak ondalık sayı veya tam sayı.

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

# floor_result = 3

kesik #

trunc yuvarlama yapmadan sayının ondalık kısmını kaldırır.

Usage:
math.trunc(x)

Parametre	Tanım
`x`	Kesilecek bir kayan nokta.

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

# trunc_result = 3

fabrikalar #

fabs , bir sayının mutlak değerini ondalık sayı olarak döndürür.

Usage:
math.fabs(x)

Parametre	Tanım
`x`	Ondalık sayı veya tam sayı.

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

# fabs_result = 3.70

Exponents & Logarithms #

güç #

pow ifadesi, x’i y kuvvetine yükseltir ve her iki girdi de tamsayı olsa bile ondalık sayı döndürür.

Usage:
math.pow(x, y)

Parametre	Tanım
`x`	Kayan noktalı veya tam sayı tabanı.
`y`	Ondalık sayı veya tam sayı üs.

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

# power_result = 8.00

karekök #

sqrt , bir sayının karekökünü hesaplar ve tam kareler için bile ondalık sayı döndürür.

Usage:
math.sqrt(x)

Parametre	Tanım
`x`	Negatif olmayan bir ondalık sayı veya tam sayı.

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

# sqrt_result = 4.00

deneyim #

exp , bir sayının üssünü hesaplar ve ondalık sayı döndürür.

Usage:
math.exp(x)

Parametre	Tanım
`x`	Ondalık sayı veya tam sayı.

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

# exp_result = 2.72

kayıt #

log bir sayının doğal logaritmasını hesaplar ve ondalık sayı döndürür.

Usage:
math.log(x)

Parametre	Tanım
`x`	Pozitif bir ondalık sayı veya tam sayı.

# 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 , bir sayının 10 tabanına göre logaritmasını hesaplar ve ondalık sayı döndürür.

Usage:
math.log10(x)

Parametre	Tanım
`x`	Pozitif bir ondalık sayı veya tam sayı.

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

# log10_result = 3.00

log2 #

log2 x 2’nin bir kuvveti olduğu durumlarda bile bir sayının 2 tabanına göre logaritmasını hesaplar ve ondalık sayı döndürür.

Usage:
math.log2(x)

Parametre	Tanım
`x`	Pozitif bir ondalık sayı veya tam sayı.

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

# log2_result = 3.00

faktöriyel #

factorial , x kadar olan tüm pozitif tamsayıların çarpımı olan xtamsayısının faktöriyelini döndürür.

Usage:
math.factorial(x)

Parametre	Tanım
`x`	Negatif olmayan bir tam sayı.

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

# factorial_result = 120

deney1 #

expm1 e^x - 1hesaplar ki bu, küçük x için daha doğrudur.

Usage:
math.expm1(x)

Parametre	Tanım
`x`	Üs değeri.

# 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 bir sayıyı kesirli ve tam sayı kısımlarına ayırır ve her ikisi de ondalık sayı olan bir (fractional part, integer part)döndürür.

Usage:
math.modf(x)

Parametre	Tanım
`x`	Ayrıştırılacak bir ondalık sayı veya tam sayı.

# 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 bir sayıyı mantis ve üs bileşenlerine ayırır ve mantisin ondalık sayı, üssün ise tam sayı olduğu bir (mantissa, exponent)döndürür.

Usage:
math.frexp(x)

Parametre	Tanım
`x`	Ayrıştırılacak bir ondalık sayı veya tam sayı.

# 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 bölünenin işaretini koruyarak bölme işleminden kalanını döndürür (x).

Usage:
math.fmod(x, y)

Parametre	Tanım
`x`	Temettü.
`y`	Bölücü.

# 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 returns x with the sign of y.

Usage:
math.copysign(x, y)

Parametre	Tanım
`x`	Değiştirilecek değer.
`y`	İşareti kopyalanacak olan değer.

# 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)ifadesini hesaplar; bu da x * 2^exp{code} ifadesine eşdeğerdir.

Usage:
math.ldexp(x, exp)

Parametre	Tanım
`x`	Temel değer.
`exp`	Üs.

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

# ldexp_result = 48.00

Comparison & Approximation #

isclose #

isclose yakındır ve iki sayının belirli bir tolerans dahilinde yaklaşık olarak eşit olup olmadığını kontrol eder.

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

Parametre	Tanım
`a`	Karşılaştırılacak ilk sayı.
`b`	Karşılaştırılacak ikinci sayı.
`rel_tol`	İsteğe bağlı. a ve b arasındaki, boyutlarına göre izin verilen maksimum fark. Varsayılan değer 1e-09’dur (çok küçük).
`abs_tol`	İsteğe bağlı. Sıfıra yakın sayıları karşılaştırırken kullanışlı olan sabit bir hata payı. Varsayılan değer 0,0’dır.

Not: Hem rel_tol hem de abs_tol sağlanmışsa, hangi koşul önce sağlanırsa sonuç o belirlenir.

# 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

sonsuzdur #

isfinite bir sayının sonlu olup olmadığını kontrol eder. Bu yöntem Boolean bir değer döndürür:

True – Sayı sonludur.
False – Sayı sonsuzdur.

Usage:
math.isfinite(x)

Parametre	Tanım
`x`	Kontrol edilecek ondalık sayı veya tam sayı.

# 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 bir sayının sonsuz olup olmadığını kontrol eder. Bu yöntem Boolean bir değer döndürür:

True – Sayı sonsuzdur.
False – Sayı sonludur.

Usage:
math.isinf(x)

Parametre	Tanım
`x`	Kontrol edilecek ondalık sayı veya tam sayı.

# 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 bir sayının NaN (Sayı Değil) olup olmadığını kontrol eder. Bu yöntem Boolean bir değer döndürür:

True – Sayı NaN’dir.
False – Sayı geçerli bir sayıdır.

Usage:
math.isnan(x)

Parametre	Tanım
`x`	Kontrol edilecek ondalık sayı veya tam sayı.

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

gama #

gamma , gerçek ve karmaşık sayılar için faktöriyel fonksiyonunu genelleştiren xgama fonksiyonunu hesaplar. Bir tam sayı n, gamma(n) = (n-1)!.

Usage:
math.gamma(x)

Parametre	Tanım
`x`	Pozitif bir ondalık sayı veya tam sayı.

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

# gamma_result = 24.00

γ #

lgamma gamma fonksiyonunun doğal logaritmasını hesaplar.

Usage:
math.lgamma(x)

Parametre	Tanım
`x`	Pozitif bir ondalık sayı veya tam sayı.

# 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 hata fonksiyonunu hesaplar.

Usage:
math.erf(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# erf_result = 0.84

erfc #

erfc , xtamamlayıcı hata fonksiyonunu hesaplar; bu fonksiyon 1 - erf(x) olarak tanımlanır.

Usage:
math.erfc(x)

Parametre	Tanım
`x`	Giriş değerini temsil eden ondalık sayı veya tam sayı.

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

# erfc_result = 0.16