sgmftr Namespace Reference


Functions

def sgmftr
def do_verify
def isMersenne
def factor_pqminus
def factor_pqplus
def factor_factor
def factor_factor_crude
def factors_multiply
def factors_divide
def factors_as_string
def factors_magnitude
def even
def print_sgmftr
def main
def do_mersenne
def do_test

Variables

int indent = 4
int verify = 1
int level = 0
int verbose = 0
tuple argc = len(sys.argv)
list arg = sys.argv[ i ]

Function Documentation

def sgmftr::do_mersenne (   i,
  argc 
)

Definition at line 284 of file sgmftr.py.

00284                           :
00285 
00286     print argc, i
00287     if argc - i < 2:
00288         min = 2
00289         max = 200
00290     elif i < argc:
00291         min = int( sys.argv[ i + 0 ] )
00292         max = int( sys.argv[ i + 1 ] )
00293 
00294     for q in range( min, max ) :
00295         ans = isMersenne( q )
00296         if ans > 0:
00297             print q, ans
00298 
def do_test( i, argc ):

def sgmftr::do_test (   i,
  argc 
)

Definition at line 299 of file sgmftr.py.

00299                       :
00300 
00301     if argc - i < 2:
00302         min = 2
00303         max = 200
00304     elif i < argc:
00305         min = int( sys.argv[ i + 0 ] )
00306         max = int( sys.argv[ i + 1 ] )
00307     
00308         two_68  = "07-08-20 09:56:12    2  68  ( 7^1 47^1 178481^1 10052678938039^1 )"
00309         two_137 = "07-10-02 18:08:03    2  137  ( 3^2 7^1 47^1 139^1 178481^1 2796203^1 168749965921^1 10052678938039^1 )"
00310 
00311         two_275_1 = "09-03-15 03:10:34    2  275  ( 3^2 5^1 7^1 13^1 47^1 139^1 277^1 1013^1 1657^1 30269^1 178481^1 2796203^1 168749965921^1 5415624023749^1 10052678938039^1                  70334392823809^1 )"
00312         two_275_2 = "09-03-18 13:03:22    2  275  ( 3^2 5^1 7^1 13^1 47^1       277^1 1013^1 1657^1 30269^1 178481^1 2796203^1                5415624023749^1                                   70334392823809^1 )"
00313         two_275_3 = "09-03-18 13:40:24    2  275  ( 3^2 5^1 7^1 13^1 47^1       277^1 1013^1 1657^1 30269^1 178481^1 2796203^1                5415624023749^1 10052678938039^1                  70334392823809^1 )"
00314         two_275_4 = "09-03-18 13:42:16    2  275  ( 3^2 5^1 7^1 13^1 47^1       277^1 1013^1 1657^1 30269^1 178481^1 2796203^1                5415624023749^1 10052678938039^1 23456245263019^1 70334392823809^1 )"
00315 
00316     p = 2
00317     for q in range( min, max ) :
00318 #        if q == 275:
00319 #            print two_275_4
00320 #            print two_275_3
00321 #            print two_275_2
00322 #            print two_275_1
00323         print_sgmftr( p, q, sgmftr( p, q ) )
00324 
if __name__ == '__main__':

def sgmftr::do_verify (   exp,
  factors 
)

Definition at line 33 of file sgmftr.py.

00033                              :
00034     
00035     got = factors_magnitude( factors )
00036 
00037     if exp != got:
00038         print "sgmftr error"
00039         print "    exp: %s" % exp
00040         print "    got: %s" % got
00041         print "    exp/got: %s" % ( exp / got )
00042         print "    got/exp: %s" % ( got / exp )
00043         print "    %s" % factors_as_string( factors )
00044 
def isMersenne( q ):

def sgmftr::even (   n  ) 

Definition at line 263 of file sgmftr.py.

00263              :
00264     if n % 2 == 0:
00265         return True
00266     else:
00267         return False
00268     
def print_sgmftr( p, q, v ):

def sgmftr::factor_factor (   v  ) 

Definition at line 171 of file sgmftr.py.

00171                       :
00172     v = mpz( v )
00173     ans = pyecm_wrapper.factors_as_dict_of_numbers( v )
00174     if verbose:
00175         print "%sf_f: %s ->  %s" % (  " " * (level + indent), v, ans )
00176     return ans
00177 
def factor_factor_crude( v ):

def sgmftr::factor_factor_crude (   v  ) 

Definition at line 178 of file sgmftr.py.

00178                             :
00179 
00180     global verbose, level
00181 
00182     ans = { }
00183     n = 2
00184     while n * n < v:
00185         if v % n == 0:
00186             ans[ n ] = ans.get( n, 0 ) + 1
00187             v = v / n
00188         if v == 1:
00189             break
00190         n += 1
00191         
00192     if v != 1:
00193         ans[ v ] = ans.get( v, 0 ) + 1
00194 
00195     if verbose:
00196         level += indent
00197         print "%sfactor: %s -> %s" % ( " " * level, v, factors_as_string( ans ) )
00198         level -= indent
00199 
00200     return ans
00201 
def factors_multiply( lfactors, rfactors ):

