NumDenMul::NumDenMul Class Reference

List of all members.

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


Detailed Description

Definition at line 40 of file NumDenMul.py.


Member Function Documentation

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  ) 

Definition at line 72 of file NumDenMul.py.

00072                         :
00073         if self._hash == None:
00074             self._hash = self._mul.__hash__( )
00075 #       if self._hash != self._mul.__hash__( ):
00076 #           print "NumDenMul::__hash__() failure"
00077 #           pydb.debugger( )
00078         return self._hash
00079 
    def copy( 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  ) 

Definition at line 403 of file NumDenMul.py.

00403                          :
00404 
00405         answer = ""
00406         answer += "  n: %s\n" % self._num.asUString( )
00407         answer += "  d: %s\n" % self._den.asUString( )
00408         answer += "  m: %s"   % self._mul.asUString( )
00409 
00410         return answer
00411 
    def reduce( 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 
)

Get/Set the instance variable den.

Definition at line 229 of file NumDenMul.py.

00229                                        :
00230         """
00231         Get/Set the instance variable den.
00232         """
00233 
00234         if aFactorList != None:
00235             self._den = aFactorList
00236 
00237         return self._den
00238 
    def mul( self, arg = 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 
)

Get/Set the instance variable num.

Definition at line 252 of file NumDenMul.py.

00252                                        :
00253         """
00254         Get/Set the instance variable num.
00255         """
00256 
00257         if aFactorList != None:
00258             self._num = aFactorList
00259 
00260         return self._num
00261 
    def power( self, anInteger = None ):

def NumDenMul::NumDenMul::order (   self  ) 

Definition at line 345 of file NumDenMul.py.

00345                      :
00346 
00347         return self._num.magnitude( )
00348 
    def sum( 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 
)

Definition at line 321 of file NumDenMul.py.

00321                                                 :   #0315
00322 
00323         lst = self._num.selectLessThan( rdr )
00324 
00325         return lst
00326 

def NumDenMul::NumDenMul::selectNumLessThanReader_old (   self  ) 

Definition at line 315 of file NumDenMul.py.

00315                                            :   #0315
00316 
00317         lst = self._num.selectLessThan( self._rdr )
00318 
00319         return lst
00320 

def NumDenMul::NumDenMul::sigma_multiply (   self,
  aNumber 
)

Definition at line 336 of file NumDenMul.py.

00336                                        :
00337 
00338         answer = self.copy( )
00339         answer._num = self._num * aNumber.sgmftr( )
00340         answer._den = self._den * aNumber
00341         answer._mul = self._mul * aNumber
00342 
00343         return answer
00344 
    def order( self ):

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  ) 

Definition at line 62 of file NumDenMul.py.

00062                     :
00063 
00064         return "NumDenMul"
00065 
    def __eq__( self, other ):

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 ):


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