"math" --- Matematiksel fonksiyonlar
************************************

======================================================================

Bu modül, C standardı tarafından tanımlanan matematiksel fonksiyonlara
erişim sağlar.

Bu fonksiyonlar karmaşık sayılarla kullanılamaz; karmaşık sayılar için
desteğe ihtiyacınız varsa "cmath" modülündeki aynı isimli
fonksiyonları kullanın. Karmaşık sayıları destekleyen ve desteklemeyen
fonksiyonlar arasındaki ayrım, çoğu kullanıcının karmaşık sayıları
anlamak için gereken kadar matematik öğrenmek istememesi nedeniyle
yapılmıştır. Karmaşık bir sonuç yerine bir istisna almak, parametre
olarak kullanılan beklenmedik karmaşık sayının daha erken tespit
edilmesini sağlar, böylece programcı ilk etapta nasıl ve neden
üretildiğini belirleyebilir.

Aşağıdaki fonksiyonlar bu modül tarafından sağlanır. Aksi açıkça
belirtilmedikçe, tüm dönüş değerleri floattır.


Sayı teorisi ve temsil fonksiyonları
====================================

math.ceil(x)

   *x*'in tavanını, yani *x*'ten büyük veya ona eşit en küçük
   tamsayıyı döndürür. Eğer *x* bir float değilse, bir "Integral"
   değeri döndürmesi gereken "x.__ceil__"'e delege eder.

math.comb(n, k)

   Tekrarlama ve sıralama olmaksızın *n* öğe arasından *k* öğeyi
   seçmenin yollarının sayısını döndürür.

   "n! / (k! * (n - k)!)" değerini "k <= n" olduğunda verir ve "k > n"
   olduğunda sıfır olarak değerlendirir.

   Binom katsayısı olarak da adlandırılır. Çünkü "(1 + x)ⁿ" polinom
   açılımındaki k. terimin katsayısına eşittir.

   Herhangi bir argümanın tamsayı olmaması durumunda "TypeError"
   fırlatır. Herhangi bir argümanın negatif olması durumunda
   "ValueError" fırlatır.

   3.8 sürümünde geldi.

math.copysign(x, y)

   Büyüklüğü (mutlak değeri) *x* olan ancak işareti *y* olan bir
   ondalıklı sayı döndürür.  İşaretli sıfırları destekleyen
   platformlarda, "copysign(1.0, -0.0)" *-1.0* döndürür.

math.fabs(x)

   *x*'in mutlak değerini döndürür.

math.factorial(n)

   *n* faktöriyeli tamsayı olarak döndürür. *n* tamsayı değil veya
   negatifse "ValueError" fırlatır.

   3.9 sürümünden beri kullanım dışı: Tam sayı değerlere sahip
   ondalıklı değerlerin kabul edilmesi ("5.0" gibi) kullanımdan
   kaldırılmıştır.

math.floor(x)

   x*'ten küçük veya ona eşit en büyük tamsayı olan *x*'in tabanını
   döndürür.  Eğer *x* bir ondalıklı sayı değilse, bir "Integral"
   değeri döndürmesi gereken "x.__floor__" değerini vermelidir.

math.fmod(x, y)

   Platform C kütüphanesi tarafından tanımlandığı gibi "fmod(x, y)"
   döndürür. Python ifadesinin "x % y" aynı sonucu
   döndürmeyebileceğini unutmayın.  C standardının amacı, "fmod(x, y)"
   ifadesinin tam olarak (matematiksel olarak; sonsuz hassasiyette)
   *n* tamsayısı için "x - n*y" değerine eşit olmasıdır, böylece sonuç
   *x* ile aynı işarete ve "abs(y)" değerinden daha küçük bir
   büyüklüğe sahip olur.  Python'un "x % y" değeri bunun yerine *y*
   işaretine sahip bir sonuç döndürür ve ondalıklı sayı bağımsız
   değişkenler için tam olarak hesaplanabilir olmayabilir. Örneğin,
   "fmod(-1e-100, 1e100)" sonucu "-1e-100" 'dür, ancak Python`un
   "-1e-100 % 1e100" sonucu "1e100-1e-100" 'dür, bu da tam olarak bir
   ondalıklı sayı olarak gösterilemez ve şaşırtıcı "1e100" değerine
   yuvarlanır.  Bu nedenle, floatlarla çalışırken genellikle "fmod()"
   fonksiyonu tercih edilirken, tamsayılarla çalışırken Python'un "x %
   y" fonksiyonu tercih edilir.

