Exemple #1
0
    def content(self):
        """Return the content of a Polynomial.

        Usage:
        ======
            Returns the content, that is, the positive greatest common
            divisor of the (integer) coefficients.

        Examples:
        =========
            >>> x, y = symbols('xy')
            >>> f = Polynomial(6*x + 20*y + 4*x*y)
            >>> f.content()
            2

        Also see L{as_primitive}, L{leading_coeff}.

        """

        result = 0
        for term in self.coeffs:
            if not isinstance(term[0], Integer):
                print "%s is no integer coefficient!" % term[0]
                return S.Zero
            result = abs(numbers.gcd(result, abs(int(term[0]))))
        return Integer(result)
Exemple #2
0
def pollard_rho(n, max_iters=5, seed=1234):
    """Use Pollard's rho method to try to extract a factor of n. The
    returned factor may be a composite number. A maximum of max_iters
    iterations are performed; if no factor is found, None is returned.

    The rho algorithm is a Monte Carlo method whose outcome can
    be affected by changing the random seed value.

    References
    ==========
    Richard Crandall & Carl Pomerance (2005), "Prime Numbers:
    A Computational Perspective", Springer, 2nd edition, 229-231

    """
    random.seed(seed + max_iters)
    for i in range(max_iters):
        a = random.randint(1, n-3)
        s = random.randint(0, n-1)
        U = V = s
        F = lambda x: (x**2 + a) % a
        while 1:
            U = F(U)
            V = F(F(V))
            g = numbers.gcd(U-V, n)
            if g == 1:
                continue
            if g == n:
                break
            return g
    return None
Exemple #3
0
def pollard_pm1(n, B=10, seed=1234):
    """Use Pollard's p-1 method to try to extract a factor of n. The
    returned factor may be a composite number. The search is performed
    up to a smoothness bound B; if no factor is found, None is
    returned.

    The p-1 algorithm is a Monte Carlo method whose outcome can
    be affected by changing the random seed value.

    Example usage
    =============
    With the default smoothness bound, this number can't be cracked:
        >>> pollard_pm1(21477639576571)

    Increasing the smoothness bound helps:
        >>> pollard_pm1(21477639576571, 2000)
        4410317L

    References
    ==========
    Richard Crandall & Carl Pomerance (2005), "Prime Numbers:
    A Computational Perspective", Springer, 2nd edition, 236-238

    """
    from math import log
    random.seed(seed + B)
    a = random.randint(2, n-1)
    for p in sieve.primerange(2, B):
        e = int(log(B, p))
        a = pow(a, p**e, n)
    g = numbers.gcd(a-1, n)
    if 1 < g < n:
        return g
    else:
        return None
Exemple #4
0
 def A(n, j):
     if j == 1:
         return Float(1)
     s = Float(0)
     pi = pi_float()
     for h in xrange(1, j):
         if gcd(h,j) == 1:
             s += cos((g(h,j)-2*h*n)*pi/j)
     return s
Exemple #5
0
    def as_integer(self):
        """Return the polynomial with integer coefficients.

        Usage:
        ======
            Starting from an instance of Polynomial with only rational
            coefficients, this function multiplies it with the common
            denominator. The result is a tuple consisting of the
            factor applied to the coefficients and a new instance of
            Polynomial in the integers.

        Example:
        ========
            >>> x, y = symbols('xy')
            >>> f = Polynomial(x/6 + y/4 + x*y/3)
            >>> denominator, f = f.as_integer()
            >>> print denominator
            12
            >>> print f
            2*x + 3*y + 4*x*y
            >>> denominator, f = f.as_integer()
            >>> print denominator
            1
            >>> print f
            2*x + 3*y + 4*x*y

        Also see L{as_monic}, L{as_primitive}.

        """

        denom = S.One
        for term in self.coeffs:
            if not isinstance(term[0], Rational):
                print "%s is no rational coefficient!" % term[0]
                return S.Zero, self
            else:
                # Compute the least common multiple of the denominators:
                denom = term[0].q*denom/numbers.gcd(int(denom), int(term[0].q))
        if denom is S.One:
            return S.One, self
        else:
            return (denom,
                    Polynomial(coeffs=tuple([((term[0]*denom),) + term[1:]
                                             for term in self.coeffs]),
                               var=self.var, order=self.order))