def sgmftr::factor_pqminus (   p,
  q 
)

factor( p ** q - 1 )

Definition at line 67 of file sgmftr.py.

00067                           :
00068     '''
00069     factor( p ** q - 1 )
00070     '''
00071 
00072     global verbose, level
00073 
00074     if verbose:
00075         level += indent
00076         print "%spqminus: %s %s" % ( " " * level, p, q )
00077 
00078     value = p ** q - 1
00079     if p == 2 and isMersenne( q ):
00080         ans = { }
00081         ans[ value ] = Number.Number( value, 1 )
00082         return ans
00083 
00084     if q == 1:
00085         ans = factor_factor( value )
00086     elif q == 2 and value < 4:
00087         ans = factor_factor( value )
00088     elif even( q ):
00089         n = q / 2
00090         if n == 1:
00091             # p^2-1 = (p-1)*(p+1)
00092             lfactors = factor_factor( p - 1 )
00093             rfactors = factor_factor( p + 1 )
00094         else:
00095             # p^2n-1 = (p^n-1)*(p^n+1)
00096             lfactors = factor_pqminus( p, n )
00097             rfactors = factor_pqplus( p, n )
00098 #        ans = lfactors * rfactors
00099         ans = factors_multiply( lfactors, rfactors )
00100     else:
00101         # p^m*m-1 = (p^m-1)*(...)
00102         qfactors = factor_factor( q )
00103         keys = qfactors.keys( )
00104         if len( keys ) == 1:
00105             ans = factor_factor( value )
00106         else:
00107             ans = { }
00108             for exp in keys:
00109                 if even( exp ):
00110                     continue
00111                 tvalue = factor_pqminus( p, exp )
00112                 for factor in tvalue.keys( ):
00113                     while value % factor == 0:
00114                         if not ans.has_key( factor ):
00115                             ans[ factor ] = Number.Number( factor, 1 )
00116                         else:
00117                             ans[ factor ] = Number.Number( factor, ans[ factor ].power( ) +  1 )
00118                         value = value / factor
00119             if value != 1:
00120                 ans = factors_multiply( ans, factor_factor( value ) )
00121 
00122     if verbose:
00123         print "%spqminus: %s %s -> %s" % ( " " * level, p, q, factors_as_string( ans ) )
00124         level -= indent
00125 
00126     return ans
00127 
def factor_pqplus( p, q ):

def sgmftr::factor_pqplus (   p,
  q 
)

factor( p ** q + 1 )
if q is odd:
    for each factor of q:
        merge factors of p**factor + 1 into result

Definition at line 128 of file sgmftr.py.

00128                          :
00129     '''
00130     factor( p ** q + 1 )
00131     if q is odd:
00132         for each factor of q:
00133             merge factors of p**factor + 1 into result
00134     '''
00135 
00136     global verbose, level
00137 
00138     if verbose:
00139         level += indent
00140         print "%spqplus: %s %s" % ( " " * level, p, q )
00141 
00142     value = p ** q + 1
00143     if q == 1:
00144         ans = factor_factor( value )
00145     elif even( q ):
00146         ans = factor_factor( value )
00147     else:
00148         ans = { }
00149         qfactors = factor_factor( q )
00150         for exp in qfactors.keys( ):
00151             if even( exp ):
00152                 continue
00153             tvalue = factor_factor( p ** exp + 1 )
00154             for factor in tvalue.keys( ):
00155                 while value % factor == 0:
00156                     if not ans.has_key( factor ):
00157                         ans[ factor ] = Number.Number( factor, 1 )
00158                     else:
00159                         ans[ factor ] = Number.Number( factor, ans[ factor ].power( ) +  1 )
00160                     value = value / factor
00161 
00162         if value != 1:
00163             ans = factors_multiply( ans, factor_factor( value ) )
00164 
00165     if verbose:
00166         print "%spqplus: %s %s -> %s" % ( " " * level, p, q, factors_as_string( ans ) )
00167         level -= indent
00168 
00169     return ans
00170 
def factor_factor( v ):

def sgmftr::factors_as_string (   factors  ) 

Definition at line 247 of file sgmftr.py.

00247                                 :
00248     ans = "("
00249     keys = factors.keys( )
00250     keys.sort( )
00251     for key in keys:
00252         ans = "%s %s^%s" % ( ans, key, factors[ key ].power( ) )
00253     ans = "%s )" % ( ans )
00254     return ans
00255 
def factors_magnitude( factors ):

def sgmftr::factors_divide (   numerator,
  denominator 
)

divide two lists of factors

Definition at line 228 of file sgmftr.py.

00228                                             :
00229     '''
00230     divide two lists of factors
00231     '''
00232 
00233     if verbose:
00234         print "%sdivide: %s %s" % ( " " * level, numerator, denominator )
00235 
00236     ans = { }
00237     for key in numerator.keys( ):
00238         diff = numerator[ key ] - denominator.get( key, 0)
00239         if diff != 0:
00240             ans[ key ] = Number.Number( key, diff )
00241 
00242     if verbose:
00243         print "%sdivide: %s %s -> %s" % ( " " * level, numerator, denominator, factors_as_string( ans ) )
00244 
00245     return ans
00246 
def factors_as_string( factors ):