math.frexp(x)

   x*'in mantissa ve üssünü "(m, e)" çifti olarak döndürür.  *m* bir
   ondalıklı sayı ve *e* bir tamsayıdır, bu yüzden "x == m * 2**e"
   doğru olarak eşittir. Eğer *x* sıfır ise "(0.0, 0)", aksi takdirde
   "0.5 <= abs(m) < 1" döndürür.  Bu, bir ondalıklı sayının iç
   temsilini taşınabilir bir şekilde "ayırmak" için kullanılır.

math.fsum(iterable)

   Iterable içindeki değerlerin doğru bir kayan noktalı toplamını
   döndür. Birden fazla ara toplamı takip ederek hassasiyet kaybını
   önler:

      >>> sum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
      0.9999999999999999
      >>> fsum([.1, .1, .1, .1, .1, .1, .1, .1, .1, .1])
      1.0

   Algoritmanın doğruluğu IEEE-754 aritmetik garantilerine ve
   yuvarlama modunun yarı-çift olduğu tipik duruma bağlıdır.  Bazı
   Windows dışı yapılarda, temel C kütüphanesi genişletilmiş
   hassasiyetli toplama kullanır ve bazen bir ara toplamı çift
   yuvarlayarak en az anlamlı bitinde eksik olmasına neden olabilir.

   Daha fazla tartışma ve iki alternatif yaklaşım için, ASPN cookbook
   recipes for accurate floating point summation sayfasına bakın.

math.gcd(*integers)

   Belirtilen tamsayı bağımsız değişkenlerinin en büyük ortak bölenini
   döndürür. Bağımsız değişkenlerden herhangi biri sıfır değilse,
   döndürülen değer tüm bağımsız değişkenlerin bölenleri olan en büyük
   pozitif tamsayıdır.  Tüm bağımsız değişkenler sıfırsa, döndürülen
   değer "0" olur.  bağımsız değişkenler olmadan "gcd()" fonksiyonu
   "0" değerini döndürür.

   3.5 sürümünde geldi.

   3.9 sürümünde değişti: İsteğe bağlı sayıda bağımsız değişken için
   destek eklendi. Önceden sadece iki argüman destekleniyordu.

math.isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)

   Eğer *a* ve *b* değerleri birbirine yakınsa "True", değilse "False"
   döndürür.

   İki değerin yakın kabul edilip edilmeyeceği, verilen mutlak ve
   göreceli toleranslara göre belirlenir.

   *rel_tol* göreli toleranstır - *a* veya *b*'nin daha büyük mutlak
   değerine göre *a* ve *b* arasında izin verilen maksimum farktır.
   Örneğin, %5'lik bir tolerans ayarlamak için "rel_tol=0.05" değerini
   girin.  Varsayılan tolerans, iki değerin yaklaşık 9 ondalık basamak
   içinde aynı olmasını sağlayan "1e-09" değeridir.  *rel_tol*
   sıfırdan büyük olmalıdır.

   *abs_tol* minimum mutlak toleranstır -- sıfıra yakın
   karşılaştırmalar için kullanışlıdır. *abs_tol* en az sıfır
   olmalıdır.

   Herhangi bir hata oluşmazsa, sonuç şöyle olacaktır: "abs(a-b) <=
   max(rel_tol * max(abs(a), abs(b)), abs_tol)".

   IEEE 754 özel değerleri olan "NaN", "inf" ve "-inf" IEEE
   kurallarına göre ele alınacaktır.  Özellikle, "NaN", "NaN" dahil
   olmak üzere başka hiçbir değere yakın kabul edilmez.  "inf" ve
   "-inf" yalnızca kendilerine yakın kabul edilir.

   3.5 sürümünde geldi.

   Ayrıca bakınız:

     **PEP 485** -- Yaklaşık eşitliği test etmek için bir fonksiyon

