I've been looking for a way to work with polynomials using python, did someone already wrote a code to do that?.

Here's what i have until now using dictionaries as polynomials -for example: x^4-6x^2+1 would be {4:1, 2:-6, 0:1}-, someone have any suggestion to make?

def degree(f):
    t = sorted(f.keys())
    if len(t)!=0:
        r = t[len(t)-1]
    else:
        r=0
    return r

def get_sum(r,s,g):
    result = {}
    while (g>=0):
        try:
            x = r[g]
        except:
            x = 0
        try:
            y = s[g]
        except:
            y = 0

        if( (x+y)!= 0):
            result[g] = x+y
        g-=1
    return result

def add(p,q):
    if( degree(p) > degree(q) ):
        suma = get_sum(p,q, degree(p))
    else:
        suma = get_sum(p,q, degree(q))

    return suma

def product(p,q):
    product_r = {}
    if ( degree(p) >= degree(q) ):
        t = degree(p)
    else:
        t = degree(q)
    m = t
    n = t
    while ( m>=0 ):
        while( n>= 0 ):
            try:
                r = p[m]*q[n]
            except:
                r = 0

            try:
                s = product_r[m+n]
            except:
                s = 0

            if( (r+s)!= 0 ):
                product_r[m+n] = r+s
            else:
                try:
                    del product_r[m+n]
                except:
                    pass
            n-= 1
        n = t
        m-=1
    return product_r

def degreeiation(p,n):
    if n!=0:
        t = p
        while (n>1):
            t = product(t,p)
            n-=1
    else:
        t={0:1}
    return t

def division(p,q):
    pol = {}
    if degree(q)!= 0:
        r = p[degree(p)]/q[degree(q)]
        pol[degree(p)-degree(q)] = r
        n_p = product(product(pol,q),{0:-1})
        p = add(p,n_p)
    else:
        pol = product(p,q[degree(q)])
        p = 0
    if len(p)== 0:
        p[0]=0

    return p,pol

def divide(p,q):
    cociente = {}
    if degree(p)>=degree(q):
        while degree(p)>=degree(q):
            qt = division(p,q)
            p = qt[0]
            cociente.update(qt[1])
    else:
        cociente = {0:0}
    return cociente

def remainder(p,q):
    if degree(p)>=degree(q):
        while degree(p)>=degree(q):
            qt=division(p,q)
            p = qt[0]
    else:
        pass
    return p

def evaluar(p,x):
    s = {0:0}
    variables = sorted(p.keys())
    for i in variables:
        a = {0:p[i]}
        b = degreeiation({0:x},i)
        c = product(a,b)
        s = add(product({0:p[i]},degreeiation({0:x},i)),s)
    try:
        r= s[0]
    except:
        r=0
    return r

def simplificar(p):
    keys_p = sorted(p.keys())
    values = []
    divisor = []
    for i in keys_p:
        values.append(p[i])
        values = sorted(values)
        i = values[-1]
        while i>0:
            div_temp=[]
            for j in keys_p:
                r = p[j]%i

                if r==0:
                    div_temp.append(0)
                else:
                    div_temp.append(1)
            if 0 in div_temp:
                divisor.append(i)
            i-=1
    values = sorted(values)

    result = product(p,{0:Racional(1,values[-1])})

    if result[sorted(result.keys())[-1]] < 0:
        for i in result.keys():
            result[i] = result[i]*(-1)
    return Polynomial(result)

def verif(remainder):
    try:
        if len(remainder.polynomial) == 1:
            if remainder.degree() == 0:
                test = [False,remainder.polynomial]
            else:
                test = [True]
        else:
            test = True
    except:
        try:
            a = remainder.polynomial
            test = [True]
        except:
            test = [False,remainder.polynomial]
    return test

class Polynomial(object):
    def __init__(self, polynomial):
        self.polynomial = polynomial

    def __repr__(self):
        try:
            keys = self.polynomial.keys()
            keys.reverse()
            pol = ''
            for i in keys:
                if i!=0:
                    if self.polynomial[i]>0:
                        pol+='  '+str(self.polynomial[i])+'X^'+str(i)
                    else:
                        pol+='  '+str(self.polynomial[i])+'X^'+str(i)
                else:
                    if self.polynomial[i]>0:
                        pol+= ' + '+str(self.polynomial[i])
                    else:
                        pol=pol+'  '+str(self.polynomial[i])

            if pol.startswith(' '):
                pol = pol[2:]
            else:
                pass
        except:
            pol = str(self.polynomial)
        return pol

    def __add__(self, other):
        return Polynomial(add(self.polynomial, other.polynomial))

    __radd__ = __add__

    def degree(self):
        return degree(self.polynomial)

    def __mul__(self, other):
        return Polynomial(product(self.polynomial, other.polynomial))

    __rmul__ = __mul__


    def __sub__(self,other):
        r_pol = {}
        r_o = {}
        keys_s = self.polynomial.keys()
        keys_s.extend(other.polynomial.keys())
        keys_s = list(set(keys_s))
        for i in other.polynomial.keys():
            r_o[i] = (-1)*other.polynomial[i]

        for i in keys_s:
            r_pol[i] = self.polynomial[i] + r_o[i]

        return r_pol

    def __rsub__(self, other):
        r_pol = {}
        r_o = {}
        keys_s = self.polynomial.keys()
        keys_s.extend(other.polynomial.keys())
        keys_s = list(set(keys_s))
        for i in self.polynomial.keys():
            r_o[i] = (-1)*self.polynomial[i]

        for i in keys_s:
            r_pol[i] = other.polynomial[i] + r_o[i]
        return r_pol


        return result
    def __div__(self, other):
        return Polynomial(divide(self.polynomial, other.polynomial))

    def __pow__(self,n):
        return Polynomial(degreeiation(self.polynomial,n))

    def __getitem__(self,i):
        return Polynomial(evaluar(self.polynomial,i))

    def __eq__(self,other):
        keys_self = self.polynomial.keys()
        keys_other = other.polynomial.keys()
        keys_self.extend(keys_other)
        l_key = keys_self[-1]
        while l_key >= 0:
            try:
                if self.polynomial[l_key] == other.polynomial[l_key]:
                    r = True
                    l_key-=1
                else:
                    r = False
                    l_key = -1
            except:
                r = False
                l_key = -1
        return r

    def __ne__(self, other):
        if (self==other) == True:
            return False
        else:
            return True         


    def __mod__(self, other):
        return Polynomial(remainder(self.polynomial, other.polynomial))

    def mcd(self, other):
        divisor = []
        remainder_s = []
        remainder = self%other

        try:
            if verif(remainder)[0] == False:
                remainder_s.append(verif(remainder)[1])
                test = False
        except:
            test = True

        while test :
            rmax_exp = int(sorted(remainder.polynomial.keys())[-1])
            omax_exp = int(sorted(other.polynomial.keys())[-1])
            remainder = simplificar(remainder.polynomial)

            if other.polynomial[omax_exp] % int(remainder.polynomial[rmax_exp]) == 0:
                remainder_s.append(remainder.polynomial)
                remainder = other % remainder
                test = verif(remainder)[0]
                if test == False:
                    remainder_s.append(verif(remainder)[1])
                print test
            else:
                print 'hey'
                test = False


        try:
            remainder_f = remainder_s[-1]
            if  remainder_f[0] == 0:
                mcd = remainder_s[-2]
            else:
                mcd = 1
        except:
            mcd = other



        return remainder_s

Related article is my code on subject which got me price in summer code snippet competition, you can compare with that.

This article has been dead for over six months. Start a new discussion instead.