def sgmftr::factors_magnitude (   factors  ) 

Definition at line 256 of file sgmftr.py.

00256                                 :
00257     ans = 1
00258     keys = factors.keys( )
00259     for key in keys:
00260         ans = ans * key ** factors[ key ].power( )
00261     return ans
00262 
def even( n ):

def sgmftr::factors_multiply (   lfactors,
  rfactors 
)

multiply two lists of factors

Definition at line 202 of file sgmftr.py.

00202                                           :
00203     '''
00204     multiply two lists of factors
00205     '''
00206     lkeys = lfactors.keys( )
00207     rkeys = rfactors.keys( )
00208     if len( lkeys ) < len( rkeys ):
00209         ans = rfactors
00210         src = lfactors
00211     else:
00212         ans = lfactors
00213         src = rfactors
00214 
00215     for p in src.keys( ):
00216 #        ans[ p ] = ans.get( p, 0 ) + src[ p ]
00217         if not ans.has_key( p ):
00218             q = src[ p ].power( )
00219         else:
00220             q = ans[ p ].power( ) + src[ p ].power( )
00221         ans[ p ] = Number.Number( p, q )
00222 
00223     if verbose:
00224         print "%smultiply: %s %s -> %s" % ( " " * level, lfactors, rfactors, factors_as_string( ans ) )
00225 
00226     return ans
00227 
def factors_divide( numerator, denominator ):

def sgmftr::isMersenne (   q  ) 

Definition at line 45 of file sgmftr.py.

00045                    :
00046     f = Factors.Factors( )
00047     ans = f.isLucasLehmerPrime( q )
00048 
00049     quiet = True
00050     if not quiet:
00051         if ans == False and isinstance( ans, types.BooleanType ):
00052             status = "N" # not prime
00053             if verbose:
00054                 print "%s: %s" % ( status, q )
00055         elif ans == 0:
00056             status = "P" # Prime, but not Mersenne prime
00057             if verbose:
00058                 print "%s: %s" % ( status, q )
00059 
00060     if ans > 0:
00061         status = "M" # Mersenne prime
00062         if verbose:
00063             print "%s: %s -> %s" % ( status, q, ans )
00064 
00065     return ans
00066 
def factor_pqminus( p, q ):

def sgmftr::main (  ) 

Definition at line 275 of file sgmftr.py.

00275            :
00276 
00277     for i in xrange( 1, len( sys.argv ), 2 ):
00278 #        level = 0
00279         p = int( sys.argv[ i ] )
00280         q = int( sys.argv[ i + 1 ] )
00281         print "sgmftr( %s, %s ) -> " % ( p, q ),
00282         factors_as_string( sgmftr( p, q ) )
00283 
def do_mersenne( i, argc ):

def sgmftr::print_sgmftr (   p,
  q,
  v 
)

Definition at line 269 of file sgmftr.py.

00269                            :
00270     s = pyecm_wrapper.time_now( )
00271     print "%s  " % s,
00272     print " %s  %s  %s" % ( p, q, factors_as_string( v ) )
00273     sys.stdout.flush( )
00274 
def main( ):

def sgmftr::sgmftr (   p,
  q 
)

sigma( p, q ) = ( p ** ( q + 1 ) - 1 ) / ( p - 1 )

Definition at line 13 of file sgmftr.py.

00013                :
00014     '''
00015     sigma( p, q ) = ( p ** ( q + 1 ) - 1 ) / ( p - 1 )
00016     '''
00017 
00018     if verbose:
00019         print "sgmftr: %s %s" % ( p, q )
00020 
00021     ans = factor_pqminus( p, q + 1 )
00022     if p > 2:
00023         ans = factors_divide( ans, factor_factor( p - 1 ) )
00024 
00025     if verbose:
00026         print "sgmftr: %s %s -> %s" % ( p, q, factors_as_string( ans ) )
00027 
00028     if verify:
00029         do_verify( ( p ** ( q + 1 ) - 1 ) / ( p - 1 ), ans )
00030 
00031     return ans
00032 
def do_verify( exp, factors ):


Variable Documentation

list sgmftr::arg = sys.argv[ i ]

Definition at line 336 of file sgmftr.py.

tuple sgmftr::argc = len(sys.argv)

Definition at line 331 of file sgmftr.py.

int sgmftr::indent = 4

Definition at line 10 of file sgmftr.py.

int sgmftr::level = 0

Definition at line 328 of file sgmftr.py.

int sgmftr::verbose = 0

Definition at line 329 of file sgmftr.py.

int sgmftr::verify = 1

Definition at line 11 of file sgmftr.py.


Generated on Sun Mar 22 09:59:14 2009 for Multiperfect Number Generator by  doxygen 1.5.8