Stowage/cpython
2
0
Fork 0
mirror of https://github.com/python/cpython.git synced 2025-10-31 13:41:24 +00:00
Code Issues Projects Releases Packages Wiki Activity

[3.13] gh-121905: Consistently use "floating-point" instead of "floating point" (GH-121907) (GH-122012)

Browse source 
(cherry picked from commit 1a0c7b9ba4)
This commit is contained in:
Serhiy Storchaka 2024-07-19 12:13:08 +03:00 • committed by GitHub
parent 225cbee8d8
commit a45d9051ed
No known key found for this signature in database
GPG key ID: B5690EEEBB952194
100 changed files with 238 additions and 238 deletions
Download patch file Download diff file Expand all files Collapse all files

8
Doc/c-api/arg.rst
View file

@ -280,10 +280,10 @@ Numbers
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.
@ -642,10 +642,10 @@ Building values
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.

10
Doc/c-api/float.rst
View file

@ -2,20 +2,20 @@
.. _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.
@ -45,7 +45,7 @@ Floating Point Objects
.. 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

2
Doc/c-api/marshal.rst
View file

@ -15,7 +15,7 @@ Numeric values are stored with the least significant byte first.
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).

8
Doc/c-api/number.rst
View file

@ -51,8 +51,8 @@ Number Protocol
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``.
@ -177,8 +177,8 @@ Number Protocol
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``.

4
Doc/faq/design.rst
View file

@ -70,7 +70,7 @@ operations. This means that as far as floating-point operations are concerned,
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
@ -87,7 +87,7 @@ which is exactly::
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.

4
Doc/faq/library.rst
View file

@ -796,12 +796,12 @@ is simple::
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:

2
Doc/faq/programming.rst
View file

@ -869,7 +869,7 @@ How do I convert a string to a number?
--------------------------------------
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') ==

4
Doc/library/array.rst
View file

@ -9,7 +9,7 @@
--------------
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
@ -263,7 +263,7 @@ The string representation is guaranteed to be able to be converted back to an
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')

2
Doc/library/colorsys.rst
View file

@ -14,7 +14,7 @@ The :mod:`colorsys` module defines bidirectional conversions of color values
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.

2
Doc/library/configparser.rst
View file

@ -1183,7 +1183,7 @@ ConfigParser Objects
.. 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*.

22
Doc/library/decimal.rst
View file

@ -1,4 +1,4 @@
:mod:`!decimal` --- Decimal fixed point and floating point arithmetic
:mod:`!decimal` --- Decimal fixed-point and floating-point arithmetic
=====================================================================
.. module:: decimal
@ -31,7 +31,7 @@
--------------
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
@ -207,7 +207,7 @@ a decimal raises :class:`InvalidOperation`::
.. 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
@ -373,7 +373,7 @@ Decimal objects
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
@ -403,7 +403,7 @@ Decimal objects
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,
@ -445,7 +445,7 @@ Decimal objects
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:
@ -1741,7 +1741,7 @@ The following table summarizes the hierarchy of signals::
.. _decimal-notes:
Floating Point Notes
Floating-Point Notes
--------------------
@ -1754,7 +1754,7 @@ can still incur round-off error when non-zero digits exceed the fixed precision.
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:
@ -1844,7 +1844,7 @@ treated as equal and their sign is informational.
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')
@ -2171,7 +2171,7 @@ value unchanged:
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:
@ -2225,7 +2225,7 @@ Q. Is the CPython implementation fast for large numbers?
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

2
Doc/library/email.utils.rst
View file

@ -159,7 +159,7 @@ of the new API.
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.

4
Doc/library/exceptions.rst
View file

@ -412,8 +412,8 @@ The following exceptions are the exceptions that are usually raised.
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:: PythonFinalizationError

2
Doc/library/fractions.rst
View file

@ -31,7 +31,7 @@ another rational number, or from a string.
: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.)

14
Doc/library/functions.rst
View file

