TripleStart::TripleStart Class Reference

List of all members.

Public Member Functions

def __init__
def type
def initialize
def __str__
def ranges_as_string
def display
def rangeCount
def rangeString
def load
def loadRowColCnt
def loadRanges
def asFactorList
def at
def prime_power
def cycleCount
def initRanges
def firstExponent
def initializePrimes
def newFirstPower
def rangesIndexOfPrimeValue
def asString
def count
def next
def primes
def __getitem__
def __setitem__
def mergeResults
def mergeFactors
def setRange
def ranges
def set_triples
def size
def clearExponents_XXX
def updateExponents
def adjMinMax_xxxdef
def adjSpan
def findResultMinMax
def findResultAndFactorReduce
def findResultSetup
def updateUpperLimits_XXX
def value
def widen


Detailed Description

Definition at line 19 of file TripleStart.py.


Member Function Documentation

def TripleStart::TripleStart::__getitem__ (   self,
  prime 
)

Definition at line 269 of file TripleStart.py.

00269                                   :
00270 
00271         try:
00272             ans = self._ranges[ prime ]
00273         except:
00274             if prime < 20:
00275                 ans = self.setRange( prime, 0 )
00276                 print ans
00277 
00278         return ans
00279 
    def __setitem__( self, prime, factor ):

def TripleStart::TripleStart::__init__ (   self,
  mode = None,
  two = None,
  seed = None 
)

Definition at line 21 of file TripleStart.py.

00021                                                               :
00022 
00023         self._ranges = AlbDict.AlbDict( )
00024         
00025         self.initRanges( )
00026         self._position = 0
00027         self._maxCol = 4
00028         self._maxRow = 250
00029         self._tst_cnt = 0
00030 
00031 #       SearchBasedOnLowCount
00032         if mode == "lc":
00033             triples = self.findResultMinMax( seed )
00034             triples.widen( 0, 3 )
00035 
00036             self.set_triples( two, triples )
00037             self.setRange( two.prime( ), two.power( ) )
00038 
00039 #       SearchBasedOnFactorReduction
00040         if mode == "fr":
00041             triples = self.findResultAndFactorReduce( seed )
00042             triples.widen( 0, 2 )
00043 
00044             self.set_triples( two, triples )
00045             self.setRange( two.prime( ), two.power( ) )
00046 
00047         return
00048 
    def type( self ):

def TripleStart::TripleStart::__setitem__ (   self,
  prime,
  factor 
)

Definition at line 280 of file TripleStart.py.

00280                                           :
00281 
00282         self._ranges[ prime ] = factor
00283 
00284         return factor
00285 
    def mergeResults( self, power, results_set ):

def TripleStart::TripleStart::__str__ (   self  ) 

Definition at line 59 of file TripleStart.py.

00059                        :
00060 
00061         #tri : max(row,col) = (250,3),  tst_cnt = 1000 
00062         #tri : ( (2,9 (1:100)) (3,10 (1:12)) (5,0 (1:9)) )
00063         #counts:  NEW - 0,  OLD - 19,  DUP - 19, TOT - 275
00064 
00065         answer = "tri : max(row,col) = (%d,%d), tst_cnt = %d\n" % ( self._maxRow, self._maxCol, self._tst_cnt )
00066         answer += "tri : %s" % self.ranges_as_string( )
00067 
00068         return answer
00069 
    def ranges_as_string( self ):

def TripleStart::TripleStart::adjMinMax_xxxdef (   self,
  seed,
  factors 
)

factors is ndm.num() for an invocation of ALB::cycle
for a new power of 2.

Definition at line 379 of file TripleStart.py.

00379                                                :
00380 
00381         """factors is ndm.num() for an invocation of ALB::cycle
00382         for a new power of 2.
00383         """
00384 
00385         starters = self.findResultMinMax( seed )
00386         starters.display( )
00387         for factor in seed.values( ):
00388             starters.addTriple( factor )
00389         self._ranges = starters
00390 
00391         if False:    # 0318 #
00392             for range in self._ranges.sortedvalues( ):
00393                 if range.prime( ) != 2:
00394                     range.min( 0 )
00395                     range.max( 0 )
00396 
00397             keys = self._ranges.primes( )
00398 
00399             range_max = max( keys )
00400             self.adjSpan( starters, factors, 8, range_max )
00401 
00402         if False:    # 0317
00403             pow_two = two.power( )
00404             power = min( pow_two + 5, 10 )
00405             for range in self._ranges.sortedvalues( ):
00406                 if range.prime( ) == 2:
00407                     continue
00408                 if range.max( ) != 0:
00409                     power = range.max( )
00410                 else:
00411                     power = power * 7 / 10
00412                     range.max( power )
00413 
00414         return
00415 
    def adjSpan( self, starters, factors, span, range_max ):

