Public Member Functions | |
def | __init__ |
def | type |
def | __str__ |
def | asStringOrderedByOrder |
def | asStringOrderedByFactors |
def | printSeeds |
def | add |
def | addResult |
def | addString |
def | at |
def | order |
def | xxx_matchFactor_xxxdef |
def | matchFactors |
def | counts |
def | updateStartTriples |
def | verify |
A cache of results stored as a dictionary of dictionaries. Outer key is the multiperfect's order. Inner key is the multiperfect's factor list. Inner value is the multiperfect number (a Result object).
Definition at line 87 of file ResultCache.py.
def ResultCache::ResultCache::__init__ | ( | self, | ||
saver | ||||
) |
Reimplemented from Cache::Cache.
Definition at line 96 of file ResultCache.py.
00096 : 00097 Cache.Cache.__init__( self, saver ) 00098 self._counter = 0 00099 self._counts = ResultCounter.ResultCounter( ) 00100 return 00101 def type( self ):
def ResultCache::ResultCache::__str__ | ( | self | ) |
Definition at line 106 of file ResultCache.py.
00106 : 00107 00108 if globals.PrintResultsByOrder: 00109 # by multiperfect's order ( 2, 3, ... ) 00110 answer = self.asStringOrderedByOrder( ) 00111 else: 00112 # by multiperfect's factors ( 2^N, 3^N, ... ) 00113 answer = self.asStringOrderedByFactors( ) 00114 00115 if answer == "": 00116 answer = "<ResultCache.ResultCache instance>" 00117 00118 return answer 00119 def asStringOrderedByOrder( self ):
def ResultCache::ResultCache::add | ( | self, | ||
anObject, | ||||
seed = None | ||||
) |
Reimplemented from Cache::Cache.
Definition at line 185 of file ResultCache.py.
00185 : 00186 00187 if isinstance( anObject, types.StringType ): 00188 string = anObject 00189 answer = self.addString( string ) 00190 else: 00191 answer = self.addResult( anObject, seed ) 00192 00193 self._counter += 1 00194 00195 return answer 00196 def addResult( self, result, seed ):
def ResultCache::ResultCache::addResult | ( | self, | ||
result, | ||||
seed | ||||
) |
Definition at line 197 of file ResultCache.py.
00197 : 00198 00199 "Add a multiperfect to the result list." 00200 "Update new/old/dup counts." 00201 00202 order = result.order( ) 00203 00204 answer = self.at( result ) 00205 if answer == None: 00206 result = result.copy( ) 00207 rco = ResultAndSeedSet( result, seed ) 00208 results_dict = self.order( order ) 00209 results_dict[ result.factors( ) ] = rco 00210 state = result.state( ) 00211 if state != "old": 00212 self._counts.update( state ) 00213 globals.Saver.newResult( ) 00214 globals.Saver.doSave( True ) 00215 00216 else: 00217 result = answer.result( ) 00218 seeds = answer.seeds( ) 00219 00220 state = result.state( ) 00221 if state != "new": 00222 self._counts.update( state ) 00223 00224 if not seed in seeds: 00225 seeds.add( seed ) 00226 globals.Saver.newResult( ) 00227 00228 return result 00229 def addString( self, line ):
def ResultCache::ResultCache::addString | ( | self, | ||
line | ||||
) |
Definition at line 230 of file ResultCache.py.
00230 : 00231 00232 if ( len( re.split( ":", line ) ) != 1 ): 00233 00234 tokens = re.split( " +", line ) 00235 date = "%s %s" % ( tokens[ 0 ], tokens[ 1 ] ) 00236 date = TimeStamp.TimeStamp( date ) 00237 order = int( tokens[ 2 ] ) 00238 power = int( tokens[ 3 ] ) 00239 00240 tokens = re.split( "[()]", line ) 00241 factors = Factors.FromString( tokens[ 1 ] ) 00242 00243 state = "old" 00244 result = Result.Result( order, factors, date, state ) 00245 00246 if self.verify( line, order, result.factors( ) ): 00247 results = self.order( order ) 00248 self._rco = ResultAndSeedSet( result, None ) 00249 results[ factors ] = self._rco 00250 self._counts.update( state ) 00251 00252 else: 00253 00254 seed = Factors.FromString( line ) 00255 self._rco.add( seed ) 00256 00257 return 00258 def at( self, aResult ):
def ResultCache::ResultCache::asStringOrderedByFactors | ( | self | ) |
Definition at line 144 of file ResultCache.py.
00144 : 00145 00146 quiet = globals.quiet 00147 globals.quiet = False 00148 00149 answer = "" 00150 rco_list = [ ] 00151 00152 for order in self.sortedkeys( ): 00153 00154 results_dict = self._dict[ order ] 00155 for rco in results_dict.values( ): 00156 rco_list.append( rco ) 00157 00158 rco_list.sort( ) 00159 00160 for rco in rco_list: 00161 result = rco.result( ) 00162 seeds = rco.seeds( ) 00163 answer += "%s\n" % result 00164 answer += "%s" % self.printSeeds( seeds ) 00165 00166 globals.quiet = quiet 00167 00168 return answer 00169 def printSeeds( self, seeds ):
def ResultCache::ResultCache::asStringOrderedByOrder | ( | self | ) |
Definition at line 120 of file ResultCache.py.
00120 : 00121 00122 quiet = globals.quiet 00123 globals.quiet = False 00124 00125 blank = "" 00126 answer = "" 00127 00128 for order in self.sortedkeys( ): 00129 answer += blank 00130 blank = "\n" 00131 00132 values = self._dict.sortedvalues( order ) 00133 00134 for rco in values: 00135 result = rco.result( ) 00136 seeds = rco.seeds( ) 00137 answer += "%s\n" % result 00138 answer += "%s\n" % self.printSeeds( seeds ) 00139 00140 globals.quiet = quiet 00141 00142 return answer 00143 def asStringOrderedByFactors( self ):
def ResultCache::ResultCache::at | ( | self, | ||
aResult | ||||
) |
Reimplemented from Cache::Cache.
Definition at line 259 of file ResultCache.py.
00259 : 00260 "Answer the cached result (or nil)." 00261 00262 order = aResult.order( ) 00263 00264 if not self._dict.has_key( order ): 00265 return None 00266 00267 results = self._dict[ order ] 00268 factors = aResult.factors( ) 00269 00270 if results.has_key( factors ): 00271 answer = results[ factors ] 00272 return answer 00273 else: 00274 return None 00275 def order( self, value ):
def ResultCache::ResultCache::counts | ( | self | ) |
Definition at line 348 of file ResultCache.py.
00348 : 00349 00350 # Accessor for ResultCounter object 00351 00352 return self._counts 00353 def updateStartTriples( self, triples, seed ):
def ResultCache::ResultCache::matchFactors | ( | self, | ||
factors, | ||||
delta = 0 | ||||
) |
Find results that match the factor list. If lacking exact match, increase power and try again.
Definition at line 319 of file ResultCache.py.
00319 : 00320 00321 ''' 00322 Find results that match the factor list. 00323 If lacking exact match, increase power and try again. 00324 ''' 00325 00326 results = set( ) 00327 two = factors[ 2 ].copy( ) 00328 00329 while True : 00330 two.power( two.power( ) + delta ) 00331 00332 for key in self._dict.keys( ): 00333 rco_list = self._dict[ key ].values( ) 00334 if rco_list == None: 00335 break 00336 for rco in rco_list: 00337 result = rco.result( ) 00338 if result.matchesFactors( factors ): 00339 results.add( result ) 00340 00341 if delta == 0: 00342 break 00343 if len( results ) != 0: 00344 break 00345 00346 return results 00347 def counts( self ):
def ResultCache::ResultCache::order | ( | self, | ||
value | ||||
) |
Definition at line 276 of file ResultCache.py.
00276 : 00277 00278 if self._dict.has_key( value ): 00279 results = self._dict[ value ] 00280 else: 00281 results = { } # dict 00282 self._dict[ value ] = results 00283 return results 00284 def xxx_matchFactor_xxxdef( self, two, delta = 0 ):
def ResultCache::ResultCache::printSeeds | ( | self, | ||
seeds | ||||
) |
Definition at line 170 of file ResultCache.py.
00170 : 00171 00172 answer = "" 00173 list = [ ] 00174 for seed in seeds: 00175 list.append( seed ) 00176 list.sort( ) 00177 for seed in list: 00178 if globals.quiet: 00179 answer += "%s\n" % seed 00180 else: 00181 answer += "%26s %s\n" % ( " ", seed ) 00182 00183 return answer 00184 def add( self, anObject, seed = None ):
def ResultCache::ResultCache::type | ( | self | ) |
def ResultCache::ResultCache::updateStartTriples | ( | self, | ||
triples, | ||||
seed | ||||
) |
find matching power of 2 in result cache find min & max powers of 3, 5, and 7
Definition at line 354 of file ResultCache.py.
00354 : 00355 00356 """ 00357 find matching power of 2 in result cache 00358 find min & max powers of 3, 5, and 7 00359 """ 00360 00361 results_set = self.matchFactors( seed ) 00362 00363 keys = triples.keys( ) 00364 for p in keys: 00365 for result in results_set: 00366 factors = result._factors 00367 if factors.has_key( p ): 00368 factor = factors[ p ] 00369 triple = triples[ p ] 00370 triple.adjMinMax( factor ) 00371 00372 return 00373 def verify( self, line, order, factors ):
def ResultCache::ResultCache::verify | ( | self, | ||
line, | ||||
order, | ||||
factors | ||||
) |
Definition at line 374 of file ResultCache.py.
00374 : 00375 00376 mag = factors.magnitude( ) 00377 sgm = factors.sgmftr( ).magnitude( ) 00378 if sgm == mag * order: 00379 return True 00380 else: 00381 order = sgm * 1.0 / mag 00382 print "%s" % "ResultCache error:" 00383 print " %s" % line 00384 print " %s %0.2f" % ( " " * 20, order ) 00385 pydb.debugger( ) 00386 return False 00387 ## if sgm == mag * order:
def ResultCache::ResultCache::xxx_matchFactor_xxxdef | ( | self, | ||
two, | ||||
delta = 0 | ||||
) |
Definition at line 285 of file ResultCache.py.
00285 : 00286 00287 pydb.debugger( ) 00288 two_q = two.power( ) 00289 results = set( ) 00290 max = 0 00291 00292 while 1 : 00293 two_q += delta 00294 00295 for key in self._dict.keys( ): 00296 rco_list = self._dict[ key ].values( ) 00297 for rco in rco_list: 00298 result = rco.result( ) 00299 seeds = rco.seeds( ) 00300 factor = result.factors( )[ 2 ] 00301 factor_q = factor.power( ) 00302 if factor_q > max: 00303 max = factor_q 00304 if factor_q == two_q: 00305 results.add( result ) 00306 00307 if delta == 0: 00308 break 00309 if len( results ) != 0: 00310 break 00311 00312 if two_q == 0: 00313 return None 00314 if two_q > max: 00315 return None 00316 00317 return results 00318 def matchFactors( self, factors, delta = 0 ):