@ -57,7 +57,7 @@ are always available. They are listed here in alphabetical order.
.. 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.
@ -538,7 +538,7 @@ are always available. They are listed here in alphabetical order.
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
@ -734,7 +734,7 @@ are always available. They are listed here in alphabetical order.
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:
@ -775,8 +775,8 @@ are always available. They are listed here in alphabetical order.
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.
@ -1003,7 +1003,7 @@ are always available. They are listed here in alphabetical order.
``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
@ -1921,7 +1921,7 @@ are always available. They are listed here in alphabetical order.
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`.

2
Doc/library/itertools.rst
View file

@ -337,7 +337,7 @@ loops that truncate the stream.
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())``.

4
Doc/library/locale.rst
View file

@ -424,7 +424,7 @@ The :mod:`locale` module defines the following exception and functions:
.. 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.
@ -455,7 +455,7 @@ The :mod:`locale` module defines the following exception and functions:
.. 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.

6
Doc/library/marshal.rst
View file

@ -42,8 +42,8 @@ supports a substantially wider range of objects than marshal.
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 (if *allow_code* is true),
where it should be understood that
tuples, lists, sets, frozensets and dictionaries are only supported as long as
@ -142,7 +142,7 @@ In addition, the following constants are defined:
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.

6
Doc/library/math.rst
View file

@ -123,7 +123,7 @@ Number-theoretic and representation functions
.. 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
@ -133,7 +133,7 @@ Number-theoretic and representation functions
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/>`_\.
@ -304,7 +304,7 @@ Number-theoretic and representation functions
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

4
Doc/library/os.path.rst
View file

@ -201,14 +201,14 @@ the :mod:`glob` module.)
.. 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.

2
Doc/library/profile.rst
View file

@ -682,7 +682,7 @@ you are using :class:`profile.Profile` or :class:`cProfile.Profile`,
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.

12
Doc/library/random.rst
View file

@ -200,8 +200,8 @@ Functions for sequences
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.
@ -298,12 +298,12 @@ be found in any statistics text.
.. 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
@ -313,7 +313,7 @@ be found in any statistics text.
.. 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.
@ -741,7 +741,7 @@ The following options are accepted:
.. option:: -f <N>
--float <N>
Print a random floating point number between 1 and N inclusive,
Print a random floating-point number between 1 and N inclusive,
using :meth:`uniform`.
If no options are given, the output depends on the input:

2
Doc/library/resource.rst
View file

@ -305,7 +305,7 @@ These functions are used to retrieve resource usage information:
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:

2
Doc/library/select.rst
View file

@ -129,7 +129,7 @@ The module defines the following:
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.

2
Doc/library/socket.rst
View file

@ -1922,7 +1922,7 @@ to sockets.
.. 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

2
Doc/library/statistics.rst
View file

@ -73,7 +73,7 @@ or sample.
======================= ===============================================================
: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:`kde` Estimate the probability density distribution of the data.

46
Doc/library/stdtypes.rst
View file

@ -209,18 +209,18 @@ Numeric Types --- :class:`int`, :class:`float`, :class:`complex`
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
@ -229,7 +229,7 @@ user-definable precision.)
.. 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
@ -238,7 +238,7 @@ user-definable precision.)
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.
@ -1497,8 +1497,8 @@ objects that compare equal might have different :attr:`~range.start`,
.. 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
@ -2442,19 +2442,19 @@ The conversion types are:
+------------+-----------------------------------------------------+-------+
| ``'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. | |
+------------+-----------------------------------------------------+-------+
@ -3661,19 +3661,19 @@ The conversion types are:
+------------+-----------------------------------------------------+-------+
| ``'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. | |
+------------+-----------------------------------------------------+-------+
@ -3895,7 +3895,7 @@ copying.
>>> 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

6
Doc/library/string.rst
View file

@ -418,7 +418,7 @@ instead.
.. 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
@ -491,9 +491,9 @@ The available integer presentation types are:
+---------+----------------------------------------------------------+
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:

6
Doc/library/threading.rst
View file

@ -412,7 +412,7 @@ since it is impossible to detect the termination of alien threads.
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
@ -794,7 +794,7 @@ item to the buffer only needs to wake up one consumer thread.
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
@ -1021,7 +1021,7 @@ method. The :meth:`~Event.wait` method blocks until the flag is true.
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

10
Doc/library/time.rst
View file

@ -69,7 +69,7 @@ An explanation of some terminology and conventions is in order.
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
@ -273,7 +273,7 @@ Functions
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).
@ -376,7 +376,7 @@ Functions
.. 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
@ -665,13 +665,13 @@ Functions
.. 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

14
Doc/reference/datamodel.rst
View file