def TripleStart::TripleStart::adjSpan (   self,
  starters,
  factors,
  span,
  range_max 
)

Definition at line 416 of file TripleStart.py.

00416                                                            :
00417 
00418         for factor in factors.sortedvalues( ):
00419             p = factor.prime( )
00420             q = factor.power( )
00421             if p == 2:
00422                 continue
00423             if p > range_max:
00424                 continue
00425             if not self._ranges.has_key( p ):
00426                 continue
00427             r = self._ranges[ p ]
00428             if q < 1:
00429                 val = 0
00430             else:
00431                 val = int( q ) - 1
00432 
00433             if starters.has_key( p ):
00434                 starter = starters[ p ]
00435                 if starter.min( ) != 0:
00436                     r.min( max( 1, starter.min( ) - 1 ) )
00437                     r.max(         starter.max( ) + 1   )
00438                     r.setExponentRange( span )
00439                 continue
00440 
00441             r.min( val )
00442             val = min( val + span, pow_two + 5 )
00443             r.max( val )
00444             r.setExponentRange( span )
00445 #           span = span * 7 / 10
00446 
00447         return
00448 
    def findResultMinMax( self, seed ):

def TripleStart::TripleStart::asFactorList (   self  ) 

Answer a factor list.

Definition at line 137 of file TripleStart.py.

00137                             :
00138         """
00139         Answer a factor list.
00140         """
00141 
00142         answer = Factors.Factors( None )
00143         for value in self._ranges.sortedvalues( ):
00144             p = value.prime( )
00145             q = value.power( )
00146             if p == 2:
00147                 answer.add( Number.Number( p, max( 1, q ) ) )
00148             elif q > 0:
00149                 answer.add( Number.Number( p, q ) )
00150 
00151         return answer
00152 
    def at( self, anInteger ):

def TripleStart::TripleStart::asString (   self  ) 

Definition at line 234 of file TripleStart.py.

00234                         :
00235         return self.__str__( )
00236 
    def count( self ):

def TripleStart::TripleStart::at (   self,
  anInteger 
)

Answer an element of the list.

Definition at line 153 of file TripleStart.py.

00153                              :
00154         """
00155         Answer an element of the list.
00156         """
00157 
00158         return self._ranges[ anInteger ]
00159 
    def prime_power( self, prime, power ):

def TripleStart::TripleStart::clearExponents_XXX (   self,
  start 
)

Definition at line 351 of file TripleStart.py.

00351                                          :
00352         for index in range( start, self.size( )  ):
00353             triple = self._ranges[ index ]
00354             triple.power( 0 )
00355 
    def updateExponents( self ):

def TripleStart::TripleStart::count (   self  ) 

Definition at line 237 of file TripleStart.py.

00237                      :
00238         return self._tst_cnt
00239 
    def next( self ):

def TripleStart::TripleStart::cycleCount (   self  ) 

Definition at line 165 of file TripleStart.py.

00165                           :
00166         "Display the receiver."
00167 
00168         count = 1
00169 
00170         for triple in self._ranges.sortedvalues( ):
00171             count = count * ( triple.max ( ) - triple.min( ) + 1 )
00172 
00173         return count 
00174         
    def initRanges( self ):

def TripleStart::TripleStart::display (   self  ) 

Definition at line 79 of file TripleStart.py.

00079                        :
00080 
00081         print "%s %d" % ( self.rangeString( ), self.rangeCount( ) )
00082 
    def rangeCount( self ):

def TripleStart::TripleStart::findResultAndFactorReduce (   self,
  seed 
)

Definition at line 464 of file TripleStart.py.

00464                                                :
00465 
00466         triples = self.findResultSetup( seed )
00467 
00468         ndm = NumDenMul.new( seed )
00469         max = 17
00470         ndm = ndm.reduceLargeFactors( max )
00471 
00472         factors = ndm.num( )
00473         triples.updateFromFactors( factors )
00474 
00475         return triples
00476 
    def findResultSetup( self, seed ):

def TripleStart::TripleStart::findResultMinMax (   self,
  seed 
)

