exe2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.1\n",
    "'''\n",
    "Medical imaging, self-driving vehicles, vital signs monitoring\n",
    "'''"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.4\n",
    "class Flower:\n",
    "    def __init__(self, name: str, petals: int, price: float):\n",
    "        self._name = self._petals = self._price = None\n",
    "\n",
    "        self.setname(name)\n",
    "        self.setpetals(petals)\n",
    "        self.setprice(price)\n",
    "\n",
    "    def setname(self, name: str):\n",
    "        try:\n",
    "            assert type(name) == str, f\"name has to be string, not {type(name)}\"\n",
    "            self._name = name\n",
    "        except Exception as err:\n",
    "            print(err)\n",
    "    \n",
    "    def setprice(self, price: float):\n",
    "        try:\n",
    "            assert type(price) == float or type(price) == int, f\"price has to be float or int, not {type(price)}\"\n",
    "            self._price = price\n",
    "        except Exception as err:\n",
    "            print(err)\n",
    "\n",
    "    def setpetals(self, petals: int):\n",
    "        try:\n",
    "            assert type(petals) == int, f\"petals has to be int, not {type(petals)}\"\n",
    "            self._petals = petals\n",
    "        except Exception as err:\n",
    "            print(err)\n",
    "\n",
    "    def getname(self):\n",
    "        print(\"Flower's name has not been set.\") if self._name is None else print(f'the flower is {self._name}')\n",
    "    \n",
    "    def getpetals(self):\n",
    "        print(\"Number of petals has not been set\") if self._petals is None else print(f'{self._name} has {self._petals} petals')\n",
    "    \n",
    "    def getprice(self):\n",
    "        print(\"The price has not been set.\") if self._price is None else print(f'{self._name} is RM{self._price}')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rose = Flower('rose',20,15)\n",
    "tulip = Flower('yellow tulip', 10, 50)\n",
    "rose.getprice()\n",
    "rose.getpetals()\n",
    "rose.setprice(20.50)\n",
    "rose.getprice()\n",
    "rose.setname('red rose')\n",
    "rose.getprice()\n",
    "tulip.getprice()\n",
    "tulip.setname('pink tulip')\n",
    "tulip.getprice()\n",
    "rose.setpetals(15.5)\n",
    "rose.getpetals()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.5 & 2.6 & 2.7\n",
    "import numbers\n",
    "\n",
    "class CreditCard:\n",
    "    \"\"\"A consumer credit card\"\"\"\n",
    "\n",
    "    def __init__(self, customer, bank, acnt, limit):\n",
    "        self._customer = customer\n",
    "        self._bank = bank\n",
    "        self._acnt = acnt\n",
    "        self._limit = limit\n",
    "        self._balance = 0\n",
    "    \n",
    "    def _get_customer(self):\n",
    "        return self._customer\n",
    "    \n",
    "    def _get_bank(self):\n",
    "        return self._bank\n",
    "\n",
    "    def _get_account(self):\n",
    "        return self._acnt\n",
    "    \n",
    "    def _get_limit(self):\n",
    "        return self._limit\n",
    "    \n",
    "    def _get_balance(self):\n",
    "        return self._balance\n",
    "    \n",
    "    def charge(self, price):\n",
    "        assert price != None and (type(price) == float or type(price) == int), f'price has to be in numerical int or float, not {type(price)}'\n",
    "        if price + self._balance > self._limit:\n",
    "            return False\n",
    "        else: \n",
    "            self._balance += price \n",
    "            return True\n",
    "\n",
    "    def make_payment(self, amount):\n",
    "        try:\n",
    "            assert isinstance(amount, numbers.Number)\n",
    "        except AssertionError:\n",
    "            print('amount must be a number, int or float')\n",
    "            return\n",
    "        if amount<=0:\n",
    "            raise ValueError(\"Amount must be positive number.\")\n",
    "        self._balance -= amount\n",
    "\n",
    "\n",
    "class CreditCardWithBalance(CreditCard):\n",
    "    def __init__(self, customer, bank, acnt, limit, balance=0):\n",
    "        super().__init__(customer,bank,acnt,limit)\n",
    "        self._balance = balance\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "johncredit = CreditCard(customer='John Doe', bank='CIMB', acnt='5110035495607789', limit=1000)\n",
    "print(johncredit._get_balance())\n",
    "johncredit.charge(100)\n",
    "print(johncredit._get_balance())\n",
    "johncredit.make_payment(100)\n",
    "print(johncredit._get_balance())\n",
    "# johncredit.make_payment(-100)\n",
    "\n",
    "johncreditbalance = CreditCardWithBalance('John Doe', 'CIMB', '5110035495607789', 1000, 50)\n",
    "print(johncreditbalance._get_balance())\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.9, 2.10, 2.11, 2.12, 2.13, 2.14, 2.15\n",
    "class Vector:\n",
    "    \"\"\"Represent a vector in a multidimensional space.\"\"\"\n",
    "    \n",
    "    def __init__(self, dim_or_n):\n",
    "        \"\"\"create d-dimensional vector of zeros.\"\"\"\n",
    "        if isinstance(dim_or_n, int):\n",
    "            self._data = [0]*dim_or_n\n",
    "        elif isinstance(dim_or_n, list):\n",
    "            self._data = dim_or_n\n",
    "        else:\n",
    "            raise ValueError('Input must be dimension in int or list')\n",
    "    \n",
    "    def __len__(self):\n",
    "        \"\"\"return the dimension of the vector\"\"\"\n",
    "        return len(self._data)\n",
    "    \n",
    "    def __getitem__(self, j):\n",
    "        \"\"\"return jth coordinate of vector\"\"\"\n",
    "        return self._data[j]\n",
    "    \n",
    "    def __setitem__(self, j, val):\n",
    "        \"\"\"set jth coordinate of vector to given value.\"\"\"\n",
    "        self._data[j] = val\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        \"\"\"return true if vector has same coordinate as other\"\"\"\n",
    "        return self._data == other._data\n",
    "\n",
    "    def __ne__(self, other):\n",
    "        \"\"\"return true if vector differs from other\"\"\"\n",
    "        return not self == other\n",
    "    \n",
    "    def __str__(self):\n",
    "        \"\"\"produce string representation of vector\"\"\"\n",
    "        return '<' + str(self._data)[1:-1] + '>'\n",
    "    \n",
    "    def __add__(self, other):\n",
    "        \"\"\"return sum of two vectors.\"\"\"\n",
    "        if len(self) != len(other):\n",
    "            raise ValueError('dimensions must agree')\n",
    "        result = Vector(len(self))\n",
    "        for j in range(len(self)):\n",
    "            result[j]=self[j]+other[j]\n",
    "        return result\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        \"\"\"return sum of two vectors.\"\"\"\n",
    "        if len(self) != len(other):\n",
    "            raise ValueError('dimensions must agree')\n",
    "        result = Vector(len(self))\n",
    "        for j in range(len(self)):\n",
    "            result[j]=other[j]+self[j]\n",
    "        return result\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        \"\"\"return subtration of two vectors\"\"\"\n",
    "        if len(self) != len(other):\n",
    "            raise ValueError('dimensions must agree')\n",
    "        result = Vector(len(self))\n",
    "        for j in range(len(self)):\n",
    "            result[j]=self[j]-other[j]\n",
    "        return result\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        \"\"\"return subtration of two vectors\"\"\"\n",
    "        if len(self) != len(other):\n",
    "            raise ValueError('dimensions must agree')\n",
    "        result = Vector(len(self))\n",
    "        for j in range(len(self)):\n",
    "            result[j]=other[j]-self[j]\n",
    "        return result\n",
    "    \n",
    "    def __mul__(self, factor):\n",
    "        \"\"\"return multiplication product\"\"\"\n",
    "        if isinstance(factor, Vector):\n",
    "            result=0\n",
    "            for j in range(len(self)):\n",
    "                result+=self[j]*factor[j]\n",
    "        else:\n",
    "            result = Vector(len(self))\n",
    "            for j in range(len(self)):\n",
    "                result[j]=self[j]*factor\n",
    "        return result\n",
    "\n",
    "    def __rmul__(self, factor):\n",
    "        \"\"\"return multiplication product\"\"\"\n",
    "        if isinstance(factor, Vector):\n",
    "            result=0\n",
    "            for j in range(len(self)):\n",
    "                result+=factor[j]*self[j]\n",
    "        else:\n",
    "            result = Vector(len(self))\n",
    "            for j in range(len(self)):\n",
    "                result[j]=factor*self[j]\n",
    "        return result\n",
    "\n",
    "    def __neg__(self):\n",
    "        \"\"\"return negated vectors\"\"\"\n",
    "        result = Vector(len(self))\n",
    "        for j in range(len(self)):\n",
    "            result[j]*=-1\n",
    "        return result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector(5)\n",
    "print(f'{len(v)}, {v}')\n",
    "v[3]=5\n",
    "print(f'{v[3]}, {v}')\n",
    "u = Vector([2,2,2,2,2])\n",
    "v_add, v_sub = v+u, v-u\n",
    "print(f\"{v_add},{v_sub}\")\n",
    "v_radd, v_rsub = u+v, u-v\n",
    "print(f\"{v_radd}, {v_rsub}\")\n",
    "v_mul, v_rmul = v*u, u*v\n",
    "print(f\"{v_mul}, {v_rmul}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.16\n",
    "\"max(0, (stop-start+step-1)//step)\"\n",
    "\"stop-start-1, is to prevent adding extra number to the iterator\"\n",
    "\"stop-start-1+step, is to add the extra n step to the last ith of iterator\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.18\n",
    "class Progression:\n",
    "    \"\"\"iterator producing a generic progression.\"\"\"\n",
    "    def __init__(self, start=0):\n",
    "        \"\"\"initialize current to the first value of the progression.\"\"\"\n",
    "        self._current=start\n",
    "    \n",
    "    def _advance(self):\n",
    "        \"\"\"update self._current to a new value.\n",
    "        should be override by a subclass to customize progression.\"\"\"\n",
    "        self._current+=1\n",
    "\n",
    "    def __next__(self):\n",
    "        \"\"\"return the next element, or raise StopIteration error.\"\"\"\n",
    "        if self._current is None:\n",
    "            raise StopIteration()\n",
    "        else:\n",
    "            answer = self._current\n",
    "            self._advance()\n",
    "            return answer\n",
    "    \n",
    "    def __iter__(self):\n",
    "        \"\"\"an iterator must return itself as an iterator\"\"\"\n",
    "        return self\n",
    "\n",
    "    def print_progression(self,n):\n",
    "        \"\"\"print next n values of the progression\"\"\"\n",
    "        print(\" \".join(str(next(self)) for j in range (n)))\n",
    "\n",
    "class FibonacciProgression(Progression):\n",
    "    \"\"\"iterator producing a generalized FIbonacci progression\"\"\"\n",
    "    def __init__(self, first=0, second=1):\n",
    "        super().__init__(first)\n",
    "        self._prev = second-first\n",
    "\n",
    "    def _advance(self):\n",
    "        self._prev, self._current = self._current, self._prev + self._current\n",
    "\n",
    "class ArithmeticProgression(Progression):\n",
    "    def __init__(self, increment=1, start=0):\n",
    "        super().__init__(start=start)\n",
    "        self._increment=increment\n",
    "    \n",
    "    def _advance(self):\n",
    "        self._current += self._increment"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fb = FibonacciProgression(first=2, second=2)\n",
    "fb.print_progression(8)\n",
    "ap = ArithmeticProgression(increment=128, start=0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.19, using the formula mentioned in R-2.16\n",
    "stop = 2**63\n",
    "start=0\n",
    "step=128\n",
    "num = max(0, ((stop-start+step-1)//step))\n",
    "print(num)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.20, 2.21\n",
    "\"\"\"\n",
    "1. the nonpublic instances from class A cannot be inherited in methods interited from other classes such as class B.\n",
    "2. methods or instances might be overwritten and harder to troubleshoot.\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.22, 2.23\n",
    "class Sequence:\n",
    "\n",
    "    def __init__(self, sequence):\n",
    "        self._seq = sequence\n",
    "        self._k = -1\n",
    "    \n",
    "    def __len__(self):\n",
    "        return len(self._seq)\n",
    "    \n",
    "    def __getitem__(self,k):\n",
    "        return self._seq[k]\n",
    "\n",
    "    def __lt__(self, i,j):\n",
    "        return i<j\n",
    "\n",
    "    def __next__(self):\n",
    "        self._k +=1\n",
    "        if self._k < len(self._seq):\n",
    "            return(self._seq[self._k])\n",
    "        else:\n",
    "            raise StopIteration()\n",
    "\n",
    "    def __iter__(self):\n",
    "        return self\n",
    "    \n",
    "    def __eq__(self, other):\n",
    "        # print(len(self._seq),len(other))\n",
    "        assert len(self._seq)==len(other), f'Dimension of both sequences has to be same'\n",
    "        for i in range(len(self._seq)):\n",
    "            if self._seq[i] == other[i]:\n",
    "                print(\"True\")\n",
    "            else: print(False)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seq1 = Sequence([5,1,2,3,6,7,3])\n",
    "next(seq1)\n",
    "seq2 = Sequence([5,1,4,3,6,7,3])\n",
    "seq3 = Sequence([5,1,2,3,6,7,3])\n",
    "seq1 == seq2\n",
    "seq1 == seq3\n",
    "print(f\"lt check: {seq1[3]>seq1[1]}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.24\n",
    "\"\"\"\n",
    "class booklist:\n",
    "    \"subclass: purchased list, new book list, latest released list etc.\"\n",
    "    def __init__(userid, list_type, bookid):\n",
    "        pass\n",
    "\n",
    "    def obtainlist(list_type):\n",
    "        pass\n",
    "\n",
    "    def updatelist(list_type, bookid):\n",
    "        pass\n",
    "\n",
    "class user:\n",
    "    def __init__(user, password):\n",
    "        pass\n",
    "\n",
    "    def purchasebook():\n",
    "        pass\n",
    "    \n",
    "    def readbook():\n",
    "        pass\n",
    "\"\"\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.26\n",
    "class ReversedSequence(Sequence):\n",
    "    def __init__(self, sequence):\n",
    "        super().__init__(sequence)\n",
    "        self._k = len(self._seq)\n",
    "\n",
    "    def __next__(self):\n",
    "        self._k -= 1\n",
    "        if  0 <= self._k < len(self._seq):\n",
    "            return(self._seq[self._k])\n",
    "        else:\n",
    "            raise StopIteration()\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "rev_seq1=ReversedSequence([7,6,5,4,3,2,1])\n",
    "for i in range(len(rev_seq1)):\n",
    "    print(next(rev_seq1))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.27\n",
    "class Range:\n",
    "    def __init__(self, start, stop=None, step=1):\n",
    "        if step==0:\n",
    "            raise ValueError('step cannot be 0')\n",
    "        \n",
    "        if stop is None:\n",
    "            start, stop = 0, start\n",
    "        \n",
    "        self._length = max(0, (stop-start+step-1)//step)\n",
    "        self._start = start\n",
    "        self._step = step\n",
    "    \n",
    "    def __len__(self):\n",
    "        return self._length\n",
    "    \n",
    "    def __getitem__(self, k):\n",
    "        if k < 0:\n",
    "            k += len(self)\n",
    "        \n",
    "        if not 0 <= k < self._length:\n",
    "            raise IndexError(\"index out of range\")\n",
    "        \n",
    "        return self._start + k * self._step\n",
    "\n",
    "    def __contain__(self, x):\n",
    "        if not self._start <= x < self._stop:\n",
    "            return False\n",
    "        if (x - self._start) % self._step == 0:\n",
    "            return True\n",
    "        else:\n",
    "            return False"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.28\n",
    "class PredatoryCreditCard(CreditCard):\n",
    "    def __init__(self, customer, bank, acnt, limit, apr):\n",
    "        super().__init__(customer, bank, acnt, limit)\n",
    "        self._apr = apr\n",
    "        self._callcount=0\n",
    "\n",
    "    def charge(self, price):\n",
    "        success = super().charge(price)\n",
    "        if success:\n",
    "            self._callcount+=1\n",
    "        else:\n",
    "            self._balance += 5\n",
    "        return success\n",
    "    \n",
    "    def process_month(self):\n",
    "        if self._balance>0:\n",
    "            monthly_factor = pow(1+self._apr,1/12)\n",
    "            print(f\"before monthly factor: {self._balance}\")\n",
    "            self._balance *= monthly_factor\n",
    "            print(f\"after monthly factor: {self._balance}\")\n",
    "        \n",
    "        if self._callcount>10:\n",
    "            self._balance+=(self._callcount-10)\n",
    "            print(f\"after call count: {self._balance}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amandacard = PredatoryCreditCard('amanda','cimb','5555666677778888',1000,5)\n",
    "for i in range(11):\n",
    "    amandacard.charge(1)\n",
    "amandacard.charge(10)\n",
    "amandacard.process_month()\n",
    "amandacard._get_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.30\n",
    "import numbers\n",
    "\n",
    "class CreditCard:\n",
    "    \"\"\"A consumer credit card\"\"\"\n",
    "\n",
    "    def __init__(self, customer, bank, acnt, limit):\n",
    "        self._customer = customer\n",
    "        self._bank = bank\n",
    "        self._acnt = acnt\n",
    "        self._limit = limit\n",
    "        self._balance = 0\n",
    "    \n",
    "    def _set_balance(self, balance):\n",
    "        self._balance = balance\n",
    "    \n",
    "    def _get_customer(self):\n",
    "        return self._customer\n",
    "    \n",
    "    def _get_bank(self):\n",
    "        return self._bank\n",
    "\n",
    "    def _get_account(self):\n",
    "        return self._acnt\n",
    "    \n",
    "    def _get_limit(self):\n",
    "        return self._limit\n",
    "    \n",
    "    def _get_balance(self):\n",
    "        return self._balance\n",
    "    \n",
    "    def charge(self, price):\n",
    "        assert price != None and (type(price) == float or type(price) == int), f'price has to be in numerical int or float, not {type(price)}'\n",
    "        if price + self._balance > self._limit:\n",
    "            return False\n",
    "        else: \n",
    "            self._balance += price \n",
    "            return True\n",
    "\n",
    "    def make_payment(self, amount):\n",
    "        try:\n",
    "            assert isinstance(amount, numbers.Number)\n",
    "        except AssertionError:\n",
    "            print('amount must be a number, int or float')\n",
    "            return\n",
    "        if amount<=0:\n",
    "            raise ValueError(\"Amount must be positive number.\")\n",
    "        self._balance -= amount\n",
    "\n",
    "\n",
    "class PredatoryCreditCard(CreditCard):\n",
    "    def __init__(self, customer, bank, acnt, limit, apr):\n",
    "        super().__init__(customer, bank, acnt, limit)\n",
    "        self._apr = apr\n",
    "        self._callcount=0\n",
    "\n",
    "    def charge(self, price):\n",
    "        success = super().charge(price)\n",
    "        if success:\n",
    "            self._callcount+=1\n",
    "        else:\n",
    "            self._balance += 5\n",
    "        return success\n",
    "    \n",
    "    def process_month(self):\n",
    "        if self._balance>0:\n",
    "            monthly_factor = pow(1+self._apr,1/12)\n",
    "            print(f\"before monthly factor: {self._balance}\")\n",
    "            self._balance *= monthly_factor\n",
    "            print(f\"after monthly factor: {self._balance}\")\n",
    "        \n",
    "        if self._callcount>10:\n",
    "            self._balance+=(self._callcount-10)\n",
    "            print(f\"after call count: {self._balance}\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amandacard = PredatoryCreditCard('amanda','cimb','5555666677778888',1000,5)\n",
    "amandacard._get_balance()\n",
    "amandacard._get_balance()\n",
    "for i in range(11):\n",
    "    amandacard.charge(1)\n",
    "amandacard.charge(10)\n",
    "amandacard.process_month()\n",
    "amandacard._get_balance()\n",
    "amandacard._balance = 50\n",
    "amandacard._get_balance()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Projects 2.33\n",
    "# play around, not standard algebraic notation, flawed but presented the concept\n",
    "class Polynomial:\n",
    "    def __init__(self, n_x, constant: list, power: list, intercept):\n",
    "        self._n_x = n_x\n",
    "        assert len(power) == n_x, ('Need to specify the power for all unknown x in the polynomial eqn, which is {n_x} in total')\n",
    "        assert len(constant) == n_x, ('Need to specify the power for all unknown x in the polynomial eqn, which is {n_x} in total')\n",
    "        self._power = power\n",
    "        self._constant = constant\n",
    "        self._intercept = intercept\n",
    "\n",
    "    def _obtain_polyeqn(self):\n",
    "        eqn = ''\n",
    "        for i in range(self._n_x):\n",
    "            eqn += f'{self._constant[i]}x^{self._power[i]} + '\n",
    "        \n",
    "        if self._intercept is not None:\n",
    "            eqn += str(self._intercept)\n",
    "        \n",
    "        return eqn\n",
    "    \n",
    "    def _get_derivatives(self):\n",
    "        self._updated_power = [i-1 for i in self._power]\n",
    "        self._updated_constant=[self._constant[i]*self._power[i] for i in range(len(self._constant))]\n",
    "        derivatives = ''\n",
    "        for i in range(len(self._updated_power)):\n",
    "            derivatives += f'{self._updated_constant[i]}x^{self._updated_power[i]} + '\n",
    "        \n",
    "        if self._updated_power[len(self._updated_power)-1] != 0:\n",
    "            self._updated_intercept = self._updated_power[len(self._updated_power)]\n",
    "            derivatives += str(self._updated_intercept)\n",
    "        \n",
    "        return derivatives"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "eqn1 = Polynomial(3,[1,-4,1],[3,2,1],-5)\n",
    "eqn1._obtain_polyeqn()\n",
    "eqn1._get_derivatives()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.34\n",
    "class ReadDoc:\n",
    "    def __init__(self, file):\n",
    "        self._doc = open(file,\"r\").read()\n",
    "        self._charlist = self._createdict('a')\n",
    "        self._capcharlist = self._createdict('A')\n",
    "        \n",
    "\n",
    "    def _readfile(self):\n",
    "        for i in self._doc:\n",
    "            if (ord('a')<=ord(i)<=ord('a')+26):\n",
    "                self._charlist[i]+=1\n",
    "            elif (ord('A')<=ord(i)<=ord('A')+26):\n",
    "                self._capcharlist[i]+=1\n",
    "    \n",
    "    def _plotchart(self):\n",
    "        for i in self._charlist:\n",
    "            print(f\"{i}: {'x'*self._charlist[i]}\")\n",
    "        for i in self._capcharlist:\n",
    "            print(f\"{i}: {'x'*self._capcharlist[i]}\")\n",
    "\n",
    "    def _createdict(self,start):\n",
    "        return {chr(i):0 for i in range(ord(start), ord(start)+26)}"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a = ReadDoc('/home/gvh/Desktop/try.txt')\n",
    "a._readfile()\n",
    "a._plotchart()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.35\n",
    "import random\n",
    "class character:\n",
    "    def __init__(self, object, partner):\n",
    "        self.CHANCE_OF_PACKING = 0.5\n",
    "        self._object = object\n",
    "        self._partner = partner\n",
    "    \n",
    "    def generate_packets(self):\n",
    "        if random.random()<=self.CHANCE_OF_PACKING:\n",
    "            self._packets=[chr(random.randint(ord('a'), ord('a')+25)) for i in range(4)]\n",
    "            print(f\"{self._object} generated packets {self._packets} for {self._partner}\")\n",
    "            return self._packets\n",
    "        else: return False\n",
    "        \n",
    "    def send_packets(self, packets):\n",
    "        self._readypackets = packets\n",
    "        if self._readypackets is not False:\n",
    "            print(f'{self._object} is sending {self._readypackets} to {self._partner}')\n",
    "            return self._readypackets\n",
    "        else: return False\n",
    "\n",
    "    def receive_packets(self, packets):\n",
    "        self._receivedpackets = packets\n",
    "        if self._receivedpackets is not False:\n",
    "            print(f'{self._object} has read {self._receivedpackets} from {self._partner} and is deleting it.')\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "alice = character('Alice','Bob')\n",
    "bob = character('Bob','Alice')\n",
    "internet = character('Internet','Bob')\n",
    "for i in range(50):\n",
    "    print(f\"checking {i}:\")\n",
    "    packets=alice.generate_packets()\n",
    "    packets=internet.send_packets(packets=packets)\n",
    "    bob.receive_packets(packets)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.36, skip 2.37\n",
    "import random\n",
    "\n",
    "class Animal:\n",
    "    def __init__(self, name, ori_location_id, ecolist):\n",
    "        self._name = name\n",
    "        self._ecolist = ecolist\n",
    "        self._ori_location_id = ori_location_id\n",
    "\n",
    "    def getname(self):\n",
    "        return self._name\n",
    "\n",
    "class Bear(Animal):\n",
    "    def __init__(self, name, ori_location_id, ecolist):\n",
    "        super().__init__(name, ori_location_id, ecolist)\n",
    "\n",
    "class Fish(Animal):\n",
    "    def __init__(self, name, ori_location_id, ecolist):\n",
    "        super().__init__(name, ori_location_id, ecolist)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "class RiverEco:\n",
    "\n",
    "    MOVE_CHANCE = 0.2\n",
    "    LEFT_RIGHT = 0.5\n",
    "\n",
    "    def __init__(self, totalnum, bearnum=2, fishnum=10):\n",
    "        \n",
    "        self._totalnum=totalnum\n",
    "        self._bearnum=bearnum\n",
    "        self._fishnum=fishnum\n",
    "        self._ecolist = [None for i in range(totalnum)]\n",
    "\n",
    "    def _init_assign_animal(self):\n",
    "        randlist = random.sample(range(0,self._totalnum-1),self._bearnum+self._fishnum)\n",
    "        bearlist = random.sample(randlist, self._bearnum)\n",
    "        fishlist = randlist.copy()\n",
    "        for i in randlist:\n",
    "            if i in bearlist:\n",
    "                fishlist.remove(i)\n",
    "        \n",
    "        for i in bearlist:\n",
    "            self._ecolist[i]=Bear('B',i, self._ecolist)\n",
    "        for i in fishlist:\n",
    "            self._ecolist[i]=Fish('F',i, self._ecolist)\n",
    "    \n",
    "    def check_species(self, location1, location2):\n",
    "        animal1, animal2 = self._ecolist[location1], self._ecolist[location2]\n",
    "        if animal1.getname() == animal2.getname(): return True # return True = create new\n",
    "        else: return False # return False = eat prey (eat Fish)\n",
    "    \n",
    "    def startgame(self):\n",
    "        self._init_assign_animal()\n",
    "        if random.random()>self.MOVE_CHANCE:\n",
    "            for i in range(len(self._ecolist)):\n",
    "                if self._ecolist[i] != None:\n",
    "                    if random.random()>self.LEFT_RIGHT and i+1<len(self._ecolist):\n",
    "                        if self._ecolist[i+1] != None:\n",
    "                            if self.check_species(i, i+1):\n",
    "                                self.createnew()\n",
    "                            else: self.remove(i,i+1)\n",
    "                        else:\n",
    "                            self._ecolist[i+1]=self._ecolist[i]\n",
    "                            self._ecolist[i] = None\n",
    "                    elif random.random()<=self.LEFT_RIGHT and i-1>=0:\n",
    "                        if self._ecolist[i-1] != None:\n",
    "                            if self.check_species(i, i-1):\n",
    "                                self.createnew()\n",
    "                            else: self.remove(i,i-1)\n",
    "                        else:\n",
    "                            self._ecolist[i-1]=self._ecolist[i]\n",
    "                            self._ecolist[i] = None\n",
    "        self.checkeco()\n",
    "    \n",
    "    def checkeco(self):\n",
    "        for i in range(1,len(self._ecolist)-1):\n",
    "            if self._ecolist[i] != None:\n",
    "                if self._ecolist[i-1] != None:\n",
    "                    if not self.check_species(i, i-1):\n",
    "                        self.remove(i,i-1)\n",
    "                elif self._ecolist[i+1] != None:\n",
    "                    if not self.check_species(i, i+1):\n",
    "                        self.remove(i,i+1)\n",
    "    \n",
    "    def createnew(self):\n",
    "        r = random.randint(0,len(self._ecolist)-1)\n",
    "        while self._ecolist[r]==None:\n",
    "            r = random.randint(0,len(self._ecolist)-1)\n",
    "        name = self._ecolist[r].getname()\n",
    "        if name == 'B':\n",
    "            self._ecolist[i]=Bear('B', r, self._ecolist)\n",
    "        elif name == 'F':\n",
    "            self._ecolist[i]=Bear('F', r, self._ecolist)\n",
    "    \n",
    "    def remove(self, location1, location2):\n",
    "        animal1, animal2 = self._ecolist[location1], self._ecolist[location2]\n",
    "        if animal1.getname() == 'B':\n",
    "            self._ecolist[location2] = None\n",
    "        elif animal2.getname() == 'B': \n",
    "            self._ecolist[location1] = None\n",
    "    \n",
    "    def printgame(self):\n",
    "        eco=''\n",
    "        for i in self._ecolist:\n",
    "            if i != None:\n",
    "                eco+=i.getname()\n",
    "            else: eco+='-'\n",
    "        print(eco)\n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "F--------FF----------F----------B---------B------F--------F---------F---------F------F---------F----\n",
      "-F-BB----F-F--------FF---------B---------B--F-F-F---------F---------F--F-F----F--------F-----FF-----\n",
      "FF-BB----FFF-F--F---B---F------B---------B--F--F-FF-B------F---F-----F--F--F-F------F--F-----FF-----\n",
      "FFFF-B-F-FF-FF-FF------B-F----B----F--F-B---F---FF-B------F--B-F-----F--FFF--F-F-----F-B----FF------\n",
      "FFFFF-B--FF-FF-F-F------B-----B------F--B--FF--F---B--F---FF--B-FF-F---FFFF---B--------B--B-FF-F----\n",
      "FFFFF-B--FF-FF-F-F------B-----F-----FF--B-FFFF-F---B--F----B--F-FF-F---FFFF---B-F---F--B--B-FF-F----\n",
      "FFFFF--B-FF-FF-FF-------B--F--F----B----B-F-B--FF--B-FF----B--FFF-F--FFFFFF----B----F-B----B-FF-----\n",
      "B-FFF-FFFF-FFFFFF-------B---F-F------B-B--F-B-FF--B--FF----B--F-B-FFF-FFFF-----B---F--B---F--FFF----\n",
      "B--F-FFFFFFF-FFFF---F---B--F-F--------B--B---B-F-B--B-F------B-B--FFFFFFFF-------B----B-FF--F-FF----\n",
      "B---FFFFFFFF-FFFF-F--B--F-F--F----F--B-----BB---B---BB-------B---B-FFFFFFF-------B----B-FF-F--FF---F\n",
      "B---FFFFF-B--FFFFF-----B-F--F----FF-B------BB-F-B---BB-------B----B-FFFFFF-------B---BB-F-FF--F---FF\n",
      "-B-F-FFFF-FFFFFFFF---F-B--F-F---FFF--F-F---BB----B--BB------B-----BB--FFFF------BB--B-B---FF-F-FF-FF\n",
      "-B-F-FFFF-FFFFFFFF---F-B--F-F---FFF--FFF---BB----B--BB------B-----BB--FFFF------BB--B-B-B-FF-F-FF-FF\n",
      "-B--B--F-FFFFFFFFF---F-B-F---B-F-F-FFFFF---B-B----B-BB-----B------B---FFFFF----BB----BB---F-FF-FFFFF\n",
      "B--B--FF-FFFFFF-FF--F-B--FF--B--F-FFFFFF----B--B---BB--B---B-------B-F-FFFF---B--B-BB-B----FFFF-FFFF\n",
      "B--B--FF-FFFFFF-FF---BB-FFF--B--F-FFFFFF-F--B--B---BB--B---B-F-F---B-F-FFFF---B--B-BB-B----FFFF-FFFF\n",
      "B--B--FF-FFFFFFFFF-F-BBB-FF--B--F-FFFFFF-F--B--B---BB--B---B-F-F-B-B-F-FFFF---B--B-B--B----FFFF-FFFF\n",
      "B--B-FFFFFFFFFFFFF-F-BBB-F-B-B-B--FFFFFF-FF-B--F---BB--B---B-F-F-B-B-F-FFFF---B-FF-B--B----FFFF-FFFF\n",
      "B--B-FFFFFFFFFFFF-B--B--B-B--B-B-F-FFFF-FF-BB---B-F---BB---B-F--B-F-F--FFFF---B-FF--BB---FF-FFF-FFFF\n",
      "B---B-FFFFFFFFFF-F-B-F-B--B-F---BB-FFFFFF--B--B-B--F-B-B--B-F----B---F-FFF--F--B----B---B-B--FF-FFFF\n",
      "B--B--FFFF-B-FFF-F-BB-F-B-B-F---B-B-F-FFF--B-F-BB-FF-B---B-B--F----B-F-FF-F--F-B-------BB--B-FF-FFFF\n",
      "-B-B--FF-BB-F-FF---BB----BB-F----BB-F-FFF-B---BB--F-B-----BB--B-----B-FFF--FFF-B------BB---B-FFFFFFF\n",
      "-B--FFF---B-F-F-F---B-FF-BB-----B--B--FF--B---BB---B-B----BB--B------B--B--FFF-B------BB---B-FFFFFFF\n",
      "-B--FFF--B---FF-F----B-B-B-F-B--B--B--FF----B-BB---B-F----BB----F---B---B--FF-----B---BB-B--B-FFFFFF\n",
      "-B-FFFF---B--FFF-FF---B-F-B--B-F---B--FF----B-B---BB-----BB--F---F--B---B--FF------B--B-BB--B-FFFFFF\n",
      "-BB-FFFF---B--FFF--F---B--B-B--F--B-B-F------F---BBB-----B--B----F--B----B-FF-------BB--B-B-B-FFFFFF\n",
      "B--FFF--F---B-F-F----F-B-B---B---B-B-----F---FF--BB--F--B---B-------B---BB-FF-------B--B-B--B-FFFFFF\n",
      "B--FFF--F---B--FF-F-F-B--B-B---B--B--B---F--F-F--BB-F---B---F--------B-B-BB-F--F------BB-B--B-FFFFFF\n",
      "B--FF-B-F---B--FF-FFF-B--B-B---B--B--B-F-F--F-F--BB-FF--B---F--F---F-B-B--B-F--F------BB-B--B-F-B-FF\n",
      "B-FF---B----B-FF--B-F--B--BB-F---B----B-FF--FFF--B--B-----B--F---F-F--BB-F-B---F----F-BB-F-B---FFF-F\n",
      "B------B----B-FFF-B-FF--BB--BB--BB----B--FF-FF--BB--B-------B----FFFF-BB--F-B----F-F--BB----B--FF-FF\n",
      "-B-----B-----B-F---B-F--B-B-BB--BB-----B-F-FFF--F--B-------F----F-B-F-BB-F-B------FF--BB-----B-FF-FF\n",
      "B---------B-B--F---B-----B-BB---F---B--B--B-F--FF----B-----F----FF-B-F--B-----F--B--F-B--B---B-F-FFF\n",
      "B---------B---B---F-F-----BBB--FFF--B--B---B-F-FF----B----FF----FF-B---B------F--B-F-BB---F---F-FFFF\n",
      "B------FF-B---B--F--F----B-B--FFFFF-B-B----B---FF---B-F--F--F--F-F--B--BB--------BB--BB-F---F-FFFFFF\n",
      "--F---FFF-B-----B---F---B-B-FFFFFFF-B-F----B---FF-B--B----F---F-FF--B---B---B----BB-B-B-F--F--FFFFFF\n",
      "--F---FFF-B-----BB--FF--B-B-FFFFFF-BB-F--F-B-F-FF-B--B----F---F-FF--B---F---B--F-BB-B-B-F--F--FFFFFF\n",
      "--FF--FFF-B--F-BB--F-----BB-FFFFFFF-B-----B--FF--B--B----FF---B-F--B-----F--F--F-B-BB--B---FFF-FFFFF\n",
      "--FF--FFF-B--F--B--F-----BB-FFFFFFF-FF----B-FFFF-B--B-F-B-F---B-F--B-F---F--F--F-B-BB--B-F-FFF-FFFFF\n",
      "--FF--FFF--B-F--B--F-----BB--B-FFFF-FF----B-FFFF-B--B-F-B-F---B-F--B-F---F--F-FF-B-B---B-F-FFF-FFFFF\n"
     ]
    }
   ],
   "source": [
    "game1 = RiverEco(totalnum=100)\n",
    "i = 0\n",
    "for i in range(40):\n",
    "    game1.startgame()\n",
    "    game1.printgame()\n",
    "    i+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.38, exclude expired copyrights and real book population\n",
    "# readbook method can substitued with python built-in function, open(fileurl) to read file\n",
    "# add one more parameter -> bookurl to booklist dict\n",
    "class ebookReader:\n",
    "    def __init__(self, user, bookshoplist, userbooklist):\n",
    "        self._name = user\n",
    "        self._shop = BookShop(bookshoplist)\n",
    "        self._user = PurchasedBook(userbooklist)\n",
    "\n",
    "    def readbook(self, book=None):\n",
    "        userlist = self._user._returnlist()\n",
    "        if book is not None:\n",
    "            assert book in userlist, print('Book requested not available, please purchase in shop')\n",
    "            print(f\"reading {book}...\")\n",
    "        else:\n",
    "            print(f\"Purchased Book List: ----------------\")\n",
    "            self._user._viewlist()\n",
    "            book = str(input('Select a book you want to read'))\n",
    "            assert book in userlist, print('Book requested not available, please purchase in shop')\n",
    "            print(f\"reading {book}...\")\n",
    "\n",
    "    def purchasebook(self):\n",
    "        shoplist = self._shop._returnlist()\n",
    "        print('Book Shop Book List: ----------------')\n",
    "        self._shop._viewlist()\n",
    "        desiredbook = str(input('Please key in the name of the book wanted to purchase'))\n",
    "        assert desiredbook in shoplist, print('Book requested not available')\n",
    "        self._user._addbook(desiredbook, shoplist[desiredbook][0], True)\n",
    "        self._shop._removebook(desiredbook)\n",
    "    \n",
    "    def showpurchased(self):\n",
    "        self._user._viewlist()\n",
    "\n",
    "class BookList:\n",
    "    def __init__(self, booklist):\n",
    "        if booklist == None:\n",
    "            self._booklist = {}\n",
    "        self._booklist = booklist\n",
    "\n",
    "    def _addbook(self, book, price, status):\n",
    "        self._book = book\n",
    "        self._price = price\n",
    "        self._status = status\n",
    "        self._booklist[self._book]=[self._price, self._status]\n",
    "\n",
    "    def _removebook(self, book):\n",
    "        self._booklist.pop(book)\n",
    "\n",
    "    def _viewlist(self):\n",
    "        for i in self._booklist:\n",
    "            print(f\"{i}, price: {self._booklist[i][0]}, Purchased? {self._booklist[i][1]}\")\n",
    "\n",
    "    def _returnlist(self):\n",
    "        return self._booklist\n",
    "\n",
    "class PurchasedBook(BookList):\n",
    "    def __init__(self, booklist):\n",
    "        super().__init__(booklist)\n",
    "\n",
    "class BookShop(BookList):\n",
    "    def __init__(self, booklist):\n",
    "        super().__init__(booklist)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "bookshoplist = {\n",
    "    \"Book1\": [10.50, False],\n",
    "    \"Book2\": [6.50, False],\n",
    "    \"Book3\": [7.50, False],\n",
    "    \"Book4\": [3.50, False],\n",
    "    \"Book5\": [8.50, False],\n",
    "    \"Book6\": [15.50, False]\n",
    "}\n",
    "amandabook = ebookReader('amanda', bookshoplist, userbooklist={})\n",
    "amandabook.purchasebook()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amandabook.showpurchased()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "amandabook.purchasebook()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amandabook.showpurchased()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "amandabook.readbook()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# 2.39 skipped"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3.9.12 ('deepcv')",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.12"
  },
  "orig_nbformat": 4,
  "vscode": {
   "interpreter": {
    "hash": "38e3adfb29cde9206c861f814c9fa42a1353f77e60ebe68d31b54d2673048b17"
   }
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}