Public Member Functions | |
def | __init__ |
def | type |
def | __eq__ |
def | __hash__ |
def | copy |
def | isInteger |
def | isPrime |
def | cur |
def | decrementPower |
def | __mul__ |
def | __div__ |
def | addDen |
def | addMul |
def | addNum |
def | den |
def | mul |
def | num |
def | power |
def | prime |
def | rdr |
def | conflict |
def | selectNumLessThanReader_old |
def | selectNumLessThanReader_new |
def | factors_multiply |
def | sigma_multiply |
def | order |
def | sum |
def | sumUnusedExponents |
def | verifyUnusedExponentSum |
def | trace |
def | asUString |
def | reduce |
def | quick_reduce |
def | reduceLargeFactors |
def | used |
def | __str__ |
def | asString |
def | printState |
Definition at line 40 of file NumDenMul.py.
def NumDenMul::NumDenMul::__div__ | ( | self, | ||
aNumber | ||||
) |
Remove aNumber from den and mul. Remove sgmftr(aNumber) from num. Reduce.
Definition at line 187 of file NumDenMul.py.
00187 : 00188 """ 00189 Remove aNumber from den and mul. 00190 Remove sgmftr(aNumber) from num. 00191 Reduce. 00192 """ 00193 00194 if aNumber.power( ) <= 0: 00195 print "NumDenMul::__div__ %s * %s" % ( self, aNumber ) 00196 self.debug( ) 00197 00198 answer = self.copy( ) 00199 00200 sgmftr = aNumber.sgmftr( ) 00201 answer._num *= aNumber 00202 answer._den *= sgmftr 00203 answer._mul /= aNumber 00204 answer.reduce( ) 00205 00206 return answer 00207 def addDen( self, factor ):
def NumDenMul::NumDenMul::__eq__ | ( | self, | ||
other | ||||
) |
Definition at line 66 of file NumDenMul.py.
00066 : 00067 if other: 00068 return self._mul == other._mul 00069 else: 00070 return False 00071 def __hash__( self ):
def NumDenMul::NumDenMul::__hash__ | ( | self | ) |
def NumDenMul::NumDenMul::__init__ | ( | self, | ||
num = None , |
||||
den = None , |
||||
mul = None | ||||
) |
Definition at line 42 of file NumDenMul.py.
00042 : 00043 self._verbose = False 00044 self._cur = Number.Number( ) 00045 if num != None: 00046 self._num = num 00047 else: 00048 self._num = Factors.new( None ) 00049 if den != None: 00050 self._den = den 00051 else: 00052 self._den = Factors.new( None ) 00053 if mul != None: 00054 self._mul = mul 00055 else: 00056 self._mul = Factors.new( None ) 00057 self._sum = None 00058 self._hash = None 00059 if num != None and den != None: 00060 self.reduce( ) 00061 def type( self ):
def NumDenMul::NumDenMul::__mul__ | ( | self, | ||
aNumber | ||||
) |
Add aNumber to den and mul. Add sgmftr(aNumber) to num. Reduce.
Definition at line 152 of file NumDenMul.py.
00152 : 00153 """ 00154 Add aNumber to den and mul. 00155 Add sgmftr(aNumber) to num. 00156 Reduce. 00157 """ 00158 00159 if aNumber.power( ) <= 0: 00160 print "NumDenMul::__mul__ %s * %s" % ( self, aNumber ) 00161 self.debug( ) 00162 00163 answer = self.copy( ) 00164 00165 if aNumber.prime( ) == 37: 00166 if verbose > 0: 00167 print "n: %s" % aNumber 00168 print "s: %s" % self 00169 00170 sgmftr = aNumber.sgmftr( ) 00171 answer._num *= sgmftr 00172 answer._den *= aNumber 00173 answer._mul *= aNumber 00174 answer.reduce( ) 00175 00176 # if aNumber.prime( ) == 37: 00177 # revert = answer / aNumber 00178 # if verbose > 0: 00179 # print "a: %s" % answer 00180 # print "r: %s" % revert 00181 # if not revert == self: 00182 # print "Error" 00183 # pydb.debugger( ) 00184 00185 return answer 00186 def __div__( self, aNumber ):
def NumDenMul::NumDenMul::__str__ | ( | self | ) |
Answer the receiver as a formatted string.
Definition at line 507 of file NumDenMul.py.
00507 : 00508 """ 00509 Answer the receiver as a formatted string. 00510 """ 00511 00512 answer = "(\n" 00513 answer += " num: %s\n" % self._num 00514 answer += " den: %s\n" % self._den 00515 answer += " mul: %s\n" % self._mul 00516 show_sum_and_reader = False 00517 if show_sum_and_reader: 00518 try: 00519 answer += " sum: %s, rdr: %s\n" % ( self.sum( ), self.rdr( ) ) 00520 except: 00521 answer += " sum: %s\n" % self.sum( ) 00522 answer += ")" 00523 00524 return answer 00525 def asString( self ):
def NumDenMul::NumDenMul::addDen | ( | self, | ||
factor | ||||
) |
Add a factor to instance variable den.
Definition at line 208 of file NumDenMul.py.
00208 : 00209 """ 00210 Add a factor to instance variable den. 00211 """ 00212 00213 self._den.add( factor.copy( ) ) 00214 def addMul( self, factor ):
def NumDenMul::NumDenMul::addMul | ( | self, | ||
factor | ||||
) |
Add a factor to instance variable den.
Definition at line 215 of file NumDenMul.py.
00215 : 00216 """ 00217 Add a factor to instance variable den. 00218 """ 00219 00220 self._mul.add( factor.copy( ) ) 00221 def addNum( self, factor ):
def NumDenMul::NumDenMul::addNum | ( | self, | ||
factor | ||||
) |
Add a factor to instance variable den.
Definition at line 222 of file NumDenMul.py.
00222 : 00223 """ 00224 Add a factor to instance variable den. 00225 """ 00226 00227 self._num.add( factor.copy( ) ) 00228 def den( self, aFactorList = None ):
def NumDenMul::NumDenMul::asString | ( | self | ) |
Definition at line 526 of file NumDenMul.py.
00526 : 00527 00528 answer = self._mul.asString( ) 00529 00530 return answer 00531 def printState( self ):
def NumDenMul::NumDenMul::asUString | ( | self | ) |
def NumDenMul::NumDenMul::conflict | ( | self | ) |
Answer True if Num and Mul overlap
Definition at line 287 of file NumDenMul.py.
00287 : 00288 """ 00289 Answer True if Num and Mul overlap 00290 """ 00291 00292 # * ( 17^1 ) 00293 # n: ( 3^2 5^1 ) 00294 # d: ( 2^4 ) 00295 # m: ( 2^7 3^1 17^1 ) 00296 00297 ans = 1 00298 str = "" 00299 00300 for n in self._num.values( ): 00301 for m in self._mul.values( ): 00302 if n.prime( ) == m.prime( ): 00303 ans = ans * n.magnitude( ) 00304 if globals.quiet < 2: 00305 str = "%s %s" % ( str, n ) 00306 break 00307 00308 if ans < 10: 00309 return False 00310 else: 00311 if globals.quiet < 2: 00312 print "NDM::conflict: %s %s" % ( ans, str ) 00313 return True 00314 def selectNumLessThanReader_old( self ): #0315
def NumDenMul::NumDenMul::copy | ( | self | ) |
Definition at line 80 of file NumDenMul.py.
00080 : 00081 # answer a copy of self 00082 00083 new = NumDenMul( ) 00084 new._num = self._num.copy( ) 00085 new._den = self._den.copy( ) 00086 new._mul = self._mul.copy( ) 00087 new._cur = self._cur.copy( ) 00088 00089 new._sum = None 00090 new._hash = None 00091 00092 return new 00093 def isInteger( self ):
def NumDenMul::NumDenMul::cur | ( | self, | ||
aFactor = None | ||||
) |
Get/Set the instance variable cur.
Definition at line 108 of file NumDenMul.py.
00108 : 00109 """ 00110 Get/Set the instance variable cur. 00111 """ 00112 00113 if aFactor != None: 00114 self._sum = None 00115 self._cur = aFactor.copy( ) 00116 00117 return self._cur 00118 def decrementPower( self ):
def NumDenMul::NumDenMul::decrementPower | ( | self | ) |
Decrement the instance variable power. ... and the sum of unused powers.
Definition at line 119 of file NumDenMul.py.
00119 : 00120 """ 00121 Decrement the instance variable power. 00122 ... and the sum of unused powers. 00123 """ 00124 00125 p = self._cur.prime( ) 00126 q = self._cur.power( ) 00127 00128 # if p == 0 or q == 0 or q == 1: 00129 # pydb.debugger( ) 00130 00131 if self._sum != self.sumUnusedExponents( ): 00132 print "NDM::dp_3 cur %s, sum %s, sue %s" % ( self._cur, self._sum, self.sumUnusedExponents( ) ) 00133 00134 self._sum -= 1 00135 self._cur.power( q - 1 ) 00136 00137 # if self._sum != self.sumUnusedExponents( ): 00138 # self._verbose = True 00139 # pydb.debugger( ) 00140 # self._verbose = False 00141 00142 # if self._cur.power( ) < 1: 00143 # pydb.debugger( ) 00144 00145 # if self._sum < 0 or q < 1: 00146 # pydb.debugger( ) 00147 # print "NumDenMul::dp_8 sum - %d, cur - %s ( %d -> %d )" % ( self._sum, cur, q, q - 1 ) 00148 # print "*************************" 00149 00150 return self._cur 00151 def __mul__( self, aNumber ):
def NumDenMul::NumDenMul::den | ( | self, | ||
aFactorList = None | ||||
) |
def NumDenMul::NumDenMul::factors_multiply | ( | self, | ||
factors | ||||
) |
Definition at line 327 of file NumDenMul.py.
00327 : 00328 00329 answer = self 00330 for factor in factors.values(): 00331 answer = answer * factor 00332 answer.reduce( ) 00333 00334 return answer 00335 def sigma_multiply( self, aNumber ):
def NumDenMul::NumDenMul::isInteger | ( | self | ) |
Answer true if instance variable den is empty.
Definition at line 94 of file NumDenMul.py.
00094 : 00095 """ 00096 Answer true if instance variable den is empty. 00097 """ 00098 00099 return len( self._den ) == 0 00100 def isPrime( self ):
def NumDenMul::NumDenMul::isPrime | ( | self | ) |
Answer true if instance variable den is empty.
Definition at line 101 of file NumDenMul.py.
00101 : 00102 """ 00103 Answer true if instance variable den is empty. 00104 """ 00105 00106 return len( self._den ) == 0 00107 def cur( self, aFactor = None ):
def NumDenMul::NumDenMul::mul | ( | self, | ||
arg = None | ||||
) |
Get/Set the instance variable mul.
Definition at line 239 of file NumDenMul.py.
00239 : 00240 """ 00241 Get/Set the instance variable mul. 00242 """ 00243 00244 if arg != None: 00245 if isinstance( arg, types.IntType ): 00246 return self._mul[ arg ] 00247 else: 00248 self._mul = arg 00249 00250 return self._mul 00251 def num( self, aFactorList = None ):
def NumDenMul::NumDenMul::num | ( | self, | ||
aFactorList = None | ||||
) |
def NumDenMul::NumDenMul::order | ( | self | ) |
def NumDenMul::NumDenMul::power | ( | self, | ||
anInteger = None | ||||
) |
Get/Set the instance variable power.
Definition at line 262 of file NumDenMul.py.
00262 : 00263 """ 00264 Get/Set the instance variable power. 00265 """ 00266 00267 return self._cur.power( anInteger ) 00268 def prime( self, anInteger = None ):
def NumDenMul::NumDenMul::prime | ( | self, | ||
anInteger = None | ||||
) |
Get/Set the instance variable prime.
Definition at line 269 of file NumDenMul.py.
00269 : 00270 """ 00271 Get/Set the instance variable prime. 00272 """ 00273 00274 return self._cur.prime( anInteger ) 00275 def rdr( self, aFactor = None ):
def NumDenMul::NumDenMul::printState | ( | self | ) |
Definition at line 532 of file NumDenMul.py.
00532 : 00533 print self 00534 if self.isPrime( ): 00535 print "multiperfect" 00536 else: 00537 print "not" 00538 print "" 00539 def Test( ):
def NumDenMul::NumDenMul::quick_reduce | ( | self, | ||
max | ||||
) |
Definition at line 433 of file NumDenMul.py.
00433 : 00434 # reduce numerator factors greater than 'max' 00435 # answer self.copy and updated max 00436 00437 answer = self.copy( ) 00438 if verbose > 0: 00439 print "mx: %s %s" % ( max, answer ) 00440 00441 while True: 00442 00443 factor = answer._num.last( ) 00444 fp = factor.prime( ) 00445 if fp <= max: 00446 if verbose > 0: 00447 print "fp <= max ( %d, %d )" % ( fp, max ) 00448 break 00449 if not answer._mul.has_key( fp ): 00450 answer *= factor 00451 op = "*" 00452 else: 00453 answer /= factor 00454 op = "/" 00455 00456 if verbose > 1: 00457 print "fp %s: %s %s" % ( op, fp, answer ) 00458 00459 if verbose > 0: 00460 print "fp: %s %s" % ( fp, answer ) 00461 00462 return ( answer, fp ) 00463 def reduceLargeFactors( self, max ):
def NumDenMul::NumDenMul::rdr | ( | self, | ||
aFactor = None | ||||
) |
Get/Set the instance variable rdr.
Definition at line 276 of file NumDenMul.py.
00276 : 00277 """ 00278 Get/Set the instance variable rdr. 00279 """ 00280 00281 if aFactor != None: 00282 # must use .copy with new_rdr 00283 self._rdr = aFactor.copy( ) 00284 00285 return self._rdr 00286 def conflict( self ):
def NumDenMul::NumDenMul::reduce | ( | self | ) |
Definition at line 412 of file NumDenMul.py.
00412 : 00413 00414 for nf in self._num.factors( ): 00415 fp = nf.prime( ) 00416 fq = nf.power( ) 00417 if not self._den.has_key( fp ): 00418 continue 00419 changed = True 00420 dq = self._den[ fp ].power( ) 00421 if fq == dq: 00422 self._num.remove( fp ) 00423 self._den.remove( fp ) 00424 elif fq > dq: 00425 self._num[ fp ].power( fq - dq ) 00426 self._den.remove( fp ) 00427 else: 00428 self._num.remove( fp ) 00429 self._den[ fp ].power( dq - fq ) 00430 00431 return self 00432 def quick_reduce( self, max ):
def NumDenMul::NumDenMul::reduceLargeFactors | ( | self, | ||
max | ||||
) |
Reduce large ndm.num primes (to less than 10)
Definition at line 464 of file NumDenMul.py.
00464 : 00465 """ 00466 Reduce large ndm.num primes (to less than 10) 00467 """ 00468 00469 changed = True 00470 answer = self.copy( ) 00471 00472 if verbose: 00473 print "reduceLargeFactors( %s )" % answer 00474 00475 while changed: 00476 changed = False 00477 values = answer.num( ).sortedvalues( ) 00478 values.reverse( ) 00479 if values[ 0 ].prime( ) < max: 00480 break 00481 print values 00482 for value in values: 00483 p = value.prime( ) 00484 if p <= max: 00485 continue 00486 if not answer.mul( ).hasPrime( p ): 00487 answer *= value 00488 if verbose: 00489 print "* %s -> %s" % ( value, answer ) 00490 changed = True 00491 else: 00492 break 00493 mul = answer._mul / value 00494 answer = new( mul ) 00495 if verbose: 00496 print "/ %s -> %s" % ( value, answer ) 00497 00498 return answer 00499 def used( self, aBoolean = None ):
def NumDenMul::NumDenMul::selectNumLessThanReader_new | ( | self, | ||
rdr | ||||
) |
def NumDenMul::NumDenMul::selectNumLessThanReader_old | ( | self | ) |
def NumDenMul::NumDenMul::sigma_multiply | ( | self, | ||
aNumber | ||||
) |
def NumDenMul::NumDenMul::sum | ( | self | ) |
Get/Set the instance variable sum to anInteger.
Definition at line 349 of file NumDenMul.py.
00349 : 00350 """ 00351 Get/Set the instance variable sum to anInteger. 00352 """ 00353 00354 if not self._sum: 00355 self._sum = self.sumUnusedExponents( ) 00356 else: 00357 s1 = self._sum 00358 s2 = self.sumUnusedExponents( ) 00359 if s1 != s2: 00360 pydb.debugger( ) 00361 00362 return self._sum 00363 def sumUnusedExponents( self ):
def NumDenMul::NumDenMul::sumUnusedExponents | ( | self | ) |
Answer the sum of the unused exponents.
Definition at line 364 of file NumDenMul.py.
00364 : 00365 """ 00366 Answer the sum of the unused exponents. 00367 """ 00368 00369 answer = 0 00370 for factor in self._num.factors( ): 00371 if factor.used( ): 00372 continue 00373 if self._mul.has_key( factor.prime( ) ): 00374 continue 00375 if factor.prime( ) != self._cur.prime( ): 00376 answer += factor.power( ) 00377 else: 00378 answer += self._cur.power( ) 00379 if self._verbose: 00380 print "%s %s" % ( factor.asUString(), answer ) 00381 00382 return answer 00383 def verifyUnusedExponentSum( self ):
def NumDenMul::NumDenMul::trace | ( | self, | ||
label, | ||||
factors | ||||
) |
Definition at line 399 of file NumDenMul.py.
00399 : 00400 00401 print "-- %s %d %d %d %s" % ( label, len( factors ), len( factors.numbers.keys()), len( factors.numbers.values()), factors.numbers.keys( ) ) 00402 def asUString( self ):
def NumDenMul::NumDenMul::type | ( | self | ) |
def NumDenMul::NumDenMul::used | ( | self, | ||
aBoolean = None | ||||
) |
Set the instance variable used to aBoolean.
Definition at line 500 of file NumDenMul.py.
00500 : 00501 """ 00502 Set the instance variable used to aBoolean. 00503 """ 00504 00505 return self._cur.used( aBoolean ) 00506 def __str__( self ):
def NumDenMul::NumDenMul::verifyUnusedExponentSum | ( | self | ) |
Definition at line 384 of file NumDenMul.py.
00384 : 00385 00386 s1 = self.sum( ) 00387 s2 = self.sumUnusedExponents( ) 00388 if s1 == s2: 00389 return True 00390 else: 00391 globals.PROG.debug( ) 00392 NDM_verbose = True 00393 s2 = self.sumUnusedExponents( ) 00394 NDM_verbose = False 00395 for factor in self._num.factors( ): 00396 print factor 00397 return False 00398 def trace( self, label, factors ):