Primeira vez aqui? Seja bem vindo e cheque o FAQ!
x

Como fazer subtração de polinômios no Python?

0 votos
14 visitas
perguntada Ago 21 em Ciência da Computação por Sergio Costa (1 ponto)  

Implementação da subtração de polinômios. Questão 7.25 do livro "A primer with Scientific Programming with Python: 6", por Hans Petter Langtangen (Capítulo 7, pág 480).

Compartilhe

1 Resposta

0 votos
respondida Ago 21 por Sergio Costa (1 ponto)  
editado 3 dias atrás por Sergio Costa

Olá, amigos,

A questão 7.25 solicita a elaboração de um método especial __sub__ na classe Polynomial definida na seção 7.3.7. do livro citado acima. Adicionalmente, pede-se para definir uma função test_Polynomial.

Ou seja, trata-se da implementação da subtração de polinômios e de um teste para verificar a validade da ferramenta.

Na classe Polynomial, os coeficientes de um dado polinômio são definidos como elementos de um vetor que o representa, onde para cada grau é armazenado em sequência o respectivo coeficiente (mesmo que \(0\)). Por exemplo: \(p(x) = 3x^2 + 4\) seria armazenado como um vetor \(z = [4, 0, 3]\).

Para levar em consideração a possibilidade de subtração de polinômios de graus diferentes (vetores com dimensões diferentes), o método especial explicita os dois casos: quando o vetor de coeficientes \(a\) (minunendo) é mais longo que o \(b\) (subtraendo), na subtração \(a - b = c\); e o segundo caso quando o vetor \(b\) é mais longo do que o \(a\).

No primeiro caso, a subtração é direta, subtraindo cada elemento do vetor mais longo pelo elemento correspondente do vetor mais curto, na quantidade de elementos do vetor mais curto.

Já quando o vetor \(b\) é mais longo que o \(a\), a solução encontrada foi tornar a subtração em uma adição do vetor de coeficientes \(a\) com o negativo do vetor de coeficientes \(b\), como em \(c = -1*b + a\). A adição é feita também por cada elemento do vetor mais longo com o respectivo do mais curto, na quantidade de elementos do vetor mais curto.

Com vetores de diferentes tamanhos, caso fosse realizada uma subtração direta utilizando como base o vetor mais longo \(b\) (subtraendo), o resultado sairia erradamente \(b-a\).

Abaixo, segue implementação:

class Polynomial(object):
 #Define vetor de coeficientes para um dado polinômio
    def __init__(self, coefficients):
        self.coeff = coefficients

 #Subtração de polinômios   
 #2 casos: self é mais longo ou igual a other;e o contrário. 
    def __sub__(self, other):
        if len(self.coeff) >= len(other.coeff):
 #quando o vetor mais longo é o minuendo, a subtração é direta
            result_coeff = self.coeff[:] # copia
            for i in range(len(other.coeff)):
                result_coeff[i] -= other.coeff[i]
        else:
 #vetor subtraendo é o mais longo, portanto multiplicado por -1    
            result_coeff = [-1*x for x in other.coeff]
            for i in range(len(self.coeff)):
                result_coeff[i] += self.coeff[i]
        return Polynomial(result_coeff)

Posteriormente, foi adicionada a função test_Polynomial como segue:

import Polynomial_sub

def test_Polynomial():
    a = Polynomial_sub.Polynomial([1, -1])
    b = Polynomial_sub.Polynomial([0, 1, 0, 0, -6, -1])

    c = a.__sub__(b)
    c_exact = Polynomial_sub.Polynomial([1, -2, 0, 0, 6, 1])
    msg = 'a = %s, b = %s\nc=a-b = %s\nmas está c = %s'%\
          (a.coeff, b.coeff, c_exact.coeff, c.coeff)
    assert c.coeff == c_exact.coeff, msg

    d = b.__sub__(a)
    d_exact = Polynomial_sub.Polynomial([-1, 2, 0, 0, -6, -1])
    msg2 = 'a = %s, b = %s\nd=b-a = %s\nmas está d = %s'%\
          (a.coeff, b.coeff, d_exact.coeff, d.coeff)
    assert d.coeff == d_exact.coeff, msg2

if __name__ == "__main__":
    test_Polynomial()

O teste consiste em verificar se uma resposta conhecida de uma subtração de polinômios confere com a subtração realizada pelo método especial definido na resoluçao da questão.

Nesta função, foram definidos dois vetores \(a= [1, -1]\) e \(b=[0, 1, 0, 0, -6, -1]\). Testou-se a operação \(a - b = c\) com o método __sub__, que caiu no caso em que é realizada a operação \(-1*b + a = c\). Em seguida, foi testada com __sub__ \(b - a = d\), onde foi realizada a subtração diretamente.

Caso o resultado estivesse errado, a verificação em assert retornaria a mensagem de erro contendo o resultado encontrado e o resultado correto.

...