StartTriple::StartTripleDict Class Reference

List of all members.

Public Member Functions

def __init__
def type
def __str__
def addTriple
def primes
def xxx_sortedkeys_xxxdef
def sortedvalues
def item_number
def first
def count
def display
def updateStartTriples
def updateFromSeed
def updateFromFactors
def widen


Detailed Description

A dictionary mapping a prime to a StartTriple instantiated with
the prime, a power, and min and max power values

Definition at line 7 of file StartTriple.py.


Member Function Documentation

def StartTriple::StartTripleDict::__init__ (   self,
  primes 
)

Initialize using an array of primes

Definition at line 12 of file StartTriple.py.

00012                                 :
00013         """Initialize using an array of primes
00014         """
00015         
00016         self._dict = { }
00017         self._primes = [ ]
00018 
00019         self.addTriple( Number.Number( 2 ) )
00020 
00021         for prime in primes:
00022             self.addTriple( Number.Number( prime ) )
00023 
00024         return
00025 
    def type( self ):

def StartTriple::StartTripleDict::__str__ (   self  ) 

Definition at line 30 of file StartTriple.py.

00030                        :
00031 
00032         answer = ""
00033         for p in self._primes:
00034             if p != 2:
00035                 answer += "%s " % self._dict[ p ]
00036 
00037         return answer
00038 
    def addTriple( self, factor, min = 0, max = 0 ):

def StartTriple::StartTripleDict::addTriple (   self,
  factor,
  min = 0,
  max = 0 
)

Definition at line 39 of file StartTriple.py.

00039                                                    :
00040 
00041         p = factor.prime( )
00042         q = factor.power( )
00043         s = StartTriple( p, q, min, max )
00044         self._dict[ p ] = s
00045 
00046         self._primes.append( p )
00047         self._primes.sort( )
00048 
00049         return
00050 
    def primes( self ):

def StartTriple::StartTripleDict::count (   self  ) 

Definition at line 95 of file StartTriple.py.

00095                      :
00096 
00097         count = 1
00098         for key in self._primes:
00099             triple = self._dict[ key ]
00100             if triple.prime( ) != 2:
00101                 count = count * ( triple.max( ) - triple.min( ) + 1 )
00102 
00103         return count
00104 
    def display( self ):

def StartTriple::StartTripleDict::display (   self  ) 

Definition at line 105 of file StartTriple.py.

00105                        :
00106 
00107         print "%s %d" % ( self, self.count( ) )
00108 
00109         return
00110 
    def updateStartTriples( self, seed ):

def StartTriple::StartTripleDict::first (   self  ) 

Answer the receiver's first item.

Definition at line 85 of file StartTriple.py.

00085                      :
00086         """
00087         Answer the receiver's first item.
00088         """
00089 
00090         p = self._primes[ 0 ]
00091         v = self._dict[ p ]
00092 
00093         return v
00094 
    def count( self ):

def StartTriple::StartTripleDict::item_number (   self,
  index 
)

Definition at line 77 of file StartTriple.py.

00077                                   :
00078 
00079         keys  = self._dict.keys( )
00080         key   = keys[ index ]
00081         value = self[ key ]
00082 
00083         return value
00084     
    def first( self ):

def StartTriple::StartTripleDict::primes (   self  ) 

return sorted list of primes (keys)

Definition at line 51 of file StartTriple.py.

00051                       :
00052         """
00053         return sorted list of primes (keys)
00054         """
00055 
00056         return self._primes
00057 
    def xxx_sortedkeys_xxxdef( self, key = None ):

def StartTriple::StartTripleDict::sortedvalues (   self  ) 

Definition at line 69 of file StartTriple.py.

00069                             :
00070 
00071         values = self._dict.values( )
00072         
00073         values.sort( )
00074 
00075         return values
00076 
    def item_number( self, index ):

def StartTriple::StartTripleDict::type (   self  ) 

Definition at line 26 of file StartTriple.py.

00026                     :
00027 
00028         return "StartTripleDict"
00029 
    def __str__( self ):

def StartTriple::StartTripleDict::updateFromFactors (   self,
  factors 
)

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

Definition at line 127 of file StartTriple.py.

00127                                           :
00128         # search result cache for the same power of two
00129         # and set up/lower limits for triples' primes
00130 
00131         """
00132         find matching power of 2 in result cache
00133         find min & max powers of 3, 5, and 7
00134         """
00135 
00136         triples = self._dict
00137         keys = triples.keys( )
00138 
00139         for p in keys:
00140             if factors.has_key( p ):
00141                 factor = factors[ p ]
00142                 triple = triples[ p ]
00143                 triple.adjMinMax( factor )
00144 
00145         return
00146 
    def widen( self, min, max ):

def StartTriple::StartTripleDict::updateFromSeed (   self,
  seed 
)

Definition at line 119 of file StartTriple.py.

00119                                     :
00120         # search result cache for the same power of two
00121         # and set up/lower limits for triples' primes
00122 
00123         globals.ResultCache.updateStartTriples( self._dict, seed )
00124 
00125         return
00126 
    def updateFromFactors( self, factors ):

def StartTriple::StartTripleDict::updateStartTriples (   self,
  seed 
)

Definition at line 111 of file StartTriple.py.

00111                                         :
00112         # search result cache for the same power of two
00113         # and set up/lower limits for triples' primes
00114 
00115         self.updateFromSeed( seed )
00116 
00117         return
00118 
    def updateFromSeed( self, seed ):

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

Definition at line 147 of file StartTriple.py.

00147                                :
00148 
00149         for triple in self._dict.values( ):
00150             triple.widen( min, max )
00151 
00152         return
00153 
class StartTriple:

def StartTriple::StartTripleDict::xxx_sortedkeys_xxxdef (   self,
  key = None 
)

Definition at line 58 of file StartTriple.py.

00058                                                  :
00059 
00060         if not key:
00061             values = self._dict.values( )
00062         else:
00063             values = self._dict[ key ].values( )
00064         
00065         values.sort( )
00066 
00067         return values
00068 
    def sortedvalues( self ):


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