StartTriple::StartTriple Class Reference

List of all members.

Public Member Functions

def __init__
def type
def initMinMax
def adjMinMax_xxxdef
def decrementPower
def finalizeMinMax
def incrementMax
def incrementPower
def widen
def max
def min
def prime
def power
def primeRatio
def __cmp__
def __repr__
def __str__
def asString
def updateMinMax
def setExponentRange


Detailed Description

A prime, a power, and min and max values

Definition at line 154 of file StartTriple.py.


Member Function Documentation

def StartTriple::StartTriple::__cmp__ (   self,
  other 
)

compare two StartTriples
if their primes are different,
return the difference of the primes
else return the difference of the powers

Definition at line 287 of file StartTriple.py.

00287                               :
00288         """compare two StartTriples
00289         if their primes are different,
00290         return the difference of the primes
00291         else return the difference of the powers
00292         """
00293         if self._prime != other._prime:
00294             return self._prime - other._prime
00295         else:
00296             return self._power - other._power
00297 
    def __repr__( self ):

def StartTriple::StartTriple::__init__ (   self,
  prime,
  power,
  lo,
  hi 
)

Definition at line 158 of file StartTriple.py.

00158                                               :
00159 
00160         self._prime = prime
00161         self._power = power
00162         if not lo or not hi:
00163             self._min = 0
00164             self._max = 0
00165         else:
00166             if lo >= hi:
00167                 lo = hi - 1
00168             self._min = max( lo, 0 )
00169             self._max = max( hi, 0 )
00170 
00171         return
00172 
    def type( self ):

def StartTriple::StartTriple::__repr__ (   self  ) 

Definition at line 298 of file StartTriple.py.

00298                         :
00299 
00300         return self.asString( )
00301 
    def __str__( self ):

def StartTriple::StartTriple::__str__ (   self  ) 

Definition at line 302 of file StartTriple.py.

00302                        :
00303 
00304         return self.asString( )
00305 
    def asString( self ):

def StartTriple::StartTriple::adjMinMax_xxxdef (   self,
  factor 
)

Definition at line 189 of file StartTriple.py.

00189                                         :
00190 
00191         power = factor.power( )
00192         if not self._min or power < self._min:
00193             self._min = power
00194         if not self._max or power > self._max:
00195             self._max = power
00196 
    def decrementPower( self ):

def StartTriple::StartTriple::asString (   self  ) 

Definition at line 306 of file StartTriple.py.

00306                         :
00307 
00308         answer = "( %s, %s (%s:%s))" % ( self._prime, self._power, self._min, self._max )
00309 
00310         return answer
00311 
    def updateMinMax( self, anInteger):

def StartTriple::StartTriple::decrementPower (   self  ) 

Definition at line 197 of file StartTriple.py.

00197                               :
00198         "Decrement instance variable power."
00199 
00200         self._power -= 1
00201 
00202         return self._power
00203 
    def finalizeMinMax( self ):

def StartTriple::StartTriple::finalizeMinMax (   self  ) 

Definition at line 204 of file StartTriple.py.

00204                               :
00205         "Finalize instance variables min and max."
00206 
00207         self._min = max( 0, self._min - 2 )
00208         self._max = self._max + 2
00209 
00210         return
00211 
    def incrementMax( self, d = 1 ):

def StartTriple::StartTriple::incrementMax (   self,
  d = 1 
)

Definition at line 212 of file StartTriple.py.

00212                                    :
00213         "Increment instance variable max."
00214 
00215         self._max = self._max + d
00216 
00217         return self._max
00218  
    def incrementPower( self, d = 1 ):

def StartTriple::StartTriple::incrementPower (   self,
  d = 1 
)

Definition at line 219 of file StartTriple.py.

00219                                      :
00220         "Increment instance variable power."
00221 
00222         if self._power < 0:
00223             self._power = self._min
00224         elif self._power == 0 and self._min != 0:
00225             self._power = self._min
00226         else:
00227             self._power += d
00228 
00229         return self._power
00230   
    def widen( self, min, max ):