math.isfinite(x)

   Eğer *x* sonsuz bir değer ya da  NaN ise "True", aksi takdirde
   "False" döndürür.  ("0.0" *sonlu* olarak kabul edilir.)

   3.2 sürümünde geldi.

math.isinf(x)

   Eğer *x* pozitif veya negatif bir sonsuz ise "True", aksi takdirde
   "False" döndürür.

math.isnan(x)

   Eğer *x* bir NaN (sayı değil) ise "True", aksi takdirde "False"
   döndürür.

math.isqrt(n)

   Negatif olmayan *n* tamsayısının tamsayı karekökünü döndürür. Bu,
   *n* tam karekökünün tabanıdır veya eşdeğer olarak *a*² ≤ *n* olacak
   şekilde en büyük *a* tamsayısıdır.

   Bazı uygulamalar için, *n* ≤ *a*² olacak şekilde en küçük *a*
   tamsayısına veya başka bir deyişle *n*'nin tam karekökünün tavanına
   sahip olmak daha uygun olabilir. Pozitif *n* için bu, "a = 1 +
   isqrt(n - 1)" kullanılarak hesaplanabilir.

   3.8 sürümünde geldi.

math.lcm(*integers)

   Belirtilen tamsayı bağımsız değişkenlerinin en küçük ortak katını
   döndürür. Tüm bağımsız değişkenler sıfır değilse, döndürülen değer
   tüm bağımsız değişkenlerin katı olan en küçük pozitif tamsayıdır.
   Bağımsız değişkenlerden herhangi biri sıfırsa, döndürülen değer "0"
   olur.  Bağımsız değişkenler olmadan "lcm()" işlevi "1" değerini
   döndürür.

   3.9 sürümünde geldi.

math.ldexp(x, i)

   "x * (2**i)" döndürür.  Bu aslında "frexp()" fonksiyonunun
   tersidir.

math.modf(x)

   x*'in kesirli ve tamsayı kısımlarını döndürür.  Her iki sonuç da
   *x* işaretini taşır ve kayan değerdir.

math.nextafter(x, y)

   x* değerinden sonra *y* değerine doğru bir sonraki kayan noktalı
   değeri döndürür.

   Eğer *x*, *y*'ye eşitse, *y* değerini döndürür.

   Örnekler:

   * "math.nextafter(x, math.inf)" yukarı gider: pozitif sonsuza
     doğru.

   * "math.nextafter(x, -math.inf)" aşağı iner: eksi sonsuza doğru.

   * "math.nextafter(x, 0.0)" sıfıra doğru gider.

   * "math.nextafter(x, math.copysign(math.inf, x))" sıfırdan
     uzaklaşır.

   Ayrıca bakınız "math.ulp()".

   3.9 sürümünde geldi.

math.perm(n, k=None)

   Tekrarlama olmadan ve sırayla *n* öğe arasından *k* öğeyi seçmenin
   yollarının sayısını döndürür.

   "n! / (k! * (n - k)!)" değerini "k <= n" olduğunda verir ve "k > n"
   olduğunda sıfır olarak değerlendirir.

   Eğer *k* belirtilmemişse veya None ise, *k* varsayılan olarak *n*
   değerini alır ve fonksiyon "n!" döndürür.

   Herhangi bir argümanın tamsayı olmaması durumunda "TypeError"
   fırlatır. Herhangi bir argümanın negatif olması durumunda
   "ValueError" fırlatır.

   3.8 sürümünde geldi.

