length 1, to a C :c:expr:`int`.
``f`` (:class:`float`) [float]
- Convert a Python floating point number to a C :c:expr:`float`.
+ Convert a Python floating-point number to a C :c:expr:`float`.
``d`` (:class:`float`) [double]
- Convert a Python floating point number to a C :c:expr:`double`.
+ Convert a Python floating-point number to a C :c:expr:`double`.
``D`` (:class:`complex`) [Py_complex]
Convert a Python complex number to a C :c:type:`Py_complex` structure.
object of length 1.
``d`` (:class:`float`) [double]
- Convert a C :c:expr:`double` to a Python floating point number.
+ Convert a C :c:expr:`double` to a Python floating-point number.
``f`` (:class:`float`) [float]
- Convert a C :c:expr:`float` to a Python floating point number.
+ Convert a C :c:expr:`float` to a Python floating-point number.
``D`` (:class:`complex`) [Py_complex \*]
Convert a C :c:type:`Py_complex` structure to a Python complex number.
.. _floatobjects:
-Floating Point Objects
+Floating-Point Objects
======================
-.. index:: pair: object; floating point
+.. index:: pair: object; floating-point
.. c:type:: PyFloatObject
- This subtype of :c:type:`PyObject` represents a Python floating point object.
+ This subtype of :c:type:`PyObject` represents a Python floating-point object.
.. c:var:: PyTypeObject PyFloat_Type
- This instance of :c:type:`PyTypeObject` represents the Python floating point
+ This instance of :c:type:`PyTypeObject` represents the Python floating-point
type. This is the same object as :class:`float` in the Python layer.
.. c:function:: double PyFloat_AsDouble(PyObject *pyfloat)
Return a C :c:expr:`double` representation of the contents of *pyfloat*. If
- *pyfloat* is not a Python floating point object but has a :meth:`~object.__float__`
+ *pyfloat* is not a Python floating-point object but has a :meth:`~object.__float__`
method, this method will first be called to convert *pyfloat* into a float.
If :meth:`!__float__` is not defined then it falls back to :meth:`~object.__index__`.
This method returns ``-1.0`` upon failure, so one should call
The module supports two versions of the data format: version 0 is the
historical version, version 1 shares interned strings in the file, and upon
-unmarshalling. Version 2 uses a binary format for floating point numbers.
+unmarshalling. Version 2 uses a binary format for floating-point numbers.
``Py_MARSHAL_VERSION`` indicates the current file format (currently 2).
Return a reasonable approximation for the mathematical value of *o1* divided by
*o2*, or ``NULL`` on failure. The return value is "approximate" because binary
- floating point numbers are approximate; it is not possible to represent all real
- numbers in base two. This function can return a floating point value when
+ floating-point numbers are approximate; it is not possible to represent all real
+ numbers in base two. This function can return a floating-point value when
passed two integers. This is the equivalent of the Python expression ``o1 / o2``.
Return a reasonable approximation for the mathematical value of *o1* divided by
*o2*, or ``NULL`` on failure. The return value is "approximate" because binary
- floating point numbers are approximate; it is not possible to represent all real
- numbers in base two. This function can return a floating point value when
+ floating-point numbers are approximate; it is not possible to represent all real
+ numbers in base two. This function can return a floating-point value when
passed two integers. The operation is done *in-place* when *o1* supports it.
This is the equivalent of the Python statement ``o1 /= o2``.
Python behaves like many popular languages including C and Java.
Many numbers that can be written easily in decimal notation cannot be expressed
-exactly in binary floating-point. For example, after::
+exactly in binary floating point. For example, after::
>>> x = 1.2
The typical precision of 53 bits provides Python floats with 15--16
decimal digits of accuracy.
-For a fuller explanation, please see the :ref:`floating point arithmetic
+For a fuller explanation, please see the :ref:`floating-point arithmetic
<tut-fp-issues>` chapter in the Python tutorial.
import random
random.random()
-This returns a random floating point number in the range [0, 1).
+This returns a random floating-point number in the range [0, 1).
There are also many other specialized generators in this module, such as:
* ``randrange(a, b)`` chooses an integer in the range [a, b).
-* ``uniform(a, b)`` chooses a floating point number in the range [a, b).
+* ``uniform(a, b)`` chooses a floating-point number in the range [a, b).
* ``normalvariate(mean, sdev)`` samples the normal (Gaussian) distribution.
Some higher-level functions operate on sequences directly, such as:
--------------------------------------
For integers, use the built-in :func:`int` type constructor, e.g. ``int('144')
-== 144``. Similarly, :func:`float` converts to floating-point,
+== 144``. Similarly, :func:`float` converts to a floating-point number,
e.g. ``float('144') == 144.0``.
By default, these interpret the number as decimal, so that ``int('0144') ==
--------------
This module defines an object type which can compactly represent an array of
-basic values: characters, integers, floating point numbers. Arrays are sequence
+basic values: characters, integers, floating-point numbers. Arrays are sequence
types and behave very much like lists, except that the type of objects stored in
them is constrained. The type is specified at object creation time by using a
:dfn:`type code`, which is a single character. The following type codes are
array with the same type and value using :func:`eval`, so long as the
:class:`~array.array` class has been imported using ``from array import array``.
Variables ``inf`` and ``nan`` must also be defined if it contains
-corresponding floating point values.
+corresponding floating-point values.
Examples::
array('l')
between colors expressed in the RGB (Red Green Blue) color space used in
computer monitors and three other coordinate systems: YIQ, HLS (Hue Lightness
Saturation) and HSV (Hue Saturation Value). Coordinates in all of these color
-spaces are floating point values. In the YIQ space, the Y coordinate is between
+spaces are floating-point values. In the YIQ space, the Y coordinate is between
0 and 1, but the I and Q coordinates can be positive or negative. In all other
spaces, the coordinates are all between 0 and 1.
.. method:: getfloat(section, option, *, raw=False, vars=None[, fallback])
A convenience method which coerces the *option* in the specified *section*
- to a floating point number. See :meth:`get` for explanation of *raw*,
+ to a floating-point number. See :meth:`get` for explanation of *raw*,
*vars* and *fallback*.
-:mod:`!decimal` --- Decimal fixed point and floating point arithmetic
+:mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic
=====================================================================
.. module:: decimal
--------------
The :mod:`decimal` module provides support for fast correctly rounded
-decimal floating point arithmetic. It offers several advantages over the
+decimal floating-point arithmetic. It offers several advantages over the
:class:`float` datatype:
* Decimal "is based on a floating-point model which was designed with people
.. versionchanged:: 3.3
Decimals interact well with much of the rest of Python. Here is a small decimal
-floating point flying circus:
+floating-point flying circus:
.. doctest::
:options: +NORMALIZE_WHITESPACE
digits, and an integer exponent. For example, ``Decimal((0, (1, 4, 1, 4), -3))``
returns ``Decimal('1.414')``.
- If *value* is a :class:`float`, the binary floating point value is losslessly
+ If *value* is a :class:`float`, the binary floating-point value is losslessly
converted to its exact decimal equivalent. This conversion can often require
53 or more digits of precision. For example, ``Decimal(float('1.1'))``
converts to
Underscores are allowed for grouping, as with integral and floating-point
literals in code.
- Decimal floating point objects share many properties with the other built-in
+ Decimal floating-point objects share many properties with the other built-in
numeric types such as :class:`float` and :class:`int`. All of the usual math
operations and special methods apply. Likewise, decimal objects can be
copied, pickled, printed, used as dictionary keys, used as set elements,
Mixed-type comparisons between :class:`Decimal` instances and other
numeric types are now fully supported.
- In addition to the standard numeric properties, decimal floating point
+ In addition to the standard numeric properties, decimal floating-point
objects also have a number of specialized methods:
.. _decimal-notes:
-Floating Point Notes
+Floating-Point Notes
--------------------
The effects of round-off error can be amplified by the addition or subtraction
of nearly offsetting quantities resulting in loss of significance. Knuth
-provides two instructive examples where rounded floating point arithmetic with
+provides two instructive examples where rounded floating-point arithmetic with
insufficient precision causes the breakdown of the associative and distributive
properties of addition:
In addition to the two signed zeros which are distinct yet equal, there are
various representations of zero with differing precisions yet equivalent in
value. This takes a bit of getting used to. For an eye accustomed to
-normalized floating point representations, it is not immediately obvious that
+normalized floating-point representations, it is not immediately obvious that
the following calculation returns a value equal to zero:
>>> 1 / Decimal('Infinity')
Q. Is there a way to convert a regular float to a :class:`Decimal`?
-A. Yes, any binary floating point number can be exactly expressed as a
+A. Yes, any binary floating-point number can be exactly expressed as a
Decimal though an exact conversion may take more precision than intuition would
suggest:
A. Yes. In the CPython and PyPy3 implementations, the C/CFFI versions of
the decimal module integrate the high speed `libmpdec
<https://www.bytereef.org/mpdecimal/doc/libmpdec/index.html>`_ library for
-arbitrary precision correctly rounded decimal floating point arithmetic [#]_.
+arbitrary precision correctly rounded decimal floating-point arithmetic [#]_.
``libmpdec`` uses `Karatsuba multiplication
<https://en.wikipedia.org/wiki/Karatsuba_algorithm>`_
for medium-sized numbers and the `Number Theoretic Transform
Fri, 09 Nov 2001 01:08:47 -0000
- Optional *timeval* if given is a floating point time value as accepted by
+ Optional *timeval* if given is a floating-point time value as accepted by
:func:`time.gmtime` and :func:`time.localtime`, otherwise the current time is
used.
represented. This cannot occur for integers (which would rather raise
:exc:`MemoryError` than give up). However, for historical reasons,
OverflowError is sometimes raised for integers that are outside a required
- range. Because of the lack of standardization of floating point exception
- handling in C, most floating point operations are not checked.
+ range. Because of the lack of standardization of floating-point exception
+ handling in C, most floating-point operations are not checked.
.. exception:: RecursionError
:class:`Fraction` instance with the same value. The next two versions accept
either a :class:`float` or a :class:`decimal.Decimal` instance, and return a
:class:`Fraction` instance with exactly the same value. Note that due to the
- usual issues with binary floating-point (see :ref:`tut-fp-issues`), the
+ usual issues with binary floating point (see :ref:`tut-fp-issues`), the
argument to ``Fraction(1.1)`` is not exactly equal to 11/10, and so
``Fraction(1.1)`` does *not* return ``Fraction(11, 10)`` as one might expect.
(But see the documentation for the :meth:`limit_denominator` method below.)
.. function:: abs(x)
Return the absolute value of a number. The argument may be an
- integer, a floating point number, or an object implementing
+ integer, a floating-point number, or an object implementing
:meth:`~object.__abs__`.
If the argument is a complex number, its magnitude is returned.
Take two (non-complex) numbers as arguments and return a pair of numbers
consisting of their quotient and remainder when using integer division. With
mixed operand types, the rules for binary arithmetic operators apply. For
- integers, the result is the same as ``(a // b, a % b)``. For floating point
+ integers, the result is the same as ``(a // b, a % b)``. For floating-point
numbers the result is ``(q, a % b)``, where *q* is usually ``math.floor(a /
b)`` but may be 1 less than that. In any case ``q * b + a % b`` is very
close to *a*, if ``a % b`` is non-zero it has the same sign as *b*, and ``0
single: NaN
single: Infinity
- Return a floating point number constructed from a number or a string.
+ Return a floating-point number constructed from a number or a string.
Examples:
Case is not significant, so, for example, "inf", "Inf", "INFINITY", and
"iNfINity" are all acceptable spellings for positive infinity.
- Otherwise, if the argument is an integer or a floating point number, a
- floating point number with the same value (within Python's floating point
+ Otherwise, if the argument is an integer or a floating-point number, a
+ floating-point number with the same value (within Python's floating-point
precision) is returned. If the argument is outside the range of a Python
float, an :exc:`OverflowError` will be raised.
``int(x)`` returns ``x.__int__()``. If the argument defines :meth:`~object.__index__`,
it returns ``x.__index__()``. If the argument defines :meth:`~object.__trunc__`,
it returns ``x.__trunc__()``.
- For floating point numbers, this truncates towards zero.
+ For floating-point numbers, this truncates towards zero.
If the argument is not a number or if *base* is given, then it must be a string,
:class:`bytes`, or :class:`bytearray` instance representing an integer
For some use cases, there are good alternatives to :func:`sum`.
The preferred, fast way to concatenate a sequence of strings is by calling
- ``''.join(sequence)``. To add floating point values with extended precision,
+ ``''.join(sequence)``. To add floating-point values with extended precision,
see :func:`math.fsum`\. To concatenate a series of iterables, consider using
:func:`itertools.chain`.
yield n
n += step
- When counting with floating point numbers, better accuracy can sometimes be
+ When counting with floating-point numbers, better accuracy can sometimes be
achieved by substituting multiplicative code such as: ``(start + step * i
for i in count())``.
.. function:: format_string(format, val, grouping=False, monetary=False)
Formats a number *val* according to the current :const:`LC_NUMERIC` setting.
- The format follows the conventions of the ``%`` operator. For floating point
+ The format follows the conventions of the ``%`` operator. For floating-point
values, the decimal point is modified if appropriate. If *grouping* is ``True``,
also takes the grouping into account.
.. function:: str(float)
- Formats a floating point number using the same format as the built-in function
+ Formats a floating-point number using the same format as the built-in function
``str(float)``, but takes the decimal point into account.
Not all Python object types are supported; in general, only objects whose value
is independent from a particular invocation of Python can be written and read by
-this module. The following types are supported: booleans, integers, floating
-point numbers, complex numbers, strings, bytes, bytearrays, tuples, lists, sets,
+this module. The following types are supported: booleans, integers, floating-point
+numbers, complex numbers, strings, bytes, bytearrays, tuples, lists, sets,
frozensets, dictionaries, and code objects, where it should be understood that
tuples, lists, sets, frozensets and dictionaries are only supported as long as
the values contained therein are themselves supported. The
Indicates the format that the module uses. Version 0 is the historical
format, version 1 shares interned strings and version 2 uses a binary format
- for floating point numbers.
+ for floating-point numbers.
Version 3 adds support for object instancing and recursion.
The current version is 4.
.. function:: fsum(iterable)
- Return an accurate floating point sum of values in the iterable. Avoids
+ Return an accurate floating-point sum of values in the iterable. Avoids
loss of precision by tracking multiple intermediate partial sums.
The algorithm's accuracy depends on IEEE-754 arithmetic guarantees and the
least significant bit.
For further discussion and two alternative approaches, see the `ASPN cookbook
- recipes for accurate floating point summation
+ recipes for accurate floating-point summation
<https://code.activestate.com/recipes/393090-binary-floating-point-summation-accurate-to-full-p/>`_\.
If the result of the remainder operation is zero, that zero will have
the same sign as *x*.
- On platforms using IEEE 754 binary floating-point, the result of this
+ On platforms using IEEE 754 binary floating point, the result of this
operation is always exactly representable: no rounding error is introduced.
.. versionadded:: 3.7
.. function:: getatime(path)
- Return the time of last access of *path*. The return value is a floating point number giving
+ Return the time of last access of *path*. The return value is a floating-point number giving
the number of seconds since the epoch (see the :mod:`time` module). Raise
:exc:`OSError` if the file does not exist or is inaccessible.
.. function:: getmtime(path)
- Return the time of last modification of *path*. The return value is a floating point number
+ Return the time of last modification of *path*. The return value is a floating-point number
giving the number of seconds since the epoch (see the :mod:`time` module).
Raise :exc:`OSError` if the file does not exist or is inaccessible.
that you choose (see :ref:`profile-calibration`). For most machines, a timer
that returns a lone integer value will provide the best results in terms of
low overhead during profiling. (:func:`os.times` is *pretty* bad, as it
- returns a tuple of floating point values). If you want to substitute a
+ returns a tuple of floating-point values). If you want to substitute a
better timer in the cleanest fashion, derive a class and hardwire a
replacement dispatch method that best handles your timer call, along with the
appropriate calibration constant.
For a given seed, the :func:`choices` function with equal weighting
typically produces a different sequence than repeated calls to
- :func:`choice`. The algorithm used by :func:`choices` uses floating
- point arithmetic for internal consistency and speed. The algorithm used
+ :func:`choice`. The algorithm used by :func:`choices` uses floating-point
+ arithmetic for internal consistency and speed. The algorithm used
by :func:`choice` defaults to integer arithmetic with repeated selections
to avoid small biases from round-off error.
.. function:: random()
- Return the next random floating point number in the range ``0.0 <= X < 1.0``
+ Return the next random floating-point number in the range ``0.0 <= X < 1.0``
.. function:: uniform(a, b)
- Return a random floating point number *N* such that ``a <= N <= b`` for
+ Return a random floating-point number *N* such that ``a <= N <= b`` for
``a <= b`` and ``b <= N <= a`` for ``b < a``.
The end-point value ``b`` may or may not be included in the range
.. function:: triangular(low, high, mode)
- Return a random floating point number *N* such that ``low <= N <= high`` and
+ Return a random floating-point number *N* such that ``low <= N <= high`` and
with the specified *mode* between those bounds. The *low* and *high* bounds
default to zero and one. The *mode* argument defaults to the midpoint
between the bounds, giving a symmetric distribution.
elements.
The fields :attr:`ru_utime` and :attr:`ru_stime` of the return value are
- floating point values representing the amount of time spent executing in user
+ floating-point values representing the amount of time spent executing in user
mode and the amount of time spent executing in system mode, respectively. The
remaining values are integers. Consult the :manpage:`getrusage(2)` man page for
detailed information about these values. A brief summary is presented here:
Empty iterables are allowed, but acceptance of three empty iterables is
platform-dependent. (It is known to work on Unix but not on Windows.) The
- optional *timeout* argument specifies a time-out as a floating point number
+ optional *timeout* argument specifies a time-out as a floating-point number
in seconds. When the *timeout* argument is omitted the function blocks until
at least one file descriptor is ready. A time-out value of zero specifies a
poll and never blocks.
.. method:: socket.settimeout(value)
Set a timeout on blocking socket operations. The *value* argument can be a
- nonnegative floating point number expressing seconds, or ``None``.
+ nonnegative floating-point number expressing seconds, or ``None``.
If a non-zero value is given, subsequent socket operations will raise a
:exc:`timeout` exception if the timeout period *value* has elapsed before
the operation has completed. If zero is given, the socket is put in
======================= ===============================================================
:func:`mean` Arithmetic mean ("average") of data.
-:func:`fmean` Fast, floating point arithmetic mean, with optional weighting.
+:func:`fmean` Fast, floating-point arithmetic mean, with optional weighting.
:func:`geometric_mean` Geometric mean of data.
:func:`harmonic_mean` Harmonic mean of data.
:func:`median` Median (middle value) of data.
pair: object; numeric
pair: object; Boolean
pair: object; integer
- pair: object; floating point
+ pair: object; floating-point
pair: object; complex number
pair: C; language
-There are three distinct numeric types: :dfn:`integers`, :dfn:`floating
-point numbers`, and :dfn:`complex numbers`. In addition, Booleans are a
-subtype of integers. Integers have unlimited precision. Floating point
+There are three distinct numeric types: :dfn:`integers`, :dfn:`floating-point
+numbers`, and :dfn:`complex numbers`. In addition, Booleans are a
+subtype of integers. Integers have unlimited precision. Floating-point
numbers are usually implemented using :c:expr:`double` in C; information
-about the precision and internal representation of floating point
+about the precision and internal representation of floating-point
numbers for the machine on which your program is running is available
in :data:`sys.float_info`. Complex numbers have a real and imaginary
-part, which are each a floating point number. To extract these parts
+part, which are each a floating-point number. To extract these parts
from a complex number *z*, use ``z.real`` and ``z.imag``. (The standard
library includes the additional numeric types :mod:`fractions.Fraction`, for
rationals, and :mod:`decimal.Decimal`, for floating-point numbers with
.. index::
pair: numeric; literals
pair: integer; literals
- pair: floating point; literals
+ pair: floating-point; literals
pair: complex number; literals
pair: hexadecimal; literals
pair: octal; literals
Numbers are created by numeric literals or as the result of built-in functions
and operators. Unadorned integer literals (including hex, octal and binary
numbers) yield integers. Numeric literals containing a decimal point or an
-exponent sign yield floating point numbers. Appending ``'j'`` or ``'J'`` to a
+exponent sign yield floating-point numbers. Appending ``'j'`` or ``'J'`` to a
numeric literal yields an imaginary number (a complex number with a zero real
part) which you can add to an integer or float to get a complex number with real
and imaginary parts.
.. seealso::
* The `linspace recipe <https://code.activestate.com/recipes/579000-equally-spaced-numbers-linspace/>`_
- shows how to implement a lazy version of range suitable for floating
- point applications.
+ shows how to implement a lazy version of range suitable for floating-point
+ applications.
.. index::
single: string; text sequence type
+------------+-----------------------------------------------------+-------+
| ``'X'`` | Signed hexadecimal (uppercase). | \(2) |
+------------+-----------------------------------------------------+-------+
-| ``'e'`` | Floating point exponential format (lowercase). | \(3) |
+| ``'e'`` | Floating-point exponential format (lowercase). | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'E'`` | Floating point exponential format (uppercase). | \(3) |
+| ``'E'`` | Floating-point exponential format (uppercase). | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'f'`` | Floating point decimal format. | \(3) |
+| ``'f'`` | Floating-point decimal format. | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'F'`` | Floating point decimal format. | \(3) |
+| ``'F'`` | Floating-point decimal format. | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'g'`` | Floating point format. Uses lowercase exponential | \(4) |
+| ``'g'`` | Floating-point format. Uses lowercase exponential | \(4) |
| | format if exponent is less than -4 or not less than | |
| | precision, decimal format otherwise. | |
+------------+-----------------------------------------------------+-------+
-| ``'G'`` | Floating point format. Uses uppercase exponential | \(4) |
+| ``'G'`` | Floating-point format. Uses uppercase exponential | \(4) |
| | format if exponent is less than -4 or not less than | |
| | precision, decimal format otherwise. | |
+------------+-----------------------------------------------------+-------+
+------------+-----------------------------------------------------+-------+
| ``'X'`` | Signed hexadecimal (uppercase). | \(2) |
+------------+-----------------------------------------------------+-------+
-| ``'e'`` | Floating point exponential format (lowercase). | \(3) |
+| ``'e'`` | Floating-point exponential format (lowercase). | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'E'`` | Floating point exponential format (uppercase). | \(3) |
+| ``'E'`` | Floating-point exponential format (uppercase). | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'f'`` | Floating point decimal format. | \(3) |
+| ``'f'`` | Floating-point decimal format. | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'F'`` | Floating point decimal format. | \(3) |
+| ``'F'`` | Floating-point decimal format. | \(3) |
+------------+-----------------------------------------------------+-------+
-| ``'g'`` | Floating point format. Uses lowercase exponential | \(4) |
+| ``'g'`` | Floating-point format. Uses lowercase exponential | \(4) |
| | format if exponent is less than -4 or not less than | |
| | precision, decimal format otherwise. | |
+------------+-----------------------------------------------------+-------+
-| ``'G'`` | Floating point format. Uses uppercase exponential | \(4) |
+| ``'G'`` | Floating-point format. Uses uppercase exponential | \(4) |
| | format if exponent is less than -4 or not less than | |
| | precision, decimal format otherwise. | |
+------------+-----------------------------------------------------+-------+
>>> a == b
False
- Note that, as with floating point numbers, ``v is w`` does *not* imply
+ Note that, as with floating-point numbers, ``v is w`` does *not* imply
``v == w`` for memoryview objects.
.. versionchanged:: 3.3
.. index:: single: _ (underscore); in string formatting
The ``'_'`` option signals the use of an underscore for a thousands
-separator for floating point presentation types and for integer
+separator for floating-point presentation types and for integer
presentation type ``'d'``. For integer presentation types ``'b'``,
``'o'``, ``'x'``, and ``'X'``, underscores will be inserted every 4
digits. For other presentation types, specifying this option is an
+---------+----------------------------------------------------------+
In addition to the above presentation types, integers can be formatted
-with the floating point presentation types listed below (except
+with the floating-point presentation types listed below (except
``'n'`` and ``None``). When doing so, :func:`float` is used to convert the
-integer to a floating point number before formatting.
+integer to a floating-point number before formatting.
The available presentation types for :class:`float` and
:class:`~decimal.Decimal` values are:
timeout occurs.
When the *timeout* argument is present and not ``None``, it should be a
- floating point number specifying a timeout for the operation in seconds
+ floating-point number specifying a timeout for the operation in seconds
(or fractions thereof). As :meth:`~Thread.join` always returns ``None``,
you must call :meth:`~Thread.is_alive` after :meth:`~Thread.join` to
decide whether a timeout happened -- if the thread is still alive, the
occurs. Once awakened or timed out, it re-acquires the lock and returns.
When the *timeout* argument is present and not ``None``, it should be a
- floating point number specifying a timeout for the operation in seconds
+ floating-point number specifying a timeout for the operation in seconds
(or fractions thereof).
When the underlying lock is an :class:`RLock`, it is not released using
the the internal flag did not become true within the given wait time.
When the timeout argument is present and not ``None``, it should be a
- floating point number specifying a timeout for the operation in seconds,
+ floating-point number specifying a timeout for the operation in seconds,
or fractions thereof.
.. versionchanged:: 3.1
systems, the clock "ticks" only 50 or 100 times a second.
* On the other hand, the precision of :func:`.time` and :func:`sleep` is better
- than their Unix equivalents: times are expressed as floating point numbers,
+ than their Unix equivalents: times are expressed as floating-point numbers,
:func:`.time` returns the most accurate time available (using Unix
:c:func:`!gettimeofday` where available), and :func:`sleep` will accept a time
with a nonzero fraction (Unix :c:func:`!select` is used to implement this, where
This is the inverse function of :func:`localtime`. Its argument is the
:class:`struct_time` or full 9-tuple (since the dst flag is needed; use ``-1``
as the dst flag if it is unknown) which expresses the time in *local* time, not
- UTC. It returns a floating point number, for compatibility with :func:`.time`.
+ UTC. It returns a floating-point number, for compatibility with :func:`.time`.
If the input value cannot be represented as a valid time, either
:exc:`OverflowError` or :exc:`ValueError` will be raised (which depends on
whether the invalid value is caught by Python or the underlying C libraries).
.. function:: sleep(secs)
Suspend execution of the calling thread for the given number of seconds.
- The argument may be a floating point number to indicate a more precise sleep
+ The argument may be a floating-point number to indicate a more precise sleep
time.
If the sleep is interrupted by a signal and no exception is raised by the
.. function:: time() -> float
- Return the time in seconds since the epoch_ as a floating point
+ Return the time in seconds since the epoch_ as a floating-point
number. The handling of `leap seconds`_ is platform dependent.
On Windows and most Unix systems, the leap seconds are not counted towards
the time in seconds since the epoch_. This is commonly referred to as `Unix
time <https://en.wikipedia.org/wiki/Unix_time>`_.
- Note that even though the time is always returned as a floating point
+ Note that even though the time is always returned as a floating-point
number, not all systems provide time with a better precision than 1 second.
While this function normally returns non-decreasing values, it can return a
lower value than a previous call if the system clock has been set back
* A sign is shown only when the number is negative.
-Python distinguishes between integers, floating point numbers, and complex
+Python distinguishes between integers, floating-point numbers, and complex
numbers:
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. index::
- pair: object; floating point
- pair: floating point; number
+ pair: object; floating-point
+ pair: floating-point; number
pair: C; language
pair: Java; language
-These represent machine-level double precision floating point numbers. You are
+These represent machine-level double precision floating-point numbers. You are
at the mercy of the underlying machine architecture (and C or Java
implementation) for the accepted range and handling of overflow. Python does not
-support single-precision floating point numbers; the savings in processor and
+support single-precision floating-point numbers; the savings in processor and
memory usage that are usually the reason for using these are dwarfed by the
overhead of using objects in Python, so there is no reason to complicate the
-language with two kinds of floating point numbers.
+language with two kinds of floating-point numbers.
:class:`numbers.Complex` (:class:`complex`)
pair: complex; number
These represent complex numbers as a pair of machine-level double precision
-floating point numbers. The same caveats apply as for floating point numbers.
+floating-point numbers. The same caveats apply as for floating-point numbers.
The real and imaginary parts of a complex number ``z`` can be retrieved through
the read-only attributes ``z.real`` and ``z.imag``.
* If either argument is a complex number, the other is converted to complex;
-* otherwise, if either argument is a floating point number, the other is
+* otherwise, if either argument is a floating-point number, the other is
converted to floating point;
* otherwise, both must be integers and no conversion is necessary.
: | `integer` | `floatnumber` | `imagnumber`
Evaluation of a literal yields an object of the given type (string, bytes,
-integer, floating point number, complex number) with the given value. The value
-may be approximated in the case of floating point and imaginary (complex)
+integer, floating-point number, complex number) with the given value. The value
+may be approximated in the case of floating-point and imaginary (complex)
literals. See section :ref:`literals` for details.
.. index::
The ``%`` (modulo) operator yields the remainder from the division of the first
argument by the second. The numeric arguments are first converted to a common
type. A zero right argument raises the :exc:`ZeroDivisionError` exception. The
-arguments may be floating point numbers, e.g., ``3.14%0.7`` equals ``0.34``
+arguments may be floating-point numbers, e.g., ``3.14%0.7`` equals ``0.34``
(since ``3.14`` equals ``4*0.7 + 0.34``.) The modulo operator always yields a
result with the same sign as its second operand (or zero); the absolute value of
the result is strictly smaller than the absolute value of the second operand
and :meth:`~object.__rmod__` methods.
The floor division operator, the modulo operator, and the :func:`divmod`
-function are not defined for complex numbers. Instead, convert to a floating
-point number using the :func:`abs` function if appropriate.
+function are not defined for complex numbers. Instead, convert to a
+floating-point number using the :func:`abs` function if appropriate.
.. index::
single: addition
----------------
.. index:: number, numeric literal, integer literal
- floating point literal, hexadecimal literal
+ floating-point literal, hexadecimal literal
octal literal, binary literal, decimal literal, imaginary literal, complex literal
-There are three types of numeric literals: integers, floating point numbers, and
+There are three types of numeric literals: integers, floating-point numbers, and
imaginary numbers. There are no complex literals (complex numbers can be formed
by adding a real number and an imaginary number).
single: _ (underscore); in numeric literal
.. _floating:
-Floating point literals
+Floating-point literals
-----------------------
-Floating point literals are described by the following lexical definitions:
+Floating-point literals are described by the following lexical definitions:
.. productionlist:: python-grammar
floatnumber: `pointfloat` | `exponentfloat`
Note that the integer and exponent parts are always interpreted using radix 10.
For example, ``077e010`` is legal, and denotes the same number as ``77e10``. The
-allowed range of floating point literals is implementation-dependent. As in
+allowed range of floating-point literals is implementation-dependent. As in
integer literals, underscores are supported for digit grouping.
-Some examples of floating point literals::
+Some examples of floating-point literals::
3.14 10. .001 1e100 3.14e-10 0e0 3.14_15_93
imagnumber: (`floatnumber` | `digitpart`) ("j" | "J")
An imaginary literal yields a complex number with a real part of 0.0. Complex
-numbers are represented as a pair of floating point numbers and have the same
+numbers are represented as a pair of floating-point numbers and have the same
restrictions on their range. To create a complex number with a nonzero real
-part, add a floating point number to it, e.g., ``(3+4j)``. Some examples of
+part, add a floating-point number to it, e.g., ``(3+4j)``. Some examples of
imaginary literals::
3.14j 10.j 10j .001j 1e100j 3.14e-10j 3.14_15_93j
.. _tut-fp-issues:
**************************************************
-Floating Point Arithmetic: Issues and Limitations
+Floating-Point Arithmetic: Issues and Limitations
**************************************************
.. sectionauthor:: Tim Peters <tim_one@users.sourceforge.net>
Python 3.1, Python (on most systems) is now able to choose the shortest of
these and simply display ``0.1``.
-Note that this is in the very nature of binary floating-point: this is not a bug
+Note that this is in the very nature of binary floating point: this is not a bug
in Python, and it is not a bug in your code either. You'll see the same kind of
thing in all languages that support your hardware's floating-point arithmetic
(although some languages may not *display* the difference by default, or in all
with "0.1" is explained in precise detail below, in the "Representation Error"
section. See `Examples of Floating Point Problems
<https://jvns.ca/blog/2023/01/13/examples-of-floating-point-problems/>`_ for
-a pleasant summary of how binary floating-point works and the kinds of
+a pleasant summary of how binary floating point works and the kinds of
problems commonly encountered in practice. Also see
`The Perils of Floating Point <http://www.indowsway.com/floatingpoint.htm>`_
for a more complete account of other common surprises.
As that says near the end, "there are no easy answers." Still, don't be unduly
-wary of floating-point! The errors in Python float operations are inherited
+wary of floating point! The errors in Python float operations are inherited
from the floating-point hardware, and on most machines are on the order of no
more than 1 part in 2\*\*53 per operation. That's more than adequate for most
tasks, but you do need to keep in mind that it's not decimal arithmetic and
20
>>> (50 - 5*6) / 4
5.0
- >>> 8 / 5 # division always returns a floating point number
+ >>> 8 / 5 # division always returns a floating-point number
1.6
The integer numbers (e.g. ``2``, ``4``, ``20``) have type :class:`int`,
* The :func:`print` function writes the value of the argument(s) it is given.
It differs from just writing the expression you want to write (as we did
earlier in the calculator examples) in the way it handles multiple arguments,
- floating point quantities, and strings. Strings are printed without quotes,
+ floating-point quantities, and strings. Strings are printed without quotes,
and a space is inserted between items, so you can format things nicely, like
this::
===========
The :mod:`math` module gives access to the underlying C library functions for
-floating point math::
+floating-point math::
>>> import math
>>> math.cos(math.pi / 4)
.. _tut-decimal-fp:
-Decimal Floating Point Arithmetic
+Decimal Floating-Point Arithmetic
=================================
The :mod:`decimal` module offers a :class:`~decimal.Decimal` datatype for
-decimal floating point arithmetic. Compared to the built-in :class:`float`
+decimal floating-point arithmetic. Compared to the built-in :class:`float`
implementation of binary floating point, the class is especially helpful for
* financial applications and other uses which require exact decimal
<https://en.wikipedia.org/wiki/C11_(C_standard_revision)#Optional_features>`_
are not required.
-* Support for `IEEE 754 <https://en.wikipedia.org/wiki/IEEE_754>`_ floating
- point numbers and `floating point Not-a-Number (NaN)
+* Support for `IEEE 754 <https://en.wikipedia.org/wiki/IEEE_754>`_
+ floating-point numbers and `floating-point Not-a-Number (NaN)
<https://en.wikipedia.org/wiki/NaN#Floating_point>`_.
* Support for threads.
lists the function arguments and the local variables for each frame.
* Various functions in the :mod:`time` module, such as :func:`~time.asctime` and
- :func:`~time.localtime`, require a floating point argument containing the time in
+ :func:`~time.localtime`, require a floating-point argument containing the time in
seconds since the epoch. The most common use of these functions is to work with
- the current time, so the floating point argument has been made optional; when a
+ the current time, so the floating-point argument has been made optional; when a
value isn't provided, the current time will be used. For example, log file
entries usually need a string containing the current time; in Python 2.1,
``time.asctime()`` can be used, instead of the lengthier
* The :func:`pow` built-in function no longer supports 3 arguments when
floating-point numbers are supplied. ``pow(x, y, z)`` returns ``(x**y) % z``,
- but this is never useful for floating point numbers, and the final result varies
+ but this is never useful for floating-point numbers, and the final result varies
unpredictably depending on the platform. A call such as ``pow(2.0, 8.0, 7.0)``
will now raise a :exc:`TypeError` exception.
In Python 2.4, the default will change to always returning floats.
Application developers should enable this feature only if all their libraries
- work properly when confronted with floating point time stamps, or if they use
+ work properly when confronted with floating-point time stamps, or if they use
the tuple API. If used, the feature should be activated on an application level
instead of trying to enable it on a per-use basis.
* Several functions return information about the platform's
floating-point support. :c:func:`PyFloat_GetMax` returns
- the maximum representable floating point value,
+ the maximum representable floating-point value,
and :c:func:`PyFloat_GetMin` returns the minimum
positive value. :c:func:`PyFloat_GetInfo` returns an object
containing more information from the :file:`float.h` file, such as
of the operands. Previously such comparisons would fall back to
Python's default rules for comparing objects, which produced arbitrary
results based on their type. Note that you still cannot combine
- :class:`!Decimal` and floating-point in other operations such as addition,
+ :class:`!Decimal` and floating point in other operations such as addition,
since you should be explicitly choosing how to convert between float and
:class:`!Decimal`. (Fixed by Mark Dickinson; :issue:`2531`.)
(Contributed by Mark Dickinson; :issue:`4707`.)
-* Python now uses David Gay's algorithm for finding the shortest floating
- point representation that doesn't change its value. This should help
- mitigate some of the confusion surrounding binary floating point
+* Python now uses David Gay's algorithm for finding the shortest floating-point
+ representation that doesn't change its value. This should help
+ mitigate some of the confusion surrounding binary floating-point
numbers.
The significance is easily seen with a number like ``1.1`` which does not
equivalent, an expression like ``float('1.1')`` evaluates to the nearest
representable value which is ``0x1.199999999999ap+0`` in hex or
``1.100000000000000088817841970012523233890533447265625`` in decimal. That
- nearest value was and still is used in subsequent floating point
+ nearest value was and still is used in subsequent floating-point
calculations.
What is new is how the number gets displayed. Formerly, Python used a
using 17 digits was that it relied on IEEE-754 guarantees to assure that
``eval(repr(1.1))`` would round-trip exactly to its original value. The
disadvantage is that many people found the output to be confusing (mistaking
- intrinsic limitations of binary floating point representation as being a
+ intrinsic limitations of binary floating-point representation as being a
problem with Python itself).
The new algorithm for ``repr(1.1)`` is smarter and returns ``'1.1'``.
it does not change the underlying values. So, it is still the case that
``1.1 + 2.2 != 3.3`` even though the representations may suggest otherwise.
- The new algorithm depends on certain features in the underlying floating
- point implementation. If the required features are not found, the old
+ The new algorithm depends on certain features in the underlying floating-point
+ implementation. If the required features are not found, the old
algorithm will continue to be used. Also, the text pickle protocols
assure cross-platform portability by using the old algorithm.
This section lists previously described changes and other bugfixes
that may require changes to your code:
-* The new floating point string representations can break existing doctests.
+* The new floating-point string representations can break existing doctests.
For example::
def e():
:issue:`45440` and :issue:`46640`.)
* Support for `IEEE 754 <https://en.wikipedia.org/wiki/IEEE_754>`_
- floating point numbers.
+ floating-point numbers.
(Contributed by Victor Stinner in :issue:`46917`.)
* The :c:macro:`!Py_NO_NAN` macro has been removed.
been relaxed. It is still unsupported (and ill-advised) to have implicit
mixing in arithmetic expressions such as ``Decimal('1.1') + float('1.1')``
because the latter loses information in the process of constructing the binary
-float. However, since existing floating point value can be converted losslessly
+float. However, since existing floating-point value can be converted losslessly
to either a decimal or rational representation, it makes sense to add them to
the constructor and to support mixed-type comparisons.
C-module and libmpdec written by Stefan Krah.
The new C version of the decimal module integrates the high speed libmpdec
-library for arbitrary precision correctly rounded decimal floating point
+library for arbitrary precision correctly rounded decimal floating-point
arithmetic. libmpdec conforms to IBM's General Decimal Arithmetic Specification.
Performance gains range from 10x for database applications to 100x for
numerically intensive applications. These numbers are expected gains
-for standard precisions used in decimal floating point arithmetic. Since
+for standard precisions used in decimal floating-point arithmetic. Since
the precision is user configurable, the exact figures may vary. For example,
in integer bignum arithmetic the differences can be significantly higher.
The :ref:`string formatting <formatspec>` language also now has support
for the ``'_'`` option to signal the use of an underscore for a thousands
-separator for floating point presentation types and for integer
+separator for floating-point presentation types and for integer
presentation type ``'d'``. For integer presentation types ``'b'``,
``'o'``, ``'x'``, and ``'X'``, underscores will be inserted every 4
digits::
------------------------------------------------------
The resolution of clocks in modern systems can exceed the limited precision
-of a floating point number returned by the :func:`time.time` function
+of a floating-point number returned by the :func:`time.time` function
and its variants. To avoid loss of precision, :pep:`564` adds six new
"nanosecond" variants of the existing timer functions to the :mod:`time`
module:
statistics
----------
-Added :func:`statistics.fmean` as a faster, floating point variant of
+Added :func:`statistics.fmean` as a faster, floating-point variant of
:func:`statistics.mean()`. (Contributed by Raymond Hettinger and
Steven D'Aprano in :issue:`35904`.)
/* Float object interface */
/*
-PyFloatObject represents a (double precision) floating point number.
+PyFloatObject represents a (double precision) floating-point number.
*/
#ifndef Py_FLOATOBJECT_H
# numbers.py for more detail.
class Decimal(object):
- """Floating point class for decimal arithmetic."""
+ """Floating-point class for decimal arithmetic."""
__slots__ = ('_exp','_int','_sign', '_is_special')
# Generally, the value of the Decimal instance is given by
__all__ = ["rgb_to_yiq","yiq_to_rgb","rgb_to_hls","hls_to_rgb",
"rgb_to_hsv","hsv_to_rgb"]
-# Some floating point constants
+# Some floating-point constants
ONE_THIRD = 1.0/3.0
ONE_SIXTH = 1.0/6.0
-"""Decimal fixed point and floating point arithmetic.
+"""Decimal fixed-point and floating-point arithmetic.
-This is an implementation of decimal floating point arithmetic based on
+This is an implementation of decimal floating-point arithmetic based on
the General Decimal Arithmetic Specification:
http://speleotrove.com/decimal/decarith.html
Fri, 09 Nov 2001 01:08:47 -0000
- Optional timeval if given is a floating point time value as accepted by
+ Optional timeval if given is a floating-point time value as accepted by
gmtime() and localtime(), otherwise the current time is used.
Optional localtime is a flag that when True, interprets timeval, and
# header. By default, _getdate() returns the current time in the appropriate
# "expires" format for a Set-Cookie header. The one optional argument is an
# offset from now, in seconds. For example, an offset of -3600 means "one hour
-# ago". The offset may be a floating point number.
+# ago". The offset may be a floating-point number.
#
_weekdayname = ['Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat', 'Sun']
method now take arbitrarily many file names as arguments.
All the print methods now take an argument that indicates how many lines
- to print. If the arg is a floating point number between 0 and 1.0, then
+ to print. If the arg is a floating-point number between 0 and 1.0, then
it is taken as a decimal percentage of the available lines to be printed
(e.g., .1 means print 10% of all available lines). If it is an integer,
it is taken to mean the number of lines of data that you wish to have
implement simulated time by writing your own functions. This can
also be used to integrate scheduling with STDWIN events; the delay
function is allowed to modify the queue. Time can be expressed as
-integers or floating point numbers, as long as it is consistent.
+integers or floating-point numbers, as long as it is consistent.
Events are specified by tuples (time, priority, action, argument, kwargs).
As in UNIX, lower priority numbers mean higher priority; in this
Function Description
================== ==================================================
mean Arithmetic mean (average) of data.
-fmean Fast, floating point arithmetic mean.
+fmean Fast, floating-point arithmetic mean.
geometric_mean Geometric mean of data.
harmonic_mean Harmonic mean of data.
median Median (middle value) of data.
self.assertEqual(a, b)
else:
# On alphas treating the byte swapped bit patters as
- # floats/doubles results in floating point exceptions
+ # floats/doubles results in floating-point exceptions
# => compare the 8bit string values instead
self.assertNotEqual(a.tobytes(), b.tobytes())
b.byteswap()
def test_hash(self):
for x in range(-30, 30):
self.assertEqual(hash(x), hash(complex(x, 0)))
- x /= 3.0 # now check against floating point
+ x /= 3.0 # now check against floating-point
self.assertEqual(hash(x), hash(complex(x, 0.)))
self.assertNotEqual(hash(2000005 - 1j), -1)
class EmptyStruct(Structure):
_fields_ = []
- obj = (EmptyStruct * 2)() # bpo37188: Floating point exception
+ obj = (EmptyStruct * 2)() # bpo37188: Floating-point exception
self.assertEqual(sizeof(obj), 0)
def test_empty_element_array(self):
_type_ = c_int
_length_ = 0
- obj = (EmptyArray * 2)() # bpo37188: Floating point exception
+ obj = (EmptyArray * 2)() # bpo37188: Floating-point exception
self.assertEqual(sizeof(obj), 0)
def test_bpo36504_signed_int_overflow(self):
faulthandler._sigfpe()
""",
3,
- 'Floating point exception')
+ 'Floating-point exception')
@unittest.skipIf(_testcapi is None, 'need _testcapi')
@unittest.skipUnless(hasattr(signal, 'SIGBUS'), 'need signal.SIGBUS')
# when 'limit' is specified, it determines how many characters
# must match exactly; lengths must always match.
# ex: limit=5, '12345678' matches '12345___'
- # (mainly for floating point format tests for which an exact match
+ # (mainly for floating-point format tests for which an exact match
# can't be guaranteed due to rounding and representation errors)
elif output and limit is not None and (
len(result)!=len(output) or result[:limit]!=output[:limit]):
return (ns * 1e-9) + 0.5e-9
def test_utime_by_indexed(self):
- # pass times as floating point seconds as the second indexed parameter
+ # pass times as floating-point seconds as the second indexed parameter
def set_time(filename, ns):
atime_ns, mtime_ns = ns
atime = self.ns_to_sec(atime_ns)
def test_order_doesnt_matter(self):
# Test that the order of data points doesn't change the result.
- # CAUTION: due to floating point rounding errors, the result actually
+ # CAUTION: due to floating-point rounding errors, the result actually
# may depend on the order. Consider this test representing an ideal.
# To avoid this test failing, only test with exact values such as ints
# or Fractions.
""")
def test_float(self):
- # Floating point numbers
+ # Floating-point numbers
self.check_tokenize("x = 3.14159", """\
NAME 'x' (1, 0) (1, 1)
OP '=' (1, 2) (1, 3)
awakened or timed out, it re-acquires the lock and returns.
When the timeout argument is present and not None, it should be a
- floating point number specifying a timeout for the operation in seconds
+ floating-point number specifying a timeout for the operation in seconds
(or fractions thereof).
When the underlying lock is an RLock, it is not released using its
the optional timeout occurs.
When the timeout argument is present and not None, it should be a
- floating point number specifying a timeout for the operation in seconds
+ floating-point number specifying a timeout for the operation in seconds
(or fractions thereof).
This method returns the internal flag on exit, so it will always return
or until the optional timeout occurs.
When the timeout argument is present and not None, it should be a
- floating point number specifying a timeout for the operation in seconds
+ floating-point number specifying a timeout for the operation in seconds
(or fractions thereof). As join() always returns None, you must call
is_alive() after join() to decide whether a timeout happened -- if the
thread is still alive, the join() call timed out.
class _QueryFloat(_QueryDialog):
- errormessage = "Not a floating point value."
+ errormessage = "Not a floating-point value."
def getresult(self):
return self.getdouble(self.entry.get())
.. nonce: KKsNOV
.. section: Tests
-Fixed floating point precision issue in turtle tests.
+Fixed floating-point precision issue in turtle tests.
..
.. nonce: ajJjkh
.. section: Build
-Building Python now requires support for floating point Not-a-Number (NaN):
+Building Python now requires support for floating-point Not-a-Number (NaN):
remove the ``Py_NO_NAN`` macro. Patch by Victor Stinner.
..
.. nonce: fry4aK
.. section: Build
-Building Python now requires support of IEEE 754 floating point numbers.
+Building Python now requires support of IEEE 754 floating-point numbers.
Patch by Victor Stinner.
..
.. section: Tests
Fix pystone micro-benchmark: use floor division instead of true division to
-benchmark integers instead of floating point numbers. Set pystone version to
+benchmark integers instead of floating-point numbers. Set pystone version to
1.2. Patch written by Lennart Regebro.
..
.. nonce: 9vMWSP
.. section: Core and Builtins
-Fix an assertion error in :func:`format` in debug build for floating point
+Fix an assertion error in :func:`format` in debug build for floating-point
formatting with "n" format, zero padding and small width. Release build is
not impacted. Patch by Karthikeyan Singaravelan.
.. nonce: V88MCD
.. section: Library
-Added statistics.fmean() as a faster, floating point variant of the existing
+Added statistics.fmean() as a faster, floating-point variant of the existing
mean() function.
..
.. section: Core and Builtins
On FreeBSD, Python no longer calls ``fedisableexcept()`` at startup to
-control the floating point control mode. The call became useless since
+control the floating-point control mode. The call became useless since
FreeBSD 6: it became the default mode.
..
/*
* Test3C struct tests the MAX_STRUCT_SIZE 32. Structs containing arrays of up
- * to four floating point types are passed in registers on Arm platforms.
+ * to four floating-point types are passed in registers on Arm platforms.
* This struct is used for within bounds test on Arm platfroms and for an
* out-of-bounds tests for platfroms where MAX_STRUCT_SIZE is less than 32.
* See gh-110190.
/*
* Test3D struct tests the MAX_STRUCT_SIZE 64. Structs containing arrays of up
- * to eight floating point types are passed in registers on PPC64LE platforms.
+ * to eight floating-point types are passed in registers on PPC64LE platforms.
* This struct is used for within bounds test on PPC64LE platfroms and for an
* out-of-bounds tests for platfroms where MAX_STRUCT_SIZE is less than 64.
* See gh-110190.
[clinic start generated code]*/
/*[clinic end generated code: output=da39a3ee5e6b4b0d input=ed98569b726feada]*/
-/* support functions for formatting floating point numbers */
+/* support functions for formatting floating-point numbers */
/* the grouping is terminated by either 0 or CHAR_MAX */
static PyObject*
#define RANGE_ERROR(state, f, flag) return _range_error(state, f, flag)
-/* Floating point helpers */
+/* Floating-point helpers */
static PyObject *
unpack_halffloat(const char *p, /* start of 2-byte string */
PyDoc_STRVAR(module_doc,
"This module defines an object type which can efficiently represent\n\
-an array of basic values: characters, integers, floating point\n\
+an array of basic values: characters, integers, floating-point\n\
numbers. Arrays are sequence types and behave very much like lists,\n\
except that the type of objects stored in them is constrained.\n");
'L' unsigned integer 4\n\
'q' signed integer 8 (see note)\n\
'Q' unsigned integer 8 (see note)\n\
- 'f' floating point 4\n\
- 'd' floating point 8\n\
+ 'f' floating-point 4\n\
+ 'd' floating-point 8\n\
\n\
NOTE: The 'u' typecode corresponds to Python's unicode character. On\n\
narrow builds this is 2-bytes on wide builds this is 4-bytes.\n\
"fsum($module, seq, /)\n"
"--\n"
"\n"
-"Return an accurate floating point sum of values in the iterable seq.\n"
+"Return an accurate floating-point sum of values in the iterable seq.\n"
"\n"
-"Assumes IEEE-754 floating point arithmetic.");
+"Assumes IEEE-754 floating-point arithmetic.");
#define MATH_FSUM_METHODDEF \
{"fsum", (PyCFunction)math_fsum, METH_O, math_fsum__doc__},
"isclose($module, /, a, b, *, rel_tol=1e-09, abs_tol=0.0)\n"
"--\n"
"\n"
-"Determine whether two floating point numbers are close in value.\n"
+"Determine whether two floating-point numbers are close in value.\n"
"\n"
" rel_tol\n"
" maximum difference for being considered \"close\", relative to the\n"
exit:
return return_value;
}
-/*[clinic end generated code: output=91a0357265a2a553 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=bd6c271030b9698b input=a9049054013a1b77]*/
"\n"
"The object returned behaves like a named tuple with these fields:\n"
" (utime, stime, cutime, cstime, elapsed_time)\n"
-"All fields are floating point numbers.");
+"All fields are floating-point numbers.");
#define OS_TIMES_METHODDEF \
{"times", (PyCFunction)os_times, METH_NOARGS, os_times__doc__},
#ifndef OS_WAITSTATUS_TO_EXITCODE_METHODDEF
#define OS_WAITSTATUS_TO_EXITCODE_METHODDEF
#endif /* !defined(OS_WAITSTATUS_TO_EXITCODE_METHODDEF) */
-/*[clinic end generated code: output=e2cf3ab750346780 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=6f0c08f692891c72 input=a9049054013a1b77]*/
"gotten from a fileno() method call on one of those.\n"
"\n"
"The optional 4th argument specifies a timeout in seconds; it may be\n"
-"a floating point number to specify fractions of seconds. If it is absent\n"
+"a floating-point number to specify fractions of seconds. If it is absent\n"
"or None, the call will never time out.\n"
"\n"
"The return value is a tuple of three lists corresponding to the first three\n"
#ifndef SELECT_KQUEUE_CONTROL_METHODDEF
#define SELECT_KQUEUE_CONTROL_METHODDEF
#endif /* !defined(SELECT_KQUEUE_CONTROL_METHODDEF) */
-/*[clinic end generated code: output=64516114287e894d input=a9049054013a1b77]*/
+/*[clinic end generated code: output=4d031b2402ee40e7 input=a9049054013a1b77]*/
"\n"
"Like sigwaitinfo(), but with a timeout.\n"
"\n"
-"The timeout is specified in seconds, with floating point numbers allowed.");
+"The timeout is specified in seconds, with floating-point numbers allowed.");
#define SIGNAL_SIGTIMEDWAIT_METHODDEF \
{"sigtimedwait", _PyCFunction_CAST(signal_sigtimedwait), METH_FASTCALL, signal_sigtimedwait__doc__},
#ifndef SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
#define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
#endif /* !defined(SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF) */
-/*[clinic end generated code: output=2b54dc607f6e3146 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=29cc8fb029d04c97 input=a9049054013a1b77]*/
#ifdef SIGILL
{SIGILL, 0, "Illegal instruction", },
#endif
- {SIGFPE, 0, "Floating point exception", },
+ {SIGFPE, 0, "Floating-point exception", },
{SIGABRT, 0, "Aborted", },
/* define SIGSEGV at the end to make it the default choice if searching the
handler fails in faulthandler_fatal_error() */
static DoubleLength
dl_fast_sum(double a, double b)
{
- /* Algorithm 1.1. Compensated summation of two floating point numbers. */
+ /* Algorithm 1.1. Compensated summation of two floating-point numbers. */
assert(fabs(a) >= fabs(b));
double x = a + b;
double y = (a - x) + b;
seq: object
/
-Return an accurate floating point sum of values in the iterable seq.
+Return an accurate floating-point sum of values in the iterable seq.
-Assumes IEEE-754 floating point arithmetic.
+Assumes IEEE-754 floating-point arithmetic.
[clinic start generated code]*/
static PyObject *
math_fsum(PyObject *module, PyObject *seq)
-/*[clinic end generated code: output=ba5c672b87fe34fc input=c51b7d8caf6f6e82]*/
+/*[clinic end generated code: output=ba5c672b87fe34fc input=4506244ded6057dc]*/
{
PyObject *item, *iter, *sum = NULL;
Py_ssize_t i, j, n = 0, m = NUM_PARTIALS;
To minimize loss of information during the accumulation of fractional
values, each term has a separate accumulator. This also breaks up
sequential dependencies in the inner loop so the CPU can maximize
-floating point throughput. [4] On an Apple M1 Max, hypot(*vec)
+floating-point throughput. [4] On an Apple M1 Max, hypot(*vec)
takes only 3.33 µsec when len(vec) == 1000.
The square root differential correction is needed because a
maximum difference for being considered "close", regardless of the
magnitude of the input values
-Determine whether two floating point numbers are close in value.
+Determine whether two floating-point numbers are close in value.
Return True if a is close in value to b, and False otherwise.
static int
math_isclose_impl(PyObject *module, double a, double b, double rel_tol,
double abs_tol)
-/*[clinic end generated code: output=b73070207511952d input=f28671871ea5bfba]*/
+/*[clinic end generated code: output=b73070207511952d input=12d41764468bfdb8]*/
{
double diff = 0.0;
The object returned behaves like a named tuple with these fields:
(utime, stime, cutime, cstime, elapsed_time)
-All fields are floating point numbers.
+All fields are floating-point numbers.
[clinic start generated code]*/
static PyObject *
os_times_impl(PyObject *module)
-/*[clinic end generated code: output=35f640503557d32a input=2bf9df3d6ab2e48b]*/
+/*[clinic end generated code: output=35f640503557d32a input=8dbfe33a2dcc3df3]*/
#ifdef MS_WINDOWS
{
FILETIME create, exit, kernel, user;
gotten from a fileno() method call on one of those.
The optional 4th argument specifies a timeout in seconds; it may be
-a floating point number to specify fractions of seconds. If it is absent
+a floating-point number to specify fractions of seconds. If it is absent
or None, the call will never time out.
The return value is a tuple of three lists corresponding to the first three
static PyObject *
select_select_impl(PyObject *module, PyObject *rlist, PyObject *wlist,
PyObject *xlist, PyObject *timeout_obj)
-/*[clinic end generated code: output=2b3cfa824f7ae4cf input=e467f5d68033de00]*/
+/*[clinic end generated code: output=2b3cfa824f7ae4cf input=1199d5e101abca4a]*/
{
#ifdef SELECT_USES_HEAP
pylist *rfd2obj, *wfd2obj, *efd2obj;
res = "Aborted";
break;
case SIGFPE:
- res = "Floating point exception";
+ res = "Floating-point exception";
break;
case SIGSEGV:
res = "Segmentation fault";
Like sigwaitinfo(), but with a timeout.
-The timeout is specified in seconds, with floating point numbers allowed.
+The timeout is specified in seconds, with floating-point numbers allowed.
[clinic start generated code]*/
static PyObject *
signal_sigtimedwait_impl(PyObject *module, sigset_t sigset,
PyObject *timeout_obj)
-/*[clinic end generated code: output=59c8971e8ae18a64 input=87fd39237cf0b7ba]*/
+/*[clinic end generated code: output=59c8971e8ae18a64 input=955773219c1596cd]*/
{
_PyTime_t timeout;
if (_PyTime_FromSecondsObject(&timeout,
PyDoc_STRVAR(time_doc,
-"time() -> floating point number\n\
+"time() -> floating-point number\n\
\n\
Return the current time in seconds since the Epoch.\n\
Fractions of a second may be present if the system clock provides them.");
}
PyDoc_STRVAR(clock_getres_doc,
-"clock_getres(clk_id) -> floating point number\n\
+"clock_getres(clk_id) -> floating-point number\n\
\n\
Return the resolution (precision) of the specified clock clk_id.");
"sleep(seconds)\n\
\n\
Delay execution for a given number of seconds. The argument may be\n\
-a floating point number for subsecond precision.");
+a floating-point number for subsecond precision.");
static PyStructSequence_Field struct_time_type_fields[] = {
{"tm_year", "year, for example, 1993"},
}
PyDoc_STRVAR(mktime_doc,
-"mktime(tuple) -> floating point number\n\
+"mktime(tuple) -> floating-point number\n\
\n\
Convert a time tuple in local time to seconds since the Epoch.\n\
Note that mktime(gmtime(0)) will not generally return zero for most\n\
\n\
There are two standard representations of time. One is the number\n\
of seconds since the Epoch, in UTC (a.k.a. GMT). It may be an integer\n\
-or a floating point number (to represent fractions of seconds).\n\
+or a floating-point number (to represent fractions of seconds).\n\
The epoch is the point where the time starts, the return value of time.gmtime(0).\n\
It is January 1, 1970, 00:00:00 (UTC) on all platforms.\n\
\n\
"float(x=0, /)\n"
"--\n"
"\n"
-"Convert a string or number to a floating point number, if possible.");
+"Convert a string or number to a floating-point number, if possible.");
static PyObject *
float_new_impl(PyTypeObject *type, PyObject *x);
"It exists mainly to be used in Python\'s test suite.\n"
"\n"
"This function returns whichever of \'unknown\', \'IEEE, big-endian\' or \'IEEE,\n"
-"little-endian\' best describes the format of floating point numbers used by the\n"
+"little-endian\' best describes the format of floating-point numbers used by the\n"
"C type named by typestr.");
#define FLOAT___GETFORMAT___METHODDEF \
exit:
return return_value;
}
-/*[clinic end generated code: output=ea329577074911b9 input=a9049054013a1b77]*/
+/*[clinic end generated code: output=e6e3f5f833b37eba input=a9049054013a1b77]*/
* FloatingPointError extends ArithmeticError
*/
SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
- "Floating point operation failed.");
+ "Floating-point operation failed.");
/*
x: object(c_default="NULL") = 0
/
-Convert a string or number to a floating point number, if possible.
+Convert a string or number to a floating-point number, if possible.
[clinic start generated code]*/
static PyObject *
float_new_impl(PyTypeObject *type, PyObject *x)
-/*[clinic end generated code: output=ccf1e8dc460ba6ba input=f43661b7de03e9d8]*/
+/*[clinic end generated code: output=ccf1e8dc460ba6ba input=55909f888aa0c8a6]*/
{
if (type != &PyFloat_Type) {
if (x == NULL) {
It exists mainly to be used in Python's test suite.
This function returns whichever of 'unknown', 'IEEE, big-endian' or 'IEEE,
-little-endian' best describes the format of floating point numbers used by the
+little-endian' best describes the format of floating-point numbers used by the
C type named by typestr.
[clinic start generated code]*/
static PyObject *
float___getformat___impl(PyTypeObject *type, const char *typestr)
-/*[clinic end generated code: output=2bfb987228cc9628 input=d5a52600f835ad67]*/
+/*[clinic end generated code: output=2bfb987228cc9628 input=90d5e246409a246e]*/
{
float_format_type r;
float_format_type detected_double_format, detected_float_format;
/* We attempt to determine if this machine is using IEEE
- floating point formats by peering at the bits of some
+ floating-point formats by peering at the bits of some
carefully chosen values. If it looks like we are on an
IEEE platform, the float packing/unpacking routines can
just copy bits, if not they resort to arithmetic & shifts
int(x, base=10) -> integer\n\
\n\
Convert a number or string to an integer, or return 0 if no arguments\n\
-are given. If x is a number, return x.__int__(). For floating point\n\
+are given. If x is a number, return x.__int__(). For floating-point\n\
numbers, this truncates towards zero.\n\
\n\
If x is not a number or if base is given, then x must be a string,\n\
Not all Python object types are supported; in general, only objects\n\
whose value is independent from a particular invocation of Python can be\n\
written and read by this module. The following types are supported:\n\
-None, integers, floating point numbers, strings, bytes, bytearrays,\n\
+None, integers, floating-point numbers, strings, bytes, bytearrays,\n\
tuples, lists, sets, dictionaries, and code objects, where it\n\
should be understood that tuples, lists and dictionaries are only\n\
supported as long as the values contained therein are themselves\n\
\n\
version -- indicates the format that the module uses. Version 0 is the\n\
historical format, version 1 shares interned strings and version 2\n\
- uses a binary format for floating point numbers.\n\
+ uses a binary format for floating-point numbers.\n\
Version 3 shares common object references (New in version 3.4).\n\
\n\
Functions:\n\
projects / thirdparty / Python / cpython.git / commitdiff
