"math" --- Mathematical functions
*********************************

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

This module provides access to common mathematical functions and
constants, including those defined by the C standard.

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.

+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Number-theoretic functions**                                                                                                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "comb(n, k)"                                         | Number of ways to choose *k* items from *n* items without repetition and without order                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "factorial(n)"                                       | *n* factorial                                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "gcd(*integers)"                                     | Greatest common divisor of the integer arguments                                                                       |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isqrt(n)"                                           | Integer square root of a nonnegative integer *n*                                                                       |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "lcm(*integers)"                                     | Least common multiple of the integer arguments                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "perm(n, k)"                                         | Number of ways to choose *k* items from *n* items without repetition and with order                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Floating point arithmetic**                                                                                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ceil(x)"                                            | Ceiling of *x*, the smallest integer greater than or equal to *x*                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fabs(x)"                                            | Absolute value of *x*                                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "floor(x)"                                           | Floor of *x*, the largest integer less than or equal to *x*                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fma(x, y, z)"                                       | Fused multiply-add operation: "(x * y) + z"                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fmod(x, y)"                                         | Remainder of division "x / y"                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "modf(x)"                                            | Fractional and integer parts of *x*                                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "remainder(x, y)"                                    | Remainder of *x* with respect to *y*                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "trunc(x)"                                           | Integer part of *x*                                                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Floating point manipulation functions**                                                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "copysign(x, y)"                                     | Magnitude (absolute value) of *x* with the sign of *y*                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "frexp(x)"                                           | Mantissa and exponent of *x*                                                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isclose(a, b, rel_tol, abs_tol)"                    | Check if the values *a* and *b* are close to each other                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isfinite(x)"                                        | Check if *x* is neither an infinity nor a NaN                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isinf(x)"                                           | Check if *x* is a positive or negative infinity                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "isnan(x)"                                           | Check if *x* is a NaN  (not a number)                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ldexp(x, i)"                                        | "x * (2**i)", inverse of function "frexp()"                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "nextafter(x, y, steps)"                             | Floating-point value *steps* steps after *x* towards *y*                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "ulp(x)"                                             | Value of the least significant bit of *x*                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Power, exponential and logarithmic functions**                                                                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cbrt(x)"                                            | Cube root of *x*                                                                                                       |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "exp(x)"                                             | *e* raised to the power *x*                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "exp2(x)"                                            | *2* raised to the power *x*                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "expm1(x)"                                           | *e* raised to the power *x*, minus 1                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log(x, base)"                                       | Logarithm of *x* to the given base (*e* by default)                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log1p(x)"                                           | Natural logarithm of *1+x* (base *e*)                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log2(x)"                                            | Base-2 logarithm of *x*                                                                                                |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "log10(x)"                                           | Base-10 logarithm of *x*                                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "pow(x, y)"                                          | *x* raised to the power *y*                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sqrt(x)"                                            | Square root of *x*                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Summation and product functions**                                                                                                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "dist(p, q)"                                         | Euclidean distance between two points *p* and *q* given as an iterable of coordinates                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "fsum(iterable)"                                     | Sum of values in the input *iterable*                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "hypot(*coordinates)"                                | Euclidean norm of an iterable of coordinates                                                                           |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "prod(iterable, start)"                              | Product of elements in the input *iterable* with a *start* value                                                       |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sumprod(p, q)"                                      | Sum of products from two iterables *p* and *q*                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Angular conversion**                                                                                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "degrees(x)"                                         | Convert angle *x* from radians to degrees                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "radians(x)"                                         | Convert angle *x* from degrees to radians                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Trigonometric functions**                                                                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "acos(x)"                                            | Arc cosine of *x*                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "asin(x)"                                            | Arc sine of *x*                                                                                                        |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atan(x)"                                            | Arc tangent of *x*                                                                                                     |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atan2(y, x)"                                        | "atan(y / x)"                                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cos(x)"                                             | Cosine of *x*                                                                                                          |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sin(x)"                                             | Sine of *x*                                                                                                            |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tan(x)"                                             | Tangent of *x*                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Hyperbolic functions**                                                                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "acosh(x)"                                           | Inverse hyperbolic cosine of *x*                                                                                       |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "asinh(x)"                                           | Inverse hyperbolic sine of *x*                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "atanh(x)"                                           | Inverse hyperbolic tangent of *x*                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "cosh(x)"                                            | Hyperbolic cosine of *x*                                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "sinh(x)"                                            | Hyperbolic sine of *x*                                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tanh(x)"                                            | Hyperbolic tangent of *x*                                                                                              |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Special functions**                                                                                                                                                         |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "erf(x)"                                             | Error function at *x*                                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "erfc(x)"                                            | Complementary error function at *x*                                                                                    |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "gamma(x)"                                           | Gamma function at *x*                                                                                                  |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "lgamma(x)"                                          | Natural logarithm of the absolute value of the Gamma function at *x*                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| **Constants**                                                                                                                                                                 |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "pi"                                                 | *π* = 3.141592...                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "e"                                                  | *e* = 2.718281...                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "tau"                                                | *τ* = 2*π* = 6.283185...                                                                                               |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "inf"                                                | Positive infinity                                                                                                      |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+
| "nan"                                                | "Not a number" (NaN)                                                                                                   |
+------------------------------------------------------+------------------------------------------------------------------------------------------------------------------------+