math.prod(iterable, *, start=1)

   Girdi *iterable* içindeki tüm elemanların çarpımını hesaplar.
   Çarpım için varsayılan *başlangıç* değeri "1" 'dir.

   Yinelenebilir boş olduğunda, başlangıç değerini döndürür.  Bu
   fonksiyon özellikle sayısal değerlerle kullanılmak üzere
   tasarlanmıştır ve sayısal olmayan türleri reddedebilir.

   3.8 sürümünde geldi.

math.remainder(x, y)

   x*'in *y*'ye göre IEEE 754 tarzı kalanını döndürür.  Sonlu *x* ve
   sonlu sıfır olmayan *y* için bu, "x - n*y" farkıdır; burada "n", "x
   / y" bölümünün tam değerine en yakın tamsayıdır.  Eğer "x / y"
   ardışık iki tamsayının tam ortası ise, "n" için en yakın *çift*
   tamsayı kullanılır.  Kalan "r = remainder(x, y)" böylece her zaman
   "abs(r) <= 0.5 * abs(y)" sağlar.

   Özel durumlar IEEE 754'ü takip eder: özellikle, "remainder(x,
   math.inf)" herhangi bir sonlu *x* için *x*'dir ve "remainder(x, 0)"
   ve "remainder(math.inf, x)" NaN olmayan herhangi bir *x* için
   "ValueError" yükseltir. Eğer kalan işleminin sonucu sıfır ise, bu
   sıfır *x* ile aynı işarete sahip olacaktır.

   IEEE 754 ikili kayan nokta kullanan platformlarda, bu işlemin
   sonucu her zaman tam olarak gösterilebilir: yuvarlama hatası
   oluşmaz.

   3.7 sürümünde geldi.

math.trunc(x)

   Kesirli kısmı çıkarılmış ve tamsayı kısmı bırakılmış *x* döndürür.
   Bu 0'a yuvarlanır: "trunc()" pozitif *x* için "floor()" ve negatif
   *x* için "ceil()" ile eşdeğerdir. Eğer *x* bir float değilse, bir
   "Integral" değeri döndürmesi gereken "x.__trunc__"'a delege eder.

math.ulp(x)

   float *x* öğesinin en az anlamlı bitinin değerini döndürür:

   * Eğer *x* bir NaN (sayı değil) ise "True", aksi takdirde "False"
     döndürür.

   * Eğer *x* negatif ise, "ulp(-x)" döndürür.

   * Eğer *x* pozitif bir sonsuzluk ise, *x* değerini döndürür.

   * Eğer *x* sıfıra eşitse, temsil edilebilir en küçük pozitif
     *normalize* floatı döndürür (minimum pozitif *normalize* floattan
     daha küçük, "sys.float_info.min").

   * Eğer *x* pozitif olarak temsil edilebilen en büyük float değerine
     eşitse, *x* değerinden küçük olan ilk float değeri "x - ulp(x)"
     olacak şekilde *x* değerinin en küçük anlamlı bitinin değerini
     döndürür.

   * Aksi takdirde (*x* pozitif bir sonlu sayıdır), *x*'in en az
     anlamlı bitinin değerini döndürür, öyle ki *x*'ten büyük ilk
     float "x + ulp(x)" olur.

   ULP, "Son Yerdeki Birim" anlamına gelmektedir.

   Ayrıca bakınız "math.nextafter()" ve "sys.float_info.epsilon".

   3.9 sürümünde geldi.

