Lines Matching +full:- +full:j
18 (1+1j, 0+0j),
19 (1+1j, 0.0),
20 (1+1j, 0),
21 (1.0, 0+0j),
22 (1, 0+0j),
63 def assertCloseAbs(self, x, y, eps=1e-9):
73 self.assertTrue(abs((x-y)/y) < eps)
75 def assertClose(self, x, y, eps=1e-9):
95 simple_real = [float(i) for i in range(-5, 6)]
103 self.check_div(complex(1e200, 1e200), 1+0j)
104 self.check_div(complex(1e-200, 1e-200), 1+0j)
111 self.assertAlmostEqual(complex.__truediv__(2+0j, 1+1j), 1-1j)
112 self.assertRaises(TypeError, operator.truediv, 1j, None)
113 self.assertRaises(TypeError, operator.truediv, None, 1j)
127 (1+1j) // (1+0j)
129 (1+1j) // 1.0
131 (1+1j) // 1
133 1.0 // (1+0j)
135 1 // (1+0j)
143 self.assertIs(complex.__eq__(1+1j, 1<<10000), False)
144 self.assertIs(complex.__lt__(1+1j, None), NotImplemented)
145 self.assertIs(complex.__eq__(1+1j, None), NotImplemented)
146 self.assertIs(complex.__eq__(1+1j, 1+1j), True)
147 self.assertIs(complex.__eq__(1+1j, 2+2j), False)
148 self.assertIs(complex.__ne__(1+1j, 1+1j), False)
149 self.assertIs(complex.__ne__(1+1j, 2+2j), True)
152 self.assertIs(complex.__eq__(f+0j, f), True)
153 self.assertIs(complex.__ne__(f+0j, f), False)
156 self.assertIs(complex.__lt__(1+1j, 2+2j), NotImplemented)
157 self.assertIs(complex.__le__(1+1j, 2+2j), NotImplemented)
158 self.assertIs(complex.__gt__(1+1j, 2+2j), NotImplemented)
159 self.assertIs(complex.__ge__(1+1j, 2+2j), NotImplemented)
160 self.assertRaises(TypeError, operator.lt, 1+1j, 2+2j)
161 self.assertRaises(TypeError, operator.le, 1+1j, 2+2j)
162 self.assertRaises(TypeError, operator.gt, 1+1j, 2+2j)
163 self.assertRaises(TypeError, operator.ge, 1+1j, 2+2j)
164 self.assertIs(operator.eq(1+1j, 1+1j), True)
165 self.assertIs(operator.eq(1+1j, 2+2j), False)
166 self.assertIs(operator.ne(1+1j, 1+1j), False)
167 self.assertIs(operator.ne(1+1j, 2+2j), True)
168 self.assertIs(operator.eq(1+1j, 2.0), False)
177 # For IEEE-754 doubles the following should hold:
178 # x in [2 ** (52 + i), 2 ** (53 + i + 1)] -> x mod 2 ** i == 0
185 check(2 ** 53, range(-100, 0), lambda delta: True)
188 self.assertEqual(1j + int(+1), complex(+1, 1))
189 self.assertEqual(1j + int(-1), complex(-1, 1))
190 self.assertRaises(OverflowError, operator.add, 1j, 10**1000)
191 self.assertRaises(TypeError, operator.add, 1j, None)
192 self.assertRaises(TypeError, operator.add, None, 1j)
195 self.assertEqual(1j - int(+1), complex(-1, 1))
196 self.assertEqual(1j - int(-1), complex(1, 1))
197 self.assertRaises(OverflowError, operator.sub, 1j, 10**1000)
198 self.assertRaises(TypeError, operator.sub, 1j, None)
199 self.assertRaises(TypeError, operator.sub, None, 1j)
202 self.assertEqual(1j * int(20), complex(0, 20))
203 self.assertEqual(1j * int(-1), complex(0, -1))
204 self.assertRaises(OverflowError, operator.mul, 1j, 10**1000)
205 self.assertRaises(TypeError, operator.mul, 1j, None)
206 self.assertRaises(TypeError, operator.mul, None, 1j)
211 (1+1j) % (1+0j)
213 (1+1j) % 1.0
215 (1+1j) % 1
217 1.0 % (1+0j)
219 1 % (1+0j)
227 self.assertRaises(TypeError, divmod, 1+1j, 1+0j)
228 self.assertRaises(TypeError, divmod, 1+1j, 1.0)
229 self.assertRaises(TypeError, divmod, 1+1j, 1)
230 self.assertRaises(TypeError, divmod, 1.0, 1+0j)
231 self.assertRaises(TypeError, divmod, 1, 1+0j)
238 self.assertAlmostEqual(pow(1+1j, 0+0j), 1.0)
239 self.assertAlmostEqual(pow(0+0j, 2+0j), 0.0)
240 self.assertEqual(pow(0+0j, 2000+0j), 0.0)
241 self.assertEqual(pow(0, 0+0j), 1.0)
242 self.assertEqual(pow(-1, 0+0j), 1.0)
243 self.assertRaises(ZeroDivisionError, pow, 0+0j, 1j)
244 self.assertRaises(ZeroDivisionError, pow, 0+0j, -1000)
245 self.assertAlmostEqual(pow(1j, -1), 1/1j)
246 self.assertAlmostEqual(pow(1j, 200), 1)
247 self.assertRaises(ValueError, pow, 1+1j, 1+1j, 1+1j)
248 self.assertRaises(OverflowError, pow, 1e200+1j, 1e200+1j)
249 self.assertRaises(TypeError, pow, 1j, None)
250 self.assertRaises(TypeError, pow, None, 1j)
251 self.assertAlmostEqual(pow(1j, 0.5), 0.7071067811865476+0.7071067811865475j)
253 a = 3.33+4.43j
254 self.assertEqual(a ** 0j, 1)
255 self.assertEqual(a ** 0.+0.j, 1)
257 self.assertEqual(3j ** 0j, 1)
258 self.assertEqual(3j ** 0, 1)
261 0j ** a
268 0j ** (3-2j)
276 self.assertEqual(a ** -105, a ** -105)
277 self.assertEqual(a ** -30, a ** -30)
279 self.assertEqual(0.0j ** 0, 1)
281 b = 5.1+2.3j
289 values = (sys.maxsize, sys.maxsize+1, sys.maxsize-1,
290 -sys.maxsize, -sys.maxsize+1, -sys.maxsize+1)
304 # gh-113841: possible undefined division by 0 in _Py_c_pow()
305 x, y = 9j, 33j**3
315 complex(-4.0, INF),
318 exponents = [-19, -5, -3, -2, -1, 0, 1, 2, 3, 5, 19]
339 self.assertTrue(complex(random() + 1e-6, random() + 1e-6))
341 self.assertTrue(1j)
344 self.assertClose(complex(5.3, 9.8).conjugate(), 5.3-9.8j)
355 check(complex(4.25+0j), 4.25, 0.0)
356 check(complex(4.25+0.5j), 4.25, 0.5)
357 check(complex(ComplexSubclass(4.25+0.5j)), 4.25, 0.5)
358 check(complex(WithComplex(4.25+0.5j)), 4.25, 0.5)
368 check(complex(4.25+0j, 0), 4.25, 0.0)
369 check(complex(ComplexSubclass(4.25+0j), 0), 4.25, 0.0)
370 check(complex(WithComplex(4.25+0j), 0), 4.25, 0.0)
371 check(complex(4.25j, 0), 0.0, 4.25)
372 check(complex(0j, 4.25), 0.0, 4.25)
373 check(complex(0, 4.25+0j), 0.0, 4.25)
374 check(complex(0, ComplexSubclass(4.25+0j)), 0.0, 4.25)
377 complex(0, WithComplex(4.25+0j))
378 check(complex(0.0, 4.25j), -4.25, 0.0)
379 check(complex(4.25+0j, 0j), 4.25, 0.0)
380 check(complex(4.25j, 0j), 0.0, 4.25)
381 check(complex(0j, 4.25+0j), 0.0, 4.25)
382 check(complex(0j, 4.25j), -4.25, 0.0)
385 check(complex(real=4.25+0j), 4.25, 0.0)
386 check(complex(real=4.25+1.5j), 4.25, 1.5)
393 for x in 1.0, -1.0:
394 for y in 0.0, -0.0:
427 self.assertRaises(TypeError, complex, WithComplex(4.25+0j), object())
472 return 42j
476 def __new__(self, value=0j):
487 check(complex(complex0(1j)), 0.0, 42.0)
489 check(complex(complex1(1j)), 0.0, 2.0)
490 self.assertRaises(TypeError, complex, complex2(1j))
493 z = 3 + 4j
497 z = ComplexSubclass(3 + 4j)
498 self.assertEqual(z.__complex__(), 3 + 4j)
503 for x in 0.0, -0.0, INF, -INF, NAN:
504 for y in 0.0, -0.0, INF, -INF, NAN:
529 check(complex("1j"), 0.0, 1.0)
530 check(complex("-1"), -1.0, 0.0)
532 check(complex("1+2j"), 1.0, 2.0)
533 check(complex("(1+2j)"), 1.0, 2.0)
534 check(complex("(1.5+4.25j)"), 1.5, 4.25)
535 check(complex("4.25+1J"), 4.25, 1.0)
536 check(complex(" ( +4.25-6J )"), 4.25, -6.0)
537 check(complex(" ( +4.25-J )"), 4.25, -1.0)
538 check(complex(" ( +4.25+j )"), 4.25, 1.0)
539 check(complex("J"), 0.0, 1.0)
540 check(complex("( j )"), 0.0, 1.0)
541 check(complex("+J"), 0.0, 1.0)
542 check(complex("( -j)"), 0.0, -1.0)
543 check(complex('1-1j'), 1.0, -1.0)
544 check(complex('1J'), 0.0, 1.0)
546 check(complex('1e-500'), 0.0, 0.0)
547 check(complex('-1e-500j'), 0.0, -0.0)
548 check(complex('1e-500+1e-500j'), 0.0, 0.0)
549 check(complex('-1e-500+1e-500j'), -0.0, 0.0)
550 check(complex('1e-500-1e-500j'), 0.0, -0.0)
551 check(complex('-1e-500-1e-500j'), -0.0, -0.0)
555 self.assertRaises(ValueError, complex, '1+1j\0j')
560 self.assertRaises(ValueError, complex, "1+1j+1j")
561 self.assertRaises(ValueError, complex, "--")
562 self.assertRaises(ValueError, complex, "(1+2j")
563 self.assertRaises(ValueError, complex, "1+2j)")
564 self.assertRaises(ValueError, complex, "1+(2j)")
565 self.assertRaises(ValueError, complex, "(1+2j)123")
567 self.assertRaises(ValueError, complex, "1j+2")
570 self.assertRaises(ValueError, complex, ")1+2j(")
572 self.assertRaises(ValueError, complex, "1..1j")
573 self.assertRaises(ValueError, complex, "1.11.1j")
574 self.assertRaises(ValueError, complex, "1e1.1j")
579 self.assertEqual(complex('\N{EM SPACE}(\N{EN SPACE}1+1j ) '), 1+1j)
581 # See bpo-34087
585 self.assertEqual(copysign(1., complex("-nan").real), -1.)
586 self.assertEqual(copysign(1., complex("-nanj").imag), -1.)
587 self.assertEqual(copysign(1., complex("-nan-nanj").real), -1.)
588 self.assertEqual(copysign(1., complex("-nan-nanj").imag), -1.)
603 for x in range(-30, 30):
605 x /= 3.0 # now check against floating-point
608 self.assertNotEqual(hash(2000005 - 1j), -1)
611 nums = [complex(x/3., y/7.) for x in range(-9,9) for y in range(-9,9)]
622 test(1+6j, '(1+6j)')
623 test(1-6j, '(1-6j)')
625 test(-(1+0j), '(-1+-0j)', test_fn=self.assertNotEqual)
628 test(complex(1., -INF), "(1-infj)")
629 test(complex(INF, 1), "(inf+1j)")
630 test(complex(-INF, INF), "(-inf+infj)")
631 test(complex(NAN, 1), "(nan+1j)")
634 test(complex(-NAN, -NAN), "(nan+nanj)")
637 test(complex(0, -INF), "-infj")
640 self.assertEqual(1-6j,complex(repr(1-6j)))
641 self.assertEqual(1+6j,complex(repr(1+6j)))
642 self.assertEqual(-6j,complex(repr(-6j)))
643 self.assertEqual(6j,complex(repr(6j)))
651 test(complex(0., 1.), "1j")
652 test(complex(-0., 1.), "(-0+1j)")
653 test(complex(0., -1.), "-1j")
654 test(complex(-0., -1.), "(-0-1j)")
656 test(complex(0., 0.), "0j")
657 test(complex(0., -0.), "-0j")
658 test(complex(-0., 0.), "(-0+0j)")
659 test(complex(-0., -0.), "(-0-0j)")
662 self.assertEqual(+(1+6j), 1+6j)
663 self.assertEqual(+ComplexSubclass(1, 6), 1+6j)
667 self.assertEqual(-(1+6j), -1-6j)
670 self.assertEqual((1+2j).__getnewargs__(), (1.0, 2.0))
671 self.assertEqual((1-2j).__getnewargs__(), (1.0, -2.0))
672 self.assertEqual((2j).__getnewargs__(), (0.0, 2.0))
673 self.assertEqual((-0j).__getnewargs__(), (0.0, -0.0))
679 # test that -0j and 0j literals are not identified
680 z1, z2 = 0j, -0j
682 self.assertFloatsAreIdentical(z2.imag, -0.0)
686 z0 = -0j
687 z1 = -7j
688 z2 = -1e1000j
690 # accidentally ended up with real part 0.0 instead of -0.0, thanks to a
691 # modification during CST -> AST translation (see issue #9011). That's
693 self.assertFloatsAreIdentical(z0.real, -0.0)
694 self.assertFloatsAreIdentical(z0.imag, -0.0)
695 self.assertFloatsAreIdentical(z1.real, -0.0)
696 self.assertFloatsAreIdentical(z1.imag, -7.0)
697 self.assertFloatsAreIdentical(z2.real, -0.0)
698 self.assertFloatsAreIdentical(z2.imag, -INF)
703 self.assertEqual(complex("-1e500j"), complex(0.0, -INF))
704 self.assertEqual(complex("-1e500+1.8e308j"), complex(-INF, INF))
708 vals = [0.0, 1e-500, 1e-315, 1e-200, 0.0123, 3.1415, 1e50, INF, NAN]
709 vals += [-v for v in vals]
727 # adding 0.0 has no effect beside changing -0.0 to 0.0
735 self.assertEqual(format(1+3j, ''), str(1+3j))
736 self.assertEqual(format(1.5+3.5j, ''), str(1.5+3.5j))
737 self.assertEqual(format(3j, ''), str(3j))
738 self.assertEqual(format(3.2j, ''), str(3.2j))
739 self.assertEqual(format(3+0j, ''), str(3+0j))
740 self.assertEqual(format(3.2+0j, ''), str(3.2+0j))
744 self.assertEqual(format(3.2+0j, '-'), str(3.2+0j))
745 self.assertEqual(format(3.2+0j, '<'), str(3.2+0j))
746 z = 4/7. - 100j/7.
748 self.assertEqual(format(z, '-'), str(z))
753 self.assertEqual(format(z, '-'), str(z))
756 z = complex(-0.0, 2.0)
758 self.assertEqual(format(z, '-'), str(z))
762 self.assertEqual(format(1+3j, 'g'), '1+3j')
763 self.assertEqual(format(3j, 'g'), '0+3j')
764 self.assertEqual(format(1.5+3.5j, 'g'), '1.5+3.5j')
766 self.assertEqual(format(1.5+3.5j, '+g'), '+1.5+3.5j')
767 self.assertEqual(format(1.5-3.5j, '+g'), '+1.5-3.5j')
768 self.assertEqual(format(1.5-3.5j, '-g'), '1.5-3.5j')
769 self.assertEqual(format(1.5+3.5j, ' g'), ' 1.5+3.5j')
770 self.assertEqual(format(1.5-3.5j, ' g'), ' 1.5-3.5j')
771 self.assertEqual(format(-1.5+3.5j, ' g'), '-1.5+3.5j')
772 self.assertEqual(format(-1.5-3.5j, ' g'), '-1.5-3.5j')
774 self.assertEqual(format(-1.5-3.5e-20j, 'g'), '-1.5-3.5e-20j')
775 self.assertEqual(format(-1.5-3.5j, 'f'), '-1.500000-3.500000j')
776 self.assertEqual(format(-1.5-3.5j, 'F'), '-1.500000-3.500000j')
777 self.assertEqual(format(-1.5-3.5j, 'e'), '-1.500000e+00-3.500000e+00j')
778 self.assertEqual(format(-1.5-3.5j, '.2e'), '-1.50e+00-3.50e+00j')
779 self.assertEqual(format(-1.5-3.5j, '.2E'), '-1.50E+00-3.50E+00j')
780 self.assertEqual(format(-1.5e10-3.5e5j, '.2G'), '-1.5E+10-3.5E+05j')
782 self.assertEqual(format(1.5+3j, '<20g'), '1.5+3j ')
783 self.assertEqual(format(1.5+3j, '*<20g'), '1.5+3j**************')
784 self.assertEqual(format(1.5+3j, '>20g'), ' 1.5+3j')
785 self.assertEqual(format(1.5+3j, '^20g'), ' 1.5+3j ')
786 self.assertEqual(format(1.5+3j, '<20'), '(1.5+3j) ')
787 self.assertEqual(format(1.5+3j, '>20'), ' (1.5+3j)')
788 self.assertEqual(format(1.5+3j, '^20'), ' (1.5+3j) ')
789 self.assertEqual(format(1.123-3.123j, '^20.2'), ' (1.1-3.1j) ')
791 self.assertEqual(format(1.5+3j, '20.2f'), ' 1.50+3.00j')
792 self.assertEqual(format(1.5+3j, '>20.2f'), ' 1.50+3.00j')
793 self.assertEqual(format(1.5+3j, '<20.2f'), '1.50+3.00j ')
794 self.assertEqual(format(1.5e20+3j, '<20.2f'), '150000000000000000000.00+3.00j')
795 self.assertEqual(format(1.5e20+3j, '>40.2f'), ' 150000000000000000000.00+3.00j')
796 self.assertEqual(format(1.5e20+3j, '^40,.2f'), ' 150,000,000,000,000,000,000.00+3.00j ')
797 self.assertEqual(format(1.5e21+3j, '^40,.2f'), ' 1,500,000,000,000,000,000,000.00+3.00j ')
798 self.assertEqual(format(1.5e21+3000j, ',.2f'), '1,500,000,000,000,000,000,000.00+3,000.00j')
801 self.assertEqual(format(1+1j, '.0e'), '1e+00+1e+00j')
802 self.assertEqual(format(1+1j, '#.0e'), '1.e+00+1.e+00j')
803 self.assertEqual(format(1+1j, '.0f'), '1+1j')
804 self.assertEqual(format(1+1j, '#.0f'), '1.+1.j')
805 self.assertEqual(format(1.1+1.1j, 'g'), '1.1+1.1j')
806 self.assertEqual(format(1.1+1.1j, '#g'), '1.10000+1.10000j')
809 self.assertEqual(format(1+1j, '.1e'), '1.0e+00+1.0e+00j')
810 self.assertEqual(format(1+1j, '#.1e'), '1.0e+00+1.0e+00j')
811 self.assertEqual(format(1+1j, '.1f'), '1.0+1.0j')
812 self.assertEqual(format(1+1j, '#.1f'), '1.0+1.0j')
815 self.assertEqual(format((-1.5+0.5j), '#f'), '-1.500000+0.500000j')
816 self.assertEqual(format((-1.5+0.5j), '#.0f'), '-2.+0.j')
817 self.assertEqual(format((-1.5+0.5j), '#e'), '-1.500000e+00+5.000000e-01j')
818 self.assertEqual(format((-1.5+0.5j), '#.0e'), '-2.e+00+5.e-01j')
819 self.assertEqual(format((-1.5+0.5j), '#g'), '-1.50000+0.500000j')
820 self.assertEqual(format((-1.5+0.5j), '.0g'), '-2+0.5j')
821 self.assertEqual(format((-1.5+0.5j), '#.0g'), '-2.+0.5j')
824 self.assertRaises(ValueError, (1.5+0.5j).__format__, '010f')
827 self.assertRaises(ValueError, (1.5+3j).__format__, '=20')
831 self.assertRaises(ValueError, (1.5+0.5j).__format__, t)
834 self.assertEqual('*{0:.3f}*'.format(3.14159+2.71828j), '*3.142+2.718j*')
839 self.assertEqual(format(complex(NAN, 1), 'f'), 'nan+1.000000j')
840 self.assertEqual(format(complex(NAN, -1), 'f'), 'nan-1.000000j')
843 self.assertEqual(format(complex(NAN, 1), 'F'), 'NAN+1.000000j')
844 self.assertEqual(format(complex(NAN, -1), 'F'), 'NAN-1.000000j')
847 self.assertEqual(format(complex(INF, 1), 'f'), 'inf+1.000000j')
848 self.assertEqual(format(complex(INF, -1), 'f'), 'inf-1.000000j')
851 self.assertEqual(format(complex(INF, 1), 'F'), 'INF+1.000000j')
852 self.assertEqual(format(complex(INF, -1), 'F'), 'INF-1.000000j')