1 """Tests for Lib/fractions.py."""
3 from decimal
import Decimal
4 from test
.test_support
import run_unittest
10 from copy
import copy
, deepcopy
11 from cPickle
import dumps
, loads
12 F
= fractions
.Fraction
15 class DummyFloat(object):
16 """Dummy float class for testing comparisons with Fractions"""
18 def __init__(self
, value
):
19 if not isinstance(value
, float):
20 raise TypeError("DummyFloat can only be initialized from float")
23 def _richcmp(self
, other
, op
):
24 if isinstance(other
, numbers
.Rational
):
25 return op(F
.from_float(self
.value
), other
)
26 elif isinstance(other
, DummyFloat
):
27 return op(self
.value
, other
.value
)
31 def __eq__(self
, other
): return self
._richcmp
(other
, operator
.eq
)
32 def __le__(self
, other
): return self
._richcmp
(other
, operator
.le
)
33 def __lt__(self
, other
): return self
._richcmp
(other
, operator
.lt
)
34 def __ge__(self
, other
): return self
._richcmp
(other
, operator
.ge
)
35 def __gt__(self
, other
): return self
._richcmp
(other
, operator
.gt
)
37 # shouldn't be calling __float__ at all when doing comparisons
39 assert False, "__float__ should not be invoked for comparisons"
41 # same goes for subtraction
42 def __sub__(self
, other
):
43 assert False, "__sub__ should not be invoked for comparisons"
47 class DummyRational(object):
48 """Test comparison of Fraction with a naive rational implementation."""
50 def __init__(self
, num
, den
):
55 def __eq__(self
, other
):
56 if isinstance(other
, fractions
.Fraction
):
57 return (self
.num
== other
._numerator
and
58 self
.den
== other
._denominator
)
62 def __lt__(self
, other
):
63 return(self
.num
* other
._denominator
< self
.den
* other
._numerator
)
65 def __gt__(self
, other
):
66 return(self
.num
* other
._denominator
> self
.den
* other
._numerator
)
68 def __le__(self
, other
):
69 return(self
.num
* other
._denominator
<= self
.den
* other
._numerator
)
71 def __ge__(self
, other
):
72 return(self
.num
* other
._denominator
>= self
.den
* other
._numerator
)
74 # this class is for testing comparisons; conversion to float
75 # should never be used for a comparison, since it loses accuracy
77 assert False, "__float__ should not be invoked"
79 class GcdTest(unittest
.TestCase
):
82 self
.assertEquals(0, gcd(0, 0))
83 self
.assertEquals(1, gcd(1, 0))
84 self
.assertEquals(-1, gcd(-1, 0))
85 self
.assertEquals(1, gcd(0, 1))
86 self
.assertEquals(-1, gcd(0, -1))
87 self
.assertEquals(1, gcd(7, 1))
88 self
.assertEquals(-1, gcd(7, -1))
89 self
.assertEquals(1, gcd(-23, 15))
90 self
.assertEquals(12, gcd(120, 84))
91 self
.assertEquals(-12, gcd(84, -120))
95 return (r
.numerator
, r
.denominator
)
98 class FractionTest(unittest
.TestCase
):
100 def assertTypedEquals(self
, expected
, actual
):
101 """Asserts that both the types and values are the same."""
102 self
.assertEquals(type(expected
), type(actual
))
103 self
.assertEquals(expected
, actual
)
105 def assertRaisesMessage(self
, exc_type
, message
,
106 callable, *args
, **kwargs
):
107 """Asserts that callable(*args, **kwargs) raises exc_type(message)."""
109 callable(*args
, **kwargs
)
111 self
.assertEquals(message
, str(e
))
113 self
.fail("%s not raised" % exc_type
.__name
__)
116 self
.assertEquals((0, 1), _components(F()))
117 self
.assertEquals((7, 1), _components(F(7)))
118 self
.assertEquals((7, 3), _components(F(F(7, 3))))
120 self
.assertEquals((-1, 1), _components(F(-1, 1)))
121 self
.assertEquals((-1, 1), _components(F(1, -1)))
122 self
.assertEquals((1, 1), _components(F(-2, -2)))
123 self
.assertEquals((1, 2), _components(F(5, 10)))
124 self
.assertEquals((7, 15), _components(F(7, 15)))
125 self
.assertEquals((10**23, 1), _components(F(10**23)))
127 self
.assertEquals((3, 77), _components(F(F(3, 7), 11)))
128 self
.assertEquals((-9, 5), _components(F(2, F(-10, 9))))
129 self
.assertEquals((2486, 2485), _components(F(F(22, 7), F(355, 113))))
131 self
.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
133 self
.assertRaises(TypeError, F
, 1.5)
134 self
.assertRaises(TypeError, F
, 1.5 + 3j
)
136 self
.assertRaises(TypeError, F
, "3/2", 3)
137 self
.assertRaises(TypeError, F
, 3, 0j
)
138 self
.assertRaises(TypeError, F
, 3, 1j
)
141 def testFromString(self
):
142 self
.assertEquals((5, 1), _components(F("5")))
143 self
.assertEquals((3, 2), _components(F("3/2")))
144 self
.assertEquals((3, 2), _components(F(" \n +3/2")))
145 self
.assertEquals((-3, 2), _components(F("-3/2 ")))
146 self
.assertEquals((13, 2), _components(F(" 013/02 \n ")))
147 self
.assertEquals((13, 2), _components(F(u
" 013/02 \n ")))
149 self
.assertEquals((16, 5), _components(F(" 3.2 ")))
150 self
.assertEquals((-16, 5), _components(F(u
" -3.2 ")))
151 self
.assertEquals((-3, 1), _components(F(u
" -3. ")))
152 self
.assertEquals((3, 5), _components(F(u
" .6 ")))
153 self
.assertEquals((1, 3125), _components(F("32.e-5")))
154 self
.assertEquals((1000000, 1), _components(F("1E+06")))
155 self
.assertEquals((-12300, 1), _components(F("-1.23e4")))
156 self
.assertEquals((0, 1), _components(F(" .0e+0\t")))
157 self
.assertEquals((0, 1), _components(F("-0.000e0")))
160 self
.assertRaisesMessage(
161 ZeroDivisionError, "Fraction(3, 0)",
163 self
.assertRaisesMessage(
164 ValueError, "Invalid literal for Fraction: '3/'",
166 self
.assertRaisesMessage(
167 ValueError, "Invalid literal for Fraction: '/2'",
169 self
.assertRaisesMessage(
170 ValueError, "Invalid literal for Fraction: '3 /2'",
172 self
.assertRaisesMessage(
173 # Denominators don't need a sign.
174 ValueError, "Invalid literal for Fraction: '3/+2'",
176 self
.assertRaisesMessage(
177 # Imitate float's parsing.
178 ValueError, "Invalid literal for Fraction: '+ 3/2'",
180 self
.assertRaisesMessage(
181 # Avoid treating '.' as a regex special character.
182 ValueError, "Invalid literal for Fraction: '3a2'",
184 self
.assertRaisesMessage(
185 # Don't accept combinations of decimals and fractions.
186 ValueError, "Invalid literal for Fraction: '3/7.2'",
188 self
.assertRaisesMessage(
189 # Don't accept combinations of decimals and fractions.
190 ValueError, "Invalid literal for Fraction: '3.2/7'",
192 self
.assertRaisesMessage(
193 # Allow 3. and .3, but not .
194 ValueError, "Invalid literal for Fraction: '.'",
197 def testImmutable(self
):
200 self
.assertEquals((7, 3), _components(r
))
202 self
.assertRaises(AttributeError, setattr, r
, 'numerator', 12)
203 self
.assertRaises(AttributeError, setattr, r
, 'denominator', 6)
204 self
.assertEquals((7, 3), _components(r
))
206 # But if you _really_ need to:
209 self
.assertEquals((4, 2), _components(r
))
210 # Which breaks some important operations:
211 self
.assertNotEquals(F(4, 2), r
)
213 def testFromFloat(self
):
214 self
.assertRaises(TypeError, F
.from_float
, 3+4j
)
215 self
.assertEquals((10, 1), _components(F
.from_float(10)))
216 bigint
= 1234567890123456789
217 self
.assertEquals((bigint
, 1), _components(F
.from_float(bigint
)))
218 self
.assertEquals((0, 1), _components(F
.from_float(-0.0)))
219 self
.assertEquals((10, 1), _components(F
.from_float(10.0)))
220 self
.assertEquals((-5, 2), _components(F
.from_float(-2.5)))
221 self
.assertEquals((99999999999999991611392, 1),
222 _components(F
.from_float(1e23
)))
223 self
.assertEquals(float(10**23), float(F
.from_float(1e23
)))
224 self
.assertEquals((3602879701896397, 1125899906842624),
225 _components(F
.from_float(3.2)))
226 self
.assertEquals(3.2, float(F
.from_float(3.2)))
230 self
.assertRaisesMessage(
231 TypeError, "Cannot convert inf to Fraction.",
233 self
.assertRaisesMessage(
234 TypeError, "Cannot convert -inf to Fraction.",
236 self
.assertRaisesMessage(
237 TypeError, "Cannot convert nan to Fraction.",
240 def testFromDecimal(self
):
241 self
.assertRaises(TypeError, F
.from_decimal
, 3+4j
)
242 self
.assertEquals(F(10, 1), F
.from_decimal(10))
243 self
.assertEquals(F(0), F
.from_decimal(Decimal("-0")))
244 self
.assertEquals(F(5, 10), F
.from_decimal(Decimal("0.5")))
245 self
.assertEquals(F(5, 1000), F
.from_decimal(Decimal("5e-3")))
246 self
.assertEquals(F(5000), F
.from_decimal(Decimal("5e3")))
247 self
.assertEquals(1 - F(1, 10**30),
248 F
.from_decimal(Decimal("0." + "9" * 30)))
250 self
.assertRaisesMessage(
251 TypeError, "Cannot convert Infinity to Fraction.",
252 F
.from_decimal
, Decimal("inf"))
253 self
.assertRaisesMessage(
254 TypeError, "Cannot convert -Infinity to Fraction.",
255 F
.from_decimal
, Decimal("-inf"))
256 self
.assertRaisesMessage(
257 TypeError, "Cannot convert NaN to Fraction.",
258 F
.from_decimal
, Decimal("nan"))
259 self
.assertRaisesMessage(
260 TypeError, "Cannot convert sNaN to Fraction.",
261 F
.from_decimal
, Decimal("snan"))
263 def testLimitDenominator(self
):
264 rpi
= F('3.1415926535897932')
265 self
.assertEqual(rpi
.limit_denominator(10000), F(355, 113))
266 self
.assertEqual(-rpi
.limit_denominator(10000), F(-355, 113))
267 self
.assertEqual(rpi
.limit_denominator(113), F(355, 113))
268 self
.assertEqual(rpi
.limit_denominator(112), F(333, 106))
269 self
.assertEqual(F(201, 200).limit_denominator(100), F(1))
270 self
.assertEqual(F(201, 200).limit_denominator(101), F(102, 101))
271 self
.assertEqual(F(0).limit_denominator(10000), F(0))
273 def testConversions(self
):
274 self
.assertTypedEquals(-1, math
.trunc(F(-11, 10)))
275 self
.assertTypedEquals(-1, int(F(-11, 10)))
277 self
.assertEquals(False, bool(F(0, 1)))
278 self
.assertEquals(True, bool(F(3, 2)))
279 self
.assertTypedEquals(0.1, float(F(1, 10)))
281 # Check that __float__ isn't implemented by converting the
282 # numerator and denominator to float before dividing.
283 self
.assertRaises(OverflowError, float, long('2'*400+'7'))
284 self
.assertAlmostEquals(2.0/3,
285 float(F(long('2'*400+'7'), long('3'*400+'1'))))
287 self
.assertTypedEquals(0.1+0j
, complex(F(1,10)))
290 def testArithmetic(self
):
291 self
.assertEquals(F(1, 2), F(1, 10) + F(2, 5))
292 self
.assertEquals(F(-3, 10), F(1, 10) - F(2, 5))
293 self
.assertEquals(F(1, 25), F(1, 10) * F(2, 5))
294 self
.assertEquals(F(1, 4), F(1, 10) / F(2, 5))
295 self
.assertTypedEquals(2, F(9, 10) // F(2, 5))
296 self
.assertTypedEquals(10**23, F(10**23, 1) // F(1))
297 self
.assertEquals(F(2, 3), F(-7, 3) % F(3, 2))
298 self
.assertEquals(F(8, 27), F(2, 3) ** F(3))
299 self
.assertEquals(F(27, 8), F(2, 3) ** F(-3))
300 self
.assertTypedEquals(2.0, F(4) ** F(1, 2))
301 # Will return 1j in 3.0:
302 self
.assertRaises(ValueError, pow, F(-1), F(1, 2))
304 def testMixedArithmetic(self
):
305 self
.assertTypedEquals(F(11, 10), F(1, 10) + 1)
306 self
.assertTypedEquals(1.1, F(1, 10) + 1.0)
307 self
.assertTypedEquals(1.1 + 0j
, F(1, 10) + (1.0 + 0j
))
308 self
.assertTypedEquals(F(11, 10), 1 + F(1, 10))
309 self
.assertTypedEquals(1.1, 1.0 + F(1, 10))
310 self
.assertTypedEquals(1.1 + 0j
, (1.0 + 0j
) + F(1, 10))
312 self
.assertTypedEquals(F(-9, 10), F(1, 10) - 1)
313 self
.assertTypedEquals(-0.9, F(1, 10) - 1.0)
314 self
.assertTypedEquals(-0.9 + 0j
, F(1, 10) - (1.0 + 0j
))
315 self
.assertTypedEquals(F(9, 10), 1 - F(1, 10))
316 self
.assertTypedEquals(0.9, 1.0 - F(1, 10))
317 self
.assertTypedEquals(0.9 + 0j
, (1.0 + 0j
) - F(1, 10))
319 self
.assertTypedEquals(F(1, 10), F(1, 10) * 1)
320 self
.assertTypedEquals(0.1, F(1, 10) * 1.0)
321 self
.assertTypedEquals(0.1 + 0j
, F(1, 10) * (1.0 + 0j
))
322 self
.assertTypedEquals(F(1, 10), 1 * F(1, 10))
323 self
.assertTypedEquals(0.1, 1.0 * F(1, 10))
324 self
.assertTypedEquals(0.1 + 0j
, (1.0 + 0j
) * F(1, 10))
326 self
.assertTypedEquals(F(1, 10), F(1, 10) / 1)
327 self
.assertTypedEquals(0.1, F(1, 10) / 1.0)
328 self
.assertTypedEquals(0.1 + 0j
, F(1, 10) / (1.0 + 0j
))
329 self
.assertTypedEquals(F(10, 1), 1 / F(1, 10))
330 self
.assertTypedEquals(10.0, 1.0 / F(1, 10))
331 self
.assertTypedEquals(10.0 + 0j
, (1.0 + 0j
) / F(1, 10))
333 self
.assertTypedEquals(0, F(1, 10) // 1)
334 self
.assertTypedEquals(0.0, F(1, 10) // 1.0)
335 self
.assertTypedEquals(10, 1 // F(1, 10))
336 self
.assertTypedEquals(10**23, 10**22 // F(1, 10))
337 self
.assertTypedEquals(10.0, 1.0 // F(1, 10))
339 self
.assertTypedEquals(F(1, 10), F(1, 10) % 1)
340 self
.assertTypedEquals(0.1, F(1, 10) % 1.0)
341 self
.assertTypedEquals(F(0, 1), 1 % F(1, 10))
342 self
.assertTypedEquals(0.0, 1.0 % F(1, 10))
344 # No need for divmod since we don't override it.
346 # ** has more interesting conversion rules.
347 self
.assertTypedEquals(F(100, 1), F(1, 10) ** -2)
348 self
.assertTypedEquals(F(100, 1), F(10, 1) ** 2)
349 self
.assertTypedEquals(0.1, F(1, 10) ** 1.0)
350 self
.assertTypedEquals(0.1 + 0j
, F(1, 10) ** (1.0 + 0j
))
351 self
.assertTypedEquals(4 , 2 ** F(2, 1))
352 # Will return 1j in 3.0:
353 self
.assertRaises(ValueError, pow, (-1), F(1, 2))
354 self
.assertTypedEquals(F(1, 4) , 2 ** F(-2, 1))
355 self
.assertTypedEquals(2.0 , 4 ** F(1, 2))
356 self
.assertTypedEquals(0.25, 2.0 ** F(-2, 1))
357 self
.assertTypedEquals(1.0 + 0j
, (1.0 + 0j
) ** F(1, 10))
359 def testMixingWithDecimal(self
):
360 # Decimal refuses mixed comparisons.
361 self
.assertRaisesMessage(
363 "unsupported operand type(s) for +: 'Fraction' and 'Decimal'",
364 operator
.add
, F(3,11), Decimal('3.1415926'))
365 self
.assertNotEquals(F(5, 2), Decimal('2.5'))
367 def testComparisons(self
):
368 self
.assertTrue(F(1, 2) < F(2, 3))
369 self
.assertFalse(F(1, 2) < F(1, 2))
370 self
.assertTrue(F(1, 2) <= F(2, 3))
371 self
.assertTrue(F(1, 2) <= F(1, 2))
372 self
.assertFalse(F(2, 3) <= F(1, 2))
373 self
.assertTrue(F(1, 2) == F(1, 2))
374 self
.assertFalse(F(1, 2) == F(1, 3))
375 self
.assertFalse(F(1, 2) != F(1, 2))
376 self
.assertTrue(F(1, 2) != F(1, 3))
378 def testComparisonsDummyRational(self
):
379 self
.assertTrue(F(1, 2) == DummyRational(1, 2))
380 self
.assertTrue(DummyRational(1, 2) == F(1, 2))
381 self
.assertFalse(F(1, 2) == DummyRational(3, 4))
382 self
.assertFalse(DummyRational(3, 4) == F(1, 2))
384 self
.assertTrue(F(1, 2) < DummyRational(3, 4))
385 self
.assertFalse(F(1, 2) < DummyRational(1, 2))
386 self
.assertFalse(F(1, 2) < DummyRational(1, 7))
387 self
.assertFalse(F(1, 2) > DummyRational(3, 4))
388 self
.assertFalse(F(1, 2) > DummyRational(1, 2))
389 self
.assertTrue(F(1, 2) > DummyRational(1, 7))
390 self
.assertTrue(F(1, 2) <= DummyRational(3, 4))
391 self
.assertTrue(F(1, 2) <= DummyRational(1, 2))
392 self
.assertFalse(F(1, 2) <= DummyRational(1, 7))
393 self
.assertFalse(F(1, 2) >= DummyRational(3, 4))
394 self
.assertTrue(F(1, 2) >= DummyRational(1, 2))
395 self
.assertTrue(F(1, 2) >= DummyRational(1, 7))
397 self
.assertTrue(DummyRational(1, 2) < F(3, 4))
398 self
.assertFalse(DummyRational(1, 2) < F(1, 2))
399 self
.assertFalse(DummyRational(1, 2) < F(1, 7))
400 self
.assertFalse(DummyRational(1, 2) > F(3, 4))
401 self
.assertFalse(DummyRational(1, 2) > F(1, 2))
402 self
.assertTrue(DummyRational(1, 2) > F(1, 7))
403 self
.assertTrue(DummyRational(1, 2) <= F(3, 4))
404 self
.assertTrue(DummyRational(1, 2) <= F(1, 2))
405 self
.assertFalse(DummyRational(1, 2) <= F(1, 7))
406 self
.assertFalse(DummyRational(1, 2) >= F(3, 4))
407 self
.assertTrue(DummyRational(1, 2) >= F(1, 2))
408 self
.assertTrue(DummyRational(1, 2) >= F(1, 7))
410 def testComparisonsDummyFloat(self
):
411 x
= DummyFloat(1./3.)
413 self
.assertTrue(x
!= y
)
414 self
.assertTrue(x
< y
or x
> y
)
415 self
.assertFalse(x
== y
)
416 self
.assertFalse(x
<= y
and x
>= y
)
417 self
.assertTrue(y
!= x
)
418 self
.assertTrue(y
< x
or y
> x
)
419 self
.assertFalse(y
== x
)
420 self
.assertFalse(y
<= x
and y
>= x
)
422 def testMixedLess(self
):
423 self
.assertTrue(2 < F(5, 2))
424 self
.assertFalse(2 < F(4, 2))
425 self
.assertTrue(F(5, 2) < 3)
426 self
.assertFalse(F(4, 2) < 2)
428 self
.assertTrue(F(1, 2) < 0.6)
429 self
.assertFalse(F(1, 2) < 0.4)
430 self
.assertTrue(0.4 < F(1, 2))
431 self
.assertFalse(0.5 < F(1, 2))
433 self
.assertFalse(float('inf') < F(1, 2))
434 self
.assertTrue(float('-inf') < F(0, 10))
435 self
.assertFalse(float('nan') < F(-3, 7))
436 self
.assertTrue(F(1, 2) < float('inf'))
437 self
.assertFalse(F(17, 12) < float('-inf'))
438 self
.assertFalse(F(144, -89) < float('nan'))
440 def testMixedLessEqual(self
):
441 self
.assertTrue(0.5 <= F(1, 2))
442 self
.assertFalse(0.6 <= F(1, 2))
443 self
.assertTrue(F(1, 2) <= 0.5)
444 self
.assertFalse(F(1, 2) <= 0.4)
445 self
.assertTrue(2 <= F(4, 2))
446 self
.assertFalse(2 <= F(3, 2))
447 self
.assertTrue(F(4, 2) <= 2)
448 self
.assertFalse(F(5, 2) <= 2)
450 self
.assertFalse(float('inf') <= F(1, 2))
451 self
.assertTrue(float('-inf') <= F(0, 10))
452 self
.assertFalse(float('nan') <= F(-3, 7))
453 self
.assertTrue(F(1, 2) <= float('inf'))
454 self
.assertFalse(F(17, 12) <= float('-inf'))
455 self
.assertFalse(F(144, -89) <= float('nan'))
457 def testBigFloatComparisons(self
):
458 # Because 10**23 can't be represented exactly as a float:
459 self
.assertFalse(F(10**23) == float(10**23))
460 # The first test demonstrates why these are important.
461 self
.assertFalse(1e23
< float(F(math
.trunc(1e23
) + 1)))
462 self
.assertTrue(1e23
< F(math
.trunc(1e23
) + 1))
463 self
.assertFalse(1e23
<= F(math
.trunc(1e23
) - 1))
464 self
.assertTrue(1e23
> F(math
.trunc(1e23
) - 1))
465 self
.assertFalse(1e23
>= F(math
.trunc(1e23
) + 1))
467 def testBigComplexComparisons(self
):
468 self
.assertFalse(F(10**23) == complex(10**23))
469 self
.assertTrue(F(10**23) > complex(10**23))
470 self
.assertFalse(F(10**23) <= complex(10**23))
472 def testMixedEqual(self
):
473 self
.assertTrue(0.5 == F(1, 2))
474 self
.assertFalse(0.6 == F(1, 2))
475 self
.assertTrue(F(1, 2) == 0.5)
476 self
.assertFalse(F(1, 2) == 0.4)
477 self
.assertTrue(2 == F(4, 2))
478 self
.assertFalse(2 == F(3, 2))
479 self
.assertTrue(F(4, 2) == 2)
480 self
.assertFalse(F(5, 2) == 2)
481 self
.assertFalse(F(5, 2) == float('nan'))
482 self
.assertFalse(float('nan') == F(3, 7))
483 self
.assertFalse(F(5, 2) == float('inf'))
484 self
.assertFalse(float('-inf') == F(2, 5))
486 def testStringification(self
):
487 self
.assertEquals("Fraction(7, 3)", repr(F(7, 3)))
488 self
.assertEquals("Fraction(6283185307, 2000000000)",
489 repr(F('3.1415926535')))
490 self
.assertEquals("Fraction(-1, 100000000000000000000)",
492 self
.assertEquals("7/3", str(F(7, 3)))
493 self
.assertEquals("7", str(F(7, 1)))
496 self
.assertEquals(hash(2.5), hash(F(5, 2)))
497 self
.assertEquals(hash(10**50), hash(F(10**50)))
498 self
.assertNotEquals(hash(float(10**23)), hash(F(10**23)))
500 def testApproximatePi(self
):
501 # Algorithm borrowed from
502 # http://docs.python.org/lib/decimal-recipes.html
504 lasts
, t
, s
, n
, na
, d
, da
= 0, three
, 3, 1, 0, 0, 24
505 while abs(s
- lasts
) > F(1, 10**9):
511 self
.assertAlmostEquals(math
.pi
, s
)
513 def testApproximateCos1(self
):
514 # Algorithm borrowed from
515 # http://docs.python.org/lib/decimal-recipes.html
517 i
, lasts
, s
, fact
, num
, sign
= 0, 0, F(1), 1, 1, 1
518 while abs(s
- lasts
) > F(1, 10**9):
524 s
+= num
/ fact
* sign
525 self
.assertAlmostEquals(math
.cos(1), s
)
527 def test_copy_deepcopy_pickle(self
):
529 self
.assertEqual(r
, loads(dumps(r
)))
530 self
.assertEqual(id(r
), id(copy(r
)))
531 self
.assertEqual(id(r
), id(deepcopy(r
)))
533 def test_slots(self
):
536 self
.assertRaises(AttributeError, setattr, r
, 'a', 10)
539 run_unittest(FractionTest
, GcdTest
)
541 if __name__
== '__main__':