/test/test_mpz.txt

http://gmpy.googlecode.com/ · Plain Text · 485 lines · 449 code · 36 blank · 0 comment · 0 complexity · 90c4a72abd5d9ef7a9d052bfcc2bfa0b MD5 · raw file

  1. MPZ Functionality
  2. =================
  3. Testing of mpz functionality is split into multiple files.
  4. test_mpz.txt
  5. Test basic functionality and stuff not covered anywhere else.
  6. test_mpz_functions.txt
  7. Test mpz functions, including error messages.
  8. test_mpz_io.txt
  9. Test input/output and formating.
  10. test_mpz_comp.txt
  11. Test comparisons.
  12. >>> import gmpy2 as G
  13. >>> from gmpy2 import mpz, mpq, mpfr, mpc
  14. >>> from decimal import Decimal as D
  15. >>> from fractions import Fraction as F
  16. >>> a = mpz(123)
  17. >>> b = mpz(456)
  18. >>> c = 12345678901234567890
  19. Test elementary operations
  20. ==========================
  21. Test addition
  22. -------------
  23. >>> a+1
  24. mpz(124)
  25. >>> a+(-1)
  26. mpz(122)
  27. >>> 1+a
  28. mpz(124)
  29. >>> (-1)+a
  30. mpz(122)
  31. >>> a+b
  32. mpz(579)
  33. >>> b+a
  34. mpz(579)
  35. >>> a+'b'
  36. Traceback (most recent call last):
  37. File "<stdin>", line 1, in <module>
  38. TypeError: unsupported operand type(s) for +: 'mpz' and 'str'
  39. >>> 'b'+a
  40. Traceback (most recent call last):
  41. File "<stdin>", line 1, in <module>
  42. TypeError: ** message detail varies **
  43. >>> print(a+c)
  44. 12345678901234568013
  45. >>> print(c+a)
  46. 12345678901234568013
  47. Test subtraction
  48. ----------------
  49. >>> a-1
  50. mpz(122)
  51. >>> a-(-1)
  52. mpz(124)
  53. >>> 1-a
  54. mpz(-122)
  55. >>> (-1)-a
  56. mpz(-124)
  57. >>> a-b
  58. mpz(-333)
  59. >>> b-a
  60. mpz(333)
  61. >>> a-'b'
  62. Traceback (most recent call last):
  63. File "<stdin>", line 1, in <module>
  64. TypeError: unsupported operand type(s) for -: 'mpz' and 'str'
  65. >>> 'b'-a
  66. Traceback (most recent call last):
  67. File "<stdin>", line 1, in <module>
  68. TypeError: ** message detail varies **
  69. >>> print(a-c)
  70. -12345678901234567767
  71. >>> print(c-a)
  72. 12345678901234567767
  73. Test multiplication
  74. -------------------
  75. >>> a*b
  76. mpz(56088)
  77. >>> b*a
  78. mpz(56088)
  79. >>> a*0
  80. mpz(0)
  81. >>> 0*a
  82. mpz(0)
  83. >>> a*123
  84. mpz(15129)
  85. >>> 123*a
  86. mpz(15129)
  87. >>> print(a*c)
  88. 1518518504851851850470
  89. >>> print(c*a)
  90. 1518518504851851850470
  91. >>> a*'b'
  92. 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
  93. >>> 'b'*a
  94. 'bbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbbb'
  95. Test division
  96. -------------
  97. >>> a//b
  98. mpz(0)
  99. >>> a/b
  100. mpfr('0.26973684210526316')
  101. >>> b//a
  102. mpz(3)
  103. >>> b/a
  104. mpfr('3.7073170731707319')
  105. >>> (a*b)//b
  106. mpz(123)
  107. >>> (a*b)//a
  108. mpz(456)
  109. >>> a//0
  110. Traceback (most recent call last):
  111. File "<stdin>", line 1, in <module>
  112. ZeroDivisionError: division or modulo by zero
  113. >>> a/0
  114. Traceback (most recent call last):
  115. File "<stdin>", line 1, in <module>
  116. ZeroDivisionError: division or modulo by zero
  117. >>> a/0.0
  118. mpfr('inf')
  119. >>> print(c//a)
  120. 100371373180768844
  121. >>> a**10//c
  122. mpz(64)
  123. Test modulo
  124. -----------
  125. >>> a%b
  126. mpz(123)
  127. >>> b%a
  128. mpz(87)
  129. >>> divmod(a,b)
  130. (mpz(0), mpz(123))
  131. >>> divmod(b,a)
  132. (mpz(3), mpz(87))
  133. >>> divmod(a,0)
  134. Traceback (most recent call last):
  135. ...
  136. ZeroDivisionError: division or modulo by zero
  137. >>> divmod(a,mpz(0))
  138. Traceback (most recent call last):
  139. File "<stdin>", line 1, in <module>
  140. ZeroDivisionError: division or modulo by zero
  141. >>> divmod(123,mpz(0))
  142. Traceback (most recent call last):
  143. File "<stdin>", line 1, in <module>
  144. ZeroDivisionError: division or modulo by zero
  145. >>> divmod(b,123)
  146. (mpz(3), mpz(87))
  147. >>> divmod(a,c)
  148. (mpz(0), mpz(123))
  149. >>> divmod(a,int(c))
  150. (mpz(0), mpz(123))
  151. >>> print("%s %s" % divmod(a*(c-1),c))
  152. 122 12345678901234567767
  153. >>> print("%s %s" % divmod(a*(c-1),int(c)))
  154. 122 12345678901234567767
  155. >>> divmod(a*(c-1),-c)
  156. (mpz(-123), mpz(-123))
  157. >>> divmod(a*(c-1),-int(c))
  158. (mpz(-123), mpz(-123))
  159. >>> print("%s %s" % divmod(int(a*(c-1)),-int(c)))
  160. -123 -123
  161. Test miscellaneous
  162. ------------------
  163. >>> a+True
  164. mpz(124)
  165. >>> a+False
  166. mpz(123)
  167. >>> a*False
  168. mpz(0)
  169. >>> a//True
  170. mpz(123)
  171. >>> abs(-a) == a
  172. True
  173. >>> print(pow(a,10))
  174. 792594609605189126649
  175. >>> pow(a,7,b)
  176. mpz(99)
  177. >>> G.sign(b-a)
  178. 1
  179. >>> G.sign(b-b)
  180. 0
  181. >>> G.sign(a-b)
  182. -1
  183. >>> G.sign(a)
  184. 1
  185. >>> G.sign(-a)
  186. -1
  187. >>> z=b-b; G.sign(z)
  188. 0
  189. Test pickle
  190. -----------
  191. >>> import pickle
  192. >>> pickle.loads(pickle.dumps(G.mpz(12346789)))
  193. mpz(12346789)
  194. >>> pickle.loads(pickle.dumps(G.mpz(-12346789)))
  195. mpz(-12346789)
  196. >>> pickle.loads(pickle.dumps(G.mpz(0)))
  197. mpz(0)
  198. Test mpz.__index__
  199. ------------------
  200. >>> range(333)[a]
  201. 123
  202. >>> range(333)[b]
  203. Traceback (innermost last):
  204. ...
  205. IndexError: range object index out of range
  206. Test operations involving NaN/Inf
  207. ---------------------------------
  208. >>> a + float('Inf')
  209. mpfr('inf')
  210. >>> float('Inf') + a
  211. mpfr('inf')
  212. >>> a + float('-Inf')
  213. mpfr('-inf')
  214. >>> float('-Inf') + a
  215. mpfr('-inf')
  216. >>> a + float('nan')
  217. mpfr('nan')
  218. >>> float('nan') + a
  219. mpfr('nan')
  220. >>> a - float('Inf')
  221. mpfr('-inf')
  222. >>> float('Inf') - a
  223. mpfr('inf')
  224. >>> a - float('-Inf')
  225. mpfr('inf')
  226. >>> float('-Inf') - a
  227. mpfr('-inf')
  228. >>> a - float('nan')
  229. mpfr('nan')
  230. >>> float('nan') - a
  231. mpfr('nan')
  232. >>> a * float('Inf')
  233. mpfr('inf')
  234. >>> float('Inf') * a
  235. mpfr('inf')
  236. >>> a * float('-Inf')
  237. mpfr('-inf')
  238. >>> float('-Inf') * a
  239. mpfr('-inf')
  240. >>> -a * float('Inf')
  241. mpfr('-inf')
  242. >>> float('Inf') * -a
  243. mpfr('-inf')
  244. >>> -a * float('-Inf')
  245. mpfr('inf')
  246. >>> float('-Inf') * -a
  247. mpfr('inf')
  248. >>> a * float('nan')
  249. mpfr('nan')
  250. >>> float('nan') * a
  251. mpfr('nan')
  252. >>> G.mpz(0) * float('Inf')
  253. mpfr('nan')
  254. >>> G.mpz(0) * float('-Inf')
  255. mpfr('nan')
  256. >>> float('Inf') * G.mpz(0)
  257. mpfr('nan')
  258. >>> float('-Inf') * G.mpz(0)
  259. mpfr('nan')
  260. >>> a / float('Inf')
  261. mpfr('0.0')
  262. >>> -a / float('Inf')
  263. mpfr('-0.0')
  264. >>> float('Inf') / a
  265. mpfr('inf')
  266. >>> float('Inf') / -a
  267. mpfr('-inf')
  268. >>> a / float('-Inf')
  269. mpfr('-0.0')
  270. >>> -a / float('-Inf')
  271. mpfr('0.0')
  272. >>> float('-Inf') / a
  273. mpfr('-inf')
  274. >>> float('-Inf') / -a
  275. mpfr('inf')
  276. >>> a / float('nan')
  277. mpfr('nan')
  278. >>> float('nan') / a
  279. mpfr('nan')
  280. >>> float('nan') / G.mpz(0)
  281. mpfr('nan')
  282. >>> float('nan') / G.mpz(0)
  283. mpfr('nan')
  284. >>> a - mpfr('Inf')
  285. mpfr('-inf')
  286. >>> mpfr('Inf') - a
  287. mpfr('inf')
  288. >>> a - mpfr('-Inf')
  289. mpfr('inf')
  290. >>> mpfr('-Inf') - a
  291. mpfr('-inf')
  292. >>> a - mpfr('nan')
  293. mpfr('nan')
  294. >>> mpfr('nan') - a
  295. mpfr('nan')
  296. >>> a * mpfr('Inf')
  297. mpfr('inf')
  298. >>> mpfr('Inf') * a
  299. mpfr('inf')
  300. >>> a * mpfr('-Inf')
  301. mpfr('-inf')
  302. >>> mpfr('-Inf') * a
  303. mpfr('-inf')
  304. >>> -a * mpfr('Inf')
  305. mpfr('-inf')
  306. >>> mpfr('Inf') * -a
  307. mpfr('-inf')
  308. >>> -a * mpfr('-Inf')
  309. mpfr('inf')
  310. >>> mpfr('-Inf') * -a
  311. mpfr('inf')
  312. >>> a * mpfr('nan')
  313. mpfr('nan')
  314. >>> mpfr('nan') * a
  315. mpfr('nan')
  316. >>> G.mpz(0) * mpfr('Inf')
  317. mpfr('nan')
  318. >>> G.mpz(0) * mpfr('-Inf')
  319. mpfr('nan')
  320. >>> mpfr('Inf') * G.mpz(0)
  321. mpfr('nan')
  322. >>> mpfr('-Inf') * G.mpz(0)
  323. mpfr('nan')
  324. >>> a / mpfr('Inf')
  325. mpfr('0.0')
  326. >>> -a / mpfr('Inf')
  327. mpfr('-0.0')
  328. >>> mpfr('Inf') / a
  329. mpfr('inf')
  330. >>> mpfr('Inf') / -a
  331. mpfr('-inf')
  332. >>> a / mpfr('-Inf')
  333. mpfr('-0.0')
  334. >>> -a / mpfr('-Inf')
  335. mpfr('0.0')
  336. >>> mpfr('-Inf') / a
  337. mpfr('-inf')
  338. >>> mpfr('-Inf') / -a
  339. mpfr('inf')
  340. >>> a / mpfr('nan')
  341. mpfr('nan')
  342. >>> mpfr('nan') / a
  343. mpfr('nan')
  344. >>> mpfr('nan') / G.mpz(0)
  345. mpfr('nan')
  346. >>> mpfr('nan') / G.mpz(0)
  347. mpfr('nan')
  348. >>> divmod(a, mpfr('Inf'))
  349. (mpfr('0.0'), mpfr('123.0'))
  350. >>> divmod(a, mpfr('-Inf'))
  351. (mpfr('-1.0'), mpfr('-inf'))
  352. >>> divmod(-a, mpfr('Inf'))
  353. (mpfr('-1.0'), mpfr('inf'))
  354. >>> divmod(-a, mpfr('-Inf'))
  355. (mpfr('0.0'), mpfr('-123.0'))
  356. >>> divmod(a, mpfr('nan'))
  357. (mpfr('nan'), mpfr('nan'))
  358. >>> divmod(-a, mpfr('nan'))
  359. (mpfr('nan'), mpfr('nan'))
  360. >>> divmod(G.mpz(0), mpfr('Inf'))
  361. (mpfr('0.0'), mpfr('0.0'))
  362. >>> divmod(G.mpz(0), mpfr('-Inf'))
  363. (mpfr('-0.0'), mpfr('-0.0'))
  364. >>> divmod(G.mpz(0), mpfr('nan'))
  365. (mpfr('nan'), mpfr('nan'))
  366. >>> divmod(mpfr('Inf'), a)
  367. (mpfr('nan'), mpfr('nan'))
  368. >>> divmod(mpfr('-Inf'), a)
  369. (mpfr('nan'), mpfr('nan'))
  370. >>> divmod(mpfr('Inf'), -a)
  371. (mpfr('nan'), mpfr('nan'))
  372. >>> divmod(mpfr('-Inf'), -a)
  373. (mpfr('nan'), mpfr('nan'))
  374. >>> divmod(mpfr('nan'), a)
  375. (mpfr('nan'), mpfr('nan'))
  376. >>> divmod(mpfr('nan'), -a)
  377. (mpfr('nan'), mpfr('nan'))
  378. >>> divmod(mpfr('Inf'), G.mpz(0))
  379. (mpfr('nan'), mpfr('nan'))
  380. >>> divmod(mpfr('-Inf'), G.mpz(0))
  381. (mpfr('nan'), mpfr('nan'))
  382. >>> divmod(mpfr('nan'), G.mpz(0))
  383. (mpfr('nan'), mpfr('nan'))
  384. >>> divmod(a, mpfr('Inf'))
  385. (mpfr('0.0'), mpfr('123.0'))
  386. >>> divmod(a, mpfr('-Inf'))
  387. (mpfr('-1.0'), mpfr('-inf'))
  388. >>> divmod(-a, mpfr('Inf'))
  389. (mpfr('-1.0'), mpfr('inf'))
  390. >>> divmod(-a, mpfr('-Inf'))
  391. (mpfr('0.0'), mpfr('-123.0'))
  392. >>> divmod(a, mpfr('nan'))
  393. (mpfr('nan'), mpfr('nan'))
  394. >>> divmod(-a, mpfr('nan'))
  395. (mpfr('nan'), mpfr('nan'))
  396. >>> divmod(G.mpz(0), mpfr('Inf'))
  397. (mpfr('0.0'), mpfr('0.0'))
  398. >>> divmod(G.mpz(0), mpfr('-Inf'))
  399. (mpfr('-0.0'), mpfr('-0.0'))
  400. >>> divmod(G.mpz(0), mpfr('nan'))
  401. (mpfr('nan'), mpfr('nan'))
  402. >>> divmod(mpfr('Inf'), a)
  403. (mpfr('nan'), mpfr('nan'))
  404. >>> divmod(mpfr('-Inf'), a)
  405. (mpfr('nan'), mpfr('nan'))
  406. >>> divmod(mpfr('Inf'), -a)
  407. (mpfr('nan'), mpfr('nan'))
  408. >>> divmod(mpfr('-Inf'), -a)
  409. (mpfr('nan'), mpfr('nan'))
  410. >>> divmod(mpfr('nan'), a)
  411. (mpfr('nan'), mpfr('nan'))
  412. >>> divmod(mpfr('nan'), -a)
  413. (mpfr('nan'), mpfr('nan'))
  414. >>> divmod(mpfr('Inf'), G.mpz(0))
  415. (mpfr('nan'), mpfr('nan'))
  416. >>> divmod(mpfr('-Inf'), G.mpz(0))
  417. (mpfr('nan'), mpfr('nan'))
  418. >>> divmod(mpfr('nan'), G.mpz(0))
  419. (mpfr('nan'), mpfr('nan'))
  420. Test bit operations
  421. -------------------
  422. >>> ~a
  423. mpz(-124)
  424. >>> a&b
  425. mpz(72)
  426. >>> a|b
  427. mpz(507)
  428. >>> a^b
  429. mpz(435)
  430. >>> a<<1
  431. mpz(246)
  432. >>> a>>1
  433. mpz(61)
  434. >>> a<<-1
  435. Traceback (innermost last):
  436. ...
  437. ValueError: negative shift count
  438. >>> a>>-2
  439. Traceback (innermost last):
  440. ...
  441. ValueError: negative shift count
  442. >>> a<<0
  443. mpz(123)
  444. >>> a>>0
  445. mpz(123)
  446. Test conversions
  447. ----------------
  448. >>> int(G.mpz(-3))
  449. -3