mirror of
https://github.com/python/cpython.git
synced 2025-07-24 19:54:21 +00:00

svn+ssh://pythondev@svn.python.org/python/trunk ........ r60618 | walter.doerwald | 2008-02-06 15:31:55 +0100 (Wed, 06 Feb 2008) | 6 lines Remove month parameter from Calendar.yeardatescalendar(), Calendar.yeardays2calendar() and Calendar.yeardayscalendar() as the methods don't have such a parameter. Fixes issue #2017. Rewrap content to 80 chars. ........ r60622 | facundo.batista | 2008-02-06 20:28:49 +0100 (Wed, 06 Feb 2008) | 4 lines Fixes issue 1959. Converted tests to unittest. Thanks Giampaolo Rodola. ........ r60626 | thomas.heller | 2008-02-06 21:29:17 +0100 (Wed, 06 Feb 2008) | 3 lines Fixed refcounts and error handling. Should not be merged to py3k branch. ........ r60630 | mark.dickinson | 2008-02-06 23:10:50 +0100 (Wed, 06 Feb 2008) | 4 lines Issue 1979: Make Decimal comparisons (other than !=, ==) involving NaN raise InvalidOperation (and return False if InvalidOperation is trapped). ........ r60632 | mark.dickinson | 2008-02-06 23:25:16 +0100 (Wed, 06 Feb 2008) | 2 lines Remove incorrect usage of :const: in documentation. ........ r60634 | georg.brandl | 2008-02-07 00:45:51 +0100 (Thu, 07 Feb 2008) | 2 lines Revert accidental changes to test_queue in r60605. ........ r60636 | raymond.hettinger | 2008-02-07 01:54:20 +0100 (Thu, 07 Feb 2008) | 1 line Issue 2025: Add tuple.count() and tuple.index() to follow the ABC in collections.Sequence. ........ r60637 | mark.dickinson | 2008-02-07 02:14:23 +0100 (Thu, 07 Feb 2008) | 2 lines Fix broken link in decimal documentation. ........ r60638 | mark.dickinson | 2008-02-07 02:42:06 +0100 (Thu, 07 Feb 2008) | 3 lines IEEE 754 should be IEEE 854; give precise reference for comparisons involving NaNs. ........ r60639 | raymond.hettinger | 2008-02-07 03:12:52 +0100 (Thu, 07 Feb 2008) | 1 line Return ints instead of longs for tuple.count() and tuple.index(). ........ r60640 | raymond.hettinger | 2008-02-07 04:10:33 +0100 (Thu, 07 Feb 2008) | 1 line Merge 60627. ........ r60641 | raymond.hettinger | 2008-02-07 04:25:46 +0100 (Thu, 07 Feb 2008) | 1 line Merge r60628, r60631, and r60633. Register UserList and UserString will the appropriate ABCs. ........ r60642 | brett.cannon | 2008-02-07 08:47:31 +0100 (Thu, 07 Feb 2008) | 3 lines Cast a struct to a void pointer so as to do a type-safe pointer comparison (mistmatch found by clang). ........ r60643 | brett.cannon | 2008-02-07 09:04:07 +0100 (Thu, 07 Feb 2008) | 2 lines Remove unnecessary curly braces around an int literal. ........ r60644 | andrew.kuchling | 2008-02-07 12:43:47 +0100 (Thu, 07 Feb 2008) | 1 line Update URL ........ r60645 | facundo.batista | 2008-02-07 17:16:29 +0100 (Thu, 07 Feb 2008) | 4 lines Fixes issue 2026. Tests converted to unittest. Thanks Giampaolo Rodola. ........ r60646 | christian.heimes | 2008-02-07 18:15:30 +0100 (Thu, 07 Feb 2008) | 1 line Added some statistics code to dict and list object code. I wanted to test how a larger freelist affects the reusage of freed objects. Contrary to my gut feelings 80 objects is more than fine for small apps. I haven't profiled a large app yet. ........ r60648 | facundo.batista | 2008-02-07 20:06:52 +0100 (Thu, 07 Feb 2008) | 6 lines Fixes Issue 1401. When redirected, a possible POST get converted to GET, so it loses its payload. So, it also must lose the headers related to the payload (if it has no content any more, it shouldn't indicate content length and type). ........ r60649 | walter.doerwald | 2008-02-07 20:30:22 +0100 (Thu, 07 Feb 2008) | 3 lines Clarify that the output of TextCalendar.formatmonth() and TextCalendar.formatyear() for custom instances won't be influenced by calls to the module global setfirstweekday() function. Fixes #2018. ........ r60651 | walter.doerwald | 2008-02-07 20:48:34 +0100 (Thu, 07 Feb 2008) | 3 lines Fix documentation for Calendar.iterweekdays(): firstweekday is a property. Fixes second part of #2018. ........ r60653 | walter.doerwald | 2008-02-07 20:57:32 +0100 (Thu, 07 Feb 2008) | 2 lines Fix typo in docstring for Calendar.itermonthdays(). ........ r60655 | raymond.hettinger | 2008-02-07 21:04:37 +0100 (Thu, 07 Feb 2008) | 1 line The float conversion recipe is simpler in Py2.6 ........ r60657 | raymond.hettinger | 2008-02-07 21:10:49 +0100 (Thu, 07 Feb 2008) | 1 line Fix typo ........ r60660 | brett.cannon | 2008-02-07 23:27:10 +0100 (Thu, 07 Feb 2008) | 3 lines Make sure a switch statement does not have repetitive case statements. Error found through LLVM post-2.1 svn. ........ r60661 | christian.heimes | 2008-02-08 01:11:31 +0100 (Fri, 08 Feb 2008) | 1 line Deallocate content of the dict free list on interpreter shutdown ........ r60662 | christian.heimes | 2008-02-08 01:14:34 +0100 (Fri, 08 Feb 2008) | 1 line Use prefix decrement ........ r60663 | amaury.forgeotdarc | 2008-02-08 01:56:02 +0100 (Fri, 08 Feb 2008) | 5 lines issue 2045: Infinite recursion when printing a subclass of defaultdict, if default_factory is set to a bound method. Will backport. ........ r60667 | jeffrey.yasskin | 2008-02-08 07:45:40 +0100 (Fri, 08 Feb 2008) | 2 lines Oops! 2.6's Rational.__ne__ didn't work. ........ r60671 | hyeshik.chang | 2008-02-08 18:10:20 +0100 (Fri, 08 Feb 2008) | 2 lines Update big5hkscs codec to conform to the HKSCS:2004 revision. ........ r60673 | raymond.hettinger | 2008-02-08 23:30:04 +0100 (Fri, 08 Feb 2008) | 4 lines Remove unnecessary modulo division. The preceding test guarantees that 0 <= i < len. ........ r60674 | raymond.hettinger | 2008-02-09 00:02:27 +0100 (Sat, 09 Feb 2008) | 1 line Speed-up __iter__() mixin method. ........ r60675 | raymond.hettinger | 2008-02-09 00:34:21 +0100 (Sat, 09 Feb 2008) | 1 line Fill-in missing Set comparisons ........ r60677 | raymond.hettinger | 2008-02-09 00:57:06 +0100 (Sat, 09 Feb 2008) | 1 line Add advice on choosing between DictMixin and MutableMapping ........
427 lines
17 KiB
Python
427 lines
17 KiB
Python
"""Tests for Lib/rational.py."""
|
|
|
|
from decimal import Decimal
|
|
from test.test_support import run_unittest, verbose
|
|
import math
|
|
import operator
|
|
import rational
|
|
import unittest
|
|
from copy import copy, deepcopy
|
|
from pickle import dumps, loads
|
|
R = rational.Rational
|
|
gcd = rational.gcd
|
|
|
|
|
|
class GcdTest(unittest.TestCase):
|
|
|
|
def testMisc(self):
|
|
self.assertEquals(0, gcd(0, 0))
|
|
self.assertEquals(1, gcd(1, 0))
|
|
self.assertEquals(-1, gcd(-1, 0))
|
|
self.assertEquals(1, gcd(0, 1))
|
|
self.assertEquals(-1, gcd(0, -1))
|
|
self.assertEquals(1, gcd(7, 1))
|
|
self.assertEquals(-1, gcd(7, -1))
|
|
self.assertEquals(1, gcd(-23, 15))
|
|
self.assertEquals(12, gcd(120, 84))
|
|
self.assertEquals(-12, gcd(84, -120))
|
|
|
|
|
|
def _components(r):
|
|
return (r.numerator, r.denominator)
|
|
|
|
|
|
class RationalTest(unittest.TestCase):
|
|
|
|
def assertTypedEquals(self, expected, actual):
|
|
"""Asserts that both the types and values are the same."""
|
|
self.assertEquals(type(expected), type(actual))
|
|
self.assertEquals(expected, actual)
|
|
|
|
def assertRaisesMessage(self, exc_type, message,
|
|
callable, *args, **kwargs):
|
|
"""Asserts that callable(*args, **kwargs) raises exc_type(message)."""
|
|
try:
|
|
callable(*args, **kwargs)
|
|
except exc_type as e:
|
|
self.assertEquals(message, str(e))
|
|
else:
|
|
self.fail("%s not raised" % exc_type.__name__)
|
|
|
|
def testInit(self):
|
|
self.assertEquals((0, 1), _components(R()))
|
|
self.assertEquals((7, 1), _components(R(7)))
|
|
self.assertEquals((7, 3), _components(R(R(7, 3))))
|
|
|
|
self.assertEquals((-1, 1), _components(R(-1, 1)))
|
|
self.assertEquals((-1, 1), _components(R(1, -1)))
|
|
self.assertEquals((1, 1), _components(R(-2, -2)))
|
|
self.assertEquals((1, 2), _components(R(5, 10)))
|
|
self.assertEquals((7, 15), _components(R(7, 15)))
|
|
self.assertEquals((10**23, 1), _components(R(10**23)))
|
|
|
|
self.assertRaisesMessage(ZeroDivisionError, "Rational(12, 0)",
|
|
R, 12, 0)
|
|
self.assertRaises(TypeError, R, 1.5)
|
|
self.assertRaises(TypeError, R, 1.5 + 3j)
|
|
|
|
self.assertRaises(TypeError, R, R(1, 2), 3)
|
|
self.assertRaises(TypeError, R, "3/2", 3)
|
|
|
|
def testFromString(self):
|
|
self.assertEquals((5, 1), _components(R("5")))
|
|
self.assertEquals((3, 2), _components(R("3/2")))
|
|
self.assertEquals((3, 2), _components(R(" \n +3/2")))
|
|
self.assertEquals((-3, 2), _components(R("-3/2 ")))
|
|
self.assertEquals((3, 2), _components(R(" 03/02 \n ")))
|
|
self.assertEquals((3, 2), _components(R(" 03/02 \n ")))
|
|
self.assertEquals((16, 5), _components(R(" 3.2 ")))
|
|
self.assertEquals((-16, 5), _components(R(" -3.2 ")))
|
|
self.assertEquals((-3, 1), _components(R(" -3. ")))
|
|
self.assertEquals((3, 5), _components(R(" .6 ")))
|
|
|
|
self.assertRaisesMessage(
|
|
ZeroDivisionError, "Rational(3, 0)",
|
|
R, "3/0")
|
|
self.assertRaisesMessage(
|
|
ValueError, "Invalid literal for Rational: 3/",
|
|
R, "3/")
|
|
self.assertRaisesMessage(
|
|
ValueError, "Invalid literal for Rational: 3 /2",
|
|
R, "3 /2")
|
|
self.assertRaisesMessage(
|
|
# Denominators don't need a sign.
|
|
ValueError, "Invalid literal for Rational: 3/+2",
|
|
R, "3/+2")
|
|
self.assertRaisesMessage(
|
|
# Imitate float's parsing.
|
|
ValueError, "Invalid literal for Rational: + 3/2",
|
|
R, "+ 3/2")
|
|
self.assertRaisesMessage(
|
|
# Avoid treating '.' as a regex special character.
|
|
ValueError, "Invalid literal for Rational: 3a2",
|
|
R, "3a2")
|
|
self.assertRaisesMessage(
|
|
# Only parse ordinary decimals, not scientific form.
|
|
ValueError, "Invalid literal for Rational: 3.2e4",
|
|
R, "3.2e4")
|
|
self.assertRaisesMessage(
|
|
# Don't accept combinations of decimals and rationals.
|
|
ValueError, "Invalid literal for Rational: 3/7.2",
|
|
R, "3/7.2")
|
|
self.assertRaisesMessage(
|
|
# Don't accept combinations of decimals and rationals.
|
|
ValueError, "Invalid literal for Rational: 3.2/7",
|
|
R, "3.2/7")
|
|
self.assertRaisesMessage(
|
|
# Allow 3. and .3, but not .
|
|
ValueError, "Invalid literal for Rational: .",
|
|
R, ".")
|
|
|
|
def testImmutable(self):
|
|
r = R(7, 3)
|
|
r.__init__(2, 15)
|
|
self.assertEquals((7, 3), _components(r))
|
|
|
|
self.assertRaises(AttributeError, setattr, r, 'numerator', 12)
|
|
self.assertRaises(AttributeError, setattr, r, 'denominator', 6)
|
|
self.assertEquals((7, 3), _components(r))
|
|
|
|
# But if you _really_ need to:
|
|
r._numerator = 4
|
|
r._denominator = 2
|
|
self.assertEquals((4, 2), _components(r))
|
|
# Which breaks some important operations:
|
|
self.assertNotEquals(R(4, 2), r)
|
|
|
|
def testFromFloat(self):
|
|
self.assertRaisesMessage(
|
|
TypeError, "Rational.from_float() only takes floats, not 3 (int)",
|
|
R.from_float, 3)
|
|
|
|
self.assertEquals((0, 1), _components(R.from_float(-0.0)))
|
|
self.assertEquals((10, 1), _components(R.from_float(10.0)))
|
|
self.assertEquals((-5, 2), _components(R.from_float(-2.5)))
|
|
self.assertEquals((99999999999999991611392, 1),
|
|
_components(R.from_float(1e23)))
|
|
self.assertEquals(float(10**23), float(R.from_float(1e23)))
|
|
self.assertEquals((3602879701896397, 1125899906842624),
|
|
_components(R.from_float(3.2)))
|
|
self.assertEquals(3.2, float(R.from_float(3.2)))
|
|
|
|
inf = 1e1000
|
|
nan = inf - inf
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert inf to Rational.",
|
|
R.from_float, inf)
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert -inf to Rational.",
|
|
R.from_float, -inf)
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert nan to Rational.",
|
|
R.from_float, nan)
|
|
|
|
def testFromDecimal(self):
|
|
self.assertRaisesMessage(
|
|
TypeError,
|
|
"Rational.from_decimal() only takes Decimals, not 3 (int)",
|
|
R.from_decimal, 3)
|
|
self.assertEquals(R(0), R.from_decimal(Decimal("-0")))
|
|
self.assertEquals(R(5, 10), R.from_decimal(Decimal("0.5")))
|
|
self.assertEquals(R(5, 1000), R.from_decimal(Decimal("5e-3")))
|
|
self.assertEquals(R(5000), R.from_decimal(Decimal("5e3")))
|
|
self.assertEquals(1 - R(1, 10**30),
|
|
R.from_decimal(Decimal("0." + "9" * 30)))
|
|
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert Infinity to Rational.",
|
|
R.from_decimal, Decimal("inf"))
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert -Infinity to Rational.",
|
|
R.from_decimal, Decimal("-inf"))
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert NaN to Rational.",
|
|
R.from_decimal, Decimal("nan"))
|
|
self.assertRaisesMessage(
|
|
TypeError, "Cannot convert sNaN to Rational.",
|
|
R.from_decimal, Decimal("snan"))
|
|
|
|
def testFromContinuedFraction(self):
|
|
self.assertRaises(TypeError, R.from_continued_fraction, None)
|
|
phi = R.from_continued_fraction([1]*100)
|
|
self.assertEquals(round(phi - (1 + 5 ** 0.5) / 2, 10), 0.0)
|
|
|
|
minusphi = R.from_continued_fraction([-1]*100)
|
|
self.assertEquals(round(minusphi + (1 + 5 ** 0.5) / 2, 10), 0.0)
|
|
|
|
self.assertEquals(R.from_continued_fraction([0]), R(0))
|
|
self.assertEquals(R.from_continued_fraction([]), R(0))
|
|
|
|
def testAsContinuedFraction(self):
|
|
self.assertEqual(R.from_float(math.pi).as_continued_fraction()[:15],
|
|
[3, 7, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3, 3])
|
|
self.assertEqual(R.from_float(-math.pi).as_continued_fraction()[:16],
|
|
[-4, 1, 6, 15, 1, 292, 1, 1, 1, 2, 1, 3, 1, 14, 3, 3])
|
|
self.assertEqual(R(0).as_continued_fraction(), [0])
|
|
|
|
def testApproximateFrom(self):
|
|
self.assertEqual(R.from_float(math.pi).approximate(10000), R(355, 113))
|
|
self.assertEqual(R.from_float(-math.pi).approximate(10000), R(-355, 113))
|
|
self.assertEqual(R.from_float(0.0).approximate(10000), R(0))
|
|
|
|
def testConversions(self):
|
|
self.assertTypedEquals(-1, math.trunc(R(-11, 10)))
|
|
self.assertTypedEquals(-2, math.floor(R(-11, 10)))
|
|
self.assertTypedEquals(-1, math.ceil(R(-11, 10)))
|
|
self.assertTypedEquals(-1, math.ceil(R(-10, 10)))
|
|
self.assertTypedEquals(-1, int(R(-11, 10)))
|
|
|
|
self.assertTypedEquals(0, round(R(-1, 10)))
|
|
self.assertTypedEquals(0, round(R(-5, 10)))
|
|
self.assertTypedEquals(-2, round(R(-15, 10)))
|
|
self.assertTypedEquals(-1, round(R(-7, 10)))
|
|
|
|
self.assertEquals(False, bool(R(0, 1)))
|
|
self.assertEquals(True, bool(R(3, 2)))
|
|
self.assertTypedEquals(0.1, float(R(1, 10)))
|
|
|
|
# Check that __float__ isn't implemented by converting the
|
|
# numerator and denominator to float before dividing.
|
|
self.assertRaises(OverflowError, float, int('2'*400+'7'))
|
|
self.assertAlmostEquals(2.0/3,
|
|
float(R(int('2'*400+'7'), int('3'*400+'1'))))
|
|
|
|
self.assertTypedEquals(0.1+0j, complex(R(1,10)))
|
|
|
|
def testRound(self):
|
|
self.assertTypedEquals(R(-200), round(R(-150), -2))
|
|
self.assertTypedEquals(R(-200), round(R(-250), -2))
|
|
self.assertTypedEquals(R(30), round(R(26), -1))
|
|
self.assertTypedEquals(R(-2, 10), round(R(-15, 100), 1))
|
|
self.assertTypedEquals(R(-2, 10), round(R(-25, 100), 1))
|
|
|
|
|
|
def testArithmetic(self):
|
|
self.assertEquals(R(1, 2), R(1, 10) + R(2, 5))
|
|
self.assertEquals(R(-3, 10), R(1, 10) - R(2, 5))
|
|
self.assertEquals(R(1, 25), R(1, 10) * R(2, 5))
|
|
self.assertEquals(R(1, 4), R(1, 10) / R(2, 5))
|
|
self.assertTypedEquals(2, R(9, 10) // R(2, 5))
|
|
self.assertTypedEquals(10**23, R(10**23, 1) // R(1))
|
|
self.assertEquals(R(2, 3), R(-7, 3) % R(3, 2))
|
|
self.assertEquals(R(8, 27), R(2, 3) ** R(3))
|
|
self.assertEquals(R(27, 8), R(2, 3) ** R(-3))
|
|
self.assertTypedEquals(2.0, R(4) ** R(1, 2))
|
|
z = pow(R(-1), R(1, 2))
|
|
self.assertAlmostEquals(z.real, 0)
|
|
self.assertEquals(z.imag, 1)
|
|
|
|
def testMixedArithmetic(self):
|
|
self.assertTypedEquals(R(11, 10), R(1, 10) + 1)
|
|
self.assertTypedEquals(1.1, R(1, 10) + 1.0)
|
|
self.assertTypedEquals(1.1 + 0j, R(1, 10) + (1.0 + 0j))
|
|
self.assertTypedEquals(R(11, 10), 1 + R(1, 10))
|
|
self.assertTypedEquals(1.1, 1.0 + R(1, 10))
|
|
self.assertTypedEquals(1.1 + 0j, (1.0 + 0j) + R(1, 10))
|
|
|
|
self.assertTypedEquals(R(-9, 10), R(1, 10) - 1)
|
|
self.assertTypedEquals(-0.9, R(1, 10) - 1.0)
|
|
self.assertTypedEquals(-0.9 + 0j, R(1, 10) - (1.0 + 0j))
|
|
self.assertTypedEquals(R(9, 10), 1 - R(1, 10))
|
|
self.assertTypedEquals(0.9, 1.0 - R(1, 10))
|
|
self.assertTypedEquals(0.9 + 0j, (1.0 + 0j) - R(1, 10))
|
|
|
|
self.assertTypedEquals(R(1, 10), R(1, 10) * 1)
|
|
self.assertTypedEquals(0.1, R(1, 10) * 1.0)
|
|
self.assertTypedEquals(0.1 + 0j, R(1, 10) * (1.0 + 0j))
|
|
self.assertTypedEquals(R(1, 10), 1 * R(1, 10))
|
|
self.assertTypedEquals(0.1, 1.0 * R(1, 10))
|
|
self.assertTypedEquals(0.1 + 0j, (1.0 + 0j) * R(1, 10))
|
|
|
|
self.assertTypedEquals(R(1, 10), R(1, 10) / 1)
|
|
self.assertTypedEquals(0.1, R(1, 10) / 1.0)
|
|
self.assertTypedEquals(0.1 + 0j, R(1, 10) / (1.0 + 0j))
|
|
self.assertTypedEquals(R(10, 1), 1 / R(1, 10))
|
|
self.assertTypedEquals(10.0, 1.0 / R(1, 10))
|
|
self.assertTypedEquals(10.0 + 0j, (1.0 + 0j) / R(1, 10))
|
|
|
|
self.assertTypedEquals(0, R(1, 10) // 1)
|
|
self.assertTypedEquals(0, R(1, 10) // 1.0)
|
|
self.assertTypedEquals(10, 1 // R(1, 10))
|
|
self.assertTypedEquals(10**23, 10**22 // R(1, 10))
|
|
self.assertTypedEquals(10, 1.0 // R(1, 10))
|
|
|
|
self.assertTypedEquals(R(1, 10), R(1, 10) % 1)
|
|
self.assertTypedEquals(0.1, R(1, 10) % 1.0)
|
|
self.assertTypedEquals(R(0, 1), 1 % R(1, 10))
|
|
self.assertTypedEquals(0.0, 1.0 % R(1, 10))
|
|
|
|
# No need for divmod since we don't override it.
|
|
|
|
# ** has more interesting conversion rules.
|
|
self.assertTypedEquals(R(100, 1), R(1, 10) ** -2)
|
|
self.assertTypedEquals(R(100, 1), R(10, 1) ** 2)
|
|
self.assertTypedEquals(0.1, R(1, 10) ** 1.0)
|
|
self.assertTypedEquals(0.1 + 0j, R(1, 10) ** (1.0 + 0j))
|
|
self.assertTypedEquals(4 , 2 ** R(2, 1))
|
|
z = pow(-1, R(1, 2))
|
|
self.assertAlmostEquals(0, z.real)
|
|
self.assertEquals(1, z.imag)
|
|
self.assertTypedEquals(R(1, 4) , 2 ** R(-2, 1))
|
|
self.assertTypedEquals(2.0 , 4 ** R(1, 2))
|
|
self.assertTypedEquals(0.25, 2.0 ** R(-2, 1))
|
|
self.assertTypedEquals(1.0 + 0j, (1.0 + 0j) ** R(1, 10))
|
|
|
|
def testMixingWithDecimal(self):
|
|
# Decimal refuses mixed comparisons.
|
|
self.assertRaisesMessage(
|
|
TypeError,
|
|
"unsupported operand type(s) for +: 'Rational' and 'Decimal'",
|
|
operator.add, R(3,11), Decimal('3.1415926'))
|
|
self.assertNotEquals(R(5, 2), Decimal('2.5'))
|
|
|
|
def testComparisons(self):
|
|
self.assertTrue(R(1, 2) < R(2, 3))
|
|
self.assertFalse(R(1, 2) < R(1, 2))
|
|
self.assertTrue(R(1, 2) <= R(2, 3))
|
|
self.assertTrue(R(1, 2) <= R(1, 2))
|
|
self.assertFalse(R(2, 3) <= R(1, 2))
|
|
self.assertTrue(R(1, 2) == R(1, 2))
|
|
self.assertFalse(R(1, 2) == R(1, 3))
|
|
self.assertFalse(R(1, 2) != R(1, 2))
|
|
self.assertTrue(R(1, 2) != R(1, 3))
|
|
|
|
def testMixedLess(self):
|
|
self.assertTrue(2 < R(5, 2))
|
|
self.assertFalse(2 < R(4, 2))
|
|
self.assertTrue(R(5, 2) < 3)
|
|
self.assertFalse(R(4, 2) < 2)
|
|
|
|
self.assertTrue(R(1, 2) < 0.6)
|
|
self.assertFalse(R(1, 2) < 0.4)
|
|
self.assertTrue(0.4 < R(1, 2))
|
|
self.assertFalse(0.5 < R(1, 2))
|
|
|
|
def testMixedLessEqual(self):
|
|
self.assertTrue(0.5 <= R(1, 2))
|
|
self.assertFalse(0.6 <= R(1, 2))
|
|
self.assertTrue(R(1, 2) <= 0.5)
|
|
self.assertFalse(R(1, 2) <= 0.4)
|
|
self.assertTrue(2 <= R(4, 2))
|
|
self.assertFalse(2 <= R(3, 2))
|
|
self.assertTrue(R(4, 2) <= 2)
|
|
self.assertFalse(R(5, 2) <= 2)
|
|
|
|
def testBigFloatComparisons(self):
|
|
# Because 10**23 can't be represented exactly as a float:
|
|
self.assertFalse(R(10**23) == float(10**23))
|
|
# The first test demonstrates why these are important.
|
|
self.assertFalse(1e23 < float(R(math.trunc(1e23) + 1)))
|
|
self.assertTrue(1e23 < R(math.trunc(1e23) + 1))
|
|
self.assertFalse(1e23 <= R(math.trunc(1e23) - 1))
|
|
self.assertTrue(1e23 > R(math.trunc(1e23) - 1))
|
|
self.assertFalse(1e23 >= R(math.trunc(1e23) + 1))
|
|
|
|
def testBigComplexComparisons(self):
|
|
self.assertFalse(R(10**23) == complex(10**23))
|
|
self.assertTrue(R(10**23) > complex(10**23))
|
|
self.assertFalse(R(10**23) <= complex(10**23))
|
|
|
|
def testMixedEqual(self):
|
|
self.assertTrue(0.5 == R(1, 2))
|
|
self.assertFalse(0.6 == R(1, 2))
|
|
self.assertTrue(R(1, 2) == 0.5)
|
|
self.assertFalse(R(1, 2) == 0.4)
|
|
self.assertTrue(2 == R(4, 2))
|
|
self.assertFalse(2 == R(3, 2))
|
|
self.assertTrue(R(4, 2) == 2)
|
|
self.assertFalse(R(5, 2) == 2)
|
|
|
|
def testStringification(self):
|
|
self.assertEquals("Rational(7,3)", repr(R(7, 3)))
|
|
self.assertEquals("7/3", str(R(7, 3)))
|
|
self.assertEquals("7", str(R(7, 1)))
|
|
|
|
def testHash(self):
|
|
self.assertEquals(hash(2.5), hash(R(5, 2)))
|
|
self.assertEquals(hash(10**50), hash(R(10**50)))
|
|
self.assertNotEquals(hash(float(10**23)), hash(R(10**23)))
|
|
|
|
def testApproximatePi(self):
|
|
# Algorithm borrowed from
|
|
# http://docs.python.org/lib/decimal-recipes.html
|
|
three = R(3)
|
|
lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
|
|
while abs(s - lasts) > R(1, 10**9):
|
|
lasts = s
|
|
n, na = n+na, na+8
|
|
d, da = d+da, da+32
|
|
t = (t * n) / d
|
|
s += t
|
|
self.assertAlmostEquals(math.pi, s)
|
|
|
|
def testApproximateCos1(self):
|
|
# Algorithm borrowed from
|
|
# http://docs.python.org/lib/decimal-recipes.html
|
|
x = R(1)
|
|
i, lasts, s, fact, num, sign = 0, 0, R(1), 1, 1, 1
|
|
while abs(s - lasts) > R(1, 10**9):
|
|
lasts = s
|
|
i += 2
|
|
fact *= i * (i-1)
|
|
num *= x * x
|
|
sign *= -1
|
|
s += num / fact * sign
|
|
self.assertAlmostEquals(math.cos(1), s)
|
|
|
|
def test_copy_deepcopy_pickle(self):
|
|
r = R(13, 7)
|
|
self.assertEqual(r, loads(dumps(r)))
|
|
self.assertEqual(id(r), id(copy(r)))
|
|
self.assertEqual(id(r), id(deepcopy(r)))
|
|
|
|
def test_main():
|
|
run_unittest(RationalTest, GcdTest)
|
|
|
|
if __name__ == '__main__':
|
|
test_main()
|