SigmaFactor::SigmaFactor Class Reference

List of all members.

Public Member Functions

def __init__
def type
def __str__
def value
def factor
def factors
def sgmftr
def powerMinus1
def powerPlus1
def div
def isMersenne
def pmcheck
def factor_simple
def sgmftr_old


Detailed Description

Computes sgmftr( p ** q )

Definition at line 31 of file SigmaFactor.py.


Member Function Documentation

def SigmaFactor::SigmaFactor::__init__ (   self,
  p = None,
  q = None 
)

Definition at line 36 of file SigmaFactor.py.

00036                                             :
00037         self._p = mpz( p )
00038         self._q = mpz( q )
00039         self._v = self.sgmftr( )
00040         return
00041 
    def type( self ):

def SigmaFactor::SigmaFactor::__str__ (   self  ) 

Definition at line 46 of file SigmaFactor.py.

00046                        :
00047         try:
00048             ans = "%s" % self._v
00049         except:
00050             ans = "%s %s None" % ( self._p, self._q )
00051         return ans
00052 
    def value( self ):

def SigmaFactor::SigmaFactor::div (   self,
  list,
  value 
)

Definition at line 218 of file SigmaFactor.py.

00218                                 :
00219         print "div: %s %s" % ( list, value )
00220         answer = [ ] # list
00221         for index in range( 0, len( list ), 2):
00222             prime = list[ index ]
00223             power = list[ index + 1]
00224             if prime == value:
00225                 value = 0
00226                 if power == 1:
00227                     continue
00228                 else:
00229                     power -= 1
00230             answer += [ prime, power ]
00231 
00232             if globals.verbose:
00233                 print "           %s" % answer
00234         return answer
00235 
    def isMersenne( self, q ):

def SigmaFactor::SigmaFactor::factor (   self,
  n 
)

Definition at line 63 of file SigmaFactor.py.

00063                          :
00064         return Factors.Factors( n )
00065 
    def factors( self ):

def SigmaFactor::SigmaFactor::factor_simple (   self,
  i 
)

Definition at line 274 of file SigmaFactor.py.

00274                                 :
00275 
00276         # simplistic factoring of a number
00277         r = [ ] # list
00278         v = i
00279         p = 2
00280         while p * p <= v:
00281             q = 0
00282             while v % p == 0:
00283                 q += 1
00284                 v = v / p
00285             if q != 0:
00286                 r += ( p, q )
00287             p += 1
00288 
00289         if v > 1:
00290             r += ( v, 1 )
00291 
00292         return r
00293 
    def sgmftr_old( self ):

def SigmaFactor::SigmaFactor::factors (   self  ) 

Definition at line 66 of file SigmaFactor.py.

00066                        :
00067         return self._v
00068 
    def sgmftr( self ):

def SigmaFactor::SigmaFactor::isMersenne (   self,
  q 
)

Definition at line 236 of file SigmaFactor.py.

00236                              :
00237         f = Factors.Factors( )
00238         return f.isLucasLehmerPrime( q )
00239 
00240 #    ./PowerFactor.py p2 q47.50
00241 #
00242 #    pmcheck - OK - 2 ** 47
00243 #                   [2351, 1, 4513, 1, 13264529, 1]
00244 #    pmcheck - OK - 2 ** 48
00245 #                   [7, 1, 3, 2, 65, 1, 4097, 1, 16777217, 1]
00246 #    pmcheck - OK - 2 ** 49
00247 #                   [127, 1, 4432676798593L, 1]
00248 
    def pmcheck( self ):

def SigmaFactor::SigmaFactor::pmcheck (   self  ) 

Definition at line 249 of file SigmaFactor.py.

00249                        :
00250         # compute result directly
00251         v1 = self._p ** self._q - 1
00252 
00253         # compute result by factoring then multiplying
00254         print "pmx ..."
00255         pmx = self.powerMinus1( self._p, self._q )
00256         
00257         print "o: %s" % pmx.__class__
00258 
00259         v2 = 1
00260         for factor in pmx.factors( ):
00261             print "   %s" % factor
00262             v2 = v2 * factor.prime( ) ** factor.power( )
00263 
00264         # compare results
00265         if v1 != v2:
00266             print "pmcheck - error - %s ^ %s - 1" % ( self._p, self._q )
00267             print "                  %s" % v1
00268             print "                  %s" % v2
00269             print "                  %s %s" % ( v2 / v1, v2 % v1 )
00270             print "                  %s" % pmx
00271 
00272         return pmx
00273 
    def factor_simple( self, i ):

def SigmaFactor::SigmaFactor::powerMinus1 (   self,
  p,
  q 
)

factors p**q-1 and answers a Factors object

Definition at line 104 of file SigmaFactor.py.

