.. function:: round(x[, n])
Return the floating point value *x* rounded to *n* digits after the decimal
- point. If *n* is omitted, it defaults to zero. The result is a floating point
- number. Values are rounded to the closest multiple of 10 to the power minus
- *n*; if two multiples are equally close, rounding is done away from 0 (so. for
- example, ``round(0.5)`` is ``1.0`` and ``round(-0.5)`` is ``-1.0``).
+ point. If *n* is omitted, it defaults to zero. Values are rounded to the
+ closest multiple of 10 to the power minus *n*; if two multiples are equally
+ close, rounding is done toward the even choice (so, for example, both
+ ``round(0.5)`` and ``round(-0.5)`` are ``0``, and ``round(1.5)`` is
+ ``2``). Delegates to ``x.__round__(n)``.
+
+ .. versionchanged:: 2.6
.. function:: set([iterable])
.. versionadded:: 2.2
+.. function:: trunc(x)
+
+ Return the :class:`Real` value *x* truncated to an :class:`Integral` (usually
+ a long integer). Delegates to ``x.__trunc__()``.
+
+ .. versionadded:: 2.6
+
+
.. function:: tuple([iterable])
Return a tuple whose items are the same and in the same order as *iterable*'s
.. function:: ceil(x)
- Return the ceiling of *x* as a float, the smallest integer value greater than or
- equal to *x*.
+ Return the ceiling of *x* as a float, the smallest integer value greater than
+ or equal to *x*. If *x* is not a float, delegates to ``x.__ceil__()``, which
+ should return an :class:`Integral` value.
.. function:: fabs(x)
.. function:: floor(x)
- Return the floor of *x* as a float, the largest integer value less than or equal
- to *x*.
+ Return the floor of *x* as a float, the largest integer value less than or
+ equal to *x*. If *x* is not a float, delegates to ``x.__floor__()``, which
+ should return an :class:`Integral` value.
.. function:: fmod(x, y)
--- /dev/null
+
+:mod:`numbers` --- Numeric abstract base classes
+================================================
+
+.. module:: numbers
+ :synopsis: Numeric abstract base classes (Complex, Real, Integral, etc.).
+
+The :mod:`numbers` module (:pep:`3141`) defines a hierarchy of numeric abstract
+base classes which progressively define more operations. These concepts also
+provide a way to distinguish exact from inexact types. None of the types defined
+in this module can be instantiated.
+
+
+.. class:: Number
+
+ The root of the numeric hierarchy. If you just want to check if an argument
+ *x* is a number, without caring what kind, use ``isinstance(x, Number)``.
+
+
+Exact and inexact operations
+----------------------------
+
+.. class:: Exact
+
+ Subclasses of this type have exact operations.
+
+ As long as the result of a homogenous operation is of the same type, you can
+ assume that it was computed exactly, and there are no round-off errors. Laws
+ like commutativity and associativity hold.
+
+
+.. class:: Inexact
+
+ Subclasses of this type have inexact operations.
+
+ Given X, an instance of :class:`Inexact`, it is possible that ``(X + -X) + 3
+ == 3``, but ``X + (-X + 3) == 0``. The exact form this error takes will vary
+ by type, but it's generally unsafe to compare this type for equality.
+
+
+The numeric tower
+-----------------
+
+.. class:: Complex
+
+ Subclasses of this type describe complex numbers and include the operations
+ that work on the builtin :class:`complex` type. These are: conversions to
+ :class:`complex` and :class:`bool`, :attr:`.real`, :attr:`.imag`, ``+``,
+ ``-``, ``*``, ``/``, :func:`abs`, :meth:`conjugate`, ``==``, and ``!=``. All
+ except ``-`` and ``!=`` are abstract.
+
+.. attribute:: Complex.real
+
+ Abstract. Retrieves the :class:`Real` component of this number.
+
+.. attribute:: Complex.imag
+
+ Abstract. Retrieves the :class:`Real` component of this number.
+
+.. method:: Complex.conjugate()
+
+ Abstract. Returns the complex conjugate. For example, ``(1+3j).conjugate() ==
+ (1-3j)``.
+
+.. class:: Real
+
+ To :class:`Complex`, :class:`Real` adds the operations that work on real
+ numbers.
+
+ In short, those are: a conversion to :class:`float`, :func:`trunc`,
+ :func:`round`, :func:`math.floor`, :func:`math.ceil`, :func:`divmod`, ``//``,
+ ``%``, ``<``, ``<=``, ``>``, and ``>=``.
+
+ Real also provides defaults for :func:`complex`, :attr:`Complex.real`,
+ :attr:`Complex.imag`, and :meth:`Complex.conjugate`.
+
+
+.. class:: Rational
+
+ Subtypes both :class:`Real` and :class:`Exact`, and adds
+ :attr:`Rational.numerator` and :attr:`Rational.denominator` properties, which
+ should be in lowest terms. With these, it provides a default for
+ :func:`float`.
+
+.. attribute:: Rational.numerator
+
+ Abstract.
+
+.. attribute:: Rational.denominator
+
+ Abstract.
+
+
+.. class:: Integral
+
+ Subtypes :class:`Rational` and adds a conversion to :class:`long`, the
+ 3-argument form of :func:`pow`, and the bit-string operations: ``<<``,
+ ``>>``, ``&``, ``^``, ``|``, ``~``. Provides defaults for :func:`float`,
+ :attr:`Rational.numerator`, and :attr:`Rational.denominator`.
********************************
The modules described in this chapter provide numeric and math-related functions
-and data types. The :mod:`math` and :mod:`cmath` contain various mathematical
-functions for floating-point and complex numbers. For users more interested in
-decimal accuracy than in speed, the :mod:`decimal` module supports exact
-representations of decimal numbers.
+and data types. The :mod:`numbers` module defines an abstract hierarchy of
+numeric types. The :mod:`math` and :mod:`cmath` modules contain various
+mathematical functions for floating-point and complex numbers. For users more
+interested in decimal accuracy than in speed, the :mod:`decimal` module supports
+exact representations of decimal numbers.
The following modules are documented in this chapter:
.. toctree::
+ numbers.rst
math.rst
cmath.rst
decimal.rst
:func:`long`, :func:`float`, and :func:`complex` can be used to produce numbers
of a specific type.
-All numeric types (except complex) support the following operations, sorted by
-ascending priority (operations in the same box have the same priority; all
-numeric operations have a higher priority than comparison operations):
+All builtin numeric types support the following operations. See
+:ref:`power` and later sections for the operators' priorities.
+--------------------+---------------------------------+--------+
| Operation | Result | Notes |
+--------------------+---------------------------------+--------+
| ``x / y`` | quotient of *x* and *y* | \(1) |
+--------------------+---------------------------------+--------+
-| ``x // y`` | (floored) quotient of *x* and | \(5) |
+| ``x // y`` | (floored) quotient of *x* and | (4)(5) |
| | *y* | |
+--------------------+---------------------------------+--------+
| ``x % y`` | remainder of ``x / y`` | \(4) |
+--------------------+---------------------------------+--------+
| ``+x`` | *x* unchanged | |
+--------------------+---------------------------------+--------+
-| ``abs(x)`` | absolute value or magnitude of | |
+| ``abs(x)`` | absolute value or magnitude of | \(3) |
| | *x* | |
+--------------------+---------------------------------+--------+
| ``int(x)`` | *x* converted to integer | \(2) |
| | *im* defaults to zero. | |
+--------------------+---------------------------------+--------+
| ``c.conjugate()`` | conjugate of the complex number | |
-| | *c* | |
+| | *c*. (Identity on real numbers) | |
+--------------------+---------------------------------+--------+
| ``divmod(x, y)`` | the pair ``(x // y, x % y)`` | (3)(4) |
+--------------------+---------------------------------+--------+
-| ``pow(x, y)`` | *x* to the power *y* | |
+| ``pow(x, y)`` | *x* to the power *y* | \(3) |
+--------------------+---------------------------------+--------+
| ``x ** y`` | *x* to the power *y* | |
+--------------------+---------------------------------+--------+
pair: numeric; conversions
pair: C; language
- Conversion from floating point to (long or plain) integer may round or truncate
- as in C; see functions :func:`floor` and :func:`ceil` in the :mod:`math` module
- for well-defined conversions.
+ Conversion from floating point to (long or plain) integer may round or
+ truncate as in C.
+
+ .. deprecated:: 2.6
+ Instead, convert floats to long explicitly with :func:`trunc`,
+ :func:`math.floor`, or :func:`math.ceil`.
(3)
See :ref:`built-in-funcs` for a full description.
.. versionadded:: 2.6
+All :class:`numbers.Real` types (:class:`int`, :class:`long`, and
+:class:`float`) also include the following operations:
+
++--------------------+--------------------------------+--------+
+| Operation | Result | Notes |
++====================+================================+========+
+| ``trunc(x)`` | *x* truncated to Integral | |
++--------------------+--------------------------------+--------+
+| ``round(x[, n])`` | *x* rounded to n digits, | |
+| | rounding half to even. If n is | |
+| | omitted, it defaults to 0. | |
++--------------------+--------------------------------+--------+
+| ``math.floor(x)`` | the greatest Integral <= *x* | |
++--------------------+--------------------------------+--------+
+| ``math.ceil(x)`` | the least Integral >= *x* | |
++--------------------+--------------------------------+--------+
.. XXXJH exceptions: overflow (when? what operations?) zerodivision
indicate the presence of the ``...`` syntax in a slice. Its truth value is
true.
-Numbers
+:class:`numbers.Number`
.. index:: object: numeric
These are created by numeric literals and returned as results by arithmetic
Python distinguishes between integers, floating point numbers, and complex
numbers:
- Integers
+ :class:`numbers.Integral`
.. index:: object: integer
These represent elements from the mathematical set of integers (positive and
without causing overflow, will yield the same result in the long integer domain
or when using mixed operands.
- Floating point numbers
+ :class:`numbers.Real` (:class:`float`)
.. index::
object: floating point
pair: floating point; number
overhead of using objects in Python, so there is no reason to complicate the
language with two kinds of floating point numbers.
- Complex numbers
+ :class:`numbers.Complex`
.. index::
object: complex
pair: complex; number
raised).
Raising ``0.0`` to a negative power results in a :exc:`ZeroDivisionError`.
-Raising a negative number to a fractional power results in a :exc:`ValueError`.
+Raising a negative number to a fractional power results in a :class:`complex`
+number. (Since Python 2.6. In earlier versions it raised a :exc:`ValueError`.)
.. _unary:
--- /dev/null
+# Copyright 2007 Google, Inc. All Rights Reserved.
+# Licensed to PSF under a Contributor Agreement.
+
+"""Abstract Base Classes (ABCs) for numbers, according to PEP 3141.
+
+TODO: Fill out more detailed documentation on the operators."""
+
+from abc import ABCMeta, abstractmethod, abstractproperty
+
+__all__ = ["Number", "Exact", "Inexact",
+ "Complex", "Real", "Rational", "Integral",
+ ]
+
+
+class Number(object):
+ """All numbers inherit from this class.
+
+ If you just want to check if an argument x is a number, without
+ caring what kind, use isinstance(x, Number).
+ """
+ __metaclass__ = ABCMeta
+
+
+class Exact(Number):
+ """Operations on instances of this type are exact.
+
+ As long as the result of a homogenous operation is of the same
+ type, you can assume that it was computed exactly, and there are
+ no round-off errors. Laws like commutativity and associativity
+ hold.
+ """
+
+Exact.register(int)
+Exact.register(long)
+
+
+class Inexact(Number):
+ """Operations on instances of this type are inexact.
+
+ Given X, an instance of Inexact, it is possible that (X + -X) + 3
+ == 3, but X + (-X + 3) == 0. The exact form this error takes will
+ vary by type, but it's generally unsafe to compare this type for
+ equality.
+ """
+
+Inexact.register(complex)
+Inexact.register(float)
+# Inexact.register(decimal.Decimal)
+
+
+class Complex(Number):
+ """Complex defines the operations that work on the builtin complex type.
+
+ In short, those are: a conversion to complex, .real, .imag, +, -,
+ *, /, abs(), .conjugate, ==, and !=.
+
+ If it is given heterogenous arguments, and doesn't have special
+ knowledge about them, it should fall back to the builtin complex
+ type as described below.
+ """
+
+ @abstractmethod
+ def __complex__(self):
+ """Return a builtin complex instance. Called for complex(self)."""
+
+ def __bool__(self):
+ """True if self != 0. Called for bool(self)."""
+ return self != 0
+
+ @abstractproperty
+ def real(self):
+ """Retrieve the real component of this number.
+
+ This should subclass Real.
+ """
+ raise NotImplementedError
+
+ @abstractproperty
+ def imag(self):
+ """Retrieve the real component of this number.
+
+ This should subclass Real.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __add__(self, other):
+ """self + other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __radd__(self, other):
+ """other + self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __neg__(self):
+ """-self"""
+ raise NotImplementedError
+
+ def __pos__(self):
+ """+self"""
+ raise NotImplementedError
+
+ def __sub__(self, other):
+ """self - other"""
+ return self + -other
+
+ def __rsub__(self, other):
+ """other - self"""
+ return -self + other
+
+ @abstractmethod
+ def __mul__(self, other):
+ """self * other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rmul__(self, other):
+ """other * self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __div__(self, other):
+ """self / other; should promote to float or complex when necessary."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rdiv__(self, other):
+ """other / self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __pow__(self, exponent):
+ """self**exponent; should promote to float or complex when necessary."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rpow__(self, base):
+ """base ** self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __abs__(self):
+ """Returns the Real distance from 0. Called for abs(self)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def conjugate(self):
+ """(x+y*i).conjugate() returns (x-y*i)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __eq__(self, other):
+ """self == other"""
+ raise NotImplementedError
+
+ # __ne__ is inherited from object and negates whatever __eq__ does.
+
+Complex.register(complex)
+
+
+class Real(Complex):
+ """To Complex, Real adds the operations that work on real numbers.
+
+ In short, those are: a conversion to float, trunc(), divmod,
+ %, <, <=, >, and >=.
+
+ Real also provides defaults for the derived operations.
+ """
+
+ @abstractmethod
+ def __float__(self):
+ """Any Real can be converted to a native float object.
+
+ Called for float(self)."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __trunc__(self):
+ """trunc(self): Truncates self to an Integral.
+
+ Returns an Integral i such that:
+ * i>0 iff self>0;
+ * abs(i) <= abs(self);
+ * for any Integral j satisfying the first two conditions,
+ abs(i) >= abs(j) [i.e. i has "maximal" abs among those].
+ i.e. "truncate towards 0".
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __floor__(self):
+ """Finds the greatest Integral <= self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __ceil__(self):
+ """Finds the least Integral >= self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __round__(self, ndigits=None):
+ """Rounds self to ndigits decimal places, defaulting to 0.
+
+ If ndigits is omitted or None, returns an Integral, otherwise
+ returns a Real. Rounds half toward even.
+ """
+ raise NotImplementedError
+
+ def __divmod__(self, other):
+ """divmod(self, other): The pair (self // other, self % other).
+
+ Sometimes this can be computed faster than the pair of
+ operations.
+ """
+ return (self // other, self % other)
+
+ def __rdivmod__(self, other):
+ """divmod(other, self): The pair (self // other, self % other).
+
+ Sometimes this can be computed faster than the pair of
+ operations.
+ """
+ return (other // self, other % self)
+
+ @abstractmethod
+ def __floordiv__(self, other):
+ """self // other: The floor() of self/other."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rfloordiv__(self, other):
+ """other // self: The floor() of other/self."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __mod__(self, other):
+ """self % other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rmod__(self, other):
+ """other % self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __lt__(self, other):
+ """self < other
+
+ < on Reals defines a total ordering, except perhaps for NaN."""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __le__(self, other):
+ """self <= other"""
+ raise NotImplementedError
+
+ # Concrete implementations of Complex abstract methods.
+ def __complex__(self):
+ """complex(self) == complex(float(self), 0)"""
+ return complex(float(self))
+
+ @property
+ def real(self):
+ """Real numbers are their real component."""
+ return +self
+
+ @property
+ def imag(self):
+ """Real numbers have no imaginary component."""
+ return 0
+
+ def conjugate(self):
+ """Conjugate is a no-op for Reals."""
+ return +self
+
+Real.register(float)
+# Real.register(decimal.Decimal)
+
+
+class Rational(Real, Exact):
+ """.numerator and .denominator should be in lowest terms."""
+
+ @abstractproperty
+ def numerator(self):
+ raise NotImplementedError
+
+ @abstractproperty
+ def denominator(self):
+ raise NotImplementedError
+
+ # Concrete implementation of Real's conversion to float.
+ def __float__(self):
+ """float(self) = self.numerator / self.denominator"""
+ return self.numerator / self.denominator
+
+
+class Integral(Rational):
+ """Integral adds a conversion to long and the bit-string operations."""
+
+ @abstractmethod
+ def __long__(self):
+ """long(self)"""
+ raise NotImplementedError
+
+ def __index__(self):
+ """index(self)"""
+ return long(self)
+
+ @abstractmethod
+ def __pow__(self, exponent, modulus=None):
+ """self ** exponent % modulus, but maybe faster.
+
+ Accept the modulus argument if you want to support the
+ 3-argument version of pow(). Raise a TypeError if exponent < 0
+ or any argument isn't Integral. Otherwise, just implement the
+ 2-argument version described in Complex.
+ """
+ raise NotImplementedError
+
+ @abstractmethod
+ def __lshift__(self, other):
+ """self << other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rlshift__(self, other):
+ """other << self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rshift__(self, other):
+ """self >> other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rrshift__(self, other):
+ """other >> self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __and__(self, other):
+ """self & other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rand__(self, other):
+ """other & self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __xor__(self, other):
+ """self ^ other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __rxor__(self, other):
+ """other ^ self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __or__(self, other):
+ """self | other"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __ror__(self, other):
+ """other | self"""
+ raise NotImplementedError
+
+ @abstractmethod
+ def __invert__(self):
+ """~self"""
+ raise NotImplementedError
+
+ # Concrete implementations of Rational and Real abstract methods.
+ def __float__(self):
+ """float(self) == float(long(self))"""
+ return float(long(self))
+
+ @property
+ def numerator(self):
+ """Integers are their own numerators."""
+ return +self
+
+ @property
+ def denominator(self):
+ """Integers have a denominator of 1."""
+ return 1
+
+Integral.register(int)
+Integral.register(long)
--- /dev/null
+"""Unit tests for numbers.py."""
+
+import unittest
+from test import test_support
+from numbers import Number
+from numbers import Exact, Inexact
+from numbers import Complex, Real, Rational, Integral
+import operator
+
+class TestNumbers(unittest.TestCase):
+ def test_int(self):
+ self.failUnless(issubclass(int, Integral))
+ self.failUnless(issubclass(int, Complex))
+ self.failUnless(issubclass(int, Exact))
+ self.failIf(issubclass(int, Inexact))
+
+ self.assertEqual(7, int(7).real)
+ self.assertEqual(0, int(7).imag)
+ self.assertEqual(7, int(7).conjugate())
+ self.assertEqual(7, int(7).numerator)
+ self.assertEqual(1, int(7).denominator)
+
+ def test_long(self):
+ self.failUnless(issubclass(long, Integral))
+ self.failUnless(issubclass(long, Complex))
+ self.failUnless(issubclass(long, Exact))
+ self.failIf(issubclass(long, Inexact))
+
+ self.assertEqual(7, long(7).real)
+ self.assertEqual(0, long(7).imag)
+ self.assertEqual(7, long(7).conjugate())
+ self.assertEqual(7, long(7).numerator)
+ self.assertEqual(1, long(7).denominator)
+
+ def test_float(self):
+ self.failIf(issubclass(float, Rational))
+ self.failUnless(issubclass(float, Real))
+ self.failIf(issubclass(float, Exact))
+ self.failUnless(issubclass(float, Inexact))
+
+ self.assertEqual(7.3, float(7.3).real)
+ self.assertEqual(0, float(7.3).imag)
+ self.assertEqual(7.3, float(7.3).conjugate())
+
+ def test_complex(self):
+ self.failIf(issubclass(complex, Real))
+ self.failUnless(issubclass(complex, Complex))
+ self.failIf(issubclass(complex, Exact))
+ self.failUnless(issubclass(complex, Inexact))
+
+ c1, c2 = complex(3, 2), complex(4,1)
+ # XXX: This is not ideal, but see the comment in builtin_trunc().
+ self.assertRaises(AttributeError, trunc, c1)
+ self.assertRaises(TypeError, float, c1)
+ self.assertRaises(TypeError, int, c1)
+
+def test_main():
+ test_support.run_unittest(TestNumbers)
+
+
+if __name__ == "__main__":
+ unittest.main()
else:
self.assertAlmostEqual(pow(x, y, z), 24.0)
+ self.assertAlmostEqual(pow(-1, 0.5), 1j)
+ self.assertAlmostEqual(pow(-1, 1./3), 0.5 + 0.8660254037844386j)
+
self.assertRaises(TypeError, pow, -1, -2, 3)
self.assertRaises(ValueError, pow, 1, 2, 0)
self.assertRaises(TypeError, pow, -1L, -2L, 3L)
self.assertRaises(ValueError, pow, 1L, 2L, 0L)
- self.assertRaises(ValueError, pow, -342.43, 0.234)
self.assertRaises(TypeError, pow)
def test_round(self):
self.assertEqual(round(0.0), 0.0)
+ self.assertEqual(type(round(0.0)), float) # Will be int in 3.0.
self.assertEqual(round(1.0), 1.0)
self.assertEqual(round(10.0), 10.0)
self.assertEqual(round(1000000000.0), 1000000000.0)
self.assertEqual(round(-999999999.9), -1000000000.0)
self.assertEqual(round(-8.0, -1), -10.0)
+ self.assertEqual(type(round(-8.0, -1)), float)
+
+ self.assertEqual(type(round(-8.0, 0)), float)
+ self.assertEqual(type(round(-8.0, 1)), float)
+
+ # Check even / odd rounding behaviour
+ self.assertEqual(round(5.5), 6)
+ self.assertEqual(round(6.5), 6)
+ self.assertEqual(round(-5.5), -6)
+ self.assertEqual(round(-6.5), -6)
+
+ # Check behavior on ints
+ self.assertEqual(round(0), 0)
+ self.assertEqual(round(8), 8)
+ self.assertEqual(round(-8), -8)
+ self.assertEqual(type(round(0)), float) # Will be int in 3.0.
+ self.assertEqual(type(round(-8, -1)), float)
+ self.assertEqual(type(round(-8, 0)), float)
+ self.assertEqual(type(round(-8, 1)), float)
# test new kwargs
self.assertEqual(round(number=-8.0, ndigits=-1), -10.0)
self.assertRaises(TypeError, round)
+ # test generic rounding delegation for reals
+ class TestRound(object):
+ def __round__(self):
+ return 23
+
+ class TestNoRound(object):
+ pass
+
+ self.assertEqual(round(TestRound()), 23)
+
+ self.assertRaises(TypeError, round, 1, 2, 3)
+ # XXX: This is not ideal, but see the comment in builtin_round().
+ self.assertRaises(AttributeError, round, TestNoRound())
+
+ t = TestNoRound()
+ t.__round__ = lambda *args: args
+ self.assertEquals((), round(t))
+ self.assertEquals((0,), round(t, 0))
+
def test_setattr(self):
setattr(sys, 'spam', 1)
self.assertEqual(sys.spam, 1)
raise ValueError
self.assertRaises(ValueError, sum, BadSeq())
+ def test_trunc(self):
+
+ self.assertEqual(trunc(1), 1)
+ self.assertEqual(trunc(-1), -1)
+ self.assertEqual(type(trunc(1)), int)
+ self.assertEqual(type(trunc(1.5)), int)
+ self.assertEqual(trunc(1.5), 1)
+ self.assertEqual(trunc(-1.5), -1)
+ self.assertEqual(trunc(1.999999), 1)
+ self.assertEqual(trunc(-1.999999), -1)
+ self.assertEqual(trunc(-0.999999), -0)
+ self.assertEqual(trunc(-100.999), -100)
+
+ class TestTrunc(object):
+ def __trunc__(self):
+ return 23
+
+ class TestNoTrunc(object):
+ pass
+
+ self.assertEqual(trunc(TestTrunc()), 23)
+
+ self.assertRaises(TypeError, trunc)
+ self.assertRaises(TypeError, trunc, 1, 2)
+ # XXX: This is not ideal, but see the comment in builtin_trunc().
+ self.assertRaises(AttributeError, trunc, TestNoTrunc())
+
+ t = TestNoTrunc()
+ t.__trunc__ = lambda *args: args
+ self.assertEquals((), trunc(t))
+ self.assertRaises(TypeError, trunc, t, 0)
+
def test_tuple(self):
self.assertEqual(tuple(()), ())
t0_3 = (0, 1, 2, 3)
"1. ** huge", "huge ** 1.", "1. ** mhuge", "mhuge ** 1.",
"math.sin(huge)", "math.sin(mhuge)",
"math.sqrt(huge)", "math.sqrt(mhuge)", # should do better
- "math.floor(huge)", "math.floor(mhuge)"]:
+ # math.floor() of an int returns an int now
+ ##"math.floor(huge)", "math.floor(mhuge)",
+ ]:
self.assertRaises(OverflowError, eval, test, namespace)
self.ftest('ceil(-1.0)', math.ceil(-1.0), -1)
self.ftest('ceil(-1.5)', math.ceil(-1.5), -1)
+ class TestCeil(object):
+ def __ceil__(self):
+ return 42
+ class TestNoCeil(object):
+ pass
+ self.ftest('ceil(TestCeil())', math.ceil(TestCeil()), 42)
+ self.assertRaises(TypeError, math.ceil, TestNoCeil())
+
+ t = TestNoCeil()
+ t.__ceil__ = lambda *args: args
+ self.assertRaises(TypeError, math.ceil, t)
+ self.assertRaises(TypeError, math.ceil, t, 0)
+
def testCos(self):
self.assertRaises(TypeError, math.cos)
self.ftest('cos(-pi/2)', math.cos(-math.pi/2), 0)
self.ftest('floor(1.23e167)', math.floor(1.23e167), 1.23e167)
self.ftest('floor(-1.23e167)', math.floor(-1.23e167), -1.23e167)
+ class TestFloor(object):
+ def __floor__(self):
+ return 42
+ class TestNoFloor(object):
+ pass
+ self.ftest('floor(TestFloor())', math.floor(TestFloor()), 42)
+ self.assertRaises(TypeError, math.floor, TestNoFloor())
+
+ t = TestNoFloor()
+ t.__floor__ = lambda *args: args
+ self.assertRaises(TypeError, math.floor, t)
+ self.assertRaises(TypeError, math.floor, t, 0)
+
def testFmod(self):
self.assertRaises(TypeError, math.fmod)
self.ftest('fmod(10,1)', math.fmod(10,1), 0)
expected = ['startTest', 'test', 'stopTest']
self.assertEqual(events, expected)
+class Test_Assertions(TestCase):
+ def test_AlmostEqual(self):
+ self.failUnlessAlmostEqual(1.00000001, 1.0)
+ self.failIfAlmostEqual(1.0000001, 1.0)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 1.0000001, 1.0)
+ self.assertRaises(AssertionError,
+ self.failIfAlmostEqual, 1.00000001, 1.0)
+
+ self.failUnlessAlmostEqual(1.1, 1.0, places=0)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 1.1, 1.0, places=1)
+
+ self.failUnlessAlmostEqual(0, .1+.1j, places=0)
+ self.failIfAlmostEqual(0, .1+.1j, places=1)
+ self.assertRaises(AssertionError,
+ self.failUnlessAlmostEqual, 0, .1+.1j, places=1)
+ self.assertRaises(AssertionError,
+ self.failIfAlmostEqual, 0, .1+.1j, places=0)
+
######################################################################
## Main
######################################################################
def test_main():
test_support.run_unittest(Test_TestCase, Test_TestLoader,
- Test_TestSuite, Test_TestResult, Test_FunctionTestCase)
+ Test_TestSuite, Test_TestResult, Test_FunctionTestCase,
+ Test_Assertions)
if __name__ == "__main__":
test_main()
Note that decimal places (from zero) are usually not the same
as significant digits (measured from the most signficant digit).
"""
- if round(second-first, places) != 0:
+ if round(abs(second-first), places) != 0:
raise self.failureException, \
(msg or '%r != %r within %r places' % (first, second, places))
Note that decimal places (from zero) are usually not the same
as significant digits (measured from the most signficant digit).
"""
- if round(second-first, places) == 0:
+ if round(abs(second-first), places) == 0:
raise self.failureException, \
(msg or '%r == %r within %r places' % (first, second, places))
Library
-------
+- Issue #1689: PEP 3141, numeric abstract base classes.
+
- Tk issue #1851526: Return results from Python callbacks to Tcl as
Tcl objects.
FUNC2(atan2, atan2,
"atan2(y, x)\n\nReturn the arc tangent (measured in radians) of y/x.\n"
"Unlike atan(y/x), the signs of both x and y are considered.")
-FUNC1(ceil, ceil,
- "ceil(x)\n\nReturn the ceiling of x as a float.\n"
- "This is the smallest integral value >= x.")
+
+static PyObject * math_ceil(PyObject *self, PyObject *number) {
+ static PyObject *ceil_str = NULL;
+ PyObject *method;
+
+ if (ceil_str == NULL) {
+ ceil_str = PyString_FromString("__ceil__");
+ if (ceil_str == NULL)
+ return NULL;
+ }
+
+ method = _PyType_Lookup(Py_Type(number), ceil_str);
+ if (method == NULL)
+ return math_1(number, ceil);
+ else
+ return PyObject_CallFunction(method, "O", number);
+}
+
+PyDoc_STRVAR(math_ceil_doc,
+ "ceil(x)\n\nReturn the ceiling of x as a float.\n"
+ "This is the smallest integral value >= x.");
+
FUNC1(cos, cos,
"cos(x)\n\nReturn the cosine of x (measured in radians).")
FUNC1(cosh, cosh,
"exp(x)\n\nReturn e raised to the power of x.")
FUNC1(fabs, fabs,
"fabs(x)\n\nReturn the absolute value of the float x.")
-FUNC1(floor, floor,
- "floor(x)\n\nReturn the floor of x as a float.\n"
- "This is the largest integral value <= x.")
+
+static PyObject * math_floor(PyObject *self, PyObject *number) {
+ static PyObject *floor_str = NULL;
+ PyObject *method;
+
+ if (floor_str == NULL) {
+ floor_str = PyString_FromString("__floor__");
+ if (floor_str == NULL)
+ return NULL;
+ }
+
+ method = _PyType_Lookup(Py_Type(number), floor_str);
+ if (method == NULL)
+ return math_1(number, floor);
+ else
+ return PyObject_CallFunction(method, "O", number);
+}
+
+PyDoc_STRVAR(math_floor_doc,
+ "floor(x)\n\nReturn the floor of x as a float.\n"
+ "This is the largest integral value <= x.");
+
FUNC2(fmod, fmod,
"fmod(x,y)\n\nReturn fmod(x, y), according to platform C."
" x % y may differ.")
return combined;
}
+/* This macro may return! */
+#define TO_COMPLEX(obj, c) \
+ if (PyComplex_Check(obj)) \
+ c = ((PyComplexObject *)(obj))->cval; \
+ else if (to_complex(&(obj), &(c)) < 0) \
+ return (obj)
+
+static int
+to_complex(PyObject **pobj, Py_complex *pc)
+{
+ PyObject *obj = *pobj;
+
+ pc->real = pc->imag = 0.0;
+ if (PyInt_Check(obj)) {
+ pc->real = PyInt_AS_LONG(obj);
+ return 0;
+ }
+ if (PyLong_Check(obj)) {
+ pc->real = PyLong_AsDouble(obj);
+ if (pc->real == -1.0 && PyErr_Occurred()) {
+ *pobj = NULL;
+ return -1;
+ }
+ return 0;
+ }
+ if (PyFloat_Check(obj)) {
+ pc->real = PyFloat_AsDouble(obj);
+ return 0;
+ }
+ Py_INCREF(Py_NotImplemented);
+ *pobj = Py_NotImplemented;
+ return -1;
+}
+
+
static PyObject *
complex_add(PyComplexObject *v, PyComplexObject *w)
{
}
static PyObject *
-complex_pow(PyComplexObject *v, PyObject *w, PyComplexObject *z)
+complex_pow(PyObject *v, PyObject *w, PyObject *z)
{
Py_complex p;
Py_complex exponent;
long int_exponent;
+ Py_complex a, b;
+ TO_COMPLEX(v, a);
+ TO_COMPLEX(w, b);
- if ((PyObject *)z!=Py_None) {
+ if (z!=Py_None) {
PyErr_SetString(PyExc_ValueError, "complex modulo");
return NULL;
}
PyFPE_START_PROTECT("complex_pow", return 0)
errno = 0;
- exponent = ((PyComplexObject*)w)->cval;
+ exponent = b;
int_exponent = (long)exponent.real;
if (exponent.imag == 0. && exponent.real == int_exponent)
- p = c_powi(v->cval,int_exponent);
+ p = c_powi(a,int_exponent);
else
- p = c_pow(v->cval,exponent);
+ p = c_pow(a,exponent);
PyFPE_END_PROTECT(p)
Py_ADJUST_ERANGE2(p.real, p.imag);
{
PyObject *t, *r;
+ if (PyErr_Warn(PyExc_DeprecationWarning,
+ "complex divmod(), // and % are deprecated") < 0)
+ return NULL;
+
t = complex_divmod(v, w);
if (t != NULL) {
r = PyTuple_GET_ITEM(t, 0);
return PyComplex_FromCComplex(c);
}
+PyDoc_STRVAR(complex_conjugate_doc,
+"complex.conjugate() -> complex\n"
+"\n"
+"Returns the complex conjugate of its argument. (3-4j).conjugate() == 3+4j.");
+
static PyObject *
complex_getnewargs(PyComplexObject *v)
{
}
static PyMethodDef complex_methods[] = {
- {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS},
+ {"conjugate", (PyCFunction)complex_conjugate, METH_NOARGS,
+ complex_conjugate_doc},
{"__getnewargs__", (PyCFunction)complex_getnewargs, METH_NOARGS},
{NULL, NULL} /* sentinel */
};
* bugs so we have to figure it out ourselves.
*/
if (iw != floor(iw)) {
- PyErr_SetString(PyExc_ValueError, "negative number "
- "cannot be raised to a fractional power");
- return NULL;
+ /* Negative numbers raised to fractional powers
+ * become complex.
+ */
+ return PyComplex_Type.tp_as_number->nb_power(v, w, z);
}
/* iw is an exact integer, albeit perhaps a very large one.
* -1 raised to an exact integer should never be exceptional.
return PyFloat_FromDouble(-v->ob_fval);
}
-static PyObject *
-float_pos(PyFloatObject *v)
-{
- if (PyFloat_CheckExact(v)) {
- Py_INCREF(v);
- return (PyObject *)v;
- }
- else
- return PyFloat_FromDouble(v->ob_fval);
-}
-
static PyObject *
float_abs(PyFloatObject *v)
{
}
static PyObject *
-float_long(PyObject *v)
-{
- double x = PyFloat_AsDouble(v);
- return PyLong_FromDouble(x);
-}
-
-static PyObject *
-float_int(PyObject *v)
+float_trunc(PyObject *v)
{
double x = PyFloat_AsDouble(v);
double wholepart; /* integral portion of x, rounded toward 0 */
return PyLong_FromDouble(wholepart);
}
+static PyObject *
+float_round(PyObject *v, PyObject *args)
+{
+#define UNDEF_NDIGITS (-0x7fffffff) /* Unlikely ndigits value */
+ double x;
+ double f;
+ double flr, cil;
+ double rounded;
+ int i;
+ int ndigits = UNDEF_NDIGITS;
+
+ if (!PyArg_ParseTuple(args, "|i", &ndigits))
+ return NULL;
+
+ x = PyFloat_AsDouble(v);
+
+ if (ndigits != UNDEF_NDIGITS) {
+ f = 1.0;
+ i = abs(ndigits);
+ while (--i >= 0)
+ f = f*10.0;
+ if (ndigits < 0)
+ x /= f;
+ else
+ x *= f;
+ }
+
+ flr = floor(x);
+ cil = ceil(x);
+
+ if (x-flr > 0.5)
+ rounded = cil;
+ else if (x-flr == 0.5)
+ rounded = fmod(flr, 2) == 0 ? flr : cil;
+ else
+ rounded = flr;
+
+ if (ndigits != UNDEF_NDIGITS) {
+ if (ndigits < 0)
+ rounded *= f;
+ else
+ rounded /= f;
+ }
+
+ return PyFloat_FromDouble(rounded);
+#undef UNDEF_NDIGITS
+}
+
static PyObject *
float_float(PyObject *v)
{
"Overrides the automatic determination of C-level floating point type.\n"
"This affects how floats are converted to and from binary strings.");
+static PyObject *
+float_getzero(PyObject *v, void *closure)
+{
+ return PyFloat_FromDouble(0.0);
+}
+
static PyMethodDef float_methods[] = {
+ {"conjugate", (PyCFunction)float_float, METH_NOARGS,
+ "Returns self, the complex conjugate of any float."},
+ {"__trunc__", (PyCFunction)float_trunc, METH_NOARGS,
+ "Returns the Integral closest to x between 0 and x."},
+ {"__round__", (PyCFunction)float_round, METH_VARARGS,
+ "Returns the Integral closest to x, rounding half toward even.\n"
+ "When an argument is passed, works like built-in round(x, ndigits)."},
{"__getnewargs__", (PyCFunction)float_getnewargs, METH_NOARGS},
{"__getformat__", (PyCFunction)float_getformat,
METH_O|METH_CLASS, float_getformat_doc},
{NULL, NULL} /* sentinel */
};
+static PyGetSetDef float_getset[] = {
+ {"real",
+ (getter)float_float, (setter)NULL,
+ "the real part of a complex number",
+ NULL},
+ {"imag",
+ (getter)float_getzero, (setter)NULL,
+ "the imaginary part of a complex number",
+ NULL},
+ {NULL} /* Sentinel */
+};
+
PyDoc_STRVAR(float_doc,
"float(x) -> floating point number\n\
\n\
float_divmod, /*nb_divmod*/
float_pow, /*nb_power*/
(unaryfunc)float_neg, /*nb_negative*/
- (unaryfunc)float_pos, /*nb_positive*/
+ (unaryfunc)float_float, /*nb_positive*/
(unaryfunc)float_abs, /*nb_absolute*/
(inquiry)float_nonzero, /*nb_nonzero*/
0, /*nb_invert*/
0, /*nb_xor*/
0, /*nb_or*/
float_coerce, /*nb_coerce*/
- float_int, /*nb_int*/
- float_long, /*nb_long*/
+ float_trunc, /*nb_int*/
+ float_trunc, /*nb_long*/
float_float, /*nb_float*/
0, /* nb_oct */
0, /* nb_hex */
0, /* tp_iternext */
float_methods, /* tp_methods */
0, /* tp_members */
- 0, /* tp_getset */
+ float_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
#include "Python.h"
#include <ctype.h>
+static PyObject *int_int(PyIntObject *v);
+
long
PyInt_GetMax(void)
{
return PyInt_FromLong(-a);
}
-static PyObject *
-int_pos(PyIntObject *v)
-{
- if (PyInt_CheckExact(v)) {
- Py_INCREF(v);
- return (PyObject *)v;
- }
- else
- return PyInt_FromLong(v->ob_ival);
-}
-
static PyObject *
int_abs(PyIntObject *v)
{
if (v->ob_ival >= 0)
- return int_pos(v);
+ return int_int(v);
else
return int_neg(v);
}
return NULL;
}
if (a == 0 || b == 0)
- return int_pos(v);
+ return int_int(v);
if (b >= LONG_BIT) {
vv = PyLong_FromLong(PyInt_AS_LONG(v));
if (vv == NULL)
return NULL;
}
if (a == 0 || b == 0)
- return int_pos(v);
+ return int_int(v);
if (b >= LONG_BIT) {
if (a < 0)
a = -1;
return Py_BuildValue("(l)", v->ob_ival);
}
+static PyObject *
+int_getN(PyIntObject *v, void *context) {
+ return PyInt_FromLong((intptr_t)context);
+}
+
+static PyObject *
+int_round(PyObject *self, PyObject *args)
+{
+#define UNDEF_NDIGITS (-0x7fffffff) /* Unlikely ndigits value */
+ int ndigits = UNDEF_NDIGITS;
+ double x;
+ PyObject *res;
+
+ if (!PyArg_ParseTuple(args, "|i", &ndigits))
+ return NULL;
+
+ if (ndigits == UNDEF_NDIGITS)
+ return int_float((PyIntObject *)self);
+
+ /* If called with two args, defer to float.__round__(). */
+ x = (double) PyInt_AS_LONG(self);
+ self = PyFloat_FromDouble(x);
+ if (self == NULL)
+ return NULL;
+ res = PyObject_CallMethod(self, "__round__", "i", ndigits);
+ Py_DECREF(self);
+ return res;
+#undef UNDEF_NDIGITS
+}
+
static PyMethodDef int_methods[] = {
+ {"conjugate", (PyCFunction)int_int, METH_NOARGS,
+ "Returns self, the complex conjugate of any int."},
+ {"__trunc__", (PyCFunction)int_int, METH_NOARGS,
+ "Truncating an Integral returns itself."},
+ {"__floor__", (PyCFunction)int_int, METH_NOARGS,
+ "Flooring an Integral returns itself."},
+ {"__ceil__", (PyCFunction)int_int, METH_NOARGS,
+ "Ceiling of an Integral returns itself."},
+ {"__round__", (PyCFunction)int_round, METH_VARARGS,
+ "Rounding an Integral returns itself.\n"
+ "Rounding with an ndigits arguments defers to float.__round__."},
{"__getnewargs__", (PyCFunction)int_getnewargs, METH_NOARGS},
{NULL, NULL} /* sentinel */
};
+static PyGetSetDef int_getset[] = {
+ {"real",
+ (getter)int_int, (setter)NULL,
+ "the real part of a complex number",
+ NULL},
+ {"imag",
+ (getter)int_getN, (setter)NULL,
+ "the imaginary part of a complex number",
+ (void*)0},
+ {"numerator",
+ (getter)int_int, (setter)NULL,
+ "the numerator of a rational number in lowest terms",
+ NULL},
+ {"denominator",
+ (getter)int_getN, (setter)NULL,
+ "the denominator of a rational number in lowest terms",
+ (void*)1},
+ {NULL} /* Sentinel */
+};
+
PyDoc_STRVAR(int_doc,
"int(x[, base]) -> integer\n\
\n\
(binaryfunc)int_divmod, /*nb_divmod*/
(ternaryfunc)int_pow, /*nb_power*/
(unaryfunc)int_neg, /*nb_negative*/
- (unaryfunc)int_pos, /*nb_positive*/
+ (unaryfunc)int_int, /*nb_positive*/
(unaryfunc)int_abs, /*nb_absolute*/
(inquiry)int_nonzero, /*nb_nonzero*/
(unaryfunc)int_invert, /*nb_invert*/
0, /* tp_iternext */
int_methods, /* tp_methods */
0, /* tp_members */
- 0, /* tp_getset */
+ int_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
/* forward */
static PyLongObject *x_divrem
(PyLongObject *, PyLongObject *, PyLongObject **);
-static PyObject *long_pos(PyLongObject *);
+static PyObject *long_long(PyObject *v);
static int long_divrem(PyLongObject *, PyLongObject *,
PyLongObject **, PyLongObject **);
return (PyObject *)x;
}
-static PyObject *
-long_pos(PyLongObject *v)
-{
- if (PyLong_CheckExact(v)) {
- Py_INCREF(v);
- return (PyObject *)v;
- }
- else
- return _PyLong_Copy(v);
-}
-
static PyObject *
long_neg(PyLongObject *v)
{
if (v->ob_size < 0)
return long_neg(v);
else
- return long_pos(v);
+ return long_long((PyObject *)v);
}
static int
return Py_BuildValue("(N)", _PyLong_Copy(v));
}
+static PyObject *
+long_getN(PyLongObject *v, void *context) {
+ return PyLong_FromLong((intptr_t)context);
+}
+
+static PyObject *
+long_round(PyObject *self, PyObject *args)
+{
+#define UNDEF_NDIGITS (-0x7fffffff) /* Unlikely ndigits value */
+ int ndigits = UNDEF_NDIGITS;
+ double x;
+ PyObject *res;
+
+ if (!PyArg_ParseTuple(args, "|i", &ndigits))
+ return NULL;
+
+ if (ndigits == UNDEF_NDIGITS)
+ return long_float(self);
+
+ /* If called with two args, defer to float.__round__(). */
+ x = PyLong_AsDouble(self);
+ if (x == -1.0 && PyErr_Occurred())
+ return NULL;
+ self = PyFloat_FromDouble(x);
+ if (self == NULL)
+ return NULL;
+ res = PyObject_CallMethod(self, "__round__", "i", ndigits);
+ Py_DECREF(self);
+ return res;
+#undef UNDEF_NDIGITS
+}
+
static PyMethodDef long_methods[] = {
+ {"conjugate", (PyCFunction)long_long, METH_NOARGS,
+ "Returns self, the complex conjugate of any long."},
+ {"__trunc__", (PyCFunction)long_long, METH_NOARGS,
+ "Truncating an Integral returns itself."},
+ {"__floor__", (PyCFunction)long_long, METH_NOARGS,
+ "Flooring an Integral returns itself."},
+ {"__ceil__", (PyCFunction)long_long, METH_NOARGS,
+ "Ceiling of an Integral returns itself."},
+ {"__round__", (PyCFunction)long_round, METH_VARARGS,
+ "Rounding an Integral returns itself.\n"
+ "Rounding with an ndigits arguments defers to float.__round__."},
{"__getnewargs__", (PyCFunction)long_getnewargs, METH_NOARGS},
{NULL, NULL} /* sentinel */
};
+static PyGetSetDef long_getset[] = {
+ {"real",
+ (getter)long_long, (setter)NULL,
+ "the real part of a complex number",
+ NULL},
+ {"imag",
+ (getter)long_getN, (setter)NULL,
+ "the imaginary part of a complex number",
+ (void*)0},
+ {"numerator",
+ (getter)long_long, (setter)NULL,
+ "the numerator of a rational number in lowest terms",
+ NULL},
+ {"denominator",
+ (getter)long_getN, (setter)NULL,
+ "the denominator of a rational number in lowest terms",
+ (void*)1},
+ {NULL} /* Sentinel */
+};
+
PyDoc_STRVAR(long_doc,
"long(x[, base]) -> integer\n\
\n\
long_divmod, /*nb_divmod*/
long_pow, /*nb_power*/
(unaryfunc) long_neg, /*nb_negative*/
- (unaryfunc) long_pos, /*tp_positive*/
+ (unaryfunc) long_long, /*tp_positive*/
(unaryfunc) long_abs, /*tp_absolute*/
(inquiry) long_nonzero, /*tp_nonzero*/
(unaryfunc) long_invert, /*nb_invert*/
0, /* tp_iternext */
long_methods, /* tp_methods */
0, /* tp_members */
- 0, /* tp_getset */
+ long_getset, /* tp_getset */
0, /* tp_base */
0, /* tp_dict */
0, /* tp_descr_get */
static PyObject *
builtin_round(PyObject *self, PyObject *args, PyObject *kwds)
{
- double number;
- double f;
- int ndigits = 0;
- int i;
+#define UNDEF_NDIGITS (-0x7fffffff) /* Unlikely ndigits value */
+ int ndigits = UNDEF_NDIGITS;
static char *kwlist[] = {"number", "ndigits", 0};
+ PyObject *number;
- if (!PyArg_ParseTupleAndKeywords(args, kwds, "d|i:round",
+ if (!PyArg_ParseTupleAndKeywords(args, kwds, "O|i:round",
kwlist, &number, &ndigits))
return NULL;
- f = 1.0;
- i = abs(ndigits);
- while (--i >= 0)
- f = f*10.0;
- if (ndigits < 0)
- number /= f;
- else
- number *= f;
- if (number >= 0.0)
- number = floor(number + 0.5);
- else
- number = ceil(number - 0.5);
- if (ndigits < 0)
- number *= f;
- else
- number /= f;
- return PyFloat_FromDouble(number);
+
+ // The py3k branch gets better errors for this by using
+ // _PyType_Lookup(), but since float's mro isn't set in py2.6,
+ // we just use PyObject_CallMethod here.
+ if (ndigits == UNDEF_NDIGITS)
+ return PyObject_CallMethod(number, "__round__", "");
+ else
+ return PyObject_CallMethod(number, "__round__", "i", ndigits);
+#undef UNDEF_NDIGITS
}
PyDoc_STRVAR(round_doc,
"round(number[, ndigits]) -> floating point number\n\
\n\
Round a number to a given precision in decimal digits (default 0 digits).\n\
-This always returns a floating point number. Precision may be negative.");
+This returns an int when called with one argument, otherwise a float.\n\
+Precision may be negative.");
static PyObject *
builtin_sorted(PyObject *self, PyObject *args, PyObject *kwds)
Without arguments, equivalent to locals().\n\
With an argument, equivalent to object.__dict__.");
+static PyObject *
+builtin_trunc(PyObject *self, PyObject *number)
+{
+ // XXX: The py3k branch gets better errors for this by using
+ // _PyType_Lookup(), but since float's mro isn't set in py2.6,
+ // we just use PyObject_CallMethod here.
+ return PyObject_CallMethod(number, "__trunc__", "");
+}
+
+PyDoc_STRVAR(trunc_doc,
+"trunc(Real) -> Integral\n\
+\n\
+returns the integral closest to x between 0 and x.");
+
static PyObject*
builtin_sum(PyObject *self, PyObject *args)
{"unichr", builtin_unichr, METH_VARARGS, unichr_doc},
#endif
{"vars", builtin_vars, METH_VARARGS, vars_doc},
+ {"trunc", builtin_trunc, METH_O, trunc_doc},
{"zip", builtin_zip, METH_VARARGS, zip_doc},
{NULL, NULL},
};
projects / python / commitdiff