Ticket #5945: trac_5945-461rc0.patch

module_list.py

@@ -1175 +1175 @@
 
     Extension('sage.rings.integer',
               sources = ['sage/rings/integer.pyx'],
-              libraries=['ntl', 'gmp', 'pari'],
-              depends = numpy_depends),
+              libraries=['ntl', 'gmp', 'pari', 'flint'], 
+              include_dirs = [SAGE_INC + '/FLINT/'], 
+              depends = numpy_depends + flint_depends),
 
     Extension('sage.rings.integer_ring',
               sources = ['sage/rings/integer_ring.pyx'],

sage/libs/flint/long_extras.pxd

@@ -6 +6 @@
 
 cdef extern from "FLINT/long_extras.h":
 
+    ctypedef struct factor_t: 
+        int num 
+        unsigned long p[15] 
+        unsigned long exp[15] 
+
     cdef unsigned long z_randint(unsigned long limit)
 
     cdef unsigned long z_randbits(unsigned long bits)

sage/misc/sageinspect.py

@@ -1053 +1053 @@
     A cython function with default arguments (one of which is a string)::
     
         sage: sage_getdef(sage.rings.integer.Integer.factor, obj_name='factor')
-        "factor(algorithm='pari', proof=True, limit=None)"
+        "factor(algorithm='pari', proof=True, limit=None, int_=False, verbose=0)"
 
     This used to be problematic, but was fixed in #10094::
         

sage/rings/arith.py

@@ -2076 +2076 @@
     else:
         return ZZ(n).trial_division(bound)
 
-def __factor_using_trial_division(n):
-    """
-    Returns the factorization of the integer n as a sorted list of
-    tuples (p,e).
-    
-    INPUT:
-    
-    
-    -  ``n`` - an integer
-    
-    
-    OUTPUT:
-    
-    
-    -  ``list`` - factorization of n
-
-    EXAMPLES::
-
-        sage: from sage.rings.arith import __factor_using_trial_division
-        sage: __factor_using_trial_division(100)
-        [(2, 2), (5, 2)]
-    """
-    if n in [-1, 0, 1]: return []
-    if n < 0: n = -n
-    F = []
-    while n != 1:
-        p = trial_division(n)
-        e = 1
-        n /= p
-        while n%p == 0:
-            e += 1; n /= p
-        F.append((p,e))
-    F.sort()
-    return F
-
-def __factor_using_pari(n, int_=False, debug_level=0, proof=None):
-    """
-    Factors an integer using pari.
-
-    INPUT:
-    
-    -  ``n`` - an integer
-
-    EXAMPLES::
-
-        sage: from sage.rings.arith import __factor_using_pari
-        sage: __factor_using_pari(100)
-        [(2, 2), (5, 2)]
-        sage: __factor_using_pari(720)
-        [(2, 4), (3, 2), (5, 1)]
-    """
-    if proof is None:
-        from sage.structure.proof.proof import get_flag
-        proof = get_flag(proof, "arithmetic")
-    if int_:
-        Z = int  
-    else:
-        Z = ZZ
-    prev = pari.get_debug_level()
-    
-    if prev != debug_level:
-        pari.set_debug_level(debug_level)
-        
-    F = pari(n).factor(proof=proof)
-    B = F[0]
-    e = F[1]
-    v = [(Z(B[i]),Z(e[i])) for i in xrange(len(B))]
-            
-    if prev != debug_level:
-        pari.set_debug_level(prev)
-        
-    return v
-
-
-#todo: add a limit option to factor, so it will only split off
-# primes at most a given limit.
-
 def factor(n, proof=None, int_=False, algorithm='pari', verbose=0, **kwds):
     """
-    Returns the factorization of n. The result depends on the type of
-    n.
-    
-    If n is an integer, factor returns the factorization of the
-    integer n as an object of type Factorization.  
+    Returns the factorization of ``n``.  The result depends on the 
+    type of ``n``.
+    
+    If ``n`` is an integer, returns the factorization as an object 
+    of type ``Factorization``.
     
     If n is not an integer, ``n.factor(proof=proof, **kwds)`` gets called. 
     See ``n.factor??`` for more documentation in this case.
 
     .. warning::
     
-       This means that applying factor to an integer result of
+       This means that applying ``factor`` to an integer result of
        a symbolic computation will not factor the integer, because it is 
        considered as an element of a larger symbolic ring.
        
@@ -2176 +2099 @@
            sage: is_prime(f(3))
            False
            sage: factor(f(3))
-           9    
+           9
 
     INPUT:
     
@@ -2200 +2123 @@
        variable is set to this; e.g., set to 4 or 8 to see lots of output
        during factorization.
     
-    
-    OUTPUT: factorization of n
+    OUTPUT:
+
+    -  factorization of n
     
     The qsieve and ecm commands give access to highly optimized
     implementations of algorithms for doing certain integer
@@ -2261 +2185 @@
         sage: factor(2^(2^7)+1)
         59649589127497217 * 5704689200685129054721
     
-    Sage calls PARI's factor, which has proof False by default. Sage
-    has a global proof flag, set to True by default (see
-    :mod:`sage.structure.proof.proof`, or proof.[tab]). To override the default,
-    call this function with proof=False.
+    Sage calls PARI's factor, which has proof False by default. 
+    Sage has a global proof flag, set to True by default (see
+    :mod:`sage.structure.proof.proof`, or proof.[tab]). To override 
+    the default, call this function with proof=False.
     
     ::
     
@@ -2273 +2197 @@
     
     ::
     
-        sage: factor(2^197 + 1)       # takes a long time (e.g., 3 seconds!)
+        sage: factor(2^197 + 1)  # long time
         3 * 197002597249 * 1348959352853811313 * 251951573867253012259144010843
     
     Any object which has a factor method can be factored like this::
@@ -2296 +2220 @@
         [4, 3, 5, 7]
 
     """
-    if not isinstance(n, (int,long, integer.Integer)):
-        # this happens for example if n = x**2 + y**2 + 2*x*y
+    if isinstance(n, (int, long)):
+        n = ZZ(n)
+
+    if isinstance(n, integer.Integer):
+        return n.factor(proof=proof, algorithm=algorithm, 
+                        int_ = int_, verbose=verbose)
+    else:
+        # e.g. n = x**2 + y**2 + 2*x*y
         try:
             return n.factor(proof=proof, **kwds)
         except AttributeError:
             raise TypeError, "unable to factor n"
-        except TypeError:  # just in case factor method doesn't have a proof option.
+        except TypeError:
+            # Just in case factor method doesn't have a proof option.
             try:
                 return n.factor(**kwds)
             except AttributeError:
                 raise TypeError, "unable to factor n"
-    #n = abs(n)
-    n = ZZ(n)
-    if n < 0:
-        unit = ZZ(-1)
-        n = -n
-    else:
-        unit = ZZ(1)
-
-    if n == 0:
-        raise ArithmeticError, "Prime factorization of 0 not defined."
-    if n == 1:
-        return factorization.Factorization([], unit)
-    
-    if n < 10000000000000:
-        return factorization.Factorization(__factor_using_trial_division(n), unit)
-    
-    if algorithm == 'pari':
-        return factorization.Factorization(__factor_using_pari(n,
-                                   int_=int_, debug_level=verbose, proof=proof), unit)
-    elif algorithm in ['kash', 'magma']:
-        if algorithm == 'kash':
-            from sage.interfaces.all import kash as I
-        else:
-            from sage.interfaces.all import magma as I
-        F = I.eval('Factorization(%s)'%n)
-        i = F.rfind(']') + 1
-        F = F[:i]
-        F = F.replace("<","(").replace(">",")")
-        F = eval(F)
-        if not int_:
-            F = [(ZZ(a), ZZ(b)) for a,b in F]
-        return factorization.Factorization(F, unit)
-    else:
-        raise ValueError, "Algorithm is not known"
-        
-
-def prime_divisors(n):    
+
+def prime_divisors(n):
     """
     The prime divisors of the integer n, sorted in increasing order. If
     n is negative, we do *not* include -1 among the prime divisors,

sage/rings/integer.pyx

@@ -163 +163 @@
     cdef double ceil_c "ceil" (double)
 
 from sage.libs.pari.gen cimport gen as pari_gen, PariInstance
+from sage.libs.flint.long_extras cimport * 
 
 import sage.rings.infinity
 import sage.libs.pari.all
@@ -2950 +2951 @@
 
     def trial_division(self, long bound=LONG_MAX):
         """
-        Return smallest prime divisor of self up to limit, or
-        abs(self) if no such divisor is found.
-
-        INPUT:
-            - ``bound`` -- positive integer
+        Return smallest prime divisor of self up to bound, 
+        or abs(self) if no such divisor is found.
+
+        INPUT:
+
+            - ``bound`` -- a positive integer that fits in a C signed long
 
         OUTPUT:
+
             - a positive integer
-        
+
         EXAMPLES::
 
             sage: n = next_prime(10^6)*next_prime(10^7); n.trial_division()
@@ -3055 +3058 @@
             mpz_abs(x.value, self.value)
             return x
 
-    def _factor_trial_division(self, limit):
+    def _factor_trial_division(self, long limit=LONG_MAX):
         """
         Return partial factorization of self obtained using trial division
         for all primes up to limit, where limit must fit in a signed int.
         
         INPUT:
         
-        
-        -  ``limit`` - integer that fits in a signed int
-        
-        
-        ALGORITHM: Uses Pari.
+            -  ``limit`` - integer that fits in a C signed long
         
         EXAMPLES::
         
@@ -3076 +3075 @@
             sage: n._factor_trial_division(2000)
             2 * 11 * 1531 * 27325696005058797691594630609938486205809701
         """
-        import sage.structure.factorization as factorization
-        F = self._pari_().factor(limit)
+        from sage.structure.factorization_integer import IntegerFactorization
+        cdef Integer n = PY_NEW(Integer), p, unit
+        cdef unsigned long e
+        
+        if mpz_sgn(self.value) > 0:
+            mpz_set(n.value, self.value)
+            unit = ONE
+        else:
+            mpz_neg(n.value,self.value)
+            unit = PY_NEW(Integer)
+            mpz_set_si(unit.value, -1)
+
+        F = []
+        while mpz_cmpabs_ui(n.value, 1):
+            p = n.trial_division(bound=limit)
+            e = mpz_remove(n.value, n.value, p.value)
+            F.append((p,e))
+
+        return IntegerFactorization(F, unit=unit, unsafe=True, 
+                                       sort=False, simplify=False)
+
+    def __factor_using_pari(n, int_=False, debug_level=0, proof=None):
+        """
+        Factors this (positive) integer using PARI.
+
+        This method returns a list of pairs, not a ``Factorization`` 
+        object.  The first element of each pair is the factor, of type 
+        ``Integer`` if ``int_`` is ``False`` or ``int`` otherwise, 
+        the second element is the positive exponent, of type ``int``.
+
+        INPUT:
+
+            - ``int_`` -- (default: ``False``), whether the factors are 
+              of type ``int`` instead of ``Integer``
+
+            - ``debug_level`` -- (default: 0), debug level of the call 
+              to PARI
+
+            - ``proof`` -- (default: ``None``), whether the factors are 
+              required to be proven prime;  if ``None``, the global default 
+              is used
+
+        OUTPUT:
+
+            -  a list of pairs
+
+        EXAMPLES::
+
+            sage: factor(2**72 - 3, algorithm='pari')  # indirect doctest
+            83 * 131 * 294971519 * 1472414939
+        """
+        from sage.libs.pari.gen import pari
+
+        if proof is None:
+            from sage.structure.proof.proof import get_flag
+            proof = get_flag(proof, "arithmetic")
+
+        prev = pari.get_debug_level()
+        
+        if prev != debug_level:
+            pari.set_debug_level(debug_level)
+            
+        F = pari(n).factor(proof=proof)
         B, e = F
-        return factorization.Factorization([(the_integer_ring(B[i]), the_integer_ring(e[i])) for i in range(len(B))])
-
-    def factor(self, algorithm='pari', proof=True, limit=None):
-        """
-        Return the prime factorization of the integer as a list of pairs
-        `(p,e)`, where `p` is prime and `e` is a
-        positive integer.
-        
-        INPUT:
-        
+        if int_:
+            v = [(int(B[i]), int(e[i])) for i in xrange(len(B))]
+        else:
+            v = [(Integer(B[i]), int(e[i])) for i in xrange(len(B))]
+
+        if prev != debug_level:
+            pari.set_debug_level(prev)
+
+        return v
+
+    def factor(self, algorithm='pari', proof=None, limit=None, int_=False, 
+                     verbose=0):
+        """
+        Return the prime factorization of this integer as a list of pairs
+        `(p, e)`, where `p` is prime and `e` is a positive integer.
+        
+        INPUT:
         
         -  ``algorithm`` - string
         
-           - ``'pari'`` - (default) use the PARI c library
-        
-           - ``'kash'`` - use KASH computer algebra system (requires
-             the optional kash package be installed)
+           - ``'pari'`` - (default) use the PARI library
+        
+           - ``'kash'`` - use the KASH computer algebra system (requires
+             the optional kash package)
         
         -  ``proof`` - bool (default: True) whether or not to
            prove primality of each factor (only applicable for PARI).
@@ -3104 +3171 @@
            given it must fit in a signed int, and the factorization is done
            using trial division and primes up to limit.
         
-        
         EXAMPLES::
         
             sage: n = 2^100 - 1; n.factor()
@@ -3131 +3197 @@
             ...
             ValueError: Algorithm is not known
         """
+        from sage.structure.factorization import Factorization
+        from sage.structure.factorization_integer import IntegerFactorization
+
+        cdef Integer n, p, unit
+        cdef int i
+        cdef factor_t f
+
+        if mpz_sgn(self.value) == 0:
+            raise ArithmeticError, "Prime factorization of 0 not defined."
+
+        if mpz_sgn(self.value) > 0:
+            n    = self
+            unit = ONE
+        else:
+            n    = PY_NEW(Integer)
+            unit = PY_NEW(Integer)
+            mpz_neg(n.value, self.value)
+            mpz_set_si(unit.value, -1)
+
+        if mpz_cmpabs_ui(n.value, 1) == 0:
+            return IntegerFactorization([], unit=unit, unsafe=True, 
+                                            sort=False, simplify=False)
+
         if limit is not None:
             return self._factor_trial_division(limit)
-        import sage.rings.integer_ring
-        return sage.rings.integer_ring.factor(self, algorithm=algorithm, proof=proof)
+
+        if proof is None:
+            from sage.structure.proof.proof import get_flag
+            proof = get_flag(proof, "arithmetic")
+
+        if mpz_fits_slong_p(n.value):
+            z_factor(&f, mpz_get_ui(n.value), proof)
+            F = [(Integer(f.p[i]), int(f.exp[i])) for i from 0 <= i < f.num]
+            F.sort()
+            return IntegerFactorization(F, unit=unit, unsafe=True, 
+                                           sort=False, simplify=False)
+
+        if mpz_sizeinbase(n.value, 2) < 40:
+            return self._factor_trial_division()
+
+        if algorithm == 'pari':
+            F = n.__factor_using_pari(int_=int_, debug_level=verbose, proof=proof)
+            F.sort()
+            return IntegerFactorization(F, unit=unit, unsafe=True, 
+                                           sort=False, simplify=False)
+        elif algorithm in ['kash', 'magma']:
+            if algorithm == 'kash':
+                from sage.interfaces.all import kash as I
+            else:
+                from sage.interfaces.all import magma as I
+            F = I.eval('Factorization(%s)'%n)
+            i = F.rfind(']') + 1
+            F = F[:i]
+            F = F.replace("<","(").replace(">",")")
+            F = eval(F)
+            if not int_:
+                F = [(Integer(a), int(b)) for a,b in F]
+            return Factorization(F, unit)
+        else:
+            raise ValueError, "Algorithm is not known"
 
     def _factor_cunningham(self, proof=True):
         """

sage/rings/integer_ring.pyx

@@ -80 +80 @@
 
 import ring
 
+arith = None
+cdef void late_import():
+    global arith
+    if arith is None:
+        import sage.rings.arith
+        arith = sage.rings.arith
+
 cdef int number_of_integer_rings = 0
 
 def is_IntegerRing(x):
@@ -1054 +1061 @@
     """
     return ZZ
 
-def factor(n, algorithm='pari', proof=True):
+def factor(*args, **kwds):
     """
-    Return the factorization of the positive integer `n` as a
-    sorted list of tuples `(p_i,e_i)` such that
-    `n=\prod p_i^{e_i}`.
-    
-    For further documentation see sage.rings.arith.factor()
-    
+    This function is deprecated.  To factor an Integer `n`, call `n.factor()`. 
+    For other objects, use the factor method from sage.rings.arith.
+
     EXAMPLE::
-    
-        sage: sage.rings.integer_ring.factor(420)
-        2^2 * 3 * 5 * 7
+
+        sage: sage.rings.integer_ring.factor(1)
+        doctest:...: DeprecationWarning: This function is deprecated...
+        1
     """
-    import sage.rings.arith
-    return sage.rings.arith.factor(n, algorithm=algorithm, proof=proof)
-    
+    from sage.misc.misc import deprecation
+    deprecation("This function is deprecated.  Call the factor method of an Integer,"
+                +"or sage.arith.factor instead.")
+    #deprecated 4.6.2
+
+    late_import()
+    return arith.factor(*args, **kwds)
+
 import sage.misc.misc
 def crt_basis(X, xgcd=None):
     """

new file sage/structure/factorization_integer.py

@@ +1 @@
+from sage.structure.factorization import Factorization
+
+from sage.rings.integer_ring import ZZ
+
+class IntegerFactorization(Factorization):
+    """
+    A lightweight class for an ``IntegerFactorization`` object, 
+    inheriting from the more general ``Factorization`` class.
+
+    In the ``Factorization`` class the user has to create a list 
+    containing the factorization data, which is then passed to the 
+    actual ``Factorization`` object upon initialization.
+
+    However, for the typical use of integer factorization via 
+    the ``Integer.factor()`` method in ``sage.rings.integer`` 
+    this is noticeably too much overhead, slowing down the 
+    factorization of integers of up to about 40 bits by a factor 
+    of around 10.  Moreover, the initialization done in the 
+    ``Factorization`` class is typically unnecessary:  the caller 
+    can guarantee that the list contains pairs of an ``Integer`` 
+    and an ``int``, as well as that the list is sorted.
+
+    AUTHOR:
+
+        - Sebastian Pancratz (2010-01-10)
+    """
+
+    def __init__(self, x, unit=None, cr=False, sort=True, simplify=True, 
+                       unsafe=False):
+        """
+        Sets ``self`` to the factorization object with list ``x``, 
+        which must be a sorted list of pairs, where each pair contains 
+        a factor and an exponent.
+
+        If the flag ``unsafe`` is set to ``False`` this method delegates 
+        the initialization to the parent class, which means that a rather 
+        lenient and careful way of initialization is chosen.  For example, 
+        elements are coerced or converted into the right parents, multiple 
+        occurrences of the same factor are collected (in the commutative 
+        case), the list is sorted (unless ``sort`` is ``False``) etc.
+
+        However, if the flag is set to ``True``, no error handling is 
+        carried out.  The list ``x`` is assumed to list of pairs.  The 
+        type of the factors is assumed to be constant across all factors: 
+        either ``Integer`` (the generic case) or ``int`` (as supported 
+        by the flag ``int_`` of the ``factor()`` method).  The type of 
+        the exponents is assumed to be ``int``.  The list ``x`` itself 
+        will be referenced in this factorization object and hence the 
+        caller is responsible for not changing the list after creating 
+        the factorization.  The unit is assumed to be either ``None`` or 
+        of type ``Integer``, taking one of the values `+1` or `-1`.
+
+        EXAMPLES::
+
+            sage: factor(15)
+            3 * 5
+        """
+        if unsafe:
+            if unit is None:
+                self._Factorization__unit = sage.rings.integer.ONE
+            else:
+                self._Factorization__unit = unit
+
+            self._Factorization__x        = x
+            self._Factorization__universe = ZZ
+            self._Factorization__cr       = cr
+
+            if sort:
+                self.sort()
+            if simplify:
+                self.simplify()
+
+        else:
+            super(IntegerFactorization, self).__init__(x, 
+                unit=unit, cr=cr, sort=sort, simplify=simplify)
+
+    def __sort__(self, _cmp=None):
+        """
+        Sort the factors in this factorization.
+
+        INPUT:
+
+        - ``_cmp`` - (default: None) comparison function
+
+        EXAMPLES::
+
+            sage: F = factor(15)
+            sage: F.sort(_cmp = lambda x,y: -cmp(x,y))
+            sage: F
+            5 * 3
+        """
+        self.__x.sort(_cmp)
+