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 |
Definition at line 19 of file TripleStart.py.
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 | ) |
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 | ) |
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 | ) |
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 | ||||
) |
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( ):