home *** CD-ROM | disk | FTP | other *** search
/ Maximum CD 2010 November / maximum-cd-2010-11.iso / DiscContents / calibre-0.7.13.msi / file_2255 (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2010-08-06  |  4.6 KB  |  201 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyc (Python 2.6)
  3.  
  4. __revision__ = '$Id: number.py,v 1.13 2003/04/04 18:21:07 akuchling Exp $'
  5. bignum = long
  6.  
  7. try:
  8.     from Crypto.PublicKey import _fastmath
  9. except ImportError:
  10.     _fastmath = None
  11.  
  12.  
  13. def size(N):
  14.     (bits, power) = (0, 0x1L)
  15.     while N >= power:
  16.         bits += 1
  17.         power = power << 1
  18.     return bits
  19.  
  20.  
  21. def getRandomNumber(N, randfunc):
  22.     S = randfunc(N / 8)
  23.     odd_bits = N % 8
  24.     if odd_bits != 0:
  25.         char = ord(randfunc(1)) >> 8 - odd_bits
  26.         S = chr(char) + S
  27.     
  28.     value = bytes_to_long(S)
  29.     value |= 0x2L ** (N - 1)
  30.     return value
  31.  
  32.  
  33. def GCD(x, y):
  34.     x = abs(x)
  35.     y = abs(y)
  36.     while x > 0:
  37.         x = y % x
  38.         y = x
  39.     return y
  40.  
  41.  
  42. def inverse(u, v):
  43.     u3 = long(u)
  44.     v3 = long(v)
  45.     (u1, v1) = (0x1L, 0x0L)
  46.     while v3 > 0:
  47.         q = u3 / v3
  48.         u1 = v1
  49.         v1 = u1 - v1 * q
  50.         u3 = v3
  51.         v3 = u3 - v3 * q
  52.     while u1 < 0:
  53.         u1 = u1 + v
  54.     return u1
  55.  
  56.  
  57. def getPrime(N, randfunc):
  58.     number = getRandomNumber(N, randfunc) | 1
  59.     while not isPrime(number):
  60.         number = number + 2
  61.     return number
  62.  
  63.  
  64. def isPrime(N):
  65.     if N == 1:
  66.         return 0
  67.     if N in sieve:
  68.         return 1
  69.     for i in sieve:
  70.         if N % i == 0:
  71.             return 0
  72.     
  73.     if _fastmath is not None:
  74.         return _fastmath.isPrime(N)
  75.     N1 = N - 0x1L
  76.     n = 0x1L
  77.     while n < N:
  78.         n = n << 0x1L
  79.         continue
  80.         _fastmath is not None
  81.     n = n >> 0x1L
  82.     for c in sieve[:7]:
  83.         a = long(c)
  84.         d = 0x1L
  85.         t = n
  86.         while t:
  87.             x = d * d % N
  88.             if x == 0x1L and d != 0x1L and d != N1:
  89.                 return 0
  90.             t = t >> 0x1L
  91.             continue
  92.             N in sieve if N1 & t else N % i == 0
  93.         if d != 0x1L:
  94.             return 0
  95.     
  96.     return 1
  97.  
  98. sieve = [
  99.     2,
  100.     3,
  101.     5,
  102.     7,
  103.     11,
  104.     13,
  105.     17,
  106.     19,
  107.     23,
  108.     29,
  109.     31,
  110.     37,
  111.     41,
  112.     43,
  113.     47,
  114.     53,
  115.     59,
  116.     61,
  117.     67,
  118.     71,
  119.     73,
  120.     79,
  121.     83,
  122.     89,
  123.     97,
  124.     101,
  125.     103,
  126.     107,
  127.     109,
  128.     113,
  129.     127,
  130.     131,
  131.     137,
  132.     139,
  133.     149,
  134.     151,
  135.     157,
  136.     163,
  137.     167,
  138.     173,
  139.     179,
  140.     181,
  141.     191,
  142.     193,
  143.     197,
  144.     199,
  145.     211,
  146.     223,
  147.     227,
  148.     229,
  149.     233,
  150.     239,
  151.     241,
  152.     251]
  153. import struct
  154.  
  155. def long_to_bytes(n, blocksize = 0):
  156.     s = ''
  157.     n = long(n)
  158.     pack = struct.pack
  159.     while n > 0:
  160.         s = pack('>I', n & 0xFFFFFFFFL) + s
  161.         n = n >> 32
  162.     for i in range(len(s)):
  163.         if s[i] != '\x00':
  164.             break
  165.             continue
  166.     else:
  167.         s = '\x00'
  168.         i = 0
  169.     s = s[i:]
  170.     if blocksize > 0 and len(s) % blocksize:
  171.         s = (blocksize - len(s) % blocksize) * '\x00' + s
  172.     
  173.     return s
  174.  
  175.  
  176. def bytes_to_long(s):
  177.     acc = 0x0L
  178.     unpack = struct.unpack
  179.     length = len(s)
  180.     if length % 4:
  181.         extra = 4 - length % 4
  182.         s = '\x00' * extra + s
  183.         length = length + extra
  184.     
  185.     for i in range(0, length, 4):
  186.         acc = (acc << 32) + unpack('>I', s[i:i + 4])[0]
  187.     
  188.     return acc
  189.  
  190. import warnings
  191.  
  192. def long2str(n, blocksize = 0):
  193.     warnings.warn('long2str() has been replaced by long_to_bytes()')
  194.     return long_to_bytes(n, blocksize)
  195.  
  196.  
  197. def str2long(s):
  198.     warnings.warn('str2long() has been replaced by bytes_to_long()')
  199.     return bytes_to_long(s)
  200.  
  201.