ResultCache::ResultCache Class Reference

Inheritance diagram for ResultCache::ResultCache:

Inheritance graph
[legend]
Collaboration diagram for ResultCache::ResultCache:

Collaboration graph
[legend]

List of all members.

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


Detailed Description

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.


Member Function Documentation

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  ) 

Reimplemented from Cache::Cache.

Definition at line 102 of file ResultCache.py.

00102                     :
00103 
00104         return "ResultCache"
00105 
    def __str__( 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 ):


The documentation for this class was generated from the following file:

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