Number-theoretic functions
==========================

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.

   Added in version 3.8.

math.factorial(n)

   Return factorial of the nonnegative integer *n*.

   3.10 sürümünde değişti: Floats with integral values (like "5.0")
   are no longer accepted.

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.

   Added in version 3.5.

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

   Added in version 3.8.

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.

   Added in version 3.9.

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.

   If *k* is not specified or is "None", then *k* defaults to *n* and
   the function returns "n!".

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

   Added in version 3.8.


Floating point arithmetic
=========================

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.fabs(x)

   *x*'in mutlak değerini döndürü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.fma(x, y, z)

   Fused multiply-add operation. Return "(x * y) + z", computed as
   though with infinite precision and range followed by a single round
   to the "float" format. This operation often provides better
   accuracy than the direct expression "(x * y) + z".

   This function follows the specification of the fusedMultiplyAdd
   operation described in the IEEE 754 standard. The standard leaves
   one case implementation-defined, namely the result of "fma(0, inf,
   nan)" and "fma(inf, 0, nan)". In these cases, "math.fma" returns a
   NaN, and does not raise any exception.

   Added in version 3.13.

math.fmod(x, y)

   Return the floating-point remainder of "x / y", as defined by the
   platform C library function "fmod(x, y)". Note that the Python
   expression "x % y" may not return the same result.  The intent of
   the C standard is that "fmod(x, y)" be exactly (mathematically; to
   infinite precision) equal to "x - n*y" for some integer *n* such
   that the result has the same sign as *x* and magnitude less than
   "abs(y)".  Python's "x % y" returns a result with the sign of *y*
   instead, and may not be exactly computable for float arguments. For
   example, "fmod(-1e-100, 1e100)" is "-1e-100", but the result of
   Python's "-1e-100 % 1e100" is "1e100-1e-100", which cannot be
   represented exactly as a float, and rounds to the surprising
   "1e100".  For this reason, function "fmod()" is generally preferred
   when working with floats, while Python's "x % y" is preferred when
   working with integers.

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.

   Note that "modf()" has a different call/return pattern than its C
   equivalents: it takes a single argument and return a pair of
   values, rather than returning its second return value through an
   'output parameter' (there is no such thing in Python).

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.

   On platforms using IEEE 754 binary floating point, the result of
   this operation is always exactly representable: no rounding error
   is introduced.

   Added in version 3.7.

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.

"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.