@ -215,7 +215,7 @@ properties:
* 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:
@ -259,18 +259,18 @@ Booleans (:class:`bool`)
^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
.. 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`)
@ -281,7 +281,7 @@ language with two kinds of floating point numbers.
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``.

12
Doc/reference/expressions.rst
View file

@ -33,7 +33,7 @@ implementation for built-in types works as follows:
* 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.
@ -139,8 +139,8 @@ Python supports string and bytes literals and various numeric literals:
: | `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::
@ -1361,7 +1361,7 @@ The floor division operation can be customized using the special
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
@ -1381,8 +1381,8 @@ The *modulo* operation can be customized using the special :meth:`~object.__mod_
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

16
Doc/reference/lexical_analysis.rst
View file

@ -879,10 +879,10 @@ Numeric literals
----------------
.. 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).
@ -943,10 +943,10 @@ Some examples of integer literals::
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`
@ -958,10 +958,10 @@ Floating point literals are described by the following lexical definitions:
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
@ -982,9 +982,9 @@ Imaginary literals are described by the following lexical definitions:
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

8
Doc/tutorial/floatingpoint.rst
View file

@ -6,7 +6,7 @@
.. _tut-fp-issues:
**************************************************
Floating Point Arithmetic: Issues and Limitations
Floating-Point Arithmetic: Issues and Limitations
**************************************************
.. sectionauthor:: Tim Peters <tim_one@users.sourceforge.net>
@ -88,7 +88,7 @@ the one with 17 significant digits, ``0.10000000000000001``. Starting with
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
@ -148,13 +148,13 @@ Binary floating-point arithmetic holds many surprises like this. The problem
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

4
Doc/tutorial/introduction.rst
View file

@ -62,7 +62,7 @@ For example::
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`,
@ -544,7 +544,7 @@ This example introduces several new features.
* 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::

2
Doc/tutorial/stdlib.rst
View file

@ -138,7 +138,7 @@ Mathematics
===========
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)

4
Doc/tutorial/stdlib2.rst
View file

@ -352,11 +352,11 @@ not want to run a full list sort::
.. _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

4
Doc/using/configure.rst
View file

@ -16,8 +16,8 @@ Features and minimum versions required to build CPython:
* On Windows, Microsoft Visual Studio 2017 or later is 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.

4
Doc/whatsnew/2.1.rst
View file

@ -644,9 +644,9 @@ New and Improved Modules
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

2
Doc/whatsnew/2.2.rst
View file

@ -1249,7 +1249,7 @@ Some of the more notable changes are:
* 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.

2
Doc/whatsnew/2.3.rst
View file

@ -1382,7 +1382,7 @@ complete list of changes, or look through the CVS logs for all the details.
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.

2
Doc/whatsnew/2.6.rst
View file

@ -3051,7 +3051,7 @@ Changes to Python's build process and to the C API include:
* 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

2
Doc/whatsnew/2.7.rst
View file

@ -1198,7 +1198,7 @@ changes, or look through the Subversion logs for all the details.
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`.)

16
Doc/whatsnew/3.1.rst
View file