"frexp()" ve "modf()"'un C'deki eşdeğerlerinden farklı bir çağrı/çağrı
modeline sahip olduğuna dikkat edin: tek bir argüman alırlar ve ikinci
dönüş değerlerini bir 'çıktı parametresi' aracılığıyla döndürmek
yerine bir çift değer döndürürler (Python'da böyle bir şey yoktur).

"ceil()", "floor()" ve "modf()" fonksiyonları için, yeterince büyük
büyüklükteki *tüm* kayan noktalı sayıların tam tamsayı olduğunu
unutmayın. Python kayan noktalı sayıları tipik olarak 53 bitten fazla
hassasiyet taşımaz (C platformundaki double tipiyle aynıdır), bu
durumda "abs(x) >= 2**52" olan herhangi bir *x* kayan noktalı sayısı
zorunlu olarak kesirli bitlere sahip değildir.


Güç ve logaritmik fonksiyonlar
==============================

math.cbrt(x)

   x*'in küp kökünü döndürür.

   3.11 sürümünde geldi.

math.exp(x)

   *e*'yi *x* kuvvetine yükseltilmiş olarak döndürür, burada *e* =
   2.718281... doğal logaritma tabanıdır.  Bu genellikle "math.e ** x"
   veya "pow(math.e, x)" değerinden daha doğrudur.

math.exp2(x)

   *2*'nin *x* kuvvetine yükseltilmiş halini döndürür.

   3.11 sürümünde geldi.

math.expm1(x)

   x* kuvvetine yükseltilmiş *e* döndürür, eksi 1.  Burada *e* doğal
   logaritma tabanıdır.  Küçük kayan değerler *x* için, "exp(x) - 1"
   çıkarma işlemi önemli bir hassasiyet kaybınaneden olabilir;
   "expm1()" fonksiyonu bu miktarı tam hassasiyetle hesaplamak için
   bir yol sağlar:

      >>> from math import exp, expm1
      >>> exp(1e-5) - 1  # gives result accurate to 11 places
      1.0000050000069649e-05
      >>> expm1(1e-5)    # result accurate to full precision
      1.0000050000166668e-05

   3.2 sürümünde geldi.

math.log(x[, base])

   Bir bağımsız değişkenle, *x*'in doğal logaritmasını döndürür (*e*
   tabanına göre).

   İki bağımsız değişkenle, "log(x)/log(taban)" şeklinde hesaplanan
   *x* değerinin verilen *taban* değerine göre logaritmasını döndürür.

math.log1p(x)

   *1+x*'in (*e* tabanı) doğal logaritmasını döndürür. Sonuç, sıfıra
   yakın *x* için doğru olacak şekilde hesaplanır.

math.log2(x)

   x*'in 2 taban logaritmasını döndürür. Bu genellikle "log(x, 2)"
   değerinden daha doğrudur.

   3.3 sürümünde geldi.

   Ayrıca bakınız:

     "int.bit_length()", işaret ve baştaki sıfırlar hariç olmak üzere,
     bir tamsayıyı ikili olarak temsil etmek için gerekli bit sayısını
     döndürür.

math.log10(x)

   *x* 'in 10 tabanında logaritmasını döndürür.  Bu genellikle "log(x,
   10)" 'dan daha doğrudur.

math.pow(x, y)

   x`in "y" kuvvetine yükseltilmiş halini döndürür.  İstisnai durumlar
   mümkün olduğunca IEEE 754 standardını takip eder.  Özellikle,
   "pow(1.0, x)" ve "pow(x, 0.0)", "x" sıfır veya NaN olsa bile her
   zaman "1.0" döndürür.  Eğer hem "x" hem de "y" sonlu ise, "x"
   negatif ise ve "y" bir tamsayı değilse, "pow(x, y)" tanımsızdır ve
   "ValueError" yükseltir.

   Yerleşik "**" operatörünün aksine, "math.pow()" her iki argümanını
   da "float" türüne dönüştürür.  Tam sayı kuvvetlerini hesaplamak
   için "**" veya yerleşik "pow()" fonksiyonunu kullanın.

   3.11 sürümünde değişti: Özel durumlar "pow(0.0, -inf)" ve
   "pow(-0.0, -inf)", IEEE 754 ile tutarlılık için "ValueError`"
   yükseltmek yerine "inf" döndürmek üzere değiştirildi.

math.sqrt(x)

   *x*'in karekökünü döndürür.


Trigonometrik fonksiyonlar
==========================

math.acos(x)

   Radyan cinsinden *x*'in yay kosinüsünü döndürür. Sonuç "0" ile "pi"
   arasındadır.

