Hierarchia klas: Wielomian i inne pojęcia alebraiczne

Klasa Polynomial

Stwórz klasę Polynomial, która będzie reprezentować funkcję \(W(x) = \sum_{i=0}^N c_i x^i\) gdzie \(N\) jest stopniem wielomianu a \(x\) dowolną liczbą rzeczywistą. Współczynniki \(c_i\) powinny być prywatnymi danymi klasy

Konstruktor klasy

Klasa powinna mieć konstruktor, umożliwiający łatwe tworzenie wielomianów. Zadbaj o wygodę użytkowników swojej klasy! Twój konstruktor powinien zatem być przeciążony (patrz przeciążenie). Utwórz warianty umożliwiające następujące sposoby konstruowania wielomianów:

w1 = Polynomial(1, 0, 5)      # Tworzy x^2 + 5
w2 = Polynomial([1, 0, 5])    # Tworzy x^2 + 5
w3 = Polynomial(w2)       # Konstruktor kopiujący

Dane prywatne

Zastanów się nad najwygodniejszą reprezentacją danych prywatnych klasy

Wypisywanie na ekran

Napisz metodę __str__(), która odpowiednio wydrukuje wielomian na ekranie

print(w1)      # Drukuje na ekran: x^2 + 1

Metody publiczne

Klasa Polynomial powinna mieć następujące metody: add(w), sub(w) i mul(w), które będą odpowiednio dodawać, odejmować oraz wymnażać wielomian w, modyfikując bieżący obiekt (self). Napisz także metody differentiate() i integrate(), które policzą pierwszą pochodną oraz całkę z wielomianu. Oczywiście klasa Polynomial powinna też mieć metodę eval() obliczającą wartość wielomianu w zadanym punkcie.

Na tym etapie Twoja klasa powinna umożliwić poprawne działanie następującego programu:

w1 = Polynomial(2, 0, 1)
print(w1)                    # Drukuje na ekran: x^2 + 1
w2 = Polynomial([3, 2, 1])
w3 = Polynomial(w2)
w2.add(w1)
print(w2.mul(w1))

Lepsza klasa Polynomial

Przeciążenie operatorów

Wykorzystaj Funkcje specjalne do zdefiniowania operatorów += -= *= , które zastąpią odpowiednio metody klasy: add(w), sub(w) i mul(w). W tym celu wystarczy odpowiednio zmienić nazwy metod, np add() na __iadd__(). Pamiętaj, aby metody te zwracały self. Zdefiniuj też operatory + - * a także operator wywołania (ang. call operator) jako metodę __call__(), który zastąpi metodę eval()

Zabezpieczanie danych prywatnych

Utwóż listę __slots__ w klasie Polynomial (Lista __slots__), aby nikt nie dodał nowych składowych do Twojej klasy

Dostęp do składowych

Utwóż getter coefficients udostępniający współczynniki wielomianu; dla zachowania integralności klasy metoda ta powinna zwracać głęboką kopię współczynników, ustawionych w kolejności wg. rosnących potęg.

Na tym etapie Twoja klasa powinna umożliwić poprawne działanie następującego programu:

w1 = Polynomial(2, 1)
print(w1)                     # Drukuje na ekran: x^2 + 1
w2 = Polynomial([3, 2, 1])
w3 = Polynomial(w2)
w2 += w1
w4 = w3 + w2
w5 = w3 - w2
w = w4 * w5

print(w2.coefficients)

Test jednostkowy dla klasy Polynomial

Jedną z głównych zalet obiektowego podejścia do programowania jest zamknięcie fragmentu kodu w obiekcie jako w autonomicznej całości (patrz enkapsulacja). Każdy obiekt należy jednak dokładnie przetestować. Przedstawiony poniżej plik TestPolynomial.py sprawdza działanie publicznych metod, które powinieneś zaimplementować w klasie Polynomial:

A unit test for Polynomial class

import unittest

from Polynomial import Polynomial


