DomoweSeria4.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "source": [
    "# Zadania domowe - Seria 4"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "(2.5pkt) Uzupełnij klasę liczb zespolonych omawianą na zajęciach o następujące operacje\n",
    "* porównywanie liczb zespolonych (operatory `==` i `!=`)\n",
    "* odejmowanie liczby całkowitej/rzeczywistej od liczby zespolonej\n",
    "* odejmowanie liczby zespolonej od liczby całkowitej/rzeczywistej \n",
    "* negacja liczby zespolonej +\n",
    "* mnożenie liczb zespolonych\n",
    "* mnożenie liczby zespolonej i liczby całkowitej/rzeczywistej (lewo- i prawostronnie)\n",
    "* dzielenie liczb zespolonych (jeżeli dzielimy przez 0 powinno zostać zwróceone `None`)\n",
    "* dzielenie liczby zespolonej przez liczbę całkowitą/rzeczywistą\n",
    "* dzielenie liczby całkowitej/rzeczywistej przez liczbę zespoloną\n",
    "* obliczanie modułu liczby zespolonej +\n",
    "* obliczanie argumentu liczby zespolonej\n",
    "* wypisywanie liczby zespolonej w postaci wykładniczej, np.: liczbę $3+j4$ należy wypisać jako `5exp(j0.9272)`\n",
    "\n",
    "W większości przypadków należy przeładować odpowiednie operatory.\n",
    "Wyniki operacji umieszczamy w nowych obiektach klasy `Cmplx`.\n",
    "\n",
    "Nastepnie należy przetestować i przedstawić działanie klasy i jej metod\n",
    "dla liczb zespolonych o współczynnikach wylosowanych z przedziału $(-10,10)$.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8-j0.6\n",
      "0.8+j0.6\n",
      "4.47213595499958\n",
      "0.4636476090008061\n",
      "4.47213595499958exp(+j0.4636476090008061)\n",
      "6+j6\n",
      "7+j2\n",
      "4+j2\n",
      "-4-j2\n",
      "4-j2\n",
      "True\n",
      "16+j20\n",
      "16+j20\n",
      "4+j8\n"
     ]
    }
   ],
   "source": [
    "from math import sqrt, pi, atan\n",
    "from random import randint\n",
    "\n",
    "\n",
    "class Cmplx:\n",
    "\n",
    "    def __init__(self, re, im):\n",
    "        self._im = im\n",
    "        self._re = re\n",
    "\n",
    "    def __str__(self):\n",
    "        if self._im>=0:\n",
    "            return str(self._re)+\"+j\"+str(self._im)\n",
    "        else:\n",
    "            return str(self._re)+\"-j\"+str(-self._im)\n",
    "\n",
    "    def module(self):\n",
    "        return sqrt(self._im**2+self._re**2)\n",
    "    \n",
    "    def argument(self):\n",
    "        if self._re == 0 and self._im == 0:\n",
    "            return None\n",
    "        if self._re == 0:\n",
    "            if self._im >= 0:\n",
    "                return -pi/2\n",
    "            else:\n",
    "                return pi/2\n",
    "        return atan(self._im/self._re)\n",
    "\n",
    "    def exp_form(self):\n",
    "        if self._im >= 0:\n",
    "            return str(self.module()) + \"exp(+j\" +str(self.argument())+\")\"\n",
    "        if self._im < 0:\n",
    "            return str(self.module()) + \"exp(-j\" +str(-self.argument())+\")\"\n",
    "    \n",
    "    \n",
    "    \n",
    "    @property\n",
    "    def re(self):\n",
    "        return self._re\n",
    "\n",
    "    @property\n",
    "    def im(self):\n",
    "        return self._im\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if type(other)==Cmplx:\n",
    "            return Cmplx(self.re+other.re, self.im+other.im)\n",
    "        else:\n",
    "            return Cmplx(self.re+other,self.im)\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if type(other)==Cmplx:\n",
    "            return Cmplx(self.re+other.re, self.im+other.im)\n",
    "        else:\n",
    "            return Cmplx(self.re+other,self.im)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if type(other)==Cmplx:\n",
    "            return Cmplx(self.re-other.re, self.im-other.im)\n",
    "        else:\n",
    "            return Cmplx(self.re-other, self.im)\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        if type(other)==Cmplx:\n",
    "            return Cmplx(other.re-self.re, other.im-self.im)\n",
    "        else:\n",
    "            return Cmplx(other - self.re, -self.im)\n",
    "\n",
    "    def __invert__(self):\n",
    "        return Cmplx(self.re, -self.im)\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if (type(other) == Cmplx) and (self.re == other.re) and (self.im == other.im):\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        if (type(other) == Cmplx) and (self.re == other.re) and (self.im == other.im):\n",
    "            return False\n",
    "        else:\n",
    "            return True\n",
    "\n",
    "    def __neg__(self):\n",
    "        return Cmplx(-self.re, -self.im)\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if type(other) == Cmplx:\n",
    "            return Cmplx(self.re * other.re + self.im * other.im, self.re * other.im + self.im * other.re)\n",
    "        else:\n",
    "            return Cmplx(self.re * other, self.im * other)\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        if type(other) == Cmplx:\n",
    "            return Cmplx(self.re * other.re + self.im * other.im, self.re * other.im + self.im * other.re)\n",
    "        else:\n",
    "            return Cmplx(self.re * other, self.im * other)\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        if type(other) == Cmplx:\n",
    "            if (other.re**2 + other.im**2) != 0:\n",
    "                return Cmplx( (self.re*other.re + self.im*other.im)/(other.re**2 + other.im**2), (other.re *self.im - self.re*other.im) / (other.re**2 + other.im**2))\n",
    "            else:\n",
    "                return None\n",
    "        else:\n",
    "            return Cmplx(self.re/other,self.im/other)\n",
    "\n",
    "    def __rtruediv__(self, other):\n",
    "        if type(other) == Cmplx:\n",
    "            if (other.re**2 + other.im**2) != 0:\n",
    "                return Cmplx( (self.re*other.re + self.im*other.im)/(other.re**2 + other.im**2), (other.re *self.im - self.re*other.im) / (other.re**2 + other.im**2))\n",
    "            else:\n",
    "                return None\n",
    "        else:\n",
    "            return Cmplx( (other * self.re) / (other**2 + self.im**2), (other*self.im /(other**2 + self.im**2) ))\n",
    "\n",
    "a_numb = randint(-10,10)\n",
    "b_numb = randint(-10,10)\n",
    "print( \"\")\n",
    "a = Cmplx(a_numb,b_numb)\n",
    "b = Cmplx(b_numb,a_numb)\n",
    "print(  a / b )\n",
    "print( b / a )\n",
    "print(a.module())\n",
    "print(a.argument())\n",
    "print(a.exp_form())\n",
    "print(a + b)\n",
    "print(a + 3)\n",
    "print(a)\n",
    "print(-a)\n",
    "print(~a)\n",
    "print(a==a)\n",
    "print(a*b)\n",
    "print(b*a)\n",
    "print(b*2)\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-12T21:34:47.051868100Z",
     "start_time": "2024-04-12T21:34:47.031851400Z"
    }
   }
  },
  {
   "cell_type": "markdown",
   "source": [
    "(2.5pkt) Zaimplementuj klasę `Poly` reprezentującą wielomian.\n",
    "Klasa powinna przechowywać współczynniki wielomianu i umożliwiać nastepujące operacje\n",
    "* tworzenie nowego wielomianu na podstawie listy współczynników\n",
    "* wypisywanie wielomianu w ładnej formie np: `2x^3+5x^2-3`\n",
    "* porównywanie wielomianów (operatory `==` i `!=`)\n",
    "* operacje arytmetyczne na wielomianach: dodawanie, odejmowanie, mnożenie, negacja\n",
    "* mnożenie wielomianu przez liczbę (lewo- i prawostonne)\n",
    "* obliczanie stopnia wielomianu\n",
    "\n",
    "Dodatkowo zaimplementować funkcjonalność obliczania wartości wielomianu dla konktretnej liczby.\n",
    "Wykorzystać do tego metodę specjalną `__call__()`, która umożliwia \"wywoływanie obiektu\" tak jak gdyby był funkcją np.:\n",
    "\n",
    "`a = Poly([1,2,3])`\n",
    "`a(5)`\n",
    "\n",
    "W większości przypadków należy przeładować odpowiednie operatory.\n",
    "Wyniki operacji umieszczamy w nowych obiektach klasy `Poly`\n",
    "\n",
    "Nastepnie należy przetestować i przedstawić działanie klasy i jej metod\n",
    "dla wielomianów o stopniach z przedziału $(0,10)$ i współczynnikach wylosowanych z przedziału $(-10,10)$.\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%% md\n"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "outputs": [],
   "source": [
    "class Polly:\n",
    "\n",
    "    def __init__(self, factors: list):\n",
    "        if factors[0] == 0:\n",
    "            cut_list = 1\n",
    "            for i in range(1,len(factors)):\n",
    "                if factors[i] != 0:\n",
    "                    break\n",
    "                else:\n",
    "                    cut_list+=1\n",
    "            factors = factors[cut_list:]\n",
    "        self._factors = factors\n",
    "\n",
    "    @property\n",
    "    def factors(self):\n",
    "        return self._factors\n",
    "\n",
    "    def degree(self):\n",
    "        for x in self._factors:\n",
    "            if x != 0:\n",
    "                return x\n",
    "        return 0\n",
    "\n",
    "    def print_polly(self):\n",
    "        print(str(self))\n",
    "\n",
    "\n",
    "\n",
    "    def __str__(self):\n",
    "        if(len(self._factors) > 1):\n",
    "            polly_str = str(self._factors[0]) + \"^\" + str(len(self._factors) - 1)\n",
    "        else:\n",
    "            if len(self._factors) > 1:\n",
    "                return str(self._factors[0])\n",
    "            else:\n",
    "                return \"0\"\n",
    "        if len(self._factors) >= 1:\n",
    "            for x in range(1,len(self._factors)-1):\n",
    "                if(self._factors[x] > 0):\n",
    "                    polly_str = polly_str +\"+\"+ str(self._factors[x]) + \"^\" + str(len(self._factors) - x - 1)\n",
    "                if(self._factors[x] < 0):\n",
    "                    polly_str = polly_str + str(self._factors[x]) + \"^\" +str(len(self._factors) - x - 1)\n",
    "\n",
    "            last_elem = self._factors[len(self._factors)-1]\n",
    "            if last_elem > 0:\n",
    "                polly_str += \"+\"+str(last_elem)\n",
    "            if last_elem < 0:\n",
    "                polly_str += str(last_elem)\n",
    "            return polly_str\n",
    "\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if type(other) == Polly and (len(self._factors) == len(other._factors)):\n",
    "            for x in range(0, len(self._factors)):\n",
    "                if self._factors[x] != other._factors[x]:\n",
    "                    return False\n",
    "            return True\n",
    "        else:\n",
    "            return False\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        eq_counts = 0\n",
    "        if type(other) == Polly and (len(self._factors) == len(other._factors)):\n",
    "            for x in range(0, len(self._factors)):\n",
    "                if self._factors[x] == other._factors[x]:\n",
    "                    eq_counts = eq_counts+1\n",
    "            if eq_counts == len(self._factors):\n",
    "                return False\n",
    "            return True\n",
    "        else:\n",
    "            return True\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if type(other) == Polly:\n",
    "            self._factors.reverse()\n",
    "            other._factors.reverse()\n",
    "            new_polly = [x + y for x,y in zip(self._factors, other._factors)]\n",
    "            if len(self._factors) > len(other._factors):\n",
    "                new_polly = new_polly + self._factors[len(other._factors):]\n",
    "            if len(other._factors) > len(self._factors):\n",
    "                new_polly = new_polly + other._factors[len(self._factors):]\n",
    "            new_polly.reverse()\n",
    "            return Polly(new_polly)\n",
    "        else:\n",
    "            self._factors[len(self._factors) - 1] += other\n",
    "            return Polly(self._factors)\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if type(other) == Polly:\n",
    "            new_polly = [x + y for x,y in zip(self._factors, other._factors)]\n",
    "            if len(self._factors) > len(other._factors):\n",
    "                new_polly = new_polly + self._factors[len(other._factors):]\n",
    "            if len(other._factors) > len(self._factors):\n",
    "                new_polly = new_polly + other._factors[len(self._factors):]\n",
    "            return Polly(new_polly)\n",
    "        else:\n",
    "            self._factors[len(self._factors) - 1] += other\n",
    "            return Polly(self._factors)\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if type(other) == Polly:\n",
    "            new_other = list(map(lambda x: -x, other._factors))\n",
    "            new_polly = [x + y for x,y in zip(self._factors, new_other)]\n",
    "            if len(self._factors) > len(new_other):\n",
    "                new_polly = new_polly + self._factors[len(new_other):]\n",
    "            if len(new_other) > len(self._factors):\n",
    "                new_polly = new_polly + new_other[len(self._factors):]\n",
    "            return Polly(new_polly)\n",
    "        else:\n",
    "            self._factors[len(self._factors) - 1] -= other\n",
    "            return Polly(self._factors)\n",
    "\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        self._factors = list(map(lambda x: -x,self.factors))\n",
    "        if type(other) == Polly:\n",
    "            new_polly = [x + y for x,y in zip(self._factors, other._factors)]\n",
    "            if len(self._factors) > len(other._factors):\n",
    "                new_polly = new_polly + self._factors[len(other._factors):]\n",
    "            if len(other._factors) > len(self._factors):\n",
    "                new_polly = new_polly + other._factors[len(self._factors):]\n",
    "            return Polly(new_polly)\n",
    "        else:\n",
    "            self._factors[len(self._factors) - 1] += other\n",
    "            return Polly(self._factors)\n",
    "\n",
    "    def __neg__(self):\n",
    "        return Polly(list(map(lambda x: -x,self._factors)))\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if type(other) == Polly:\n",
    "            polly_size = len(self._factors) + len(other._factors)\n",
    "            multiplicated_polly = list([0 for _ in range(0,polly_size*2)])\n",
    "            self._factors.reverse()\n",
    "            other._factors.reverse()\n",
    "            for x1 in range(0, len(self._factors)):\n",
    "                for x2 in range(0, len(other._factors)):\n",
    "                    multiplicated_polly[x1+x2] = self._factors[x1] * other._factors[x2]\n",
    "            multiplicated_polly.reverse()\n",
    "            return Polly(multiplicated_polly)\n",
    "        else:\n",
    "            return Polly(list(map(lambda x: x * other, self._factors)))\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        if type(other) == Polly:\n",
    "            polly_size = len(self._factors) + len(other._factors)\n",
    "            multiplicated_polly = list([0 for _ in range(0,polly_size*2)])\n",
    "            self._factors.reverse()\n",
    "            other._factors.reverse()\n",
    "            for x1 in range(0, len(self._factors)):\n",
    "                for x2 in range(0, len(other._factors)):\n",
    "                    multiplicated_polly[x1+x2] = self._factors[x1] * other._factors[x2]\n",
    "            multiplicated_polly.reverse()\n",
    "            return Polly(multiplicated_polly)\n",
    "        else:\n",
    "            return Polly(list(map(lambda x: x * other, self._factors)))\n",
    "\n",
    "    def __call__(self, *args, **kwargs):\n",
    "        factors = self._factors[::-1]\n",
    "        sum = 0\n",
    "        for x in range(0,len(factors)):\n",
    "            sum += factors[x]*(args[0]**(x+1))\n",
    "        return sum\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "pycharm": {
     "name": "#%%\n"
    },
    "ExecuteTime": {
     "end_time": "2024-04-12T23:13:27.940882900Z",
     "start_time": "2024-04-12T23:13:27.872847100Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Polly a ---> -10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4\n",
      "Polly b ---> -3^7+4^6+8^5+7^4+3^3+5^2-1^1-5\n",
      "value of Polly(a) -10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4\n",
      "a(1)----> 28\n",
      "a(2)----> -6136\n",
      "multiply---------| -10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4 * -3^7+4^6+8^5+7^4+3^3+5^2-1^1-5\n",
      "30^16-40^15-80^14-70^13-30^12-50^11+10^10+50^9-25^8-20^7-15^6+20^5-35^4-25^3-30^2-40^1-20\n",
      "-20^16-40^15-30^14-25^13-35^12+20^11-15^10-20^9-25^8+50^7+10^6-50^5-30^4-70^3-80^2-40^1+30\n",
      "multiply---------| -10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4 * 5\n",
      "-50^9+25^8+20^7+15^6-20^5+35^4+25^3+30^2+40^1+20\n",
      "-50^9+25^8+20^7+15^6-20^5+35^4+25^3+30^2+40^1+20\n",
      "print------------|\n",
      "-10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4\n",
      "-10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4\n",
      "add--------------| -10^9+5^8+4^7+3^6-4^5+7^4+5^3+6^2+8^1+4 + -3^7+4^6+8^5+7^4+3^3+5^2-1^1-5\n",
      "-10^9+5^8+1^7+7^6+4^5+14^4+8^3+11^2+7^1-1\n",
      "add--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 + 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10\n",
      "-20^9+10^8+8^7+6^6-8^5+14^4+10^3+12^2+16^1+8\n",
      "sub--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 - -5^7-1^6+5^5+3^4+7^3+8^2+4^1-3\n",
      "9^9+9^8+1^7+2^6-12^4-1^3+7^2+5^1-10\n",
      "sub--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 - 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10\n",
      "0\n",
      "neg--------------| - 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10\n",
      "-4^9-8^8-6^7-5^6-7^5+4^4-3^3-4^2-5^1+10\n",
      "eq--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 == 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10\n",
      "True\n",
      "neq--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 != 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10\n",
      "False\n",
      "neq--------------| 4^9+8^8+6^7+5^6+7^5-4^4+3^3+4^2+5^1-10 != -5^7-1^6+5^5+3^4+7^3+8^2+4^1-3\n",
      "True\n"
     ]
    }
   ],
   "source": [
    "from random import randint\n",
    "\n",
    "size_a = randint(1,11)\n",
    "size_b = randint(1,11)\n",
    "factors_a = [ randint(-10,10) for _ in range(0,size_a)]\n",
    "factors_b = [ randint(-10,10) for _ in range(0,size_b)]\n",
    "a = Polly(factors_a)\n",
    "b = Polly(factors_b)\n",
    "\n",
    "print(\"Polly a --->\",a)\n",
    "print(\"Polly b --->\",b)\n",
    "print(\"value of Polly(a)\",a)\n",
    "print(\"a(1)---->\",a(1))\n",
    "print(\"a(2)---->\",a(2))\n",
    "print(\"multiply---------|\", a , \"*\", b)\n",
    "print(a*b)\n",
    "print(b*a)\n",
    "print(\"multiply---------|\", a , \"*\", 5)\n",
    "print(a*5)\n",
    "print(5*a)\n",
    "print(\"print------------|\")\n",
    "a.print_polly()\n",
    "print(str(a))\n",
    "print(\"add--------------|\",a,\"+\",b)\n",
    "print(a + b)\n",
    "print(\"add--------------|\",a,\"+\",a)\n",
    "print(a + a)\n",
    "print(\"sub--------------|\",a,\"-\",b)\n",
    "print(a - b)\n",
    "print(\"sub--------------|\",a,\"-\",a)\n",
    "print(a - a)\n",
    "print(\"neg--------------|\",\"-\",a)\n",
    "print(-a)\n",
    "print(\"eq--------------|\",a,\"==\",a)\n",
    "print(a==a)\n",
    "print(\"neq--------------|\",a,\"!=\",a)\n",
    "print(a!=a)\n",
    "print(\"neq--------------|\",a,\"!=\",b)\n",
    "print(a!=b)\n",
    "\n",
    "\n",
    "\n"
   ],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "end_time": "2024-04-12T23:13:33.538750100Z",
     "start_time": "2024-04-12T23:13:33.526401700Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false,
    "ExecuteTime": {
     "start_time": "2024-04-12T23:12:21.846830Z"
    }
   }
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "outputs": [],
   "source": [],
   "metadata": {
    "collapsed": false
   }
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}