+ specify more properties for * and /

python · skirpichev · Dec 5, 2023 · Oct 29, 2025 · Oct 31, 2025 · Oct 31, 2025
commit 73534705b4e5e9d2d5efa677c2667e86695a328d
@@ -279,7 +279,6 @@ complex values for :class:`ast.Constant` node type, e.g.
 Complex Arithmetic
 ------------------
 
-
 The tables below define unary operations, additive operators (binary ``+`` and
 ``-``) and multiplicative operators (``*`` and ``/``) for all possible
 combinations of types (integer operand values will be implicitly converted to
@@ -353,29 +352,43 @@ result has imaginary type.  If both operands have imaginary type, then the
 result has real type.  If either operand has complex type, then the result has
 complex type.
 
-This specification does not indicate how exactly the results are to be evaluated
-[7]_ for complex multiplication (when *both* operands are complex numbers) and
-for division when the right operand is a complex number.  Though, if
-the implementation of floating-point arithmetic supports the IEC 60559
-floating-point standard, results of all mixed-mode operations, except for
-division, are specified above unambiguously and it's also expected that
-multiplication always must be commutative [8]_, and that division compute result
-without undue overflow or underflow.
+Results of all mixed-mode operations, except for division when the right
+operand is a complex number, are unambigously defined by floating-point
+arithmetic.  This specification does not indicate how exactly the results are
+to be evaluated [7]_ for complex multiplication (when *both* operands are
+complex numbers) and for division (when the *right* operand is a complex
+number).  Though, the following holds.
+
+For complex multiplication [8]_:
 
-The ``*`` and ``/`` operators satisfy the following infinity properties for
-all real, imaginary, and complex operands:
+-
+  .. code::
+
+     (z * w).conjugate() == z.conjugate() * w.conjugate()
+     z * w = w * z
+     (-z) * w = -(z * w)
 
 - if one operand is an infinity and the other operand is a nonzero finite
-  number or an infinity, then the result of the ``*`` operator is an infinity;
+  number or an infinity, then the result is an infinity.
+
+For division:
+
+- with a nonzero right operand
+
+  .. code::
+
+      (z / w).conjugate() == z.conjugate() / w.conjugate()
+      (-z) / w = -(z / w)
+      z / (-w) = -(z / w)
 
 - if the first operand is an infinity and the second operand is a finite
-  number, then the result of the ``/`` operator is an infinity;
+  number, then the result is an infinity;
 
 - if the first operand is a finite number and the second operand is an
-  infinity, then the result of the ``/`` operator is a zero;
+  infinity, then the result is a zero;
 
 - if the first operand is a nonzero finite number or an infinity and the second
-  operand is a zero, then the result of the ``/`` operator is an infinity.
+  operand is a zero, then the result is an infinity.
 
 
 New C API
@@ -653,8 +666,8 @@ Footnotes
 
    Other variants include using a fused multiply-add (FMA) instruction.
 
-.. [8] Its easy to smash this property, as shows the `following algorithm
-   <https://www.mjr19.org.uk/IT/IEEE_complex.html>`_:
+.. [8] Its easy to smash such properties, e.g. the commutativity, as shows the
+   `following algorithm <https://www.mjr19.org.uk/IT/IEEE_complex.html>`_:
 
        .. code:: python