class TestPolynomial(unittest.TestCase):

    def setUp(self):
        self.w1 = Polynomial([1, 2, 3, 5])      # 1*x^3 + 2*x^2 + 3*x + 5
        self.w2 = Polynomial(5, 2, 1)           #         5*x^2 + 2*x + 1
        self.w3 = Polynomial(self.w1)

    def test_coefficients(self):
        self.assertEqual([5, 3, 2, 1], self.w1.coefficients)
        self.assertEqual([1, 2, 5], self.w2.coefficients)
        self.assertEqual([5, 3, 2, 1], self.w3.coefficients)
        c = self.w3.coefficients
        c.append(7)
        self.assertEqual([5, 3, 2, 1], self.w3.coefficients)

    def test_init(self):
        args = [1, 2, 3, 5]
        w = Polynomial(args)
        args.append(7)
        self.assertEqual([5, 3, 2, 1], w.coefficients)

    def test_str(self):
        self.assertEqual("1*x^3 + 2*x^2 + 3*x + 5", str(self.w1))
        self.assertEqual("5*x^2 + 2*x + 1", str(self.w2))

    def test_add(self):
        w3 = self.w2 + self.w1
        self.assertEqual([6, 5, 7, 1], w3.coefficients)
        w3 = self.w1 + self.w2
        self.assertEqual([6, 5, 7, 1], w3.coefficients)

    def test_iadd(self):
        w = Polynomial(self.w1)
        c2 = self.w2.coefficients
        w += self.w2
        self.assertEqual([6, 5, 7, 1], w.coefficients)
        w3 = self.w1 + self.w2
        self.assertEqual(self.w2.coefficients, c2)

    def test_sub(self):
        w4 = Polynomial(self.w1)
        w3 = self.w2 - self.w1
        self.assertEqual(w4.coefficients, self.w1.coefficients)     # operation should not affect operands
        self.assertEqual([-4, -1, 3, -1], w3.coefficients)
        w4 = self.w1 - self.w2
        self.assertEqual([4, 1, -3, 1], w4.coefficients)

    def test_mul(self):
        w4 = Polynomial(self.w1)
        w3 = self.w2 * self.w1
        self.assertEqual([5, 13, 33, 20, 12, 5], w3.coefficients)
        self.assertEqual(w4.coefficients, self.w1.coefficients)     # operation should not affect operands

    def test_int_math(self):
        w3 = self.w2 * 2
        self.assertEqual([2, 4, 10], w3.coefficients)

if __name__ == '__main__':
        unittest.main()

W szczególności test ten sprawdza integralność klasy. Na przykład metoda test_init(self) tworzy wielomian dla podanej listy współczynników, a następnie modyfikuje tą listę i sprawdza, czy wielomian nie uległ zmianie.

Wielomany Czebyszewa

Wieloman Czebyszewa k-tego rzędu \(T_k(x)\) zdefiniowany jest rekurencyjnie jak nastepuje:

\(\begin{matrix} T_0(x) & = & 1\\ T_1(x) & = & x\\ T_k(x) & = & 2x T_{k-1}(x) - T_{k-2}(x)\\ \end{matrix}\)

Wydrukuj na ekranie wielomian \(T_{128}(x)\). W tym celu:

funkcja chebyshev(k)

Napisz funkcję chebyshev(k), która zwraca listę współczynników wielomanu Czebyszewa k-tego rzędu.

Klasa Chebyshev

Zawrzyj funkcję chebyshev(k) w klasie Chebyshev jako jej statyczną składową. Klasa powinna dziedziczyć po klasie Polynomial. Ponieważ konstruktor klasy Polynomial wymaga podania współczynników tworzonego wielomianu, wykorzystaj tu napisaną uprzednio statyczną metodę.

Poniżej podaję test jednostkowy dla klasy Chebyshev:

(rozwiń kod testu jednostkowego dla klasy Chebyshev)

import unittest

from Chebyshev import Chebyshev


class TestChebyshev(unittest.TestCase):

    def test_Chebyshev(self):
        c = Chebyshev(6)
        self.assertEqual([-1, 0, 18, 0, -48, 0, 32], c.coefficients)

if __name__ == '__main__':
        unittest.main()

Klasa Fractional

Stwórz klasę Fractional, która będzie reprezentować iloraz wyrażeń.

Konstruktor klasy

Klasa powinna mieć następujący konstruktor:

f = Fractional(1,5)      # Tworzy ulamek 1/5

Dane prywatne

Iloraz powinien przechowywać licznik oraz mianownik jako prywatne pola.

Publiczne pola

Zdefiniuj getter dla licznika i mianownika, nazwij je num i den

Wypisywanie na ekran

Napisz metodę __str__(), która odpowiednio wydrukuje ułamek na ekranie. Wykorzystaj w tym celu funkcję str() dla licznika i mianownika

Operatory

Klasa Fractional powinna udostępniać następujące operatory: +, - oraz *. Przy sprowadzaniu wyrażeń do wspólnego mianownika również korzystaj z operacji + oraz *, operujących odpowiednio na liczniku i mianowniku.

Na tym etapie Twoja klasa powinna umożliwić poprawne działanie następującego programu:

f1 = Fractional(2, 5)
f2 = Fractional(1,3)
print(f3)                     # Drukuje na ekran: 2/15
f3 = f1 * f2
f3 += f1
f4 = f3 - f2

Funkcje wymierne

Funkcja wymierna to nic więcej jak ułamek (Fractional) w którym zarówno licznik i mianownik to wielomiany (obiekty klasy Polynomial). Poniższy kod powinien działać poprawnie:

w1 = Polynomial(1, 2, 5)
w2 = Polynomial(1,3)
f1 = Fractional(w1, w2)
f2 = Fractional(w2, w1)
print(f1 + f2)