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 ] |
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 | ) |
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 | ||||
) |
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 ):
list sgmftr::arg = sys.argv[ i ] |
tuple sgmftr::argc = len(sys.argv) |
int sgmftr::indent = 4 |
int sgmftr::level = 0 |
int sgmftr::verbose = 0 |
int sgmftr::verify = 1 |