00104                                  :
00105         """
00106         factors p**q-1 and answers a Factors object
00107         """
00108 
00109         if globals.verbose:
00110             print "%d ** %d - 1" % ( p, q )
00111 
00112         value = p ** q - 1
00113 
00114         if q == 0:
00115             print "SigmaFactor::powerMinus1( %d, %d )" % ( p, q )
00116             return
00117 
00118         if q == 1:
00119             answer = self.factor( value )
00120             if globals.verbose:
00121                 print "... %s" % answer
00122             return answer
00123 
00124         if q % 2 == 0:
00125             # compute( p^2q - 1 ) as ( p^q - 1 ) * ( p^q + 1 )
00126             q = q / 2
00127             if q == 1:
00128                 pri_min = Factors.Factors( p - 1 )
00129                 pri_plu = Factors.Factors( p + 1 )
00130             else:
00131                 pri_min = self.powerMinus1( p, q )
00132                 pri_plu = self.powerPlus1(  p, q )
00133             answer = pri_min * pri_plu
00134             if globals.verbose:
00135                 print "... %s" % answer
00136             return answer
00137 
00138         answer = Factors.Factors( )
00139 
00140         qfactors = Factors.Factors( q )
00141 
00142         if not qfactors.isPrime( ):
00143             factors = qfactors.factors( )
00144             factors.reverse( )
00145             for factor in factors:
00146                 prime = factor.prime( )
00147                 div = p ** prime - 1
00148                 if value % div == 0:
00149                     dfactors = self.factor( div )
00150                     answer = answer * dfactors
00151                     value = value / div
00152 
00153         # possible mersenne
00154         if p == 2 and len( qfactors ) == 2:
00155             if self.isMersenne( q ):
00156                 pydb.debugger( )
00157                 if globals.verbose:
00158                     print "pm.4..%s" % value
00159                 mersenne = [ p ** q - 1, ( p ** q - 1, 1 ) ]
00160                 answer = answer * mersenne
00161                 if globals.verbose:
00162                     print "pm.4: %s,%s -> %s" % ( p, q, answer )
00163 
00164         answer = answer * self.factor( value )
00165         if globals.verbose:
00166             print "... %s" % answer
00167         return answer
00168 
    def powerPlus1( self, p, q ):

def SigmaFactor::SigmaFactor::powerPlus1 (   self,
  p,
  q 
)

factors p**q+1 and answers a Factors object

Definition at line 169 of file SigmaFactor.py.

00169                                 :
00170         """
00171         factors p**q+1 and answers a Factors object
00172         """
00173 
00174         if globals.verbose:
00175             print "%d ** %d + 1" % ( p, q )
00176 
00177         value = p ** q + 1
00178 
00179         if q == 1:
00180             answer = self.factor( value )
00181             if globals.verbose:
00182                 print "... %s" % answer
00183             return answer
00184 
00185         answer = Factors.Factors( )
00186 
00187         qfactors = Factors.Factors( q )
00188 
00189         if globals.verbose:
00190             print "qf - %s" % qfactors
00191 
00192         if len( qfactors ) == 1 and qfactors.first( ).power( ) == 1:
00193             # if prime
00194             answer = self.factor( value )
00195         else:
00196             # if not prime
00197             for factor in qfactors.factors( ):
00198                 prime = factor.prime( )
00199                 if prime == 2:
00200                     continue
00201                 div = p ** prime + 1
00202 
00203                 if value % div == 0:
00204                     value = value / div
00205                     answer = answer * self.factor( div )
00206 
00207             if value > 1:
00208                 if globals.verbose:
00209                     print "... %s" % value
00210 #                if value > 1000000:
00211 #                    pydb.debugger( )
00212                 answer *= Factors.Factors( value )
00213 
00214                 if globals.verbose:
00215                     print "... %s" % answer
00216         return answer
00217 
    def div( self, list, value ):

def SigmaFactor::SigmaFactor::sgmftr (   self  ) 

Answers a Factors object

Definition at line 69 of file SigmaFactor.py.

00069                       :
00070         """
00071         Answers a Factors object
00072         """
00073 
00074         if self._p * self._q > 100:
00075             # retrieve value from cache or generate it
00076             n = Number.Number( self._p, self._q )
00077             ans = globals.SigmaFactorCache.at( n )
00078 
00079             if ans != None:
00080                 return ans
00081 
00082         num = self.powerMinus1( self._p, self._q + 1 )
00083 
00084         if self._p == 2:
00085             ans = num
00086         else:
00087             den = Factors.Factors( self._p - 1 )
00088 #           if num == None or den == None:
00089 #               pydb.debugger( )
00090 #               print "SigmaFactor::sgmftr( %d, %d )" % ( self._p, self._q )
00091 #               print "num: %s, den: %s" % ( num, den )
00092             ans = num / den
00093 
00094         if self._p * self._q > 100:
00095             # add value to cache
00096             if self._p == 2 and self._q == 5:
00097                 print "pp:qq: %d %d" % ( self._p, self._q )
00098                 n = Number.Number( self._p, self._q )
00099             n = Number.Number( self._p, self._q )
00100             globals.SigmaFactorCache.add( n, ans )
00101 
00102         return ans
00103 
    def powerMinus1( self, p, q ):

def SigmaFactor::SigmaFactor::sgmftr_old (   self  ) 

Answers a Factors object

Definition at line 294 of file SigmaFactor.py.

00294                           :
00295         """
00296         Answers a Factors object
00297         """
00298 
00299         m = ( self._p ** ( self._q + 1 ) - 1) / ( self._p - 1 )
00300         f = self.factor( m )
00301         return f
00302 
def test( ):

def SigmaFactor::SigmaFactor::type (   self  ) 

Definition at line 42 of file SigmaFactor.py.

00042                     :
00043 
00044         return "SigmaFactor"
00045 
    def __str__( self ):

def SigmaFactor::SigmaFactor::value (   self  ) 

Answers a Factors object

Definition at line 53 of file SigmaFactor.py.

00053                      :
00054         """
00055         Answers a Factors object
00056         """
00057 
00058         try:
00059             return self._v
00060         except:
00061             return None
00062 
    def factor( self, n ):


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