Floating point manipulation functions
=====================================

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

   Note that "frexp()" has a different call/return pattern than its C
   equivalents: it takes a single argument and return a pair of
   values, rather than returning its second return value through an
   'output parameter' (there is no such thing in Python).

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.

   Whether or not two values are considered close is determined
   according to given absolute and relative tolerances.  If no errors
   occur, the result will be: "abs(a-b) <= max(rel_tol * max(abs(a),
   abs(b)), abs_tol)".

   *rel_tol* is the relative tolerance -- it is the maximum allowed
   difference between *a* and *b*, relative to the larger absolute
   value of *a* or *b*. For example, to set a tolerance of 5%, pass
   "rel_tol=0.05".  The default tolerance is "1e-09", which assures
   that the two values are the same within about 9 decimal digits.
   *rel_tol* must be nonnegative and less than "1.0".

   *abs_tol* is the absolute tolerance; it defaults to "0.0" and it
   must be nonnegative.  When comparing "x" to "0.0", "isclose(x, 0)"
   is computed as "abs(x) <= rel_tol  * abs(x)", which is "False" for
   any nonzero "x" and *rel_tol* less than "1.0".  So add an
   appropriate positive *abs_tol* argument to the call.

   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.

   Added in version 3.5.

   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.)

   Added in version 3.2.

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.ldexp(x, i)

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

math.nextafter(x, y, steps=1)

   Return the floating-point value *steps* steps after *x* towards
   *y*.

   If *x* is equal to *y*, return *y*, unless *steps* is zero.

   Ö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()".

   Added in version 3.9.

   3.12 sürümünde değişti: Added the *steps* argument.

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".

   Added in version 3.9.


Power, exponential and logarithmic functions
============================================

math.cbrt(x)

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

   Added in version 3.11.

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.

   Added in version 3.11.

math.expm1(x)

   Return *e* raised to the power *x*, minus 1.  Here *e* is the base
   of natural logarithms.  For small floats *x*, the subtraction in
   "exp(x) - 1" can result in a significant loss of precision; the
   "expm1()" function provides a way to compute this quantity to full
   precision:

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

   Added in version 3.2.

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.

   Added in version 3.3.

   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)

   Return *x* raised to the power *y*.  Exceptional cases follow the
   IEEE 754 standard as far as possible.  In particular, "pow(1.0, x)"
   and "pow(x, 0.0)" always return "1.0", even when *x* is a zero or a
   NaN.  If both *x* and *y* are finite, *x* is negative, and *y* is
   not an integer then "pow(x, y)" is undefined, and raises
   "ValueError".

   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.


Summation and product functions
===============================

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

   Added in version 3.8.

math.fsum(iterable)

   Return an accurate floating-point sum of values in the iterable.
   Avoids loss of precision by tracking multiple intermediate partial
   sums.

   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.

   For further discussion and two alternative approaches, see the ASPN
   cookbook recipes for accurate floating-point summation.

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

   Added in version 3.8.

math.sumprod(p, q)

   Return the sum of products of values from two iterables *p* and
   *q*.

   Raises "ValueError" if the inputs do not have the same length.

   Kabaca şuna eşdeğerdir:

      sum(itertools.starmap(operator.mul, zip(p, q, strict=True)))

   For float and mixed int/float inputs, the intermediate products and
   sums are computed with extended precision.

   Added in version 3.12.


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.


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.sin(x)

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

math.tan(x)

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


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

Hyperbolic functions are analogs of trigonometric functions that are
based on hyperbolas instead of circles.

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

   Added in version 3.2.

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.

   Added in version 3.2.

math.gamma(x)

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

   Added in version 3.2.

math.lgamma(x)

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

   Added in version 3.2.


Sabitler
========

math.pi

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

math.e

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

math.tau

   The mathematical constant *τ* = 6.283185..., to available
   precision. Tau is a circle constant equal to 2*π*, the ratio of a
   circle's circumference to its radius. To learn more about Tau,
   check out Vi Hart's video Pi is (still) Wrong, and start
   celebrating Tau day by eating twice as much pie!

   Added in version 3.6.

math.inf

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

   Added in version 3.5.

math.nan

   A floating-point "not a number" (NaN) value. Equivalent to the
   output of "float('nan')". Due to the requirements of the IEEE-754
   standard, "math.nan" and "float('nan')" are not considered to equal
   to any other numeric value, including themselves. To check whether
   a number is a NaN, use the "isnan()" function to test for NaNs
   instead of "is" or "==". Example:

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

   Added in version 3.5.

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

"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ı.
