Debian Codegraph @

Lib/test/test_fractions.py

raw
1 """Tests for Lib/fractions.py."""
2
3 from decimal import Decimal
4 from test.support import requires_IEEE_754, adjust_int_max_str_digits
5 import math
6 import numbers
7 import operator
8 import fractions
9 import functools
10 import os
11 import sys
12 import typing
13 import unittest
14 from copy import copy, deepcopy
15 import pickle
16 from pickle import dumps, loads
17 F = fractions.Fraction
18
19 #locate file with float format test values
20 test_dir = os.path.dirname(__file__) or os.curdir
21 format_testfile = os.path.join(test_dir, 'mathdata', 'formatfloat_testcases.txt')
22
23 class DummyFloat(object):
24 """Dummy float class for testing comparisons with Fractions"""
25
26 def __init__(self, value):
27 if not isinstance(value, float):
28 raise TypeError("DummyFloat can only be initialized from float")
29 self.value = value
30
31 def _richcmp(self, other, op):
32 if isinstance(other, numbers.Rational):
33 return op(F.from_float(self.value), other)
34 elif isinstance(other, DummyFloat):
35 return op(self.value, other.value)
36 else:
37 return NotImplemented
38
39 def __eq__(self, other): return self._richcmp(other, operator.eq)
40 def __le__(self, other): return self._richcmp(other, operator.le)
41 def __lt__(self, other): return self._richcmp(other, operator.lt)
42 def __ge__(self, other): return self._richcmp(other, operator.ge)
43 def __gt__(self, other): return self._richcmp(other, operator.gt)
44
45 # shouldn't be calling __float__ at all when doing comparisons
46 def __float__(self):
47 assert False, "__float__ should not be invoked for comparisons"
48
49 # same goes for subtraction
50 def __sub__(self, other):
51 assert False, "__sub__ should not be invoked for comparisons"
52 __rsub__ = __sub__
53
54
55 class DummyRational(object):
56 """Test comparison of Fraction with a naive rational implementation."""
57
58 def __init__(self, num, den):
59 g = math.gcd(num, den)
60 self.num = num // g
61 self.den = den // g
62
63 def __eq__(self, other):
64 if isinstance(other, fractions.Fraction):
65 return (self.num == other._numerator and
66 self.den == other._denominator)
67 else:
68 return NotImplemented
69
70 def __lt__(self, other):
71 return(self.num * other._denominator < self.den * other._numerator)
72
73 def __gt__(self, other):
74 return(self.num * other._denominator > self.den * other._numerator)
75
76 def __le__(self, other):
77 return(self.num * other._denominator <= self.den * other._numerator)
78
79 def __ge__(self, other):
80 return(self.num * other._denominator >= self.den * other._numerator)
81
82 # this class is for testing comparisons; conversion to float
83 # should never be used for a comparison, since it loses accuracy
84 def __float__(self):
85 assert False, "__float__ should not be invoked"
86
87 class DummyFraction(fractions.Fraction):
88 """Dummy Fraction subclass for copy and deepcopy testing."""
89
90
91 def _components(r):
92 return (r.numerator, r.denominator)
93
94 def typed_approx_eq(a, b):
95 return type(a) == type(b) and (a == b or math.isclose(a, b))
96
97 class Symbolic:
98 """Simple non-numeric class for testing mixed arithmetic.
99 It is not Integral, Rational, Real or Complex, and cannot be converted
100 to int, float or complex. but it supports some arithmetic operations.
101 """
102 def __init__(self, value):
103 self.value = value
104 def __mul__(self, other):
105 if isinstance(other, F):
106 return NotImplemented
107 return self.__class__(f'{self} * {other}')
108 def __rmul__(self, other):
109 return self.__class__(f'{other} * {self}')
110 def __truediv__(self, other):
111 if isinstance(other, F):
112 return NotImplemented
113 return self.__class__(f'{self} / {other}')
114 def __rtruediv__(self, other):
115 return self.__class__(f'{other} / {self}')
116 def __mod__(self, other):
117 if isinstance(other, F):
118 return NotImplemented
119 return self.__class__(f'{self} % {other}')
120 def __rmod__(self, other):
121 return self.__class__(f'{other} % {self}')
122 def __pow__(self, other):
123 if isinstance(other, F):
124 return NotImplemented
125 return self.__class__(f'{self} ** {other}')
126 def __rpow__(self, other):
127 return self.__class__(f'{other} ** {self}')
128 def __eq__(self, other):
129 if other.__class__ != self.__class__:
130 return NotImplemented
131 return self.value == other.value
132 def __str__(self):
133 return f'{self.value}'
134 def __repr__(self):
135 return f'{self.__class__.__name__}({self.value!r})'
136
137 class SymbolicReal(Symbolic):
138 pass
139 numbers.Real.register(SymbolicReal)
140
141 class SymbolicComplex(Symbolic):
142 pass
143 numbers.Complex.register(SymbolicComplex)
144
145 class Rat:
146 """Simple Rational class for testing mixed arithmetic."""
147 def __init__(self, n, d):
148 self.numerator = n
149 self.denominator = d
150 def __mul__(self, other):
151 if isinstance(other, F):
152 return NotImplemented
153 return self.__class__(self.numerator * other.numerator,
154 self.denominator * other.denominator)
155 def __rmul__(self, other):
156 return self.__class__(other.numerator * self.numerator,
157 other.denominator * self.denominator)
158 def __truediv__(self, other):
159 if isinstance(other, F):
160 return NotImplemented
161 return self.__class__(self.numerator * other.denominator,
162 self.denominator * other.numerator)
163 def __rtruediv__(self, other):
164 return self.__class__(other.numerator * self.denominator,
165 other.denominator * self.numerator)
166 def __mod__(self, other):
167 if isinstance(other, F):
168 return NotImplemented
169 d = self.denominator * other.numerator
170 return self.__class__(self.numerator * other.denominator % d, d)
171 def __rmod__(self, other):
172 d = other.denominator * self.numerator
173 return self.__class__(other.numerator * self.denominator % d, d)
174
175 return self.__class__(other.numerator / self.numerator,
176 other.denominator / self.denominator)
177 def __pow__(self, other):
178 if isinstance(other, F):
179 return NotImplemented
180 return self.__class__(self.numerator ** other,
181 self.denominator ** other)
182 def __float__(self):
183 return self.numerator / self.denominator
184 def __eq__(self, other):
185 if self.__class__ != other.__class__:
186 return NotImplemented
187 return (typed_approx_eq(self.numerator, other.numerator) and
188 typed_approx_eq(self.denominator, other.denominator))
189 def __repr__(self):
190 return f'{self.__class__.__name__}({self.numerator!r}, {self.denominator!r})'
191 numbers.Rational.register(Rat)
192
193 class Root:
194 """Simple Real class for testing mixed arithmetic."""
195 def __init__(self, v, n=F(2)):
196 self.base = v
197 self.degree = n
198 def __mul__(self, other):
199 if isinstance(other, F):
200 return NotImplemented
201 return self.__class__(self.base * other**self.degree, self.degree)
202 def __rmul__(self, other):
203 return self.__class__(other**self.degree * self.base, self.degree)
204 def __truediv__(self, other):
205 if isinstance(other, F):
206 return NotImplemented
207 return self.__class__(self.base / other**self.degree, self.degree)
208 def __rtruediv__(self, other):
209 return self.__class__(other**self.degree / self.base, self.degree)
210 def __pow__(self, other):
211 if isinstance(other, F):
212 return NotImplemented
213 return self.__class__(self.base, self.degree / other)
214 def __float__(self):
215 return float(self.base) ** (1 / float(self.degree))
216 def __eq__(self, other):
217 if self.__class__ != other.__class__:
218 return NotImplemented
219 return typed_approx_eq(self.base, other.base) and typed_approx_eq(self.degree, other.degree)
220 def __repr__(self):
221 return f'{self.__class__.__name__}({self.base!r}, {self.degree!r})'
222 numbers.Real.register(Root)
223
224 class Polar:
225 """Simple Complex class for testing mixed arithmetic."""
226 def __init__(self, r, phi):
227 self.r = r
228 self.phi = phi
229 def __mul__(self, other):
230 if isinstance(other, F):
231 return NotImplemented
232 return self.__class__(self.r * other, self.phi)
233 def __rmul__(self, other):
234 return self.__class__(other * self.r, self.phi)
235 def __truediv__(self, other):
236 if isinstance(other, F):
237 return NotImplemented
238 return self.__class__(self.r / other, self.phi)
239 def __rtruediv__(self, other):
240 return self.__class__(other / self.r, -self.phi)
241 def __pow__(self, other):
242 if isinstance(other, F):
243 return NotImplemented
244 return self.__class__(self.r ** other, self.phi * other)
245 def __eq__(self, other):
246 if self.__class__ != other.__class__:
247 return NotImplemented
248 return typed_approx_eq(self.r, other.r) and typed_approx_eq(self.phi, other.phi)
249 def __repr__(self):
250 return f'{self.__class__.__name__}({self.r!r}, {self.phi!r})'
251 numbers.Complex.register(Polar)
252
253 class Rect:
254 """Other simple Complex class for testing mixed arithmetic."""
255 def __init__(self, x, y):
256 self.x = x
257 self.y = y
258 def __mul__(self, other):
259 if isinstance(other, F):
260 return NotImplemented
261 return self.__class__(self.x * other, self.y * other)
262 def __rmul__(self, other):
263 return self.__class__(other * self.x, other * self.y)
264 def __truediv__(self, other):
265 if isinstance(other, F):
266 return NotImplemented
267 return self.__class__(self.x / other, self.y / other)
268 def __rtruediv__(self, other):
269 r = self.x * self.x + self.y * self.y
270 return self.__class__(other * (self.x / r), other * (self.y / r))
271 def __rpow__(self, other):
272 return Polar(other ** self.x, math.log(other) * self.y)
273 def __complex__(self):
274 return complex(self.x, self.y)
275 def __eq__(self, other):
276 if self.__class__ != other.__class__:
277 return NotImplemented
278 return typed_approx_eq(self.x, other.x) and typed_approx_eq(self.y, other.y)
279 def __repr__(self):
280 return f'{self.__class__.__name__}({self.x!r}, {self.y!r})'
281 numbers.Complex.register(Rect)
282
283 class RectComplex(Rect, complex):
284 pass
285
286 class Ratio:
287 def __init__(self, ratio):
288 self._ratio = ratio
289 def as_integer_ratio(self):
290 return self._ratio
291
292
293 class FractionTest(unittest.TestCase):
294
295 def assertTypedEquals(self, expected, actual):
296 """Asserts that both the types and values are the same."""
297 self.assertEqual(type(expected), type(actual))
298 self.assertEqual(expected, actual)
299
300 def assertTypedTupleEquals(self, expected, actual):
301 """Asserts that both the types and values in the tuples are the same."""
302 self.assertTupleEqual(expected, actual)
303 self.assertListEqual(list(map(type, expected)), list(map(type, actual)))
304
305 def assertRaisesMessage(self, exc_type, message,
306 callable, *args, **kwargs):
307 """Asserts that callable(*args, **kwargs) raises exc_type(message)."""
308 try:
309 callable(*args, **kwargs)
310 except exc_type as e:
311 self.assertEqual(message, str(e))
312 else:
313 self.fail("%s not raised" % exc_type.__name__)
314
315 def testInit(self):
316 self.assertEqual((0, 1), _components(F()))
317 self.assertEqual((7, 1), _components(F(7)))
318 self.assertEqual((7, 3), _components(F(F(7, 3))))
319
320 self.assertEqual((-1, 1), _components(F(-1, 1)))
321 self.assertEqual((-1, 1), _components(F(1, -1)))
322 self.assertEqual((1, 1), _components(F(-2, -2)))
323 self.assertEqual((1, 2), _components(F(5, 10)))
324 self.assertEqual((7, 15), _components(F(7, 15)))
325 self.assertEqual((10**23, 1), _components(F(10**23)))
326
327 self.assertEqual((3, 77), _components(F(F(3, 7), 11)))
328 self.assertEqual((-9, 5), _components(F(2, F(-10, 9))))
329 self.assertEqual((2486, 2485), _components(F(F(22, 7), F(355, 113))))
330
331 self.assertRaisesMessage(ZeroDivisionError, "Fraction(12, 0)",
332 F, 12, 0)
333 self.assertRaises(TypeError, F, 1.5 + 3j)
334
335 self.assertRaises(TypeError, F, "3/2", 3)
336 self.assertRaises(TypeError, F, 3, 0j)
337 self.assertRaises(TypeError, F, 3, 1j)
338 self.assertRaises(TypeError, F, 1, 2, 3)
339
340 @requires_IEEE_754
341 def testInitFromFloat(self):
342 self.assertEqual((5, 2), _components(F(2.5)))
343 self.assertEqual((0, 1), _components(F(-0.0)))
344 self.assertEqual((3602879701896397, 36028797018963968),
345 _components(F(0.1)))
346 # bug 16469: error types should be consistent with float -> int
347 self.assertRaises(ValueError, F, float('nan'))
348 self.assertRaises(OverflowError, F, float('inf'))
349 self.assertRaises(OverflowError, F, float('-inf'))
350
351 def testInitFromDecimal(self):
352 self.assertEqual((11, 10),
353 _components(F(Decimal('1.1'))))
354 self.assertEqual((7, 200),
355 _components(F(Decimal('3.5e-2'))))
356 self.assertEqual((0, 1),
357 _components(F(Decimal('.000e20'))))
358 # bug 16469: error types should be consistent with decimal -> int
359 self.assertRaises(ValueError, F, Decimal('nan'))
360 self.assertRaises(ValueError, F, Decimal('snan'))
361 self.assertRaises(OverflowError, F, Decimal('inf'))
362 self.assertRaises(OverflowError, F, Decimal('-inf'))
363
364 def testInitFromIntegerRatio(self):
365 self.assertEqual((7, 3), _components(F(Ratio((7, 3)))))
366 errmsg = (r"argument should be a string or a Rational instance or "
367 r"have the as_integer_ratio\(\) method")
368 # the type also has an "as_integer_ratio" attribute.
369 self.assertRaisesRegex(TypeError, errmsg, F, Ratio)
370 # bad ratio
371 self.assertRaises(TypeError, F, Ratio(7))
372 self.assertRaises(ValueError, F, Ratio((7,)))
373 self.assertRaises(ValueError, F, Ratio((7, 3, 1)))
374 # only single-argument form
375 self.assertRaises(TypeError, F, Ratio((3, 7)), 11)
376 self.assertRaises(TypeError, F, 2, Ratio((-10, 9)))
377
378 # as_integer_ratio not defined in a class
379 class A:
380 pass
381 a = A()
382 a.as_integer_ratio = lambda: (9, 5)
383 self.assertEqual((9, 5), _components(F(a)))
384
385 # as_integer_ratio defined in a metaclass
386 class M(type):
387 def as_integer_ratio(self):
388 return (11, 9)
389 class B(metaclass=M):
390 pass
391 self.assertRaisesRegex(TypeError, errmsg, F, B)
392 self.assertRaisesRegex(TypeError, errmsg, F, B())
393 self.assertRaises(TypeError, F.from_number, B)
394 self.assertRaises(TypeError, F.from_number, B())
395
396 def testFromString(self):
397 self.assertEqual((5, 1), _components(F("5")))
398 self.assertEqual((5, 1), _components(F("005")))
399 self.assertEqual((3, 2), _components(F("3/2")))
400 self.assertEqual((3, 2), _components(F("3 / 2")))
401 self.assertEqual((3, 2), _components(F(" \n +3/2")))
402 self.assertEqual((-3, 2), _components(F("-3/2 ")))
403 self.assertEqual((13, 2), _components(F(" 0013/002 \n ")))
404 self.assertEqual((16, 5), _components(F(" 3.2 ")))
405 self.assertEqual((16, 5), _components(F("003.2")))
406 self.assertEqual((-16, 5), _components(F(" -3.2 ")))
407 self.assertEqual((-3, 1), _components(F(" -3. ")))
408 self.assertEqual((3, 5), _components(F(" .6 ")))
409 self.assertEqual((1, 3125), _components(F("32.e-5")))
410 self.assertEqual((1000000, 1), _components(F("1E+06")))
411 self.assertEqual((-12300, 1), _components(F("-1.23e4")))
412 self.assertEqual((0, 1), _components(F(" .0e+0\t")))
413 self.assertEqual((0, 1), _components(F("-0.000e0")))
414 self.assertEqual((123, 1), _components(F("1_2_3")))
415 self.assertEqual((41, 107), _components(F("1_2_3/3_2_1")))
416 self.assertEqual((6283, 2000), _components(F("3.14_15")))
417 self.assertEqual((6283, 2*10**13), _components(F("3.14_15e-1_0")))
418 self.assertEqual((101, 100), _components(F("1.01")))
419 self.assertEqual((101, 100), _components(F("1.0_1")))
420
421 self.assertRaisesMessage(
422 ZeroDivisionError, "Fraction(3, 0)",
423 F, "3/0")
424
425 def check_invalid(s):
426 msg = "Invalid literal for Fraction: " + repr(s)
427 self.assertRaisesMessage(ValueError, msg, F, s)
428
429 check_invalid("3/")
430 check_invalid("/2")
431 # Denominators don't need a sign.
432 check_invalid("3/+2")
433 check_invalid("3/-2")
434 # Imitate float's parsing.
435 check_invalid("+ 3/2")
436 check_invalid("- 3/2")
437 # Avoid treating '.' as a regex special character.
438 check_invalid("3a2")
439 # Don't accept combinations of decimals and rationals.
440 check_invalid("3/7.2")
441 check_invalid("3.2/7")
442 # No space around dot.
443 check_invalid("3 .2")
444 check_invalid("3. 2")
445 # No space around e.
446 check_invalid("3.2 e1")
447 check_invalid("3.2e 1")
448 # Fractional part don't need a sign.
449 check_invalid("3.+2")
450 check_invalid("3.-2")
451 # Only accept base 10.
452 check_invalid("0x10")
453 check_invalid("0x10/1")
454 check_invalid("1/0x10")
455 check_invalid("0x10.")
456 check_invalid("0x10.1")
457 check_invalid("1.0x10")
458 check_invalid("1.0e0x10")
459 # Only accept decimal digits.
460 check_invalid("³")
461 check_invalid("³/2")
462 check_invalid("3/²")
463 check_invalid("³.2")
464 check_invalid("3.²")
465 check_invalid("3.2e²")
466 check_invalid("¼")
467 # Allow 3. and .3, but not .
468 check_invalid(".")
469 check_invalid("_")
470 check_invalid("_1")
471 check_invalid("1__2")
472 check_invalid("/_")
473 check_invalid("1_/")
474 check_invalid("_1/")
475 check_invalid("1__2/")
476 check_invalid("1/_")
477 check_invalid("1/_1")
478 check_invalid("1/1__2")
479 check_invalid("1._111")
480 check_invalid("1.1__1")
481 check_invalid("1.1e+_1")
482 check_invalid("1.1e+1__1")
483 check_invalid("123.dd")
484 check_invalid("123.5_dd")
485 check_invalid("dd.5")
486 check_invalid("7_dd")
487 check_invalid("1/dd")
488 check_invalid("1/123_dd")
489 check_invalid("789edd")
490 check_invalid("789e2_dd")
491 # Test catastrophic backtracking.
492 val = "9"*50 + "_"
493 check_invalid(val)
494 check_invalid("1/" + val)
495 check_invalid("1." + val)
496 check_invalid("." + val)
497 check_invalid("1.1+e" + val)
498 check_invalid("1.1e" + val)
499
500 def test_limit_int(self):
501 maxdigits = 5000
502 with adjust_int_max_str_digits(maxdigits):
503 msg = 'Exceeds the limit'
504 val = '1' * maxdigits
505 num = (10**maxdigits - 1)//9
506 self.assertEqual((num, 1), _components(F(val)))
507 self.assertRaisesRegex(ValueError, msg, F, val + '1')
508 self.assertEqual((num, 2), _components(F(val + '/2')))
509 self.assertRaisesRegex(ValueError, msg, F, val + '1/2')
510 self.assertEqual((1, num), _components(F('1/' + val)))
511 self.assertRaisesRegex(ValueError, msg, F, '1/1' + val)
512 self.assertEqual(((10**(maxdigits+1) - 1)//9, 10**maxdigits),
513 _components(F('1.' + val)))
514 self.assertRaisesRegex(ValueError, msg, F, '1.1' + val)
515 self.assertEqual((num, 10**maxdigits), _components(F('.' + val)))
516 self.assertRaisesRegex(ValueError, msg, F, '.1' + val)
517 self.assertRaisesRegex(ValueError, msg, F, '1.1e1' + val)
518 self.assertEqual((11, 10), _components(F('1.1e' + '0' * maxdigits)))
519 self.assertRaisesRegex(ValueError, msg, F, '1.1e' + '0' * (maxdigits+1))
520
521 def testImmutable(self):
522 r = F(7, 3)
523 r.__init__(2, 15)
524 self.assertEqual((7, 3), _components(r))
525
526 self.assertRaises(AttributeError, setattr, r, 'numerator', 12)
527 self.assertRaises(AttributeError, setattr, r, 'denominator', 6)
528 self.assertEqual((7, 3), _components(r))
529
530 # But if you _really_ need to:
531 r._numerator = 4
532 r._denominator = 2
533 self.assertEqual((4, 2), _components(r))
534 # Which breaks some important operations:
535 self.assertNotEqual(F(4, 2), r)
536
537 def testFromFloat(self):
538 self.assertRaises(TypeError, F.from_float, 3+4j)
539 self.assertEqual((10, 1), _components(F.from_float(10)))
540 bigint = 1234567890123456789
541 self.assertEqual((bigint, 1), _components(F.from_float(bigint)))
542 self.assertEqual((0, 1), _components(F.from_float(-0.0)))
543 self.assertEqual((10, 1), _components(F.from_float(10.0)))
544 self.assertEqual((-5, 2), _components(F.from_float(-2.5)))
545 self.assertEqual((99999999999999991611392, 1),
546 _components(F.from_float(1e23)))
547 self.assertEqual(float(10**23), float(F.from_float(1e23)))
548 self.assertEqual((3602879701896397, 1125899906842624),
549 _components(F.from_float(3.2)))
550 self.assertEqual(3.2, float(F.from_float(3.2)))
551
552 inf = 1e1000
553 nan = inf - inf
554 # bug 16469: error types should be consistent with float -> int
555 self.assertRaisesMessage(
556 OverflowError, "cannot convert Infinity to integer ratio",
557 F.from_float, inf)
558 self.assertRaisesMessage(
559 OverflowError, "cannot convert Infinity to integer ratio",
560 F.from_float, -inf)
561 self.assertRaisesMessage(
562 ValueError, "cannot convert NaN to integer ratio",
563 F.from_float, nan)
564
565 def testFromDecimal(self):
566 self.assertRaises(TypeError, F.from_decimal, 3+4j)
567 self.assertEqual(F(10, 1), F.from_decimal(10))
568 self.assertEqual(F(0), F.from_decimal(Decimal("-0")))
569 self.assertEqual(F(5, 10), F.from_decimal(Decimal("0.5")))
570 self.assertEqual(F(5, 1000), F.from_decimal(Decimal("5e-3")))
571 self.assertEqual(F(5000), F.from_decimal(Decimal("5e3")))
572 self.assertEqual(1 - F(1, 10**30),
573 F.from_decimal(Decimal("0." + "9" * 30)))
574
575 # bug 16469: error types should be consistent with decimal -> int
576 self.assertRaisesMessage(
577 OverflowError, "cannot convert Infinity to integer ratio",
578 F.from_decimal, Decimal("inf"))
579 self.assertRaisesMessage(
580 OverflowError, "cannot convert Infinity to integer ratio",
581 F.from_decimal, Decimal("-inf"))
582 self.assertRaisesMessage(
583 ValueError, "cannot convert NaN to integer ratio",
584 F.from_decimal, Decimal("nan"))
585 self.assertRaisesMessage(
586 ValueError, "cannot convert NaN to integer ratio",
587 F.from_decimal, Decimal("snan"))
588
589 def testFromNumber(self, cls=F):
590 def check(arg, numerator, denominator):
591 f = cls.from_number(arg)
592 self.assertIs(type(f), cls)
593 self.assertEqual(f.numerator, numerator)
594 self.assertEqual(f.denominator, denominator)
595
596 check(10, 10, 1)
597 check(2.5, 5, 2)
598 check(Decimal('2.5'), 5, 2)
599 check(F(22, 7), 22, 7)
600 check(DummyFraction(22, 7), 22, 7)
601 check(Rat(22, 7), 22, 7)
602 check(Ratio((22, 7)), 22, 7)
603 self.assertRaises(TypeError, cls.from_number, 3+4j)
604 self.assertRaises(TypeError, cls.from_number, '5/2')
605 self.assertRaises(TypeError, cls.from_number, [])
606 self.assertRaises(OverflowError, cls.from_number, float('inf'))
607 self.assertRaises(OverflowError, cls.from_number, Decimal('inf'))
608
609 # as_integer_ratio not defined in a class
610 class A:
611 pass
612 a = A()
613 a.as_integer_ratio = lambda: (9, 5)
614 check(a, 9, 5)
615
616 def testFromNumber_subclass(self):
617 self.testFromNumber(DummyFraction)
618
619
620 def test_is_integer(self):
621 self.assertTrue(F(1, 1).is_integer())
622 self.assertTrue(F(-1, 1).is_integer())
623 self.assertTrue(F(1, -1).is_integer())
624 self.assertTrue(F(2, 2).is_integer())
625 self.assertTrue(F(-2, 2).is_integer())
626 self.assertTrue(F(2, -2).is_integer())
627
628 self.assertFalse(F(1, 2).is_integer())
629 self.assertFalse(F(-1, 2).is_integer())
630 self.assertFalse(F(1, -2).is_integer())
631 self.assertFalse(F(-1, -2).is_integer())
632
633 def test_as_integer_ratio(self):
634 self.assertEqual(F(4, 6).as_integer_ratio(), (2, 3))
635 self.assertEqual(F(-4, 6).as_integer_ratio(), (-2, 3))
636 self.assertEqual(F(4, -6).as_integer_ratio(), (-2, 3))
637 self.assertEqual(F(0, 6).as_integer_ratio(), (0, 1))
638
639 def testLimitDenominator(self):
640 rpi = F('3.1415926535897932')
641 self.assertEqual(rpi.limit_denominator(10000), F(355, 113))
642 self.assertEqual(-rpi.limit_denominator(10000), F(-355, 113))
643 self.assertEqual(rpi.limit_denominator(113), F(355, 113))
644 self.assertEqual(rpi.limit_denominator(112), F(333, 106))
645 self.assertEqual(F(201, 200).limit_denominator(100), F(1))
646 self.assertEqual(F(201, 200).limit_denominator(101), F(102, 101))
647 self.assertEqual(F(0).limit_denominator(10000), F(0))
648 for i in (0, -1):
649 self.assertRaisesMessage(
650 ValueError, "max_denominator should be at least 1",
651 F(1).limit_denominator, i)
652
653 def testConversions(self):
654 self.assertTypedEquals(-1, math.trunc(F(-11, 10)))
655 self.assertTypedEquals(1, math.trunc(F(11, 10)))
656 self.assertTypedEquals(-2, math.floor(F(-11, 10)))
657 self.assertTypedEquals(-1, math.ceil(F(-11, 10)))
658 self.assertTypedEquals(-1, math.ceil(F(-10, 10)))
659 self.assertTypedEquals(-1, int(F(-11, 10)))
660 self.assertTypedEquals(0, round(F(-1, 10)))
661 self.assertTypedEquals(0, round(F(-5, 10)))
662 self.assertTypedEquals(-2, round(F(-15, 10)))
663 self.assertTypedEquals(-1, round(F(-7, 10)))
664
665 self.assertEqual(False, bool(F(0, 1)))
666 self.assertEqual(True, bool(F(3, 2)))
667 self.assertTypedEquals(0.1, float(F(1, 10)))
668
669 # Check that __float__ isn't implemented by converting the
670 # numerator and denominator to float before dividing.
671 self.assertRaises(OverflowError, float, int('2'*400+'7'))
672 self.assertAlmostEqual(2.0/3,
673 float(F(int('2'*400+'7'), int('3'*400+'1'))))
674
675 self.assertTypedEquals(0.1+0j, complex(F(1,10)))
676
677 def testSupportsInt(self):
678 # See bpo-44547.
679 f = F(3, 2)
680 self.assertIsInstance(f, typing.SupportsInt)
681 self.assertEqual(int(f), 1)
682 self.assertEqual(type(int(f)), int)
683
684 def testIntGuaranteesIntReturn(self):
685 # Check that int(some_fraction) gives a result of exact type `int`
686 # even if the fraction is using some other Integral type for its
687 # numerator and denominator.
688
689 class CustomInt(int):
690 """
691 Subclass of int with just enough machinery to convince the Fraction
692 constructor to produce something with CustomInt numerator and
693 denominator.
694 """
695
696 @property
697 def numerator(self):
698 return self
699
700 @property
701 def denominator(self):
702 return CustomInt(1)
703
704 def __mul__(self, other):
705 return CustomInt(int(self) * int(other))
706
707 def __floordiv__(self, other):
708 return CustomInt(int(self) // int(other))
709
710 f = F(CustomInt(13), CustomInt(5))
711
712 self.assertIsInstance(f.numerator, CustomInt)
713 self.assertIsInstance(f.denominator, CustomInt)
714 self.assertIsInstance(f, typing.SupportsInt)
715 self.assertEqual(int(f), 2)
716 self.assertEqual(type(int(f)), int)
717
718 def testBoolGuarateesBoolReturn(self):
719 # Ensure that __bool__ is used on numerator which guarantees a bool
720 # return. See also bpo-39274.
721 @functools.total_ordering
722 class CustomValue:
723 denominator = 1
724
725 def __init__(self, value):
726 self.value = value
727
728 def __bool__(self):
729 return bool(self.value)
730
731 @property
732 def numerator(self):
733 # required to preserve `self` during instantiation
734 return self
735
736 def __eq__(self, other):
737 raise AssertionError("Avoid comparisons in Fraction.__bool__")
738
739 __lt__ = __eq__
740
741 # We did not implement all abstract methods, so register:
742 numbers.Rational.register(CustomValue)
743
744 numerator = CustomValue(1)
745 r = F(numerator)
746 # ensure the numerator was not lost during instantiation:
747 self.assertIs(r.numerator, numerator)
748 self.assertIs(bool(r), True)
749
750 numerator = CustomValue(0)
751 r = F(numerator)
752 self.assertIs(bool(r), False)
753
754 def testRound(self):
755 self.assertTypedEquals(F(-200), round(F(-150), -2))
756 self.assertTypedEquals(F(-200), round(F(-250), -2))
757 self.assertTypedEquals(F(30), round(F(26), -1))
758 self.assertTypedEquals(F(-2, 10), round(F(-15, 100), 1))
759 self.assertTypedEquals(F(-2, 10), round(F(-25, 100), 1))
760
761 def testArithmetic(self):
762 self.assertEqual(F(1, 2), F(1, 10) + F(2, 5))
763 self.assertEqual(F(-3, 10), F(1, 10) - F(2, 5))
764 self.assertEqual(F(1, 25), F(1, 10) * F(2, 5))
765 self.assertEqual(F(5, 6), F(2, 3) * F(5, 4))
766 self.assertEqual(F(1, 4), F(1, 10) / F(2, 5))
767 self.assertEqual(F(-15, 8), F(3, 4) / F(-2, 5))
768 self.assertRaises(ZeroDivisionError, operator.truediv, F(1), F(0))
769 self.assertTypedEquals(2, F(9, 10) // F(2, 5))
770 self.assertTypedEquals(10**23, F(10**23, 1) // F(1))
771 self.assertEqual(F(5, 6), F(7, 3) % F(3, 2))
772 self.assertEqual(F(2, 3), F(-7, 3) % F(3, 2))
773 self.assertEqual((F(1), F(5, 6)), divmod(F(7, 3), F(3, 2)))
774 self.assertEqual((F(-2), F(2, 3)), divmod(F(-7, 3), F(3, 2)))
775 self.assertEqual(F(8, 27), F(2, 3) ** F(3))
776 self.assertEqual(F(27, 8), F(2, 3) ** F(-3))
777 self.assertTypedEquals(2.0, F(4) ** F(1, 2))
778 self.assertEqual(F(1, 1), +F(1, 1))
779 z = pow(F(-1), F(1, 2))
780 self.assertAlmostEqual(z.real, 0)
781 self.assertEqual(z.imag, 1)
782 # Regression test for #27539.
783 p = F(-1, 2) ** 0
784 self.assertEqual(p, F(1, 1))
785 self.assertEqual(p.numerator, 1)
786 self.assertEqual(p.denominator, 1)
787 p = F(-1, 2) ** -1
788 self.assertEqual(p, F(-2, 1))
789 self.assertEqual(p.numerator, -2)
790 self.assertEqual(p.denominator, 1)
791 p = F(-1, 2) ** -2
792 self.assertEqual(p, F(4, 1))
793 self.assertEqual(p.numerator, 4)
794 self.assertEqual(p.denominator, 1)
795
796 def testLargeArithmetic(self):
797 self.assertTypedEquals(
798 F(10101010100808080808080808101010101010000000000000000,
799 1010101010101010101010101011111111101010101010101010101010101),
800 F(10**35+1, 10**27+1) % F(10**27+1, 10**35-1)
801 )
802 self.assertTypedEquals(
803 F(7, 1901475900342344102245054808064),
804 F(-2**100, 3) % F(5, 2**100)
805 )
806 self.assertTypedTupleEquals(
807 (9999999999999999,
808 F(10101010100808080808080808101010101010000000000000000,
809 1010101010101010101010101011111111101010101010101010101010101)),
810 divmod(F(10**35+1, 10**27+1), F(10**27+1, 10**35-1))
811 )
812 self.assertTypedEquals(
813 -2 ** 200 // 15,
814 F(-2**100, 3) // F(5, 2**100)
815 )
816 self.assertTypedEquals(
817 1,
818 F(5, 2**100) // F(3, 2**100)
819 )
820 self.assertTypedEquals(
821 (1, F(2, 2**100)),
822 divmod(F(5, 2**100), F(3, 2**100))
823 )
824 self.assertTypedTupleEquals(
825 (-2 ** 200 // 15,
826 F(7, 1901475900342344102245054808064)),
827 divmod(F(-2**100, 3), F(5, 2**100))
828 )
829
830 def testMixedArithmetic(self):
831 self.assertTypedEquals(F(11, 10), F(1, 10) + 1)
832 self.assertTypedEquals(1.1, F(1, 10) + 1.0)
833 self.assertTypedEquals(1.1 + 0j, F(1, 10) + (1.0 + 0j))
834 self.assertTypedEquals(F(11, 10), 1 + F(1, 10))
835 self.assertTypedEquals(1.1, 1.0 + F(1, 10))
836 self.assertTypedEquals(1.1 + 0j, (1.0 + 0j) + F(1, 10))
837
838 self.assertTypedEquals(F(-9, 10), F(1, 10) - 1)
839 self.assertTypedEquals(-0.9, F(1, 10) - 1.0)
840 self.assertTypedEquals(-0.9 + 0j, F(1, 10) - (1.0 + 0j))
841 self.assertTypedEquals(F(9, 10), 1 - F(1, 10))
842 self.assertTypedEquals(0.9, 1.0 - F(1, 10))
843 self.assertTypedEquals(0.9 + 0j, (1.0 + 0j) - F(1, 10))
844
845 def testMixedMultiplication(self):
846 self.assertTypedEquals(F(1, 10), F(1, 10) * 1)
847 self.assertTypedEquals(0.1, F(1, 10) * 1.0)
848 self.assertTypedEquals(0.1 + 0j, F(1, 10) * (1.0 + 0j))
849 self.assertTypedEquals(F(1, 10), 1 * F(1, 10))
850 self.assertTypedEquals(0.1, 1.0 * F(1, 10))
851 self.assertTypedEquals(0.1 + 0j, (1.0 + 0j) * F(1, 10))
852
853 self.assertTypedEquals(F(3, 2) * DummyFraction(5, 3), F(5, 2))
854 self.assertTypedEquals(DummyFraction(5, 3) * F(3, 2), F(5, 2))
855 self.assertTypedEquals(F(3, 2) * Rat(5, 3), Rat(15, 6))
856 self.assertTypedEquals(Rat(5, 3) * F(3, 2), F(5, 2))
857
858 self.assertTypedEquals(F(3, 2) * Root(4), Root(F(9, 1)))
859 self.assertTypedEquals(Root(4) * F(3, 2), 3.0)
860 self.assertEqual(F(3, 2) * SymbolicReal('X'), SymbolicReal('3/2 * X'))
861 self.assertRaises(TypeError, operator.mul, SymbolicReal('X'), F(3, 2))
862
863 self.assertTypedEquals(F(3, 2) * Polar(4, 2), Polar(F(6, 1), 2))
864 self.assertTypedEquals(F(3, 2) * Polar(4.0, 2), Polar(6.0, 2))
865 self.assertTypedEquals(F(3, 2) * Rect(4, 3), Rect(F(6, 1), F(9, 2)))
866 self.assertTypedEquals(F(3, 2) * RectComplex(4, 3), RectComplex(6.0, 4.5))
867 self.assertRaises(TypeError, operator.mul, Polar(4, 2), F(3, 2))
868 self.assertTypedEquals(Rect(4, 3) * F(3, 2), 6.0 + 4.5j)
869 self.assertEqual(F(3, 2) * SymbolicComplex('X'), SymbolicComplex('3/2 * X'))
870 self.assertRaises(TypeError, operator.mul, SymbolicComplex('X'), F(3, 2))
871
872 self.assertEqual(F(3, 2) * Symbolic('X'), Symbolic('3/2 * X'))
873 self.assertRaises(TypeError, operator.mul, Symbolic('X'), F(3, 2))
874
875 def testMixedDivision(self):
876 self.assertTypedEquals(F(1, 10), F(1, 10) / 1)
877 self.assertTypedEquals(0.1, F(1, 10) / 1.0)
878 self.assertTypedEquals(0.1 + 0j, F(1, 10) / (1.0 + 0j))
879 self.assertTypedEquals(F(10, 1), 1 / F(1, 10))
880 self.assertTypedEquals(10.0, 1.0 / F(1, 10))
881 self.assertTypedEquals(10.0 + 0j, (1.0 + 0j) / F(1, 10))
882
883 self.assertTypedEquals(F(3, 2) / DummyFraction(3, 5), F(5, 2))
884 self.assertTypedEquals(DummyFraction(5, 3) / F(2, 3), F(5, 2))
885 self.assertTypedEquals(F(3, 2) / Rat(3, 5), Rat(15, 6))
886 self.assertTypedEquals(Rat(5, 3) / F(2, 3), F(5, 2))
887
888 self.assertTypedEquals(F(2, 3) / Root(4), Root(F(1, 9)))
889 self.assertTypedEquals(Root(4) / F(2, 3), 3.0)
890 self.assertEqual(F(3, 2) / SymbolicReal('X'), SymbolicReal('3/2 / X'))
891 self.assertRaises(TypeError, operator.truediv, SymbolicReal('X'), F(3, 2))
892
893 self.assertTypedEquals(F(3, 2) / Polar(4, 2), Polar(F(3, 8), -2))
894 self.assertTypedEquals(F(3, 2) / Polar(4.0, 2), Polar(0.375, -2))
895 self.assertTypedEquals(F(3, 2) / Rect(4, 3), Rect(0.24, 0.18))
896 self.assertRaises(TypeError, operator.truediv, Polar(4, 2), F(2, 3))
897 self.assertTypedEquals(Rect(4, 3) / F(2, 3), 6.0 + 4.5j)
898 self.assertEqual(F(3, 2) / SymbolicComplex('X'), SymbolicComplex('3/2 / X'))
899 self.assertRaises(TypeError, operator.truediv, SymbolicComplex('X'), F(3, 2))
900
901 self.assertEqual(F(3, 2) / Symbolic('X'), Symbolic('3/2 / X'))
902 self.assertRaises(TypeError, operator.truediv, Symbolic('X'), F(2, 3))
903
904 def testMixedIntegerDivision(self):
905 self.assertTypedEquals(0, F(1, 10) // 1)
906 self.assertTypedEquals(0.0, F(1, 10) // 1.0)
907 self.assertTypedEquals(10, 1 // F(1, 10))
908 self.assertTypedEquals(10**23, 10**22 // F(1, 10))
909 self.assertTypedEquals(1.0 // 0.1, 1.0 // F(1, 10))
910
911 self.assertTypedEquals(F(1, 10), F(1, 10) % 1)
912 self.assertTypedEquals(0.1, F(1, 10) % 1.0)
913 self.assertTypedEquals(F(0, 1), 1 % F(1, 10))
914 self.assertTypedEquals(1.0 % 0.1, 1.0 % F(1, 10))
915 self.assertTypedEquals(0.1, F(1, 10) % float('inf'))
916 self.assertTypedEquals(float('-inf'), F(1, 10) % float('-inf'))
917 self.assertTypedEquals(float('inf'), F(-1, 10) % float('inf'))
918 self.assertTypedEquals(-0.1, F(-1, 10) % float('-inf'))
919
920 self.assertTypedTupleEquals((0, F(1, 10)), divmod(F(1, 10), 1))
921 self.assertTypedTupleEquals(divmod(0.1, 1.0), divmod(F(1, 10), 1.0))
922 self.assertTypedTupleEquals((10, F(0)), divmod(1, F(1, 10)))
923 self.assertTypedTupleEquals(divmod(1.0, 0.1), divmod(1.0, F(1, 10)))
924 self.assertTypedTupleEquals(divmod(0.1, float('inf')), divmod(F(1, 10), float('inf')))
925 self.assertTypedTupleEquals(divmod(0.1, float('-inf')), divmod(F(1, 10), float('-inf')))
926 self.assertTypedTupleEquals(divmod(-0.1, float('inf')), divmod(F(-1, 10), float('inf')))
927 self.assertTypedTupleEquals(divmod(-0.1, float('-inf')), divmod(F(-1, 10), float('-inf')))
928
929 self.assertTypedEquals(F(3, 2) % DummyFraction(3, 5), F(3, 10))
930 self.assertTypedEquals(DummyFraction(5, 3) % F(2, 3), F(1, 3))
931 self.assertTypedEquals(F(3, 2) % Rat(3, 5), Rat(3, 6))
932 self.assertTypedEquals(Rat(5, 3) % F(2, 3), F(1, 3))
933
934 self.assertRaises(TypeError, operator.mod, F(2, 3), Root(4))
935 self.assertTypedEquals(Root(4) % F(3, 2), 0.5)
936 self.assertEqual(F(3, 2) % SymbolicReal('X'), SymbolicReal('3/2 % X'))
937 self.assertRaises(TypeError, operator.mod, SymbolicReal('X'), F(3, 2))
938
939 self.assertRaises(TypeError, operator.mod, F(3, 2), Polar(4, 2))
940 self.assertRaises(TypeError, operator.mod, F(3, 2), RectComplex(4, 3))
941 self.assertRaises(TypeError, operator.mod, Rect(4, 3), F(2, 3))
942 self.assertEqual(F(3, 2) % SymbolicComplex('X'), SymbolicComplex('3/2 % X'))
943 self.assertRaises(TypeError, operator.mod, SymbolicComplex('X'), F(3, 2))
944
945 self.assertEqual(F(3, 2) % Symbolic('X'), Symbolic('3/2 % X'))
946 self.assertRaises(TypeError, operator.mod, Symbolic('X'), F(2, 3))
947
948 def testMixedPower(self):
949 # ** has more interesting conversion rules.
950 self.assertTypedEquals(F(100, 1), F(1, 10) ** -2)
951 self.assertTypedEquals(F(100, 1), F(10, 1) ** 2)
952 self.assertTypedEquals(0.1, F(1, 10) ** 1.0)
953 self.assertTypedEquals(0.1 + 0j, F(1, 10) ** (1.0 + 0j))
954 self.assertTypedEquals(4 , 2 ** F(2, 1))
955 z = pow(-1, F(1, 2))
956 self.assertAlmostEqual(0, z.real)
957 self.assertEqual(1, z.imag)
958 self.assertTypedEquals(F(1, 4) , 2 ** F(-2, 1))
959 self.assertTypedEquals(2.0 , 4 ** F(1, 2))
960 self.assertTypedEquals(0.25, 2.0 ** F(-2, 1))
961 self.assertTypedEquals(1.0 + 0j, (1.0 + 0j) ** F(1, 10))
962 self.assertRaises(ZeroDivisionError, operator.pow,
963 F(0, 1), -2)
964
965 self.assertTypedEquals(F(3, 2) ** Rat(3, 1), F(27, 8))
966 self.assertTypedEquals(F(3, 2) ** Rat(-3, 1), F(8, 27))
967 self.assertTypedEquals(F(-3, 2) ** Rat(-3, 1), F(-8, 27))
968 self.assertTypedEquals(F(9, 4) ** Rat(3, 2), 3.375)
969 self.assertIsInstance(F(4, 9) ** Rat(-3, 2), float)
970 self.assertAlmostEqual(F(4, 9) ** Rat(-3, 2), 3.375)
971 self.assertAlmostEqual(F(-4, 9) ** Rat(-3, 2), 3.375j)
972 self.assertTypedEquals(Rat(9, 4) ** F(3, 2), 3.375)
973 self.assertTypedEquals(Rat(3, 2) ** F(3, 1), Rat(27, 8))
974 self.assertTypedEquals(Rat(3, 2) ** F(-3, 1), F(8, 27))
975 self.assertIsInstance(Rat(4, 9) ** F(-3, 2), float)
976 self.assertAlmostEqual(Rat(4, 9) ** F(-3, 2), 3.375)
977
978 self.assertTypedEquals(Root(4) ** F(2, 3), Root(4, 3.0))
979 self.assertTypedEquals(Root(4) ** F(2, 1), Root(4, F(1)))
980 self.assertTypedEquals(Root(4) ** F(-2, 1), Root(4, -F(1)))
981 self.assertTypedEquals(Root(4) ** F(-2, 3), Root(4, -3.0))
982 self.assertEqual(F(3, 2) ** SymbolicReal('X'), SymbolicReal('3/2 ** X'))
983 self.assertEqual(SymbolicReal('X') ** F(3, 2), SymbolicReal('X ** 1.5'))
984
985 self.assertTypedEquals(F(3, 2) ** Rect(2, 0), Polar(F(9,4), 0.0))
986 self.assertTypedEquals(F(1, 1) ** Rect(2, 3), Polar(F(1), 0.0))
987 self.assertTypedEquals(F(3, 2) ** RectComplex(2, 0), Polar(2.25, 0.0))
988 self.assertTypedEquals(F(1, 1) ** RectComplex(2, 3), Polar(1.0, 0.0))
989 self.assertTypedEquals(Polar(4, 2) ** F(3, 2), Polar(8.0, 3.0))
990 self.assertTypedEquals(Polar(4, 2) ** F(3, 1), Polar(64, 6))
991 self.assertTypedEquals(Polar(4, 2) ** F(-3, 1), Polar(0.015625, -6))
992 self.assertTypedEquals(Polar(4, 2) ** F(-3, 2), Polar(0.125, -3.0))
993 self.assertEqual(F(3, 2) ** SymbolicComplex('X'), SymbolicComplex('3/2 ** X'))
994 self.assertEqual(SymbolicComplex('X') ** F(3, 2), SymbolicComplex('X ** 1.5'))
995
996 self.assertEqual(F(3, 2) ** Symbolic('X'), Symbolic('3/2 ** X'))
997 self.assertEqual(Symbolic('X') ** F(3, 2), Symbolic('X ** 1.5'))
998
999 def testMixingWithDecimal(self):
1000 # Decimal refuses mixed arithmetic (but not mixed comparisons)
1001 self.assertRaises(TypeError, operator.add,
1002 F(3,11), Decimal('3.1415926'))
1003 self.assertRaises(TypeError, operator.add,
1004 Decimal('3.1415926'), F(3,11))
1005
1006 def testComparisons(self):
1007 self.assertTrue(F(1, 2) < F(2, 3))
1008 self.assertFalse(F(1, 2) < F(1, 2))
1009 self.assertTrue(F(1, 2) <= F(2, 3))
1010 self.assertTrue(F(1, 2) <= F(1, 2))
1011 self.assertFalse(F(2, 3) <= F(1, 2))
1012 self.assertTrue(F(1, 2) == F(1, 2))
1013 self.assertFalse(F(1, 2) == F(1, 3))
1014 self.assertFalse(F(1, 2) != F(1, 2))
1015 self.assertTrue(F(1, 2) != F(1, 3))
1016
1017 def testComparisonsDummyRational(self):
1018 self.assertTrue(F(1, 2) == DummyRational(1, 2))
1019 self.assertTrue(DummyRational(1, 2) == F(1, 2))
1020 self.assertFalse(F(1, 2) == DummyRational(3, 4))
1021 self.assertFalse(DummyRational(3, 4) == F(1, 2))
1022
1023 self.assertTrue(F(1, 2) < DummyRational(3, 4))
1024 self.assertFalse(F(1, 2) < DummyRational(1, 2))
1025 self.assertFalse(F(1, 2) < DummyRational(1, 7))
1026 self.assertFalse(F(1, 2) > DummyRational(3, 4))
1027 self.assertFalse(F(1, 2) > DummyRational(1, 2))
1028 self.assertTrue(F(1, 2) > DummyRational(1, 7))
1029 self.assertTrue(F(1, 2) <= DummyRational(3, 4))
1030 self.assertTrue(F(1, 2) <= DummyRational(1, 2))
1031 self.assertFalse(F(1, 2) <= DummyRational(1, 7))
1032 self.assertFalse(F(1, 2) >= DummyRational(3, 4))
1033 self.assertTrue(F(1, 2) >= DummyRational(1, 2))
1034 self.assertTrue(F(1, 2) >= DummyRational(1, 7))
1035
1036 self.assertTrue(DummyRational(1, 2) < F(3, 4))
1037 self.assertFalse(DummyRational(1, 2) < F(1, 2))
1038 self.assertFalse(DummyRational(1, 2) < F(1, 7))
1039 self.assertFalse(DummyRational(1, 2) > F(3, 4))
1040 self.assertFalse(DummyRational(1, 2) > F(1, 2))
1041 self.assertTrue(DummyRational(1, 2) > F(1, 7))
1042 self.assertTrue(DummyRational(1, 2) <= F(3, 4))
1043 self.assertTrue(DummyRational(1, 2) <= F(1, 2))
1044 self.assertFalse(DummyRational(1, 2) <= F(1, 7))
1045 self.assertFalse(DummyRational(1, 2) >= F(3, 4))
1046 self.assertTrue(DummyRational(1, 2) >= F(1, 2))
1047 self.assertTrue(DummyRational(1, 2) >= F(1, 7))
1048
1049 def testComparisonsDummyFloat(self):
1050 x = DummyFloat(1./3.)
1051 y = F(1, 3)
1052 self.assertTrue(x != y)
1053 self.assertTrue(x < y or x > y)
1054 self.assertFalse(x == y)
1055 self.assertFalse(x <= y and x >= y)
1056 self.assertTrue(y != x)
1057 self.assertTrue(y < x or y > x)
1058 self.assertFalse(y == x)
1059 self.assertFalse(y <= x and y >= x)
1060
1061 def testMixedLess(self):
1062 self.assertTrue(2 < F(5, 2))
1063 self.assertFalse(2 < F(4, 2))
1064 self.assertTrue(F(5, 2) < 3)
1065 self.assertFalse(F(4, 2) < 2)
1066
1067 self.assertTrue(F(1, 2) < 0.6)
1068 self.assertFalse(F(1, 2) < 0.4)
1069 self.assertTrue(0.4 < F(1, 2))
1070 self.assertFalse(0.5 < F(1, 2))
1071
1072 self.assertFalse(float('inf') < F(1, 2))
1073 self.assertTrue(float('-inf') < F(0, 10))
1074 self.assertFalse(float('nan') < F(-3, 7))
1075 self.assertTrue(F(1, 2) < float('inf'))
1076 self.assertFalse(F(17, 12) < float('-inf'))
1077 self.assertFalse(F(144, -89) < float('nan'))
1078
1079 def testMixedLessEqual(self):
1080 self.assertTrue(0.5 <= F(1, 2))
1081 self.assertFalse(0.6 <= F(1, 2))
1082 self.assertTrue(F(1, 2) <= 0.5)
1083 self.assertFalse(F(1, 2) <= 0.4)
1084 self.assertTrue(2 <= F(4, 2))
1085 self.assertFalse(2 <= F(3, 2))
1086 self.assertTrue(F(4, 2) <= 2)
1087 self.assertFalse(F(5, 2) <= 2)
1088
1089 self.assertFalse(float('inf') <= F(1, 2))
1090 self.assertTrue(float('-inf') <= F(0, 10))
1091 self.assertFalse(float('nan') <= F(-3, 7))
1092 self.assertTrue(F(1, 2) <= float('inf'))
1093 self.assertFalse(F(17, 12) <= float('-inf'))
1094 self.assertFalse(F(144, -89) <= float('nan'))
1095
1096 def testBigFloatComparisons(self):
1097 # Because 10**23 can't be represented exactly as a float:
1098 self.assertFalse(F(10**23) == float(10**23))
1099 # The first test demonstrates why these are important.
1100 self.assertFalse(1e23 < float(F(math.trunc(1e23) + 1)))
1101 self.assertTrue(1e23 < F(math.trunc(1e23) + 1))
1102 self.assertFalse(1e23 <= F(math.trunc(1e23) - 1))
1103 self.assertTrue(1e23 > F(math.trunc(1e23) - 1))
1104 self.assertFalse(1e23 >= F(math.trunc(1e23) + 1))
1105
1106 def testBigComplexComparisons(self):
1107 self.assertFalse(F(10**23) == complex(10**23))
1108 self.assertRaises(TypeError, operator.gt, F(10**23), complex(10**23))
1109 self.assertRaises(TypeError, operator.le, F(10**23), complex(10**23))
1110
1111 x = F(3, 8)
1112 z = complex(0.375, 0.0)
1113 w = complex(0.375, 0.2)
1114 self.assertTrue(x == z)
1115 self.assertFalse(x != z)
1116 self.assertFalse(x == w)
1117 self.assertTrue(x != w)
1118 for op in operator.lt, operator.le, operator.gt, operator.ge:
1119 self.assertRaises(TypeError, op, x, z)
1120 self.assertRaises(TypeError, op, z, x)
1121 self.assertRaises(TypeError, op, x, w)
1122 self.assertRaises(TypeError, op, w, x)
1123
1124 def testMixedEqual(self):
1125 self.assertTrue(0.5 == F(1, 2))
1126 self.assertFalse(0.6 == F(1, 2))
1127 self.assertTrue(F(1, 2) == 0.5)
1128 self.assertFalse(F(1, 2) == 0.4)
1129 self.assertTrue(2 == F(4, 2))
1130 self.assertFalse(2 == F(3, 2))
1131 self.assertTrue(F(4, 2) == 2)
1132 self.assertFalse(F(5, 2) == 2)
1133 self.assertFalse(F(5, 2) == float('nan'))
1134 self.assertFalse(float('nan') == F(3, 7))
1135 self.assertFalse(F(5, 2) == float('inf'))
1136 self.assertFalse(float('-inf') == F(2, 5))
1137
1138 def testStringification(self):
1139 self.assertEqual("Fraction(7, 3)", repr(F(7, 3)))
1140 self.assertEqual("Fraction(6283185307, 2000000000)",
1141 repr(F('3.1415926535')))
1142 self.assertEqual("Fraction(-1, 100000000000000000000)",
1143 repr(F(1, -10**20)))
1144 self.assertEqual("7/3", str(F(7, 3)))
1145 self.assertEqual("7", str(F(7, 1)))
1146
1147 def testHash(self):
1148 hmod = sys.hash_info.modulus
1149 hinf = sys.hash_info.inf
1150 self.assertEqual(hash(2.5), hash(F(5, 2)))
1151 self.assertEqual(hash(10**50), hash(F(10**50)))
1152 self.assertNotEqual(hash(float(10**23)), hash(F(10**23)))
1153 self.assertEqual(hinf, hash(F(1, hmod)))
1154 # Check that __hash__ produces the same value as hash(), for
1155 # consistency with int and Decimal. (See issue #10356.)
1156 self.assertEqual(hash(F(-1)), F(-1).__hash__())
1157
1158 def testApproximatePi(self):
1159 # Algorithm borrowed from
1160 # http://docs.python.org/lib/decimal-recipes.html
1161 three = F(3)
1162 lasts, t, s, n, na, d, da = 0, three, 3, 1, 0, 0, 24
1163 while abs(s - lasts) > F(1, 10**9):
1164 lasts = s
1165 n, na = n+na, na+8
1166 d, da = d+da, da+32
1167 t = (t * n) / d
1168 s += t
1169 self.assertAlmostEqual(math.pi, s)
1170
1171 def testApproximateCos1(self):
1172 # Algorithm borrowed from
1173 # http://docs.python.org/lib/decimal-recipes.html
1174 x = F(1)
1175 i, lasts, s, fact, num, sign = 0, 0, F(1), 1, 1, 1
1176 while abs(s - lasts) > F(1, 10**9):
1177 lasts = s
1178 i += 2
1179 fact *= i * (i-1)
1180 num *= x * x
1181 sign *= -1
1182 s += num / fact * sign
1183 self.assertAlmostEqual(math.cos(1), s)
1184
1185 def test_copy_deepcopy_pickle(self):
1186 r = F(13, 7)
1187 dr = DummyFraction(13, 7)
1188 for proto in range(0, pickle.HIGHEST_PROTOCOL + 1):
1189 self.assertEqual(r, loads(dumps(r, proto)))
1190 self.assertEqual(id(r), id(copy(r)))
1191 self.assertEqual(id(r), id(deepcopy(r)))
1192 self.assertNotEqual(id(dr), id(copy(dr)))
1193 self.assertNotEqual(id(dr), id(deepcopy(dr)))
1194 self.assertTypedEquals(dr, copy(dr))
1195 self.assertTypedEquals(dr, deepcopy(dr))
1196
1197 def test_slots(self):
1198 # Issue 4998
1199 r = F(13, 7)
1200 self.assertRaises(AttributeError, setattr, r, 'a', 10)
1201
1202 def test_int_subclass(self):
1203 class myint(int):
1204 def __mul__(self, other):
1205 return type(self)(int(self) * int(other))
1206 def __floordiv__(self, other):
1207 return type(self)(int(self) // int(other))
1208 def __mod__(self, other):
1209 x = type(self)(int(self) % int(other))
1210 return x
1211 @property
1212 def numerator(self):
1213 return type(self)(int(self))
1214 @property
1215 def denominator(self):
1216 return type(self)(1)
1217
1218 f = fractions.Fraction(myint(1 * 3), myint(2 * 3))
1219 self.assertEqual(f.numerator, 1)
1220 self.assertEqual(f.denominator, 2)
1221 self.assertEqual(type(f.numerator), myint)
1222 self.assertEqual(type(f.denominator), myint)
1223
1224 def test_format_no_presentation_type(self):
1225 # Triples (fraction, specification, expected_result).
1226 testcases = [
1227 # Explicit sign handling
1228 (F(2, 3), '+', '+2/3'),
1229 (F(-2, 3), '+', '-2/3'),
1230 (F(3), '+', '+3'),
1231 (F(-3), '+', '-3'),
1232 (F(2, 3), ' ', ' 2/3'),
1233 (F(-2, 3), ' ', '-2/3'),
1234 (F(3), ' ', ' 3'),
1235 (F(-3), ' ', '-3'),
1236 (F(2, 3), '-', '2/3'),
1237 (F(-2, 3), '-', '-2/3'),
1238 (F(3), '-', '3'),
1239 (F(-3), '-', '-3'),
1240 # Padding
1241 (F(0), '5', ' 0'),
1242 (F(2, 3), '5', ' 2/3'),
1243 (F(-2, 3), '5', ' -2/3'),
1244 (F(2, 3), '0', '2/3'),
1245 (F(2, 3), '1', '2/3'),
1246 (F(2, 3), '2', '2/3'),
1247 # Alignment
1248 (F(2, 3), '<5', '2/3 '),
1249 (F(2, 3), '>5', ' 2/3'),
1250 (F(2, 3), '^5', ' 2/3 '),
1251 (F(2, 3), '=5', ' 2/3'),
1252 (F(-2, 3), '<5', '-2/3 '),
1253 (F(-2, 3), '>5', ' -2/3'),
1254 (F(-2, 3), '^5', '-2/3 '),
1255 (F(-2, 3), '=5', '- 2/3'),
1256 # Fill
1257 (F(2, 3), 'X>5', 'XX2/3'),
1258 (F(-2, 3), '.<5', '-2/3.'),
1259 (F(-2, 3), '\n^6', '\n-2/3\n'),
1260 # Thousands separators
1261 (F(1234, 5679), ',', '1,234/5,679'),
1262 (F(-1234, 5679), '_', '-1_234/5_679'),
1263 (F(1234567), '_', '1_234_567'),
1264 (F(-1234567), ',', '-1,234,567'),
1265 # Alternate form forces a slash in the output
1266 (F(123), '#', '123/1'),
1267 (F(-123), '#', '-123/1'),
1268 (F(0), '#', '0/1'),
1269 ]
1270 for fraction, spec, expected in testcases:
1271 with self.subTest(fraction=fraction, spec=spec):
1272 self.assertEqual(format(fraction, spec), expected)
1273
1274 def test_format_e_presentation_type(self):
1275 # Triples (fraction, specification, expected_result)
1276 testcases = [
1277 (F(2, 3), '.6e', '6.666667e-01'),
1278 (F(3, 2), '.6e', '1.500000e+00'),
1279 (F(2, 13), '.6e', '1.538462e-01'),
1280 (F(2, 23), '.6e', '8.695652e-02'),
1281 (F(2, 33), '.6e', '6.060606e-02'),
1282 (F(13, 2), '.6e', '6.500000e+00'),
1283 (F(20, 2), '.6e', '1.000000e+01'),
1284 (F(23, 2), '.6e', '1.150000e+01'),
1285 (F(33, 2), '.6e', '1.650000e+01'),
1286 (F(2, 3), '.6e', '6.666667e-01'),
1287 (F(3, 2), '.6e', '1.500000e+00'),
1288 # Zero
1289 (F(0), '.3e', '0.000e+00'),
1290 # Powers of 10, to exercise the log10 boundary logic
1291 (F(1, 1000), '.3e', '1.000e-03'),
1292 (F(1, 100), '.3e', '1.000e-02'),
1293 (F(1, 10), '.3e', '1.000e-01'),
1294 (F(1, 1), '.3e', '1.000e+00'),
1295 (F(10), '.3e', '1.000e+01'),
1296 (F(100), '.3e', '1.000e+02'),
1297 (F(1000), '.3e', '1.000e+03'),
1298 # Boundary where we round up to the next power of 10
1299 (F('99.999994999999'), '.6e', '9.999999e+01'),
1300 (F('99.999995'), '.6e', '1.000000e+02'),
1301 (F('99.999995000001'), '.6e', '1.000000e+02'),
1302 # Negatives
1303 (F(-2, 3), '.6e', '-6.666667e-01'),
1304 (F(-3, 2), '.6e', '-1.500000e+00'),
1305 (F(-100), '.6e', '-1.000000e+02'),
1306 # Large and small
1307 (F('1e1000'), '.3e', '1.000e+1000'),
1308 (F('1e-1000'), '.3e', '1.000e-1000'),
1309 # Using 'E' instead of 'e' should give us a capital 'E'
1310 (F(2, 3), '.6E', '6.666667E-01'),
1311 # Tiny precision
1312 (F(2, 3), '.1e', '6.7e-01'),
1313 (F('0.995'), '.0e', '1e+00'),
1314 # Default precision is 6
1315 (F(22, 7), 'e', '3.142857e+00'),
1316 # Alternate form forces a decimal point
1317 (F('0.995'), '#.0e', '1.e+00'),
1318 # Check that padding takes the exponent into account.
1319 (F(22, 7), '11.6e', '3.142857e+00'),
1320 (F(22, 7), '12.6e', '3.142857e+00'),
1321 (F(22, 7), '13.6e', ' 3.142857e+00'),
1322 # Thousands separators
1323 (F('1234567.123456'), ',.5e', '1.23457e+06'),
1324 (F('123.123456'), '012_.2e', '0_001.23e+02'),
1325 # Thousands separators for fractional part (or for integral too)
1326 (F('1234567.123456'), '.5_e', '1.234_57e+06'),
1327 # z flag is legal, but never makes a difference to the output
1328 (F(-1, 7**100), 'z.6e', '-3.091690e-85'),
1329 ]
1330 for fraction, spec, expected in testcases:
1331 with self.subTest(fraction=fraction, spec=spec):
1332 self.assertEqual(format(fraction, spec), expected)
1333
1334 def test_format_f_presentation_type(self):
1335 # Triples (fraction, specification, expected_result)
1336 testcases = [
1337 # Simple .f formatting
1338 (F(0, 1), '.2f', '0.00'),
1339 (F(1, 3), '.2f', '0.33'),
1340 (F(2, 3), '.2f', '0.67'),
1341 (F(4, 3), '.2f', '1.33'),
1342 (F(1, 8), '.2f', '0.12'),
1343 (F(3, 8), '.2f', '0.38'),
1344 (F(1, 13), '.2f', '0.08'),
1345 (F(1, 199), '.2f', '0.01'),
1346 (F(1, 200), '.2f', '0.00'),
1347 (F(22, 7), '.5f', '3.14286'),
1348 (F('399024789'), '.2f', '399024789.00'),
1349 # Large precision (more than float can provide)
1350 (F(104348, 33215), '.50f',
1351 '3.14159265392142104470871594159265392142104470871594'),
1352 # Precision defaults to 6 if not given
1353 (F(22, 7), 'f', '3.142857'),
1354 (F(0), 'f', '0.000000'),
1355 (F(-22, 7), 'f', '-3.142857'),
1356 # Round-ties-to-even checks
1357 (F('1.225'), '.2f', '1.22'),
1358 (F('1.2250000001'), '.2f', '1.23'),
1359 (F('1.2349999999'), '.2f', '1.23'),
1360 (F('1.235'), '.2f', '1.24'),
1361 (F('1.245'), '.2f', '1.24'),
1362 (F('1.2450000001'), '.2f', '1.25'),
1363 (F('1.2549999999'), '.2f', '1.25'),
1364 (F('1.255'), '.2f', '1.26'),
1365 (F('-1.225'), '.2f', '-1.22'),
1366 (F('-1.2250000001'), '.2f', '-1.23'),
1367 (F('-1.2349999999'), '.2f', '-1.23'),
1368 (F('-1.235'), '.2f', '-1.24'),
1369 (F('-1.245'), '.2f', '-1.24'),
1370 (F('-1.2450000001'), '.2f', '-1.25'),
1371 (F('-1.2549999999'), '.2f', '-1.25'),
1372 (F('-1.255'), '.2f', '-1.26'),
1373 # Negatives and sign handling
1374 (F(2, 3), '.2f', '0.67'),
1375 (F(2, 3), '-.2f', '0.67'),
1376 (F(2, 3), '+.2f', '+0.67'),
1377 (F(2, 3), ' .2f', ' 0.67'),
1378 (F(-2, 3), '.2f', '-0.67'),
1379 (F(-2, 3), '-.2f', '-0.67'),
1380 (F(-2, 3), '+.2f', '-0.67'),
1381 (F(-2, 3), ' .2f', '-0.67'),
1382 # Formatting to zero places
1383 (F(1, 2), '.0f', '0'),
1384 (F(-1, 2), '.0f', '-0'),
1385 (F(22, 7), '.0f', '3'),
1386 (F(-22, 7), '.0f', '-3'),
1387 # Formatting to zero places, alternate form
1388 (F(1, 2), '#.0f', '0.'),
1389 (F(-1, 2), '#.0f', '-0.'),
1390 (F(22, 7), '#.0f', '3.'),
1391 (F(-22, 7), '#.0f', '-3.'),
1392 # z flag for suppressing negative zeros
1393 (F('-0.001'), 'z.2f', '0.00'),
1394 (F('-0.001'), '-z.2f', '0.00'),
1395 (F('-0.001'), '+z.2f', '+0.00'),
1396 (F('-0.001'), ' z.2f', ' 0.00'),
1397 (F('0.001'), 'z.2f', '0.00'),
1398 (F('0.001'), '-z.2f', '0.00'),
1399 (F('0.001'), '+z.2f', '+0.00'),
1400 (F('0.001'), ' z.2f', ' 0.00'),
1401 # Specifying a minimum width
1402 (F(2, 3), '6.2f', ' 0.67'),
1403 (F(12345), '6.2f', '12345.00'),
1404 (F(12345), '12f', '12345.000000'),
1405 # Fill and alignment
1406 (F(2, 3), '>6.2f', ' 0.67'),
1407 (F(2, 3), '<6.2f', '0.67 '),
1408 (F(2, 3), '^3.2f', '0.67'),
1409 (F(2, 3), '^4.2f', '0.67'),
1410 (F(2, 3), '^5.2f', '0.67 '),
1411 (F(2, 3), '^6.2f', ' 0.67 '),
1412 (F(2, 3), '^7.2f', ' 0.67 '),
1413 (F(2, 3), '^8.2f', ' 0.67 '),
1414 # '=' alignment
1415 (F(-2, 3), '=+8.2f', '- 0.67'),
1416 (F(2, 3), '=+8.2f', '+ 0.67'),
1417 # Fill character
1418 (F(-2, 3), 'X>3.2f', '-0.67'),
1419 (F(-2, 3), 'X>7.2f', 'XX-0.67'),
1420 (F(-2, 3), 'X<7.2f', '-0.67XX'),
1421 (F(-2, 3), 'X^7.2f', 'X-0.67X'),
1422 (F(-2, 3), 'X=7.2f', '-XX0.67'),
1423 (F(-2, 3), ' >7.2f', ' -0.67'),
1424 # Corner cases: weird fill characters
1425 (F(-2, 3), '\x00>7.2f', '\x00\x00-0.67'),
1426 (F(-2, 3), '\n>7.2f', '\n\n-0.67'),
1427 (F(-2, 3), '\t>7.2f', '\t\t-0.67'),
1428 (F(-2, 3), '>>7.2f', '>>-0.67'),
1429 (F(-2, 3), '<>7.2f', '<<-0.67'),
1430 (F(-2, 3), '→>7.2f', '→→-0.67'),
1431 # Zero-padding
1432 (F(-2, 3), '07.2f', '-000.67'),
1433 (F(-2, 3), '-07.2f', '-000.67'),
1434 (F(2, 3), '+07.2f', '+000.67'),
1435 (F(2, 3), ' 07.2f', ' 000.67'),
1436 # An isolated zero is a minimum width, not a zero-pad flag.
1437 # So unlike zero-padding, it's legal in combination with alignment.
1438 (F(2, 3), '0.2f', '0.67'),
1439 (F(2, 3), '>0.2f', '0.67'),
1440 (F(2, 3), '<0.2f', '0.67'),
1441 (F(2, 3), '^0.2f', '0.67'),
1442 (F(2, 3), '=0.2f', '0.67'),
1443 # Corner case: zero-padding _and_ a zero minimum width.
1444 (F(2, 3), '00.2f', '0.67'),
1445 # Thousands separator (only affects portion before the point)
1446 (F(2, 3), ',.2f', '0.67'),
1447 (F(2, 3), ',.7f', '0.6666667'),
1448 (F('123456.789'), ',.2f', '123,456.79'),
1449 (F('1234567'), ',.2f', '1,234,567.00'),
1450 (F('12345678'), ',.2f', '12,345,678.00'),
1451 (F('12345678'), ',f', '12,345,678.000000'),
1452 # Thousands separators for fractional part (or for integral too)
1453 (F('123456.789123123'), '._f', '123456.789_123'),
1454 (F('123456.789123123'), '.7_f', '123456.789_123_1'),
1455 (F('123456.789123123'), '.9_f', '123456.789_123_123'),
1456 (F('123456.789123123'), '.,f', '123456.789,123'),
1457 (F('123456.789123123'), '_.,f', '123_456.789,123'),
1458 # Underscore as thousands separator
1459 (F(2, 3), '_.2f', '0.67'),
1460 (F(2, 3), '_.7f', '0.6666667'),
1461 (F('123456.789'), '_.2f', '123_456.79'),
1462 (F('1234567'), '_.2f', '1_234_567.00'),
1463 (F('12345678'), '_.2f', '12_345_678.00'),
1464 # Thousands and zero-padding
1465 (F('1234.5678'), '07,.2f', '1,234.57'),
1466 (F('1234.5678'), '08,.2f', '1,234.57'),
1467 (F('1234.5678'), '09,.2f', '01,234.57'),
1468 (F('1234.5678'), '010,.2f', '001,234.57'),
1469 (F('1234.5678'), '011,.2f', '0,001,234.57'),
1470 (F('1234.5678'), '012,.2f', '0,001,234.57'),
1471 (F('1234.5678'), '013,.2f', '00,001,234.57'),
1472 (F('1234.5678'), '014,.2f', '000,001,234.57'),
1473 (F('1234.5678'), '015,.2f', '0,000,001,234.57'),
1474 (F('1234.5678'), '016,.2f', '0,000,001,234.57'),
1475 (F('-1234.5678'), '07,.2f', '-1,234.57'),
1476 (F('-1234.5678'), '08,.2f', '-1,234.57'),
1477 (F('-1234.5678'), '09,.2f', '-1,234.57'),
1478 (F('-1234.5678'), '010,.2f', '-01,234.57'),
1479 (F('-1234.5678'), '011,.2f', '-001,234.57'),
1480 (F('-1234.5678'), '012,.2f', '-0,001,234.57'),
1481 (F('-1234.5678'), '013,.2f', '-0,001,234.57'),
1482 (F('-1234.5678'), '014,.2f', '-00,001,234.57'),
1483 (F('-1234.5678'), '015,.2f', '-000,001,234.57'),
1484 (F('-1234.5678'), '016,.2f', '-0,000,001,234.57'),
1485 # Corner case: no decimal point
1486 (F('-1234.5678'), '06,.0f', '-1,235'),
1487 (F('-1234.5678'), '07,.0f', '-01,235'),
1488 (F('-1234.5678'), '08,.0f', '-001,235'),
1489 (F('-1234.5678'), '09,.0f', '-0,001,235'),
1490 # Corner-case - zero-padding specified through fill and align
1491 # instead of the zero-pad character.
1492 (F('1234.5678'), '0=12,.2f', '0,001,234.57'),
1493 # Corner case where it's not clear whether the '0' indicates zero
1494 # padding or gives the minimum width, but there's still an obvious
1495 # answer to give. We want this to work in case the minimum width
1496 # is being inserted programmatically: spec = f'{width}.2f'.
1497 (F('12.34'), '0.2f', '12.34'),
1498 (F('12.34'), 'X>0.2f', '12.34'),
1499 # 'F' should work identically to 'f'
1500 (F(22, 7), '.5F', '3.14286'),
1501 # %-specifier
1502 (F(22, 7), '.2%', '314.29%'),
1503 (F(1, 7), '.2%', '14.29%'),
1504 (F(1, 70), '.2%', '1.43%'),
1505 (F(1, 700), '.2%', '0.14%'),
1506 (F(1, 7000), '.2%', '0.01%'),
1507 (F(1, 70000), '.2%', '0.00%'),
1508 (F(1, 7), '.0%', '14%'),
1509 (F(1, 7), '#.0%', '14.%'),
1510 (F(100, 7), ',.2%', '1,428.57%'),
1511 (F(22, 7), '7.2%', '314.29%'),
1512 (F(22, 7), '8.2%', ' 314.29%'),
1513 (F(22, 7), '08.2%', '0314.29%'),
1514 # Test cases from #67790 and discuss.python.org Ideas thread.
1515 (F(1, 3), '.2f', '0.33'),
1516 (F(1, 8), '.2f', '0.12'),
1517 (F(3, 8), '.2f', '0.38'),
1518 (F(2545, 1000), '.2f', '2.54'),
1519 (F(2549, 1000), '.2f', '2.55'),
1520 (F(2635, 1000), '.2f', '2.64'),
1521 (F(1, 100), '.1f', '0.0'),
1522 (F(49, 1000), '.1f', '0.0'),
1523 (F(51, 1000), '.1f', '0.1'),
1524 (F(149, 1000), '.1f', '0.1'),
1525 (F(151, 1000), '.1f', '0.2'),
1526 (F(22, 7), '.02f', '3.14'), # issue gh-130662
1527 (F(22, 7), '005.02f', '03.14'),
1528 ]
1529 for fraction, spec, expected in testcases:
1530 with self.subTest(fraction=fraction, spec=spec):
1531 self.assertEqual(format(fraction, spec), expected)
1532
1533 def test_format_g_presentation_type(self):
1534 # Triples (fraction, specification, expected_result)
1535 testcases = [
1536 (F('0.000012345678'), '.6g', '1.23457e-05'),
1537 (F('0.00012345678'), '.6g', '0.000123457'),
1538 (F('0.0012345678'), '.6g', '0.00123457'),
1539 (F('0.012345678'), '.6g', '0.0123457'),
1540 (F('0.12345678'), '.6g', '0.123457'),
1541 (F('1.2345678'), '.6g', '1.23457'),
1542 (F('12.345678'), '.6g', '12.3457'),
1543 (F('123.45678'), '.6g', '123.457'),
1544 (F('1234.5678'), '.6g', '1234.57'),
1545 (F('12345.678'), '.6g', '12345.7'),
1546 (F('123456.78'), '.6g', '123457'),
1547 (F('1234567.8'), '.6g', '1.23457e+06'),
1548 # Rounding up cases
1549 (F('9.99999e+2'), '.4g', '1000'),
1550 (F('9.99999e-8'), '.4g', '1e-07'),
1551 (F('9.99999e+8'), '.4g', '1e+09'),
1552 # Check round-ties-to-even behaviour
1553 (F('-0.115'), '.2g', '-0.12'),
1554 (F('-0.125'), '.2g', '-0.12'),
1555 (F('-0.135'), '.2g', '-0.14'),
1556 (F('-0.145'), '.2g', '-0.14'),
1557 (F('0.115'), '.2g', '0.12'),
1558 (F('0.125'), '.2g', '0.12'),
1559 (F('0.135'), '.2g', '0.14'),
1560 (F('0.145'), '.2g', '0.14'),
1561 # Trailing zeros and decimal point suppressed by default ...
1562 (F(0), '.6g', '0'),
1563 (F('123.400'), '.6g', '123.4'),
1564 (F('123.000'), '.6g', '123'),
1565 (F('120.000'), '.6g', '120'),
1566 (F('12000000'), '.6g', '1.2e+07'),
1567 # ... but not when alternate form is in effect
1568 (F(0), '#.6g', '0.00000'),
1569 (F('123.400'), '#.6g', '123.400'),
1570 (F('123.000'), '#.6g', '123.000'),
1571 (F('120.000'), '#.6g', '120.000'),
1572 (F('12000000'), '#.6g', '1.20000e+07'),
1573 # 'G' format (uses 'E' instead of 'e' for the exponent indicator)
1574 (F('123.45678'), '.6G', '123.457'),
1575 (F('1234567.8'), '.6G', '1.23457E+06'),
1576 # Default precision is 6 significant figures
1577 (F('3.1415926535'), 'g', '3.14159'),
1578 # Precision 0 is treated the same as precision 1.
1579 (F('0.000031415'), '.0g', '3e-05'),
1580 (F('0.00031415'), '.0g', '0.0003'),
1581 (F('0.31415'), '.0g', '0.3'),
1582 (F('3.1415'), '.0g', '3'),
1583 (F('3.1415'), '#.0g', '3.'),
1584 (F('31.415'), '.0g', '3e+01'),
1585 (F('31.415'), '#.0g', '3.e+01'),
1586 (F('0.000031415'), '.1g', '3e-05'),
1587 (F('0.00031415'), '.1g', '0.0003'),
1588 (F('0.31415'), '.1g', '0.3'),
1589 (F('3.1415'), '.1g', '3'),
1590 (F('3.1415'), '#.1g', '3.'),
1591 (F('31.415'), '.1g', '3e+01'),
1592 # Thousands separator
1593 (F(2**64), '_.25g', '18_446_744_073_709_551_616'),
1594 # As with 'e' format, z flag is legal, but has no effect
1595 (F(-1, 7**100), 'zg', '-3.09169e-85'),
1596 ]
1597 for fraction, spec, expected in testcases:
1598 with self.subTest(fraction=fraction, spec=spec):
1599 self.assertEqual(format(fraction, spec), expected)
1600
1601 def test_invalid_formats(self):
1602 fraction = F(2, 3)
1603 with self.assertRaises(TypeError):
1604 format(fraction, None)
1605
1606 invalid_specs = [
1607 'Q6f', # regression test
1608 # illegal to use fill or alignment when zero padding
1609 'X>010f',
1610 'X<010f',
1611 'X^010f',
1612 'X=010f',
1613 '0>010f',
1614 '0<010f',
1615 '0^010f',
1616 '0=010f',
1617 '>010f',
1618 '<010f',
1619 '^010f',
1620 '=010e',
1621 '=010f',
1622 '=010g',
1623 '=010%',
1624 '>00.2f',
1625 '>00f',
1626 # Missing precision
1627 '.e',
1628 '.f',
1629 '.g',
1630 '.%',
1631 # Thousands separators before precision
1632 '._6e',
1633 '._6f',
1634 '._6g',
1635 '._6%',
1636 # Z instead of z for negative zero suppression
1637 'Z.2f'
1638 # z flag not supported for general formatting
1639 'z',
1640 # zero padding not supported for general formatting
1641 '05',
1642 ]
1643 for spec in invalid_specs:
1644 with self.subTest(spec=spec):
1645 with self.assertRaises(ValueError):
1646 format(fraction, spec)
1647
1648 @requires_IEEE_754
1649 def test_float_format_testfile(self):
1650 with open(format_testfile, encoding="utf-8") as testfile:
1651 for line in testfile:
1652 if line.startswith('--'):
1653 continue
1654 line = line.strip()
1655 if not line:
1656 continue
1657
1658 lhs, rhs = map(str.strip, line.split('->'))
1659 fmt, arg = lhs.split()
1660 if fmt == '%r':
1661 continue
1662 fmt2 = fmt[1:]
1663 with self.subTest(fmt=fmt, arg=arg):
1664 f = F(float(arg))
1665 self.assertEqual(format(f, fmt2), rhs)
1666 if f: # skip negative zero
1667 self.assertEqual(format(-f, fmt2), '-' + rhs)
1668 f = F(arg)
1669 self.assertEqual(float(format(f, fmt2)), float(rhs))
1670 self.assertEqual(float(format(-f, fmt2)), float('-' + rhs))
1671
1672 def test_complex_handling(self):
1673 # See issue gh-102840 for more details.
1674
1675 a = F(1, 2)
1676 b = 1j
1677 message = "unsupported operand type(s) for %s: '%s' and '%s'"
1678 # test forward
1679 self.assertRaisesMessage(TypeError,
1680 message % ("%", "Fraction", "complex"),
1681 operator.mod, a, b)
1682 self.assertRaisesMessage(TypeError,
1683 message % ("//", "Fraction", "complex"),
1684 operator.floordiv, a, b)
1685 self.assertRaisesMessage(TypeError,
1686 message % ("divmod()", "Fraction", "complex"),
1687 divmod, a, b)
1688 # test reverse
1689 self.assertRaisesMessage(TypeError,
1690 message % ("%", "complex", "Fraction"),
1691 operator.mod, b, a)
1692 self.assertRaisesMessage(TypeError,
1693 message % ("//", "complex", "Fraction"),
1694 operator.floordiv, b, a)
1695 self.assertRaisesMessage(TypeError,
1696 message % ("divmod()", "complex", "Fraction"),
1697 divmod, b, a)
1698
1699 def test_three_argument_pow(self):
1700 message = "unsupported operand type(s) for ** or pow(): '%s', '%s', '%s'"
1701 self.assertRaisesMessage(TypeError,
1702 message % ("Fraction", "int", "int"),
1703 pow, F(3), 4, 5)
1704 self.assertRaisesMessage(TypeError,
1705 message % ("int", "Fraction", "int"),
1706 pow, 3, F(4), 5)
1707 self.assertRaisesMessage(TypeError,
1708 message % ("int", "int", "Fraction"),
1709 pow, 3, 4, F(5))
1710
1711
1712 if __name__ == '__main__':
1713 unittest.main()