Création polynomiale classe en Python

voix
1

Je travaille actuellement sur la création d' une classe polynomiale qui comprend add , mul et eval méthodes. Je suis actuellement coincé sur la partie de plus, si quelqu'un pouvait me donner un peu d' aide sur la façon d'obtenir ce compris que serait grandement apprécié. Tout fonctionne actuellement sans erreurs mais quand je p3 = P1 + P2 et j'imprimer p3 je rentrerai les deux listes ensemble. Tous commentaires serait grandement apprécié.

class Polynomial(object):

    def __init__(self, *coeffs, num = 0):

        self.coeffs = list(coeffs) # turned into a list

        assert (type(num) is type(1)) 
        self.num = num

    # Needs to be operator overload
    '''
    def __mul__(self, other):
    '''

    def __eval__(self, other, coeff, x):
        result = coeff[-1]
        for i in range(-2, -len(coeff)-1, -1):
            result = result * x + coeff[i]
        return result


    def __add__(self, other):

        assert type(other) is Polynomial

        num = self.coeffs + other.coeffs

        return Polynomial(num)


    def __sub__(self, other):

        assert type(other) is Polynomial
        num = self.coeffs - other.coeffs

        return Polynomial(num)




    def __represntation__(self):
        return Polynomial + str(self.coeffs)   

    def __str__(self):
        rep =     
        degree = len(self.coeffs) - 1
        rep += str(self.coeffs[0]) + x^ + str(degree)       
        for i in range(1, len(self.coeffs)-1):
            coeff = self.coeffs[i]
            if coeff < 0:
                rep +=  -  +  str(-coeff) + x^ + str(degree - i)
            else:
                rep +=  +  +  str(coeff) + x^ + str(degree - i)

            if self.coeffs[-1] < 0:
                rep +=  -  + str(-self.coeffs[-1])
        else:
            rep +=  +  + str(self.coeffs[-1])  
        return rep
Créé 13/02/2020 à 23:53
source utilisateur
Dans d'autres langues...                            


3 réponses

voix
0

Le problème est ici:

num = self.coeffs + other.coeffs

Ajout d' une liste à une autre liste concaténer les. Pour ajouter simplement des éléments correspondant à l'autre, vous voulez faire

from itertools import zip_longest

...

num = [a + b for (a, b) in zip_longest(self.coeffs, other.coeffs, fillvalue=0)]

Nous utilisons au zip_longest()lieu du plus générique zip()parce qu'un polynôme est peut - être plus que l'autre et nous ne voulons pas gâcher. Soit l' un d'eux regrouper les éléments correspondants afin que nous puissions facilement les ajouter et faire une liste de ceux -ci .

Vous feriez quelque chose de similaire pour la soustraction.

Créé 13/02/2020 à 23:57
source utilisateur

voix
0

Vous ne pouvez pas ajouter directement deux listes.

def __add__(self, other):

    assert type(other) is Polynomial
    assert len(self.coeffs) != len(other.coeffs)

    new_ceffs = [item1 + item2 for (item1, item2) in zip(self.coeffs, other.coeffs)]

    return Polynomial(new_ceffs)
Créé 14/02/2020 à 00:02
source utilisateur

voix
0

vous devez inverser l'ordre des coefficients passés à votre constructeur de sorte que les index de la self.coeffscorrespondent liste des exposants. Cela simplifierait le reste de votre code et vous permettre d'utiliser zip_longest pour additions et soustractions.

Lorsque vous arrivez à d'autres opérations mais je pense que vous vous rendrez compte que votre structure interne serait plus facile à gérer si elle était un dictionnaire. Un dictionnaire est plus permissive des entrées manquantes évitant ainsi les préoccupations de l'allocation des espaces pour les nouveaux indices.

class Polynomial(object):

    def __init__(self, *coeffs):
        self.coeffs = {exp:c for exp,c in enumerate(coeffs[::-1])}

    def __add__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        result.coeffs = {**self.coeffs}
        for exp,c in other.coeffs.items():
            result.coeffs[exp] = result.coeffs.get(exp,0) + c
        return result

    def __sub__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        result.coeffs = {**self.coeffs}
        for exp,c in other.coeffs.items():
            result.coeffs[exp] = result.coeffs.get(exp,0) - c
        return result

    def __mul__(self, other):
        assert type(other) is Polynomial
        result = Polynomial(0)
        for exp1,c1 in self.coeffs.items():
            for exp2,c2 in self.coeffs.items():
                result.coeffs[exp1+exp2] = result.coeffs.get(exp1+exp2,0) + c1*c2
        return result

    def __representation__(self):
        return "Polynomial" + str(self.coeffs)   

    def __str__(self):
        result = [""]+[f"{c}x^{i}" for i,c in sorted(self.coeffs.items()) if c]+[""]
        result = "+".join(reversed(result))
        result = result.replace("+1x","+x")
        result = result.replace("-1x","-x")
        result = result.replace("x^0","")
        result = result.replace("x^1+","x+")
        result = result.replace("+-","-")
        result = result.strip("+")
        result = result.replace("+"," + ")
        result = result[:1]+result[1:].replace("-"," - ")
        return result.strip()
Créé 14/02/2020 à 02:48
source utilisateur

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more