3 ### Testing multiprecision integer (and related) functionality
5 ### (c) 2019 Straylight/Edgeware
8 ###----- Licensing notice ---------------------------------------------------
10 ### This file is part of the Python interface to Catacomb.
12 ### Catacomb/Python is free software: you can redistribute it and/or
13 ### modify it under the terms of the GNU General Public License as
14 ### published by the Free Software Foundation; either version 2 of the
15 ### License, or (at your option) any later version.
17 ### Catacomb/Python is distributed in the hope that it will be useful, but
18 ### WITHOUT ANY WARRANTY; without even the implied warranty of
19 ### MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20 ### General Public License for more details.
22 ### You should have received a copy of the GNU General Public License
23 ### along with Catacomb/Python. If not, write to the Free Software
24 ### Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307,
27 ###--------------------------------------------------------------------------
34 ###--------------------------------------------------------------------------
35 class TestMP (U
.TestCase
):
40 kk
= C
.BinPolyField(C
.GF(0x13))
43 me
.assertTrue(C
.MP(x
) is x
)
44 me
.assertEqual(C
.MP(k(8)), 8)
45 me
.assertEqual(C
.MP(kk(8)), 8)
46 me
.assertEqual(C
.MP(E(1, 4)), 1)
47 me
.assertRaises(TypeError, C
.MP
, E())
49 me
.assertEqual(int(x
), 5)
50 big
= 6556380541834372447694561492436749633
51 me
.assertEqual(type(big
), T
.long)
53 me
.assertEqual(y
, big
)
54 me
.assertEqual(int(y
), big
)
56 me
.assertEqual(C
.MP(str(big
)), big
)
57 me
.assertEqual(C
.MP('0x4eeb684a0954ec4ceb255e3e9778d41'), big
)
58 me
.assertEqual(C
.MP('4eeb684a0954ec4ceb255e3e9778d41', 16), big
)
59 me
.assertEqual(C
.MP('0x4eeb684a0954ec4ceb255e3e9778d41', 16), big
)
60 me
.assertEqual(C
.MP('0b0', 16), 176) # not 0
62 me
.assertEqual(C
.MP('047353320450112516611472622536175135706501'), big
)
63 me
.assertEqual(C
.MP('0o47353320450112516611472622536175135706501'), big
)
64 me
.assertEqual(C
.MP('047353320450112516611472622536175135706501', 8), big
)
65 me
.assertEqual(C
.MP('0o47353320450112516611472622536175135706501', 8), big
)
66 me
.assertEqual(C
.MP('47353320450112516611472622536175135706501', 8), big
)
68 me
.assertEqual(C
.MP('0b100111011011001100000010001011'), 661438603)
69 me
.assertEqual(C
.MP('0b100111011011001100000010001011', 2), 661438603)
70 me
.assertEqual(C
.MP('100111011011001100000010001011', 2), 661438603)
73 y
= C
.MP(6556380541834372447694561492436749633)
74 me
.assertEqual(str(y
), '6556380541834372447694561492436749633')
75 me
.assertEqual(repr(y
), 'MP(6556380541834372447694561492436749633)')
76 me
.assertEqual(hex(y
), '0x4eeb684a0954ec4ceb255e3e9778d41')
77 me
.assertEqual(oct(y
), T
.py23('0', '0o') +
78 '47353320450112516611472622536175135706501')
80 except NameError: pass
81 else: me
.assertEqual(bin(C
.MP(661438603)),
82 '0b100111011011001100000010001011')
85 x
, y
, m
, zero
= C
.MP(169), C
.MP(24), C
.MP(205), C
.MP(0)
87 me
.assertEqual(-x
, -169)
88 me
.assertEqual(~x
, -170)
89 me
.assertEqual(abs(x
), 169)
90 me
.assertEqual(abs(-x
), 169)
92 me
.assertEqual(x
+ y
, 193)
93 me
.assertEqual(x
- y
, 145)
94 me
.assertEqual(x
*y
, 4056)
95 me
.assertEqual(x
&y
, 8)
96 me
.assertEqual(x
&-y
, 168)
97 me
.assertEqual(x | y
, 185)
98 me
.assertEqual(x |
-y
, -23)
99 me
.assertEqual(x ^ y
, 177)
100 me
.assertEqual(x ^
-y
, -191)
102 me
.assertEqual(x
<< 3, 1352)
103 me
.assertEqual(x
<< -2, 42)
104 me
.assertEqual(x
>> 2, 42)
105 me
.assertEqual(x
>> -3, 1352)
106 me
.assertEqual(-x
<< 3, -1352)
107 me
.assertEqual(-x
>> 2, -43)
109 u
= x
/y
; me
.assertEqual((u
.numer
, u
.denom
), (169, 24))
110 me
.assertEqual(x
//y
, 7)
111 me
.assertEqual(x
%y
, 1)
112 me
.assertEqual(divmod(x
, y
), (7, 1))
113 me
.assertRaises(ZeroDivisionError, lambda: x
/zero
)
114 me
.assertRaises(ZeroDivisionError, lambda: x
//zero
)
115 me
.assertRaises(ZeroDivisionError, lambda: x
%zero
)
116 me
.assertRaises(ZeroDivisionError, divmod, x
, zero
)
118 me
.assertEqual(pow(x
, y
), 294632676319010105335586872991323185304149065116720321)
119 me
.assertEqual(pow(x
, y
, m
), 51)
120 me
.assertRaises(ValueError, pow, x
, -y
)
121 me
.assertEqual(pow(x
, -y
, m
), 201)
122 me
.assertRaises(ZeroDivisionError, pow, x
, -y
, 208)
128 x
, y
= C
.MP(169), C
.MP(24)
129 me
.assertTrue(x
== x
)
130 me
.assertFalse(x
!= x
)
131 me
.assertFalse(x
== y
)
132 me
.assertTrue(x
!= y
)
134 me
.assertFalse(y
> x
)
135 me
.assertFalse(x
> x
)
136 me
.assertTrue(x
>= y
)
137 me
.assertFalse(y
>= x
)
138 me
.assertTrue(x
>= x
)
139 me
.assertFalse(x
<= y
)
140 me
.assertTrue(y
<= x
)
141 me
.assertTrue(x
<= x
)
142 me
.assertFalse(x
< y
)
144 me
.assertFalse(x
< x
)
147 x
, y
= C
.MP(169), 24.0
148 for fn
in [T
.add
, T
.sub
, T
.mul
, T
.div
]:
149 me
.assertEqual(type(fn(x
, y
)), float)
150 me
.assertEqual(type(fn(y
, x
)), float)
151 me
.assertEqual(x
, 169.0)
152 me
.assertNotEqual(x
, 169.1)
153 me
.assertNotEqual(x
, 168.9)
154 me
.assertTrue(x
> 168.9)
155 me
.assertTrue(x
< 169.1)
157 while z
== z
+ 1: z
*= 2.0
158 me
.assertNotEqual(C
.MP(int(z
)) + 1, z
)
160 def test_strconv(me
):
161 x
, y
= C
.MP(169), "24"
162 for fn
in [T
.add
, T
.sub
, T
.div
]:
163 me
.assertRaises(TypeError, fn
, x
, y
)
164 me
.assertRaises(TypeError, fn
, y
, x
)
165 me
.assertEqual(x
*y
, 169*"24")
166 me
.assertEqual(y
*x
, 169*"24")
169 x
, y
, zero
= C
.MP(169), C
.MP(-24), C
.MP(0)
170 me
.assertTrue(x
.testbit(0))
171 me
.assertFalse(x
.testbit(1))
172 me
.assertFalse(x
.testbit(1000))
173 me
.assertFalse(y
.testbit(0))
174 me
.assertTrue(y
.testbit(3))
175 me
.assertTrue(y
.testbit(1000))
177 me
.assertEqual(x
.setbit(0), x
)
178 me
.assertEqual(x
.clearbit(0), 168)
179 me
.assertEqual(x
.setbit(1), 171)
180 me
.assertEqual(x
.clearbit(1), x
)
181 me
.assertEqual(y
.setbit(0), -23)
182 me
.assertEqual(y
.clearbit(0), y
)
183 me
.assertEqual(y
.setbit(3), y
)
184 me
.assertEqual(y
.clearbit(3), -32)
185 me
.assertEqual(y
.setbit(1000), y
)
187 me
.assertEqual(x
.nbits
, 8)
188 me
.assertEqual(y
.nbits
, 5)
189 me
.assertEqual(zero
.nbits
, 0)
191 def test_loadstore(me
):
192 x
= C
.MP(0x0123456789ab)
194 u
= C
.MP(0xfedcba9876)
196 me
.assertEqual(x
.noctets
, 6)
197 me
.assertEqual(x
.noctets2c
, 6)
198 me
.assertEqual(y
.noctets
, 6)
199 me
.assertEqual(y
.noctets2c
, 6)
200 me
.assertEqual(u
.noctets
, 5)
201 me
.assertEqual(u
.noctets2c
, 6)
203 me
.assertEqual(x
, C
.MP
.loadb(C
.bytes("0123456789ab")))
204 me
.assertEqual(x
, C
.MP
.loadb2c(C
.bytes("0123456789ab")))
205 me
.assertEqual(y
, C
.MP
.loadb2c(C
.bytes("fedcba987655")))
207 me
.assertEqual(x
.storeb(), C
.bytes("0123456789ab"))
208 me
.assertEqual(x
.storeb(3), C
.bytes("6789ab"))
209 me
.assertEqual(x
.storeb(8), C
.bytes("00000123456789ab"))
210 me
.assertEqual(x
.storeb2c(), C
.bytes("0123456789ab"))
211 me
.assertEqual(x
.storeb2c(3), C
.bytes("6789ab"))
212 me
.assertEqual(x
.storeb2c(8), C
.bytes("00000123456789ab"))
213 me
.assertEqual(u
.storeb2c(), C
.bytes("00fedcba9876"))
214 me
.assertEqual(y
.storeb2c(), C
.bytes("fedcba987655"))
215 me
.assertEqual(y
.storeb2c(3), C
.bytes("987655"))
216 me
.assertEqual(y
.storeb2c(8), C
.bytes("fffffedcba987655"))
218 me
.assertEqual(x
, C
.MP
.loadl(C
.bytes("ab8967452301")))
219 me
.assertEqual(x
, C
.MP
.loadl2c(C
.bytes("ab8967452301")))
220 me
.assertEqual(y
, C
.MP
.loadl2c(C
.bytes("557698badcfe")))
222 me
.assertEqual(x
.storel(), C
.bytes("ab8967452301"))
223 me
.assertEqual(x
.storel(3), C
.bytes("ab8967"))
224 me
.assertEqual(x
.storel(8), C
.bytes("ab89674523010000"))
225 me
.assertEqual(x
.storel2c(), C
.bytes("ab8967452301"))
226 me
.assertEqual(x
.storel2c(3), C
.bytes("ab8967"))
227 me
.assertEqual(x
.storel2c(8), C
.bytes("ab89674523010000"))
228 me
.assertEqual(u
.storel2c(), C
.bytes("7698badcfe00"))
229 me
.assertEqual(y
.storel2c(), C
.bytes("557698badcfe"))
230 me
.assertEqual(y
.storel2c(3), C
.bytes("557698"))
231 me
.assertEqual(y
.storel2c(8), C
.bytes("557698badcfeffff"))
233 me
.assertEqual(x
.tobuf(), C
.bytes("00060123456789ab"))
234 me
.assertEqual((x
, T
.bin("abcd")),
235 C
.MP
.frombuf(C
.bytes("00060123456789ab61626364")))
237 def test_numbertheory(me
):
238 p
, x
, y
, z
= C
.MP(173), C
.MP(169), C
.MP(24), C
.MP(20)
240 me
.assertEqual(x
.odd(), (0, x
))
241 me
.assertEqual(y
.odd(), (3, 3))
243 me
.assertEqual(x
.sqr(), 28561)
244 me
.assertEqual(x
.sqrt(), 13)
245 me
.assertEqual(y
.sqrt(), 4)
247 me
.assertEqual(x
.gcd(y
), 1)
248 me
.assertEqual(x
.gcdx(y
), (1, -23, 162))
249 me
.assertEqual(y
.gcdx(x
), (1, -7, 1))
250 me
.assertEqual(x
.modinv(y
), 162)
251 me
.assertEqual(y
.modinv(x
), 1)
253 me
.assertEqual(x
.jacobi(y
), 1)
254 me
.assertEqual(x
.jacobi(13), 0)
255 me
.assertEqual(y
.jacobi(x
), 1)
256 me
.assertEqual(p
.jacobi(y
), 1)
257 me
.assertEqual(p
.jacobi(z
), -1)
258 me
.assertEqual(p
.modsqrt(y
), 71)
259 me
.assertRaises(ValueError, p
.modsqrt
, z
)
261 me
.assertEqual(y
.leastcongruent(x
, 32), 184)
263 me
.assertTrue(p
.primep())
264 me
.assertFalse(x
.primep())
267 me
.assertEqual(C
.MP
.factorial(0), 1)
270 30414093201713378043612608166064768844377641568960512000000000000)
271 me
.assertRaises((ValueError, OverflowError), C
.MP
.factorial
, -1)
274 me
.assertEqual(C
.MP
.fibonacci(-2), -1)
275 me
.assertEqual(C
.MP
.fibonacci(-1), +1)
276 me
.assertEqual(C
.MP
.fibonacci( 0), 0)
277 me
.assertEqual(C
.MP
.fibonacci(+1), +1)
278 me
.assertEqual(C
.MP
.fibonacci(+2), +1)
279 me
.assertEqual(C
.MP
.fibonacci(50), 12586269025)
281 ###--------------------------------------------------------------------------
282 class TestMPMul (U
.TestCase
):
286 me
.assertTrue(m
.livep
)
289 me
.assertEqual(m
.done(), 720)
290 me
.assertFalse(m
.livep
)
292 me
.assertEqual(C
.MPMul(T
.range(1, 7)).done(), 720)
293 me
.assertEqual(C
.MP
.factorial(6), 720)
295 ###--------------------------------------------------------------------------
296 class TestMPMont (U
.TestCase
):
300 me
.assertRaises(ValueError,
301 C
.MPMont
, 35315021952044908656941308411353985942)
302 me
.assertRaises(ValueError, C
.MPMont
, -9)
304 p
= C
.MP(269464705320809171350781605680038324101)
305 g
= C
.MP(2) # lucky chance
306 x
= C
.MP(211184293914316080585277908844600399612)
307 y
= C
.MP(154454671298730680774195646814344206562)
308 xy
= C
.MP(209444562478584646216087606217820187655)
309 me
.assertTrue(p
.primep())
311 me
.assertEqual(m
.m
, p
)
313 ## The precise values of m.r and m.r2 are dependent on the internal
314 ## bignum representation. But we expect m.r to be congruent to some
315 ## power of two. (It should be 2^128.)
317 for i
in T
.range(1025):
322 me
.fail("m.r is not a small-ish power of 2")
323 me
.assertEqual(m
.r2
, pow(2, 2*i
, p
))
324 me
.assertEqual(m
.ext(m
.r
), 1)
325 me
.assertEqual(m
.reduce(m
.r
), 1)
327 me
.assertEqual(m
.ext(m
.int(x
)), x
)
328 me
.assertEqual(m
.int(x
), m
.mul(x
, m
.r2
))
329 me
.assertEqual(m
.mul(m
.int(x
), y
), xy
)
330 me
.assertEqual(m
.ext(m
.mul(m
.int(x
), m
.int(y
))), xy
)
332 me
.assertEqual(m
.exp(2, p
- 1), 1)
333 me
.assertEqual(m
.expr(m
.int(2), p
- 1), m
.r
)
335 q
, r
, s
, z
= 32, 128, 2048, pow(g
, 156, p
)
336 me
.assertEqual(m
.mexp(set([(q
, 9), (r
, 8), (s
, 5)])), z
)
337 me
.assertEqual(m
.mexp([(q
, 9), (r
, 8), (s
, 5)]), z
)
338 me
.assertEqual(m
.mexp(q
, 9, r
, 8, s
, 5), z
)
340 q
, r
, s
, z
= T
.imap(m
.int, [32, 128, 2048, pow(g
, 156, p
)])
341 me
.assertEqual(m
.mexpr(set([(q
, 9), (r
, 8), (s
, 5)])), z
)
342 me
.assertEqual(m
.mexpr([(q
, 9), (r
, 8), (s
, 5)]), z
)
343 me
.assertEqual(m
.mexpr(q
, 9, r
, 8, s
, 5), z
)
345 ###--------------------------------------------------------------------------
346 class TestMPBarrett (U
.TestCase
):
350 p
= C
.MP(269464705320809171350781605680038324101)
351 g
= C
.MP(2) # lucky chance
352 x
= C
.MP(211184293914316080585277908844600399612)
353 y
= C
.MP(154454671298730680774195646814344206562)
354 xy
= C
.MP(209444562478584646216087606217820187655)
355 me
.assertTrue(p
.primep())
357 me
.assertEqual(m
.m
, p
)
359 me
.assertEqual(m
.reduce(x
*y
), xy
)
361 me
.assertEqual(m
.exp(2, p
- 1), 1)
363 q
, r
, s
, z
= 32, 128, 2048, pow(g
, 156, p
)
364 me
.assertEqual(m
.mexp(set([(q
, 9), (r
, 8), (s
, 5)])), z
)
365 me
.assertEqual(m
.mexp([(q
, 9), (r
, 8), (s
, 5)]), z
)
366 me
.assertEqual(m
.mexp(q
, 9, r
, 8, s
, 5), z
)
368 ###--------------------------------------------------------------------------
369 class TestMPReduce (U
.TestCase
):
374 g
= C
.MP(2) # lucky chance
375 x
= C
.MP(94827182170881245766374991987593163418)
376 y
= C
.MP(106025009945795266831396608563402138277)
377 xy
= C
.MP(80027041045616838298103413933629021123)
378 me
.assertTrue(p
.primep())
380 me
.assertEqual(m
.m
, p
)
382 me
.assertEqual(m
.reduce(x
*y
), xy
)
384 me
.assertEqual(m
.exp(2, 127), 1)
386 ###--------------------------------------------------------------------------
387 class TestMPCRT (U
.TestCase
):
391 c
= C
.MPCRT(5, 7, 11)
392 me
.assertEqual(c
.moduli
, [5, 7, 11])
393 me
.assertEqual(c
.product
, 385)
394 me
.assertEqual(c
.solve([2, 3, 4]), 367)
395 me
.assertEqual(c
.solve([2, -4, -7]), 367)
397 me
.assertRaises(ValueError, C
.MPCRT
, [6, 15, 35])
399 ###--------------------------------------------------------------------------
400 class TestGF (U
.TestCase
):
405 kk
= C
.BinPolyField(C
.GF(0x13))
407 me
.assertTrue(C
.GF(x
) is x
)
408 me
.assertEqual(C
.GF(k(8)), C
.GF(8))
409 me
.assertEqual(C
.GF(kk(8)), C
.GF(8))
410 me
.assertEqual(C
.GF(E(1, 4)), C
.GF(1))
411 me
.assertRaises(TypeError, C
.GF
, E())
413 me
.assertNotEqual(x
, 5) # no implicit conversion to int
414 me
.assertEqual(int(x
), 5)
415 y
= C
.GF(0x4eeb684a0954ec4ceb255e3e9778d41)
416 me
.assertEqual(type(int(y
)), T
.long)
418 me
.assertEqual(C
.GF('0x4eeb684a0954ec4ceb255e3e9778d41'), y
)
419 me
.assertEqual(C
.GF('4eeb684a0954ec4ceb255e3e9778d41', 16), y
)
420 me
.assertEqual(C
.GF('0x4eeb684a0954ec4ceb255e3e9778d41', 16), y
)
421 me
.assertEqual(C
.GF('0b0', 16), C
.GF(176)) # not 0
423 me
.assertEqual(C
.GF('047353320450112516611472622536175135706501'), y
)
424 me
.assertEqual(C
.GF('0o47353320450112516611472622536175135706501'), y
)
425 me
.assertEqual(C
.GF('047353320450112516611472622536175135706501', 8), y
)
426 me
.assertEqual(C
.GF('0o47353320450112516611472622536175135706501', 8), y
)
427 me
.assertEqual(C
.GF('47353320450112516611472622536175135706501', 8), y
)
430 me
.assertEqual(C
.GF('0b100111011011001100000010001011'), t
)
431 me
.assertEqual(C
.GF('0b100111011011001100000010001011', 2), t
)
432 me
.assertEqual(C
.GF('100111011011001100000010001011', 2), t
)
435 y
= C
.GF(0x4eeb684a0954ec4ceb255e3e9778d41)
436 me
.assertEqual(str(y
), '0x4eeb684a0954ec4ceb255e3e9778d41')
437 me
.assertEqual(repr(y
), 'GF(0x4eeb684a0954ec4ceb255e3e9778d41)')
438 me
.assertEqual(hex(y
), '0x4eeb684a0954ec4ceb255e3e9778d41')
439 me
.assertEqual(oct(y
), T
.py23('0', '0o') +
440 '47353320450112516611472622536175135706501')
442 except NameError: pass
443 else: me
.assertEqual(bin(C
.GF(661438603)),
444 '0b100111011011001100000010001011')
447 x
, y
, m
, zero
= C
.GF(0xa9), C
.GF(0x18), C
.GF(0x11b), C
.GF(0)
449 me
.assertEqual(x
, -x
)
450 me
.assertEqual(abs(x
), x
)
452 me
.assertEqual(x
+ y
, C
.GF(0xb1))
453 me
.assertEqual(x
- y
, C
.GF(0xb1))
454 me
.assertEqual(x
*y
, C
.GF(0xfd8))
455 me
.assertEqual(x
&y
, C
.GF(0x8))
456 me
.assertEqual(x | y
, C
.GF(0xb9))
457 me
.assertEqual(x ^ y
, C
.GF(0xb1))
459 me
.assertEqual(x
<< 3, C
.GF(0x548))
460 me
.assertEqual(x
<< -2, C
.GF(0x2a))
461 me
.assertEqual(x
>> 2, C
.GF(0x2a))
462 me
.assertEqual(x
>> -3, C
.GF(0x548))
464 u
= x
/y
; me
.assertEqual((u
.numer
, u
.denom
), (C
.GF(0x67), C
.GF(0x8)))
465 me
.assertEqual(x
//y
, C
.GF(0xc))
466 me
.assertEqual(x
%y
, C
.GF(0x9))
467 me
.assertEqual(divmod(x
, y
), (C
.GF(0xc), C
.GF(0x9)))
468 me
.assertRaises(ZeroDivisionError, lambda: x
/zero
)
469 me
.assertRaises(ZeroDivisionError, lambda: x
//zero
)
470 me
.assertRaises(ZeroDivisionError, lambda: x
%zero
)
471 me
.assertRaises(ZeroDivisionError, divmod, x
, zero
)
473 me
.assertEqual(pow(x
, 24),
474 C
.GF(0x1000100000001010000010101000101010001000001))
475 me
.assertEqual(pow(x
, 24, m
), C
.GF(0x78))
476 me
.assertEqual(pow(x
, -24, m
), C
.GF(0xb6))
477 me
.assertRaises(ZeroDivisionError, pow, x
, -24, C
.GF(0x18))
483 x
, y
, z
= C
.GF(0xa9), C
.GF(0x18), C
.GF(0xb3)
484 me
.assertTrue(x
== x
)
485 me
.assertFalse(x
!= x
)
486 me
.assertFalse(x
== y
)
487 me
.assertTrue(x
!= y
)
489 me
.assertFalse(y
> x
)
490 me
.assertFalse(x
> x
)
491 me
.assertFalse(x
> z
)
492 me
.assertFalse(z
> x
)
493 me
.assertTrue(x
>= y
)
494 me
.assertFalse(y
>= x
)
495 me
.assertTrue(x
>= x
)
496 me
.assertTrue(x
>= z
)
497 me
.assertTrue(z
>= x
)
498 me
.assertFalse(x
<= y
)
499 me
.assertTrue(y
<= x
)
500 me
.assertTrue(x
<= x
)
501 me
.assertTrue(x
<= z
)
502 me
.assertTrue(z
<= x
)
503 me
.assertFalse(x
< y
)
505 me
.assertFalse(x
< x
)
506 me
.assertFalse(x
< z
)
507 me
.assertFalse(z
< x
)
510 x
, zero
= C
.GF(0xa9), C
.GF(0)
511 me
.assertTrue(x
.testbit(0))
512 me
.assertFalse(x
.testbit(1))
513 me
.assertFalse(x
.testbit(1000))
515 me
.assertEqual(x
.setbit(0), x
)
516 me
.assertEqual(x
.clearbit(0), C
.GF(0xa8))
517 me
.assertEqual(x
.setbit(1), C
.GF(0xab))
518 me
.assertEqual(x
.clearbit(1), x
)
520 me
.assertEqual(x
.nbits
, 8)
521 me
.assertEqual(x
.degree
, 7)
522 me
.assertEqual(zero
.nbits
, 0)
523 me
.assertEqual(zero
.degree
, -1)
525 def test_loadstore(me
):
526 x
= C
.GF(0x0123456789ab)
528 me
.assertEqual(x
.noctets
, 6)
530 me
.assertEqual(x
, C
.GF
.loadb(C
.bytes("0123456789ab")))
532 me
.assertEqual(x
.storeb(), C
.bytes("0123456789ab"))
533 me
.assertEqual(x
.storeb(3), C
.bytes("6789ab"))
534 me
.assertEqual(x
.storeb(8), C
.bytes("00000123456789ab"))
536 me
.assertEqual(x
, C
.GF
.loadl(C
.bytes("ab8967452301")))
538 me
.assertEqual(x
.storel(), C
.bytes("ab8967452301"))
539 me
.assertEqual(x
.storel(3), C
.bytes("ab8967"))
540 me
.assertEqual(x
.storel(8), C
.bytes("ab89674523010000"))
542 me
.assertEqual(x
.tobuf(), C
.bytes("00060123456789ab"))
543 me
.assertEqual((x
, T
.bin("abcd")),
544 C
.GF
.frombuf(C
.bytes("00060123456789ab61626364")))
546 def test_numbertheory(me
):
547 p
, x
, y
= C
.GF(0x11b), C
.GF(0xa9), C
.GF(0x18)
549 me
.assertEqual(x
.sqr(), C
.GF(0x4441))
551 me
.assertEqual(x
.gcd(y
), C
.GF(0x3))
552 me
.assertEqual(x
.gcdx(y
), (C
.GF(0x3), C
.GF(0x3), C
.GF(0x15)))
553 me
.assertEqual(p
.modinv(x
), C
.GF(0xc8))
555 me
.assertTrue(p
.irreduciblep())
556 me
.assertFalse(x
.irreduciblep())
558 ###--------------------------------------------------------------------------
559 class TestGFReduce (U
.TestCase
):
562 p
= C
.GF(0x87).setbit(128)
563 me
.assertTrue(p
.irreduciblep())
566 x
= C
.GF(0xce46b4c1d3a1523520b1bb6eb5c61883)
567 y
= C
.GF(0xb5b0b3566b8e03f4b4a2b1ac413f8566)
568 xy
= C
.GF(0x28e5b895c11b08edc2fe7e1be5694c64)
570 me
.assertEqual(m
.reduce(x
*y
), xy
)
571 me
.assertEqual(m
.trace(x
), 0)
572 me
.assertEqual(m
.trace(y
), 1)
573 me
.assertEqual(m
.sqrt(x
), C
.GF(0xa277ee4bf770e5974cf1e31b1ccb54a1))
574 me
.assertEqual(m
.halftrace(y
), C
.GF(0x9cea73e79ffd190dd3c81d33e58d8e6f))
575 me
.assertEqual(m
.quadsolve(x
), C
.GF(0x9664c09d23d168147a438de6a813c784))
577 ###--------------------------------------------------------------------------
578 class TestGFN (U
.TestCase
):
581 p
= C
.GF(0x87).setbit(128)
582 beta
= C
.GF(0xc50f387e37194d4a4b41e157a3e2b5e1)
583 y
= C
.GF(0xdaca76dc2578a63c788a2ce0fc7878f6)
584 yy
= C
.GF(0x298a98f955100f054fcee3433f96b00e)
585 zero
, one
, fff
= C
.GF(0), C
.GF(1), C
.GF(T
.long(2)**128 - 1)
586 me
.assertTrue(p
.irreduciblep())
589 me
.assertEqual(gfn
.p
, p
)
590 me
.assertEqual(gfn
.beta
, beta
)
591 me
.assertEqual(gfn
.pton(zero
), zero
)
592 me
.assertEqual(gfn
.ntop(zero
), zero
)
593 me
.assertEqual(gfn
.pton(one
), fff
)
594 me
.assertEqual(gfn
.ntop(fff
), one
)
595 me
.assertEqual(gfn
.pton(y
), yy
)
596 me
.assertEqual(gfn
.ntop(yy
), y
)
598 ## Doesn't generate a normal basis.
599 me
.assertRaises(ValueError, C
.GFN
, p
, y
)
601 ###----- That's all, folks --------------------------------------------------
603 if __name__
== "__main__": U
.main()