math.asin(x)

   Radyan cinsinden *x*'in yay sinüsünü döndürür. Sonuç "-pi/2" ile
   "pi/2" arasındadır.

math.atan(x)

   Radyan cinsinden *x*'in yay tanjantını döndürür. Sonuç "-pi/2" ile
   "pi/2" arasındadır.

math.atan2(y, x)

   Radyan cinsinden "atan(y / x)" döndürür. Sonuç "-pi" ile "pi"
   arasındadır. Düzlemde orijinden "(x, y)" noktasına kadar olan
   vektör, pozitif X ekseni ile bu açıyı yapar. "atan2()" 'nin amacı,
   her iki girdinin de işaretlerinin bilinmesidir, böylece açı için
   doğru kadranı hesaplayabilir. Örneğin, "atan(1)" ve "atan2(1, 1)"
   her ikisi de "pi/4" 'tür, ancak "atan2(-1, -1)" ise  "-3*pi/4"
   'tür.

math.cos(x)

   *x* radyanın kosinüsünü döndürür.

math.dist(p, q)

   Her biri bir koordinat dizisi (veya yinelenebilir) olarak verilen
   iki *p* ve *q* noktası arasındaki Öklid mesafesini döndürür.  İki
   nokta aynı boyuta sahip olmalıdır.

   Kabaca şuna eşdeğerdir:

      sqrt(sum((px - qx) ** 2.0 for px, qx in zip(p, q)))

   3.8 sürümünde geldi.

math.hypot(*coordinates)

   Öklid normunu döndürür, "sqrt(sum(x**2 for x in coordinates))". Bu,
   vektörün orijinden koordinatlar tarafından verilen noktaya olan
   uzunluğudur.

   İki boyutlu bir "(x, y)" noktası için bu, Pisagor teoremi "sqrt(x*x
   + y*y)" kullanılarak bir dik üçgenin hipotenüsünün hesaplanmasına
   eşdeğerdir.

   3.8 sürümünde değişti: n boyutlu noktalar için destek eklendi.
   Önceden sadece iki boyutlu durum destekleniyordu.

   3.10 sürümünde değişti: Algoritmanın doğruluğu, maksimum hata 1
   ulp'nin (son sıradaki birim) altında olacak şekilde geliştirildi.
   Daha tipik olarak, sonuç neredeyse her zaman 1/2 ulp içinde doğru
   şekilde yuvarlanır.

math.sin(x)

   *x* radyanın sinüsünü döndürür.

math.tan(x)

   *x* radyanın tanjantını döndürür.


Açısal dönüşüm
==============

math.degrees(x)

   Açıyı *x* radyandan dereceye dönüştürür.

math.radians(x)

   Açıyı *x* dereceden radyana dönüştürür.


Hiberbolik fonksiyonlar
=======================

Hiperbolik fonksiyonlar trigonometrik fonksiyonların çemberler yerine
hiperbollere dayanan analoglarıdır.

math.acosh(x)

   *x*'in ters hiperbolik kosinüsünü döndürür.

math.asinh(x)

   *x*'in ters hiperbolik sinüsünü döndürür.

math.atanh(x)

   *x*'in ters hiperbolik tanjantını döndürür.

math.cosh(x)

   *x*'in hiperbolik kosinüsünü döndürür.

math.sinh(x)

   *x*'in hiperbolik sinüsünü döndürür.

math.tanh(x)

   *x*'in hiperbolik tanjantını döndürür.


Özel fonksiyonlar
=================

math.erf(x)

   *x* adresindeki hata fonksiyonunu döndürür.

   The "erf()" function can be used to compute traditional statistical
   functions such as the cumulative standard normal distribution:

      def phi(x):
          'Cumulative distribution function for the standard normal distribution'
          return (1.0 + erf(x / sqrt(2.0))) / 2.0

   3.2 sürümünde geldi.