find matching power of 2 in result cache
find min & max powers of 3, 5, 7, ...

Definition at line 449 of file TripleStart.py.

00449                                       :
00450         """
00451         find matching power of 2 in result cache
00452         find min & max powers of 3, 5, 7, ...
00453         """
00454 
00455         triples = self.findResultSetup( seed )
00456 
00457         # search result cache for the same power of two
00458         # and set upper/lower limits for triples' primes
00459         triples.updateFromSeed( seed )
00460         triples.widen( 0, 2 )
00461 
00462         return triples
00463                     
    def findResultAndFactorReduce( self, seed ):

def TripleStart::TripleStart::findResultSetup (   self,
  seed 
)

find matching power of 2 in result cache
find min & max powers of 3, 5, 7, ...

Definition at line 477 of file TripleStart.py.

00477                                      :
00478         """
00479         find matching power of 2 in result cache
00480         find min & max powers of 3, 5, 7, ...
00481         """
00482 
00483         if globals.printDate:
00484             print "%s" % TimeStamp.TimeStamp( ),
00485 
00486         print
00487         print "*** %s ***" % seed
00488 
00489         primes = [ 3, 5, 7, 11, 13, 17, 19 ]
00490 
00491         triples = StartTriple.StartTripleDict( primes )
00492 
00493         return triples
00494                     
    def updateUpperLimits_XXX( self ):

def TripleStart::TripleStart::firstExponent (   self  ) 

Answer the first exponent

Definition at line 184 of file TripleStart.py.

00184                              :
00185         """
00186         Answer the first exponent
00187         """
00188 
00189         range = self._ranges.first( )
00190 
00191         return range.power( )
00192 
    def initializePrimes( self ):

def TripleStart::TripleStart::initialize (   self  ) 

Definition at line 53 of file TripleStart.py.

00053                           :
00054 
00055         self._first = True
00056 
00057         return self
00058 
    def __str__( self ):

def TripleStart::TripleStart::initializePrimes (   self  ) 

Initialize the receiver.

Definition at line 193 of file TripleStart.py.

00193                                 :
00194         """
00195         Initialize the receiver.
00196         """
00197 
00198         self._ranges = self._ranges.copy( 1, self._maxcol )
00199         self.second( ).decrementpower( )
00200 
00201         return
00202 
    def newFirstPower( self ):

def TripleStart::TripleStart::initRanges (   self  ) 

Definition at line 175 of file TripleStart.py.

00175                           :
00176         "Initialize with a default list of primes."
00177 
00178         primes = [ 2, 3, 5, 7, 11, 13, 17, 19 ]
00179         primes = [ 2, 3 ]
00180 
00181         for prime in primes:
00182             self.setRange( prime, 0 )
00183 
    def firstExponent( self ):

def TripleStart::TripleStart::load (   self,
  line 
)

Definition at line 106 of file TripleStart.py.

00106                           :
00107         # tri : max(row,col) = (250,3), tst_cnt = 0
00108         # tri : (( 2, 1 (1:20)) ( 3, 0 (0:0)) ( 5, 0 (0:0)) )
00109         
00110         parts = re.split( "[ (),=:]+", line )
00111         if not parts[3][0].isdigit( ):
00112             self.loadRowColCnt( parts )
00113         else:
00114             self.loadRanges( parts )
00115 
    def loadRowColCnt( self, parts ):

def TripleStart::TripleStart::loadRanges (   self,
  parts 
)

Definition at line 124 of file TripleStart.py.

00124                                  :
00125 
00126         self._ranges = AlbDict.AlbDict( ) # dict
00127 
00128         for index in range( 1, len( parts ) - 1, 4 ):
00129             prime = mpz( parts[ index + 0 ] )
00130             power = mpz( parts[ index + 1 ] )
00131             min   = mpz( parts[ index + 2 ] )
00132             max   = mpz( parts[ index + 3 ] )
00133             self.setRange( prime, power, min, max )
00134 
00135         return    
00136 
    def asFactorList( self ):

def TripleStart::TripleStart::loadRowColCnt (   self,
  parts 
)

Definition at line 116 of file TripleStart.py.

00116                                     :
00117 
00118         self._maxRow = int( parts[ 4 ] )
00119         self._maxCol = int( parts[ 5 ] )
00120         self._tst_cnt = int( parts[ 7 ] )
00121 
00122         return    
00123 
    def loadRanges( self, parts ):