def StartTriple::StartTriple::initMinMax (   self,
  min,
  max 
)

Definition at line 177 of file StartTriple.py.

00177                                     :
00178         "Initialize instance variables min and max."
00179         "Used by AlbTripleStart::newFirstPower2."
00180 
00181         self._power = 0
00182         if self._min == 0  or self._min > min:
00183             self._min = min
00184         if self._max == 0  or self._max < max:
00185             self._max = max
00186 
00187         return
00188 
    def adjMinMax_xxxdef( self, factor ):

def StartTriple::StartTriple::max (   self,
  anObject = None 
)

Definition at line 245 of file StartTriple.py.

00245                                     :
00246         "Get/Set the instance variable max."
00247 
00248 #       if anObject or anObject == 0:
00249 #       if anObject != None and ( self._max == 0 or anObject > self._max ):
00250         if anObject:
00251             if ( self._max == 0 or anObject > self._max ):
00252                 self._max = anObject
00253 
00254         return self._max
00255    
    def min( self, anObject = None ):

def StartTriple::StartTriple::min (   self,
  anObject = None 
)

Definition at line 256 of file StartTriple.py.

00256                                     :
00257         "Get/Set the instance variable min."
00258 
00259 #       if anObject or anObject == 0:
00260 #       if anObject != None and ( self._min == 0 or anObject < self._min ):
00261         if anObject:
00262             if ( self._min == 0 or anObject < self._min ):
00263                 self._min = anObject
00264 
00265         return self._min
00266    
    def prime( self, anObject = None ):

def StartTriple::StartTriple::power (   self,
  anObject = None 
)

Definition at line 275 of file StartTriple.py.

00275                                       :
00276         "Get/Set the instance variable power."
00277 
00278         if anObject or anObject == 0:
00279             self._power = anObject
00280 
00281         return self._power
00282    
    def primeRatio( self ):

def StartTriple::StartTriple::prime (   self,
  anObject = None 
)

Definition at line 267 of file StartTriple.py.

00267                                       :
00268         "Get/Set the instance variable prime."
00269 
00270         if anObject:
00271             self._prime = anObject
00272 
00273         return self._prime
00274    
    def power( self, anObject = None ):

def StartTriple::StartTriple::primeRatio (   self  ) 

Definition at line 283 of file StartTriple.py.

00283                           :
00284 
00285         return int( self._power * 3 / 5 )
00286    
    def __cmp__( self, other ):

def StartTriple::StartTriple::setExponentRange (   self,
  anInteger 
)

Definition at line 322 of file StartTriple.py.

00322                                           :
00323         "Update the receiver's span (minimum exponent range)."
00324 
00325         if anInteger == 0:
00326             return
00327 
00328         diff = self._max - self._min
00329         if diff < anInteger:
00330             delta = ( anInteger - diff ) / 2
00331             self._min -= delta
00332             self._max += delta
00333             # if less than 0, use 0..anInteger
00334             if self._min < 0:
00335                 self._min = 0
00336                 self._max = anInteger
00337 
00338         return
00339     
if __name__ == '__main__':

def StartTriple::StartTriple::type (   self  ) 

Definition at line 173 of file StartTriple.py.

00173                     :
00174 
00175         return "StartTriple"
00176 
    def initMinMax( self, min, max ):

def StartTriple::StartTriple::updateMinMax (   self,
  anInteger 
)

Definition at line 312 of file StartTriple.py.

00312                                       :
00313         "Update the receiver's exponent range."
00314 
00315         if self._min == 0 or self._min > anInteger:
00316             self._min = anInteger
00317         if self._max == 0 or self._max < anInteger:
00318             self._max = anInteger
00319 
00320         return
00321     
    def setExponentRange( self, anInteger):

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

decrease min and increase max

Definition at line 231 of file StartTriple.py.

00231                                :
00232 
00233         '''
00234         decrease min and increase max
00235         '''
00236 
00237         if self._min > min:
00238             self._min -= min
00239         else:
00240             self._min = 1
00241         self._max += max
00242 
00243         return self
00244 
    def max( self, anObject = None ):


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