math.erfc(x)

   *x* 'de tamamlayıcı hata fonksiyonunu döndürür.  Tamamlayıcı hata
   fonksiyonu "1.0 - erf(x)" olarak tanımlanır.  Birbirinden
   çıkarmanın anlamlılık kaybına neden olacağı büyük *x* değerleri
   için kullanılır.

   3.2 sürümünde geldi.

math.gamma(x)

   *x* adresindeki Gamma fonksiyonunu döndürür.

   3.2 sürümünde geldi.

math.lgamma(x)

   Gama fonksiyonunun *x*'deki mutlak değerinin doğal logaritmasını
   döndürür.

   3.2 sürümünde geldi.


Sabitler
========

math.pi

   Matematiksel sabit *π* = 3.141592..., mevcut hassasiyete göre.

math.e

   Matematiksel sabit *e* = 2,718281..., mevcut hassasiyete göre.

math.tau

   Matematiksel sabit *τ* = 6.283185..., mevcut hassasiyete göre. Tau,
   bir dairenin çevresinin yarıçapına oranı olan 2*π*'ye eşit bir
   daire sabitidir. Tau hakkında daha fazla bilgi edinmek için Vi
   Hart'ın Pi (hala) Yanlış videosuna göz atın ve Tau gününü iki kat
   daha fazla turta yiyerek kutlamaya başlayın!

   3.6 sürümünde geldi.

math.inf

   Bir kayan noktalı pozitif sonsuzluk.  (Negatif sonsuzluk için
   "-math.inf" kullanın.) "float('inf')" çıktısına eşdeğerdir.

   3.5 sürümünde geldi.

math.nan

   Bir kayan noktalı "sayı değil" (NaN) değeri. "float('nan')"
   çıktısına eşdeğerdir. IEEE-754 standardının gereklilikleri
   nedeniyle, "math.nan" ve "float('nan')" kendileri de dahil olmak
   üzere başka hiçbir sayısal değere eşit kabul edilmez. Bir sayının
   NaN olup olmadığını kontrol etmek için, "is" veya "==" yerine
   NaN'leri test etmek için "isnan()" fonksiyonunu kullanın. Örnek:

      >>> import math
      >>> math.nan == math.nan
      False
      >>> float('nan') == float('nan')
      False
      >>> math.isnan(math.nan)
      True
      >>> math.isnan(float('nan'))
      True

   3.5 sürümünde geldi.

   3.11 sürümünde değişti: Artık her zaman kullanılabilir.

**CPython uygulama ayrıntısı:** "math" modülü çoğunlukla platform C
matematik kütüphanesi fonksiyonları etrafındaki ince sarmalayıcılardan
oluşur.  İstisnai durumlarda davranış, uygun olan yerlerde C99
standardının Ek F'sini takip eder.  Mevcut uygulama, "sqrt(-1.0)" veya
"log(0.0)" gibi geçersiz işlemler için :exc:"ValueError" (C99 Annex F
geçersiz işlem veya sıfıra bölme sinyalini önerir) ve taşan sonuçlar
için "OverflowError" (örneğin, "exp(1000.0)") yükseltir.  Girdi
argümanlarından biri veya daha fazlası NaN olmadığı sürece yukarıdaki
fonksiyonların hiçbirinden NaN döndürülmeyecektir; bu durumda, çoğu
fonksiyon bir NaN döndürecektir, ancak (yine C99 Ek F'yi takip ederek)
bu kuralın bazı istisnaları vardır, örneğin "pow(float('nan'), 0.0)"
veya "hypot(float('nan'), float('inf'))".

Python'un sinyal veren NaN'ları sessiz NaN'lardan ayırt etmek için
hiçbir çaba göstermediğini ve sinyal veren NaN'lar için davranışın
belirtilmediğini unutmayın. Tipik davranış, tüm NaN'lara sessizmiş
gibi davranmaktır.

Ayrıca bakınız:

  Modül "cmath"
     Bu fonksiyonların çoğunun karmaşık sayı versiyonları.