def TripleStart::TripleStart::mergeFactors (   self,
  factors 
)

merge factors that match the default list of primes

Definition at line 295 of file TripleStart.py.

00295                                      :
00296 
00297         '''
00298         merge factors that match the default list of primes
00299         '''
00300         
00301         factors = factors.factors( )
00302         for factor in factors:
00303             p = factor.prime( )
00304             q = factor.power( )
00305             if self._ranges.has_key( p ):
00306                 triple = self[ p ]
00307                 triple.min( q )
00308                 triple.max( q )
00309             elif p < 20:
00310                 self.setRange( p, 0, q, q )
00311 
00312         return self
00313 
    def setRange( self, prime, power, min = None, max = None ):

def TripleStart::TripleStart::mergeResults (   self,
  power,
  results_set 
)

Definition at line 286 of file TripleStart.py.

00286                                                 :
00287 
00288         for result in results_set:
00289             factors = result.factors( )
00290 
00291             self.mergeFactors( factors )
00292 
00293         return self
00294 
    def mergeFactors( self, factors ):

def TripleStart::TripleStart::newFirstPower (   self  ) 

Update the exponent of the first rangeList item.

Definition at line 203 of file TripleStart.py.

00203                              :
00204         # from AlbLimitedTripleStart
00205         """
00206         Update the exponent of the first rangeList item.
00207         """
00208 
00209         first = True
00210         for triple in self._ranges.sortedvalues( ):
00211             if first:
00212                 first = False
00213                 power = triple.incrementPower( )
00214             else:
00215                 power = power * 3 / 5 
00216                 triple.initMinMax( 0, power )
00217 
00218         results = None
00219         if results:
00220             for result in results:
00221                 for factors in result:
00222                     index = self.rangesIndexOfPrimeValue( selfe._ranges, factor.prime( ) )
00223                     if index != None and factor.prime( ) != 2:
00224                         range.setMinMax( factor.power( ) )
00225 
00226         return
00227 
    def rangesIndexOfPrimeValue( self, ranges, prime ):

def TripleStart::TripleStart::next (   self  ) 

Answer a factor list.

Definition at line 240 of file TripleStart.py.

00240                     :
00241         """
00242         Answer a factor list.
00243         """
00244 
00245         if self.firstExponent( ) >= self._maxRow:
00246             return None
00247 
00248         self._tst_cnt += 1
00249         self.updateExponents( )
00250         value = self.value( )
00251 
00252         return ( self._tst_cnt, value )
00253 
    def primes( self, integers ):

def TripleStart::TripleStart::prime_power (   self,
  prime,
  power 
)

Definition at line 160 of file TripleStart.py.

00160                                          :
00161         starter = StartTriple.StartTriple( prime, 0, 0, power )
00162         self._ranges[ prime ] = starter
00163         return
00164 
    def cycleCount( self ):

def TripleStart::TripleStart::primes (   self,
  integers 
)

Save the supplied array of integers as an array of AlbStartTriples.

Definition at line 254 of file TripleStart.py.

00254                                 :
00255         """
00256         Save the supplied array of integers as an array of AlbStartTriples.
00257         """
00258 
00259         self._ranges = AlbDict.AlbDict( ) # dict
00260 
00261         for index in range( self._maxCol ):
00262             number = integers[ index ]
00263             self._ranges[ number ] = StartTriple.StartTriple( number, 0, 0, 0 )
00264         first = self._ranges[ 0 ]
00265         first.max( 30 / first.prime( ) )
00266 
00267         return
00268 
    def __getitem__( self, prime ):

def TripleStart::TripleStart::rangeCount (   self  ) 

Definition at line 83 of file TripleStart.py.

00083                           :
00084 
00085         count = 1
00086         total = 0
00087 
00088         for range in self._ranges.sortedvalues( ) :
00089             if range.prime( ) != 2:
00090                 count = count * ( range.max( ) - range.min( ) + 1 )
00091                 total = total + count
00092 
00093         return total
00094 
    def rangeString( self, pfx = None ):

def TripleStart::TripleStart::ranges (   self  ) 

Answer the rangeList.

Definition at line 326 of file TripleStart.py.

00326                       :
00327         """
00328         Answer the rangeList.
00329         """
00330 
00331         return self._ranges
00332 
    def set_triples( self, two, triples ):

def TripleStart::TripleStart::ranges_as_string (   self  ) 

Definition at line 70 of file TripleStart.py.