@ -205,9 +205,9 @@ Some smaller changes made to the core Python language are:
(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
@ -215,7 +215,7 @@ Some smaller changes made to the core Python language are:
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
@ -224,7 +224,7 @@ Some smaller changes made to the core Python language are:
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'``.
@ -236,8 +236,8 @@ Some smaller changes made to the core Python language are:
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.
@ -550,7 +550,7 @@ Porting to Python 3.1
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():

2
Doc/whatsnew/3.11.rst
View file

@ -2138,7 +2138,7 @@ Build Changes
: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.

2
Doc/whatsnew/3.2.rst
View file

@ -1312,7 +1312,7 @@ An early decision to limit the interoperability of various numeric types has
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.

4
Doc/whatsnew/3.3.rst
View file

@ -1097,12 +1097,12 @@ decimal
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.

2
Doc/whatsnew/3.6.rst
View file

@ -261,7 +261,7 @@ allowed.
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::

2
Doc/whatsnew/3.7.rst
View file

@ -339,7 +339,7 @@ PEP 564: New Time Functions With Nanosecond Resolution
------------------------------------------------------
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:

2
Doc/whatsnew/3.8.rst
View file

@ -1192,7 +1192,7 @@ post-handshake authentication.
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`.)

2
Include/floatobject.h
View file

@ -2,7 +2,7 @@
/* Float object interface */
/*
PyFloatObject represents a (double precision) floating point number.
PyFloatObject represents a (double precision) floating-point number.
*/
#ifndef Py_FLOATOBJECT_H

2
Include/internal/pycore_time.h
View file

@ -6,7 +6,7 @@
// Time formats:
//
// * Seconds.
// * Seconds as a floating point number (C double).
// * Seconds as a floating-point number (C double).
// * Milliseconds (10^-3 seconds).
// * Microseconds (10^-6 seconds).
// * 100 nanoseconds (10^-7 seconds), used on Windows.

2
Lib/_pydecimal.py
View file

@ -424,7 +424,7 @@ def sin(x):
# 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

2
Lib/colorsys.py
View file

@ -24,7 +24,7 @@
__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

2
Lib/csv.py
View file

@ -47,7 +47,7 @@ class excel:
field contains either the quotechar or the delimiter
csv.QUOTE_ALL means that quotes are always placed around fields.
csv.QUOTE_NONNUMERIC means that quotes are always placed around
fields which do not parse as integers or floating point
fields which do not parse as integers or floating-point
numbers.
csv.QUOTE_STRINGS means that quotes are always placed around
fields which are strings. Note that the Python value None

4
Lib/decimal.py
View file

@ -1,6 +1,6 @@
"""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

2
Lib/email/utils.py
View file

@ -241,7 +241,7 @@ def formatdate(timeval=None, localtime=False, usegmt=False):
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

2
Lib/http/cookies.py
View file

@ -234,7 +234,7 @@ def _unquote(str):
# 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']

2
Lib/pstats.py
View file

@ -83,7 +83,7 @@ class Stats:
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

2
Lib/random.py
View file

@ -1013,7 +1013,7 @@ def _parse_args(arg_list: list[str] | None):
help="print a random integer between 1 and N inclusive")
group.add_argument(
"-f", "--float", type=float, metavar="N",
help="print a random floating point number between 1 and N inclusive")
help="print a random floating-point number between 1 and N inclusive")
group.add_argument(
"--test", type=int, const=10_000, nargs="?",
help=argparse.SUPPRESS)

2
Lib/sched.py
View file

@ -11,7 +11,7 @@
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

2
Lib/statistics.py
View file

@ -11,7 +11,7 @@
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.

2
Lib/test/test_array.py
View file

@ -1493,7 +1493,7 @@ def test_byteswap(self):
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()

2
Lib/test/test_complex.py
View file

@ -588,7 +588,7 @@ def test_underscores(self):
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)

4
Lib/test/test_ctypes/test_arrays.py
View file

@ -253,7 +253,7 @@ def test_empty_element_struct(self):
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):
@ -261,7 +261,7 @@ class EmptyArray(Array):
_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):

2
Lib/test/test_faulthandler.py
View file

@ -236,7 +236,7 @@ def test_sigfpe(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')

2
Lib/test/test_format.py
View file

@ -36,7 +36,7 @@ def testformat(formatstr, args, output=None, limit=None, overflowok=False):
# 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]):

2
Lib/test/test_os.py
View file

@ -828,7 +828,7 @@ def ns_to_sec(ns):
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)

2
Lib/test/test_statistics.py
View file

@ -1072,7 +1072,7 @@ def test_no_inplace_modifications(self):
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.

2
Lib/test/test_tokenize.py
View file

@ -228,7 +228,7 @@ def test_long(self):
""")
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)

6
Lib/threading.py
View file

@ -336,7 +336,7 @@ def wait(self, timeout=None):
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
@ -646,7 +646,7 @@ def wait(self, timeout=None):
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
@ -1059,7 +1059,7 @@ def join(self, timeout=None):
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.

2
Lib/tkinter/simpledialog.py
View file

@ -357,7 +357,7 @@ def askinteger(title, prompt, **kw):
class _QueryFloat(_QueryDialog):
errormessage = "Not a floating point value."
errormessage = "Not a floating-point value."
def getresult(self):
return self.getdouble(self.entry.get())

2
Misc/NEWS.d/3.11.0a1.rst
View file

@ -4238,7 +4238,7 @@ harmless "malloc can't allocate region" messages spewed by test_decimal.
.. nonce: KKsNOV
.. section: Tests
Fixed floating point precision issue in turtle tests.
Fixed floating-point precision issue in turtle tests.
..

2
Misc/NEWS.d/3.11.0a6.rst
View file

@ -1054,7 +1054,7 @@ Patch by Victor Stinner.
.. 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.
..

2
Misc/NEWS.d/3.11.0a7.rst
View file

@ -1401,7 +1401,7 @@ Christian's container image ``quay.io/tiran/cpython_autoconf:269``.
.. 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.
..

2
Misc/NEWS.d/3.13.0b1.rst
View file

@ -1315,7 +1315,7 @@ Hamdan.
.. section: Library
Adjust ``logging.LogRecord`` to use ``time.time_ns()`` and fix minor bug
related to floating point math.
related to floating-point math.
..

2
Misc/NEWS.d/3.5.0a1.rst
View file

@ -5468,7 +5468,7 @@ All resources are now allowed when tests are not run by regrtest.py.
.. 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.
..

2
Misc/NEWS.d/3.8.0a1.rst
View file

@ -224,7 +224,7 @@ positives from posix, socket, time, test_io, and test_faulthandler.
.. 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.

2
Misc/NEWS.d/3.8.0a2.rst
View file

@ -202,7 +202,7 @@ the mean and standard deviation of measurement data as single entity.
.. 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.
..

2
Misc/NEWS.d/3.9.0a1.rst
View file

@ -299,7 +299,7 @@ Check the error from the system's underlying ``crypt`` or ``crypt_r``.
.. 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.
..

4
Modules/_ctypes/_ctypes_test.c
View file

@ -178,7 +178,7 @@ _testfunc_array_in_struct3B_set_defaults(void)
/*
* 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.
@ -202,7 +202,7 @@ _testfunc_array_in_struct3C_set_defaults(void)
/*
* 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.

2
Modules/_localemodule.c
View file

@ -52,7 +52,7 @@ module _locale
[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*

2
Modules/_struct.c
View file

@ -281,7 +281,7 @@ get_size_t(_structmodulestate *state, PyObject *v, size_t *p)
#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 */

6
Modules/arraymodule.c
View file

@ -2847,7 +2847,7 @@ array_new(PyTypeObject *type, PyObject *args, PyObject *kwds)
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");
@ -2875,8 +2875,8 @@ The following type codes are defined:\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\

8
Modules/clinic/mathmodule.c.h generated
View file

@ -34,9 +34,9 @@ PyDoc_STRVAR(math_fsum__doc__,
"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__},
@ -610,7 +610,7 @@ PyDoc_STRVAR(math_isclose__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"
@ -1011,4 +1011,4 @@ math_ulp(PyObject *module, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=7d03f84f77342496 input=a9049054013a1b77]*/
/*[clinic end generated code: output=755da3b1dbd9e45f input=a9049054013a1b77]*/

4
Modules/clinic/posixmodule.c.h generated
View file

@ -6348,7 +6348,7 @@ PyDoc_STRVAR(os_times__doc__,
"\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__},
@ -12819,4 +12819,4 @@ os__is_inputhook_installed(PyObject *module, PyObject *Py_UNUSED(ignored))
#ifndef OS__SUPPORTS_VIRTUAL_TERMINAL_METHODDEF
#define OS__SUPPORTS_VIRTUAL_TERMINAL_METHODDEF
#endif /* !defined(OS__SUPPORTS_VIRTUAL_TERMINAL_METHODDEF) */
/*[clinic end generated code: output=cebab1ef718b4878 input=a9049054013a1b77]*/
/*[clinic end generated code: output=6a1d88bd90c7a28b input=a9049054013a1b77]*/

4
Modules/clinic/selectmodule.c.h generated
View file

@ -26,7 +26,7 @@ PyDoc_STRVAR(select_select__doc__,
"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"
@ -1360,4 +1360,4 @@ exit:
#ifndef SELECT_KQUEUE_CONTROL_METHODDEF
#define SELECT_KQUEUE_CONTROL_METHODDEF
#endif /* !defined(SELECT_KQUEUE_CONTROL_METHODDEF) */
/*[clinic end generated code: output=f31e724f492225b1 input=a9049054013a1b77]*/
/*[clinic end generated code: output=f99427b75cbe6d44 input=a9049054013a1b77]*/

4
Modules/clinic/signalmodule.c.h generated
View file

@ -597,7 +597,7 @@ PyDoc_STRVAR(signal_sigtimedwait__doc__,
"\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__},
@ -776,4 +776,4 @@ exit:
#ifndef SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
#define SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF
#endif /* !defined(SIGNAL_PIDFD_SEND_SIGNAL_METHODDEF) */
/*[clinic end generated code: output=1c11c1b6f12f26be input=a9049054013a1b77]*/
/*[clinic end generated code: output=6d8e17a32cef668f input=a9049054013a1b77]*/

2
Modules/faulthandler.c
View file

@ -75,7 +75,7 @@ static fault_handler_t faulthandler_handlers[] = {
#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() */

14
Modules/mathmodule.c
View file

@ -107,7 +107,7 @@ typedef struct{ double hi; double lo; } DoubleLength;
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;
@ -1354,14 +1354,14 @@ math.fsum
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;
@ -2453,7 +2453,7 @@ Since lo**2 is less than 1/2 ulp(csum), we have csum+lo*lo == csum.
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
@ -3136,7 +3136,7 @@ math.isclose -> bool
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.
@ -3151,7 +3151,7 @@ only close to themselves.
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;

4
Modules/posixmodule.c
View file

@ -10585,12 +10585,12 @@ Return a collection containing process timing information.
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;

4
Modules/selectmodule.c
View file

@ -262,7 +262,7 @@ A file descriptor is either a socket or file object, or a small integer
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
@ -277,7 +277,7 @@ descriptors can be used.
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;

6
Modules/signalmodule.c
View file

@ -638,7 +638,7 @@ signal_strsignal_impl(PyObject *module, int signalnum)
res = "Aborted";
break;
case SIGFPE:
res = "Floating point exception";
res = "Floating-point exception";
break;
case SIGSEGV:
res = "Segmentation fault";
@ -1199,13 +1199,13 @@ signal.sigtimedwait
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,

10
Modules/timemodule.c
View file

@ -116,7 +116,7 @@ time_time(PyObject *self, PyObject *unused)
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.");
@ -350,7 +350,7 @@ time_clock_getres(PyObject *self, PyObject *args)
}
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.");
@ -413,7 +413,7 @@ PyDoc_STRVAR(sleep_doc,
"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"},
@ -1104,7 +1104,7 @@ time_mktime(PyObject *module, PyObject *tm_tuple)
}
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\
@ -1902,7 +1902,7 @@ PyDoc_STRVAR(module_doc,
\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\

6
Objects/clinic/floatobject.c.h generated
View file

@ -197,7 +197,7 @@ PyDoc_STRVAR(float_new__doc__,
"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);
@ -256,7 +256,7 @@ PyDoc_STRVAR(float___getformat____doc__,
"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 \
@ -318,4 +318,4 @@ float___format__(PyObject *self, PyObject *arg)
exit:
return return_value;
}
/*[clinic end generated code: output=c79743c8551c30d9 input=a9049054013a1b77]*/
/*[clinic end generated code: output=d8bbcd83977d516f input=a9049054013a1b77]*/

2
Objects/exceptions.c
View file

@ -3252,7 +3252,7 @@ SimpleExtendsException(PyExc_Exception, ArithmeticError,
* FloatingPointError extends ArithmeticError
*/
SimpleExtendsException(PyExc_ArithmeticError, FloatingPointError,
"Floating point operation failed.");
"Floating-point operation failed.");
/*

10
Objects/floatobject.c
View file

@ -1633,12 +1633,12 @@ float.__new__ as float_new
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) {
@ -1734,13 +1734,13 @@ You probably don't want to use this function.
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;
@ -1926,7 +1926,7 @@ _init_global_state(void)
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

2
Objects/longobject.c
View file

@ -6534,7 +6534,7 @@ PyDoc_STRVAR(long_doc,
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\

2
Parser/lexer/lexer.c
View file

@ -884,7 +884,7 @@ tok_get_normal_mode(struct tok_state *tok, tokenizer_mode* current_tok, struct t
return MAKE_TOKEN(ERRORTOKEN);
}
{
/* Accept floating point numbers. */
/* Accept floating-point numbers. */
if (c == '.') {
c = tok_nextc(tok);
fraction:

4
Python/marshal.c
View file

@ -1927,7 +1927,7 @@ machine architecture issues.\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\
@ -1938,7 +1938,7 @@ Variables:\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\