PageRenderTime 38ms CodeModel.GetById 19ms RepoModel.GetById 0ms app.codeStats 0ms

/test3/gmpy_test_xmpz.py

http://gmpy.googlecode.com/
Python | 685 lines | 658 code | 3 blank | 24 comment | 0 complexity | 7fe07760ae0084967747f8d24683c892 MD5 | raw file
Possible License(s): GPL-3.0, LGPL-3.0, LGPL-2.1
  1. # partial unit test for gmpy2 xmpz functionality
  2. # relies on Tim Peters' "doctest.py" test-driver
  3. import gmpy2 as _g, doctest, sys, operator, gc
  4. __test__={}
  5. a=_g.xmpz(123)
  6. b=_g.xmpz(456)
  7. aa=_g.mpz(123)
  8. bb=_g.mpz(456)
  9. __test__['index']=\
  10. r'''
  11. >>> a=_g.xmpz(123)
  12. >>> b=_g.xmpz(456)
  13. >>> range(333)[a]
  14. 123
  15. >>> range(333)[b]
  16. Traceback (innermost last):
  17. ...
  18. IndexError: range object index out of range
  19. '''
  20. __test__['elemop']=\
  21. r'''
  22. >>> a=_g.xmpz(123)
  23. >>> b=_g.xmpz(456)
  24. >>> a+b
  25. mpz(579)
  26. >>> a-b
  27. mpz(-333)
  28. >>> a*b
  29. mpz(56088)
  30. >>> a//b
  31. mpz(0)
  32. >>> a/b
  33. mpfr('0.26973684210526316')
  34. >>> b//a
  35. mpz(3)
  36. >>> b/a
  37. mpfr('3.7073170731707319')
  38. >>> a%b
  39. mpz(123)
  40. >>> 0%b
  41. mpz(0)
  42. >>> b+a
  43. mpz(579)
  44. >>> b-a
  45. mpz(333)
  46. >>> b*a
  47. mpz(56088)
  48. >>> b%a
  49. mpz(87)
  50. >>> divmod(a,b)
  51. (mpz(0), mpz(123))
  52. >>> divmod(b,a)
  53. (mpz(3), mpz(87))
  54. >>> divmod(0,b)
  55. (mpz(0), mpz(0))
  56. >>> -a
  57. >>> a
  58. xmpz(-123)
  59. >>> a=_g.xmpz(123)
  60. >>> a+1
  61. mpz(124)
  62. >>> a+=1; a
  63. xmpz(124)
  64. >>> a=_g.xmpz(123)
  65. >>> a+(-1)
  66. mpz(122)
  67. >>> a-=1; a
  68. xmpz(122)
  69. >>> a=_g.xmpz(123)
  70. >>> (-1)+a
  71. mpz(122)
  72. >>> 1+a
  73. mpz(124)
  74. >>> a-1
  75. mpz(122)
  76. >>> a-(-1)
  77. mpz(124)
  78. >>> 1-a
  79. mpz(-122)
  80. >>> (-1)-a
  81. mpz(-124)
  82. >>> a+True
  83. mpz(124)
  84. >>> a+False
  85. mpz(123)
  86. >>> a*False
  87. mpz(0)
  88. >>> a//True
  89. mpz(123)
  90. >>> -a
  91. >>> abs(a)
  92. >>> a
  93. xmpz(123)
  94. >>> pow(a,10)
  95. mpz(792594609605189126649)
  96. >>> pow(a,7,b)
  97. mpz(99)
  98. >>> _g.sign(b-a)
  99. 1
  100. >>> _g.sign(b-b)
  101. 0
  102. >>> _g.sign(a-b)
  103. -1
  104. >>> _g.sign(a)
  105. 1
  106. >>> -a
  107. >>> _g.sign(a)
  108. -1
  109. >>> a=_g.xmpz(123)
  110. >>> z=b-b; _g.sign(z)
  111. 0
  112. >>> s='12345678901234567890123456789'
  113. >>> int(s) == _g.xmpz(s)
  114. True
  115. >>> _g.xmpz(s) == int(s)
  116. True
  117. >>> del s
  118. >>> _g.is_even(a)
  119. False
  120. >>> _g.is_odd(a)
  121. True
  122. >>> _g.is_even(b)
  123. True
  124. >>> _g.is_odd(b)
  125. False
  126. >>> _g.is_even(2)
  127. True
  128. '''
  129. __test__['special'] = \
  130. r'''
  131. >>> a=_g.xmpz(123)
  132. >>> b=_g.xmpz(456)
  133. >>> a == float('Inf')
  134. False
  135. >>> a != float('Inf')
  136. True
  137. >>> a > float('Inf')
  138. False
  139. >>> a >= float('Inf')
  140. False
  141. >>> a < float('Inf')
  142. True
  143. >>> a <= float('Inf')
  144. True
  145. >>> a == float('-Inf')
  146. False
  147. >>> a != float('-Inf')
  148. True
  149. >>> a > float('-Inf')
  150. True
  151. >>> a >= float('-Inf')
  152. True
  153. >>> a < float('-Inf')
  154. False
  155. >>> a <= float('-Inf')
  156. False
  157. >>> a == float('nan')
  158. False
  159. >>> a != float('nan')
  160. True
  161. >>> a > float('nan')
  162. False
  163. >>> a >= float('nan')
  164. False
  165. >>> a < float('nan')
  166. False
  167. >>> a <= float('nan')
  168. False
  169. >>> float('Inf') == a
  170. False
  171. >>> float('Inf') != a
  172. True
  173. >>> float('Inf') > a
  174. True
  175. >>> float('Inf') >= a
  176. True
  177. >>> float('Inf') < a
  178. False
  179. >>> float('Inf') <= a
  180. False
  181. >>> float('-Inf') == a
  182. False
  183. >>> float('-Inf') != a
  184. True
  185. >>> float('-Inf') > a
  186. False
  187. >>> float('-Inf') >= a
  188. False
  189. >>> float('-Inf') < a
  190. True
  191. >>> float('-Inf') <= a
  192. True
  193. >>> float('nan') == a
  194. False
  195. >>> float('nan') != a
  196. True
  197. >>> float('nan') > a
  198. False
  199. >>> float('nan') >= a
  200. False
  201. >>> float('nan') < a
  202. False
  203. >>> float('nan') <= a
  204. False
  205. >>> a + float('Inf')
  206. mpfr('inf')
  207. >>> float('Inf') + a
  208. mpfr('inf')
  209. >>> a + float('-Inf')
  210. mpfr('-inf')
  211. >>> float('-Inf') + a
  212. mpfr('-inf')
  213. >>> a + float('nan')
  214. mpfr('nan')
  215. >>> float('nan') + a
  216. mpfr('nan')
  217. >>> a - float('Inf')
  218. mpfr('-inf')
  219. >>> float('Inf') - a
  220. mpfr('inf')
  221. >>> a - float('-Inf')
  222. mpfr('inf')
  223. >>> float('-Inf') - a
  224. mpfr('-inf')
  225. >>> a - float('nan')
  226. mpfr('nan')
  227. >>> float('nan') - a
  228. mpfr('nan')
  229. >>> a * float('Inf')
  230. mpfr('inf')
  231. >>> float('Inf') * a
  232. mpfr('inf')
  233. >>> a * float('-Inf')
  234. mpfr('-inf')
  235. >>> float('-Inf') * a
  236. mpfr('-inf')
  237. >>> -a
  238. >>> a * float('Inf')
  239. mpfr('-inf')
  240. >>> float('Inf') * a
  241. mpfr('-inf')
  242. >>> a * float('-Inf')
  243. mpfr('inf')
  244. >>> float('-Inf') * a
  245. mpfr('inf')
  246. >>> -a
  247. >>> a * float('nan')
  248. mpfr('nan')
  249. >>> float('nan') * a
  250. mpfr('nan')
  251. >>> _g.xmpz(0) * float('Inf')
  252. mpfr('nan')
  253. >>> _g.xmpz(0) * float('-Inf')
  254. mpfr('nan')
  255. >>> float('Inf') * _g.xmpz(0)
  256. mpfr('nan')
  257. >>> float('-Inf') * _g.xmpz(0)
  258. mpfr('nan')
  259. >>> a / float('Inf')
  260. mpfr('0.0')
  261. >>> float('Inf') / a
  262. mpfr('inf')
  263. >>> a / float('-Inf')
  264. mpfr('-0.0')
  265. >>> float('-Inf') / a
  266. mpfr('-inf')
  267. >>> a / float('nan')
  268. mpfr('nan')
  269. >>> float('nan') / a
  270. mpfr('nan')
  271. >>> -a
  272. >>> a / float('Inf')
  273. mpfr('-0.0')
  274. >>> float('Inf') / a
  275. mpfr('-inf')
  276. >>> a / float('-Inf')
  277. mpfr('0.0')
  278. >>> float('-Inf') / a
  279. mpfr('inf')
  280. >>> -a
  281. '''
  282. __test__['divexact']=\
  283. r'''
  284. >>> a=_g.xmpz('1234567912345678912345679')
  285. >>> b=_g.xmpz('789789789789789789789789')
  286. >>> c=a*b
  287. >>> _g.divexact(c,a)
  288. mpz(789789789789789789789789)
  289. >>>
  290. '''
  291. __test__['divmod']=\
  292. r'''
  293. >>> _g.c_divmod(17,5)
  294. (mpz(4), mpz(-3))
  295. >>> _g.c_divmod(-17,5)
  296. (mpz(-3), mpz(-2))
  297. >>> _g.c_divmod(17,-5)
  298. (mpz(-3), mpz(2))
  299. >>> _g.c_divmod(-17,-5)
  300. (mpz(4), mpz(3))
  301. >>> _g.f_divmod(17,5)
  302. (mpz(3), mpz(2))
  303. >>> _g.f_divmod(-17,5)
  304. (mpz(-4), mpz(3))
  305. >>> _g.f_divmod(17,-5)
  306. (mpz(-4), mpz(-3))
  307. >>> _g.f_divmod(-17,-5)
  308. (mpz(3), mpz(-2))
  309. >>> _g.t_divmod(17,5)
  310. (mpz(3), mpz(2))
  311. >>> _g.t_divmod(-17,5)
  312. (mpz(-3), mpz(-2))
  313. >>> _g.t_divmod(17,-5)
  314. (mpz(-3), mpz(2))
  315. >>> _g.t_divmod(-17,-5)
  316. (mpz(3), mpz(-2))
  317. '''
  318. __test__['cmpr']=\
  319. r'''
  320. >>> a=_g.xmpz(123)
  321. >>> b=_g.xmpz(456)
  322. >>> c=_g.xmpz(a)
  323. >>> c is a
  324. 0
  325. >>> c==a
  326. 1
  327. >>> c>a
  328. 0
  329. >>> c<a
  330. 0
  331. >>> d=a.copy()
  332. >>> a is d
  333. 0
  334. >>> a == d
  335. 1
  336. >>> a>b
  337. 0
  338. >>> a<b
  339. 1
  340. >>> not _g.xmpz(0)
  341. 1
  342. >>> not a
  343. 0
  344. >>> _g.xmpz(1) == None
  345. False
  346. >>> _g.xmpz(1) == '1'
  347. False
  348. >>> _g.xmpz(1) == 'abc'
  349. False
  350. >>> [_g.xmpz(23), None].count(None)
  351. 1
  352. >>> _g.xmpz(3.14)
  353. xmpz(3)
  354. >>> _g.xmpz(_g.mpq(17,3))
  355. xmpz(5)
  356. >>> _g.xmpz(23)
  357. xmpz(23)
  358. >>> _g.xmpz(-23)
  359. xmpz(-23)
  360. >>> x=1000*1000*1000*1000*1000*1000*1000
  361. >>> _g.xmpz(x)
  362. xmpz(1000000000000000000000)
  363. >>> a == float('Inf')
  364. False
  365. >>> a != float('Inf')
  366. True
  367. >>> a > float('Inf')
  368. False
  369. >>> a >= float('Inf')
  370. False
  371. >>> a < float('Inf')
  372. True
  373. >>> a <= float('Inf')
  374. True
  375. >>> a == float('-Inf')
  376. False
  377. >>> a != float('-Inf')
  378. True
  379. >>> a > float('-Inf')
  380. True
  381. >>> a >= float('-Inf')
  382. True
  383. >>> a < float('-Inf')
  384. False
  385. >>> a <= float('-Inf')
  386. False
  387. >>> a == float('nan')
  388. False
  389. >>> a != float('nan')
  390. True
  391. >>> a > float('nan')
  392. False
  393. >>> a >= float('nan')
  394. False
  395. >>> a < float('nan')
  396. False
  397. >>> a <= float('nan')
  398. False
  399. '''
  400. __test__['bitops']=\
  401. r'''
  402. >>> a=_g.xmpz(123)
  403. >>> b=_g.xmpz(456)
  404. >>> ~a
  405. >>> a
  406. xmpz(-124)
  407. >>> a=_g.xmpz(123)
  408. >>> a&b
  409. mpz(72)
  410. >>> a|b
  411. mpz(507)
  412. >>> a^b
  413. mpz(435)
  414. >>> a<<1
  415. mpz(246)
  416. >>> a>>1
  417. mpz(61)
  418. >>> a<<-1
  419. Traceback (innermost last):
  420. ...
  421. ValueError: negative shift count
  422. >>> a>>-2
  423. Traceback (innermost last):
  424. ...
  425. ValueError: negative shift count
  426. >>> a<<0
  427. mpz(123)
  428. >>> a>>0
  429. mpz(123)
  430. >>> a.bit_set(20)
  431. mpz(1048699)
  432. >>> a=_g.xmpz(123)
  433. >>> a.bit_clear(0)
  434. mpz(122)
  435. >>> a=_g.xmpz(123)
  436. >>> for i in range(8):
  437. ... print(a.bit_test(i))
  438. ...
  439. True
  440. True
  441. False
  442. True
  443. True
  444. True
  445. True
  446. False
  447. >>> for i in range(10):
  448. ... print(b.bit_test(i))
  449. ...
  450. False
  451. False
  452. False
  453. True
  454. False
  455. False
  456. True
  457. True
  458. True
  459. False
  460. >>> [a.bit_scan0(j) for j in range(33)]
  461. [2, 2, 2, 7, 7, 7, 7, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]
  462. >>> [a.bit_scan1(j) for j in range(10)]
  463. [0, 1, 3, 3, 4, 5, 6, None, None, None]
  464. >>> n=_g.xmpz(-(7+6*16+5*256+7*4092))
  465. >>> [n.bit_scan0(j) for j in range(18)]
  466. [1, 1, 3, 3, 6, 6, 6, 8, 8, 10, 10, 12, 12, 13, 14, -1, None, None]
  467. >>> [n.bit_scan1(j) for j in range(33)]
  468. [0, 2, 2, 4, 4, 5, 7, 7, 9, 9, 11, 11, 15, 15, 15, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31, 32]
  469. >>> _g.xmpz(0).bit_length()
  470. 0
  471. >>> _g.xmpz(12345).bit_length()
  472. 14
  473. >>> _g.bit_mask(9)
  474. mpz(511)
  475. >>> _g.xbit_mask(9)
  476. xmpz(511)
  477. '''
  478. __test__['format']=\
  479. r'''
  480. >>> a=_g.xmpz(123)
  481. >>> b=_g.xmpz(456)
  482. >>> str(a)
  483. '123'
  484. >>> repr(a)
  485. 'xmpz(123)'
  486. >>> hex(a)
  487. '0x7b'
  488. >>> oct(a)
  489. '0o173'
  490. >>> _g.xmpz('123')
  491. xmpz(123)
  492. >>> _g.xmpz('1001001011',2)
  493. xmpz(587)
  494. >>> _g.xmpz('0b1001001011')
  495. xmpz(587)
  496. >>> _g.xmpz('1001001011',2).digits(2)
  497. '0b1001001011'
  498. >>> for i in range(2,63):
  499. ... print(a.digits(i))
  500. ...
  501. 0b1111011
  502. 11120
  503. 1323
  504. 443
  505. 323
  506. 234
  507. 0o173
  508. 146
  509. 123
  510. 102
  511. a3
  512. 96
  513. 8b
  514. 83
  515. 0x7b
  516. 74
  517. 6f
  518. 69
  519. 63
  520. 5i
  521. 5d
  522. 58
  523. 53
  524. 4n
  525. 4j
  526. 4f
  527. 4b
  528. 47
  529. 43
  530. 3u
  531. 3r
  532. 3o
  533. 3l
  534. 3i
  535. 3f
  536. 3C
  537. 39
  538. 36
  539. 33
  540. 30
  541. 2d
  542. 2b
  543. 2Z
  544. 2X
  545. 2V
  546. 2T
  547. 2R
  548. 2P
  549. 2N
  550. 2L
  551. 2J
  552. 2H
  553. 2F
  554. 2D
  555. 2B
  556. 29
  557. 27
  558. 25
  559. 23
  560. 21
  561. 1z
  562. >>> print(a.digits(63))
  563. Traceback (innermost last):
  564. ...
  565. ValueError: base must be in the interval 2 ... 62
  566. >>> _g.xmpz('43')
  567. xmpz(43)
  568. >>> _g.xmpz('043')
  569. xmpz(43)
  570. >>> _g.xmpz('43',10)
  571. xmpz(43)
  572. >>> _g.xmpz('0o43',0)
  573. xmpz(35)
  574. >>> _g.xmpz('0x43')
  575. xmpz(67)
  576. >>> _g.xmpz('0x43',10)
  577. Traceback (innermost last):
  578. File "<pyshell#181>", line 1, in ?
  579. _g.xmpz('0x43')
  580. ValueError: invalid digits
  581. >>>
  582. '''
  583. __test__['number']=\
  584. r'''
  585. >>> a=_g.xmpz(123)
  586. >>> b=_g.xmpz(456)
  587. >>> _g.is_square(a)
  588. 0
  589. >>> _g.is_power(a)
  590. 0
  591. >>> _g.is_square(99*99)
  592. 1
  593. >>> _g.is_square(99*99*99)
  594. 0
  595. >>> _g.is_square(0)
  596. 1
  597. >>> _g.is_square(-1)
  598. 0
  599. >>> _g.is_power(99*99*99)
  600. 1
  601. >>> _g.gcd(a,b)
  602. mpz(3)
  603. >>> temp=_g.gcdext(a,b)
  604. >>> temp[0]==a*temp[1]+b*temp[2]
  605. True
  606. >>> _g.lcm(a,b)
  607. mpz(18696)
  608. >>> _g.fac(7)
  609. mpz(5040)
  610. >>> _g.fib(17)
  611. mpz(1597)
  612. >>> del temp
  613. >>> for i in range(10):
  614. ... print(_g.bincoef(10,i))
  615. ...
  616. 1
  617. 10
  618. 45
  619. 120
  620. 210
  621. 252
  622. 210
  623. 120
  624. 45
  625. 10
  626. >>> _g.divm(b,a,_g.xmpz(20))
  627. mpz(12)
  628. >>> _g.divm(a,b,100)
  629. Traceback (innermost last):
  630. File "<pyshell#184>", line 1, in ?
  631. _g.divm(a,b,100)
  632. ZeroDivisionError: not invertible
  633. >>> _g.divm(6,12,14)
  634. mpz(4)
  635. >>> _g.divm(0,1,2)
  636. mpz(0)
  637. '''
  638. def _test(chat=None):
  639. if chat:
  640. print("Unit tests for gmpy2 (xmpz functionality)")
  641. print(" on Python %s" % sys.version)
  642. print("Testing gmpy2 {0}".format(_g.version()))
  643. print(" Mutliple-precision library: {0}".format(_g.mp_version()))
  644. print(" Floating-point library: {0}".format(_g.mpfr_version()))
  645. print(" Complex library: {0}".format(_g.mpc_version()))
  646. print(" Caching Values: (Number) {0}".format(_g.get_cache()[0]))
  647. print(" Caching Values: (Size, limbs) {0}".format(_g.get_cache()[1]))
  648. thismod = sys.modules.get(__name__)
  649. doctest.testmod(thismod, report=0)
  650. if chat: print("Repeating tests, with caching disabled")
  651. _g.set_cache(0,128)
  652. sav = sys.stdout
  653. class _Dummy:
  654. encoding = None
  655. def write(self,*whatever):
  656. pass
  657. try:
  658. sys.stdout = _Dummy()
  659. doctest.testmod(thismod, report=0)
  660. finally:
  661. sys.stdout = sav
  662. if chat:
  663. print()
  664. print("Overall results for mpz:")
  665. return doctest.master.summarize(chat)
  666. if __name__=='__main__':
  667. _test(1)