00070                                 :
00071 
00072         answer = "("
00073         for range in self._ranges.sortedvalues( ):
00074             answer += "%s " % range
00075         answer += ")"
00076 
00077         return answer
00078 
    def display( self ):

def TripleStart::TripleStart::rangesIndexOfPrimeValue (   self,
  ranges,
  prime 
)

Definition at line 228 of file TripleStart.py.

00228                                                       :
00229         for range in ranges:
00230             if range.prime( ) == prime:
00231                 return range
00232         return None
00233 
    def asString( self ):

def TripleStart::TripleStart::rangeString (   self,
  pfx = None 
)

Definition at line 95 of file TripleStart.py.

00095                                        :
00096 
00097         result = ""
00098 
00099         for range in self._ranges.sortedvalues( ) :
00100             if pfx: result +=  pfx
00101             if range.prime( ) != 2:
00102                 result += "%s " % range
00103 
00104         return result
00105 
    def load( self, line ):

def TripleStart::TripleStart::set_triples (   self,
  two,
  triples 
)

Definition at line 333 of file TripleStart.py.

00333                                          :
00334 
00335         range = self._ranges[ 2 ]
00336         range.power( two.power( ) )
00337 
00338         dict = triples._dict
00339         for triple in dict.values( ):
00340             self._ranges[ triple.prime( ) ] = triple
00341 
00342         return self
00343 
    def size( self ):

def TripleStart::TripleStart::setRange (   self,
  prime,
  power,
  min = None,
  max = None 
)

Definition at line 314 of file TripleStart.py.

00314                                                               :
00315 
00316         if not min:
00317             min = power
00318         if not max:
00319             max = power
00320 
00321         starter = StartTriple.StartTriple( prime, power, min, max )
00322         self._ranges[ prime ] = starter
00323 
00324         return starter
00325 
    def ranges( self ):

def TripleStart::TripleStart::size (   self  ) 

Answer the number of elements in the receiver's range list.

Definition at line 344 of file TripleStart.py.

00344                     :
00345         """
00346         Answer the number of elements in the receiver's range list.
00347         """
00348 
00349         return len( self._ranges )
00350 
    def clearExponents_XXX( self, start ):

def TripleStart::TripleStart::type (   self  ) 

Definition at line 49 of file TripleStart.py.

00049                     :
00050 
00051         return "TripleStart"
00052 
    def initialize( self ):

def TripleStart::TripleStart::updateExponents (   self  ) 

Update exponents.

Definition at line 356 of file TripleStart.py.

00356                                :
00357         """
00358         Update exponents.
00359         """
00360         
00361         if self._first:
00362             self._first = False
00363             return
00364 
00365         for triple in self._ranges.sortedvalues( ):
00366             if triple.prime( ) == 2:
00367                 continue
00368             if triple.power( ) < triple.max( ):
00369                 triple.incrementPower( )
00370                 return
00371             else:
00372                 triple.power( 0 )
00373 #                triple.power( triple.min( ) )
00374 
00375         self.newFirstPower( )
00376 
00377         return
00378 
    def adjMinMax_xxxdef( self, seed, factors ):

def TripleStart::TripleStart::updateUpperLimits_XXX (   self  ) 

Update the upper limits of the range list.

Definition at line 495 of file TripleStart.py.

00495                                      :
00496         """
00497         Update the upper limits of the range list.
00498         """
00499 
00500         pydb.debugger( )
00501         for index in range( self._position, self.size( ) - 1 ):
00502             cur = self.at( index )
00503             nxt = self.at( index + 1 )
00504             limit = cur.primeRatio( )
00505             if limit > nxt.max( ):
00506                 nxt.max( limit )
00507 
00508         return
00509 
    def value( self ):

def TripleStart::TripleStart::value (   self  ) 

Answer a factor list.

Definition at line 510 of file TripleStart.py.

00510                      :
00511         """
00512         Answer a factor list.
00513         """
00514 
00515         return self.asFactorList( )
00516 
    def widen( self, min, max ):

def TripleStart::TripleStart::widen (   self,
  min,
  max 
)

decrease min and increase max

Definition at line 517 of file TripleStart.py.

00517                                :
00518 
00519         '''
00520         decrease min and increase max
00521         '''
00522 
00523         for range in self._ranges.sortedvalues( ):
00524             if range.prime( ) != 2:
00525                 range.widen( min, max )
00526 
00527         return self
00528 
def TestStarter_1( ):


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

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