Chapter 2 - Arrays.ipynb

{
 "metadata": {
  "name": "",
  "signature": "sha256:0cdf200479cb45c126f9773bd9d617dc0324ef8c22b43c0364a14404bd5eb8cb"
 },
 "nbformat": 3,
 "nbformat_minor": 0,
 "worksheets": [
  {
   "cells": [
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Imports\n",
      "import numpy\n",
      "# For random string generation\n",
      "from string import ascii_letters\n",
      "from random import choice\n",
      "from time import time # For analysis of the running time\n",
      "import matplotlib.pyplot as plt # to plot the run time analysis"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 1
    },
    {
     "cell_type": "heading",
     "level": 1,
     "metadata": {},
     "source": [
      "CHAPTER 2 - ARRAYS"
     ]
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.1, PAGE 75"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Definition of Class Rectangle\n",
      "\n",
      "class Rectangle:\n",
      "    def __init__(self,x=None,y=None,h=None,w=None):\n",
      "        '''Constructor of Rectangle'''\n",
      "        pass\n",
      "    def __del__(self):\n",
      "        '''Destructor of Rectangle'''\n",
      "        pass\n",
      "    def get_height(self):\n",
      "        '''returns Height of rectangle'''\n",
      "        pass\n",
      "    def get_width(self):\n",
      "        '''Returns Width of rectangle'''\n",
      "        pass\n",
      "    _x_low = None\n",
      "    _y_low = None\n",
      "    _height = None\n",
      "    _width = None\n",
      "    # In python attributes starting with an underscore are conventionaly understood to be private attributes."
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 2
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.2, PAGE 76"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Implementations of Operations on Rectangle\n",
      "def get_height(self):\n",
      "    return self._height\n",
      "def get_width(self):\n",
      "    return self._width\n",
      "\n",
      "Rectangle.get_height = get_height\n",
      "Rectangle.get_width = get_width\n",
      "\n",
      "# This is the closest C++ equivalent to defining class methods outside the class. [ using class::member() {} ]\n",
      "\n",
      "# Though THIS IS NOT AN ACCEPTED PRACTICE IN PYTHON. This would be an workaround to define \n",
      "# the member functions outside of the class definition as and when the functionality of the method in defined\n",
      "# in the text"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 3
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.4, PAGE 78"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Definition Of Constructor For Rectangle\n",
      "\n",
      "def constructor_for_Rectangle_class(self,x=None,y=None,h=None,w=None):\n",
      "    '''Constructor for class Rectangle'''\n",
      "    self._x_low = x\n",
      "    self._y_low = x\n",
      "    self._height = h\n",
      "    self._width = w\n",
      "\n",
      "# __init__ method is invoked in python when a member of the class is instantiated\n",
      "Rectangle.__init__ = constructor_for_Rectangle_class"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 4
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.3, PAGE 77"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "r = Rectangle(1,2,5,6)\n",
      "s = Rectangle(1,2,8,9)\n",
      "\n",
      "t = s\n",
      "\n",
      "if ( r.get_height() * r.get_width() ) > ( t.get_height() * t.get_width() ):\n",
      "    print 'r',\n",
      "else:\n",
      "    print 's',\n",
      "\n",
      "print 'has the greater area'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "s has the greater area\n"
       ]
      }
     ],
     "prompt_number": 5
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.6, PAGE 80"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "s._x_low"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "pyout",
       "prompt_number": 6,
       "text": [
        "1"
       ]
      }
     ],
     "prompt_number": 6
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Overloading the equality check operator\n",
      "\n",
      "# Operator == is specified as a function __eq__(op1,op2)\n",
      "\n",
      "def __eq__(self,rhs):\n",
      "    if (self._x_low == rhs._x_low) and (self._y_low == rhs._y_low) and ( self._height == rhs._height ) and ( self._width == rhs._width ) :\n",
      "        return True\n",
      "    else:\n",
      "        return False\n",
      "    \n",
      "# Overriding the default behaviour of == by defining a __eq__ memeber function\n",
      "Rectangle.__eq__ = __eq__\n",
      "\n",
      "# SAMPLE O/P\n",
      "print r == s"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "False\n"
       ]
      }
     ],
     "prompt_number": 7
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.7, PAGE 80"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Overloading the right shift operator <<\n",
      "import operator, sys, io, IPython\n",
      "\n",
      "\n",
      "class MyStdout(IPython.kernel.zmq.iostream.OutStream):\n",
      "    \"\"\"\n",
      "    MyStdout class inherits from the OutStream of IPython kernel.\n",
      "    This is done to simulate the C++ OutStream \"cout\"\n",
      "    \"\"\"    \n",
      "    def __init__(self):\n",
      "        self.__dict__ = sys.stdout.__dict__.copy()\n",
      "        # All elements of sys.stdout are copied to the MyStdout [inherited class]\n",
      "\n",
      "    def __lshift__(self,rect_instance):\n",
      "        # lshift ( << ) operator is overloaded to allow printing of Rectangle\n",
      "        \n",
      "        if isinstance(rect_instance, Rectangle):    \n",
      "            self.write('Position is:'+str(rect_instance._x_low)+' '+str(rect_instance._y_low))\n",
      "            self.write('\\nHeight is: '+str(rect_instance._height))\n",
      "            self.write('\\nWidth is: '+str(rect_instance._width))\n",
      "        else:\n",
      "            self.write(rect_instance)\n",
      "            \n",
      "# A new MyStdout Class inheriting the elements of stdout <file class> [OutStream Object Class] is created with the \n",
      "# overloaded operator function __lshift__. \n",
      "\n",
      "sys.stdout = MyStdout()\n",
      "\n",
      "#an instance of MyStdout is then assigned to sys.stdout\n",
      "\n",
      "#Operator << is specified as a function __lshift__() [Equivalent to c++ style 'operator<<'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 8
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# C++ Style I/O using << operator overloading in python !\n",
      "\n",
      "cout = sys.stdout\n",
      "endl = '\\n'\n",
      "\n",
      "cout<<r\n",
      "\n",
      "#r is an instance of the Rectangle Class Defined earlier\n",
      "\n",
      "cout<<endl\n",
      "cout<<'Sample Text to emphasize the fact that base functionality of sys.stdout remains unchanged'"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Position is:1 1\n",
        "Height is: 5\n",
        "Width is: 6\n",
        "Sample Text to emphasize the fact that base functionality of sys.stdout remains unchanged"
       ]
      }
     ],
     "prompt_number": 9
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "ADT 2.1, PAGE NO 82"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Abstract Data Type NaturalNumber : \n",
      "class NaturalNumber():\n",
      "    def __init__(self,value = 0):\n",
      "        self.value = 0\n",
      "        \n",
      "    def is_zero(self):\n",
      "        if self.value == 0 : \n",
      "            return True\n",
      "        return False\n",
      "    \n",
      "    def __add__(self,y):\n",
      "        # overloading + operator\n",
      "        if isinstance(y, NaturalNumber):\n",
      "            return self.value + y.value\n",
      "        elif type(y) in [int, float, long]:\n",
      "            return self.value + int(y)\n",
      "        else:\n",
      "            raise(TypeError)\n",
      "            \n",
      "    def __eq__(self,y):\n",
      "        # overloading == operator\n",
      "        if isinstance(y, NaturalNumber):\n",
      "            return self.value == y.value\n",
      "        elif type(y) in [int,float,long]:\n",
      "            return self.value == y\n",
      "        else:\n",
      "            raise(TypeError)\n",
      "            \n",
      "    def successor(self):\n",
      "        return self.value+1\n",
      "    \n",
      "    # Python has no limit on number size [virtually]. The max no can be understood as float(\"inf\")\n",
      "    \n",
      "    def __sub__(self,y):\n",
      "        '''overloading + operator'''\n",
      "        if isinstance(y, NaturalNumber):\n",
      "            res = self.value - y.value\n",
      "        elif type(y) in [int,float,long]:\n",
      "            res = self.value + y\n",
      "        else:\n",
      "            raise(TypeError)\n",
      "        return res if res >= 0 else 0"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 10
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "ADT 2.2, PAGE 85"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Abstract Data Type GeneralArray\n",
      "default_value = 0\n",
      "\n",
      "class GeneralArray:\n",
      "    def __init__(self, j, List, init_value = default_value):\n",
      "        pass\n",
      "    def retrieve(self,index):\n",
      "        pass\n",
      "    def store(self,index,x):\n",
      "        x = float(x)\n",
      "        pass   "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 11
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "ADT 2.3, PAGE 88 &nbsp; & &nbsp; PROGRAM 2.8, PAGE 91 &nbsp; & &nbsp; PROGRAM 2.9, PAGE 92"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Adding two Polynomials\n",
      "\n",
      "# Declaring and Defining Prerequisites Term and Polynomial\n",
      "\n",
      "# Class Terms to define a single term of a polynomial.\n",
      "\n",
      "# Refer Page 90\n",
      "\n",
      "# NOTE : This is just to illustrate how a Polynomial data type can be constructed in Python\n",
      "# For all practical purposes, use sympy, an efficient symbolic math and Computer Algebra System library in Python\n",
      "\n",
      "class Term:\n",
      "    def __init__(self):\n",
      "        self.coef = 0.0\n",
      "        self.exp = 0\n",
      "\n",
      "        \n",
      "# Abstract data type Polynomial - Representation 3 [ Refer Page 89 ]\n",
      "class Polynomial:\n",
      "    def __init__(self,d=0):\n",
      "        self.degree = d\n",
      "        self.coeff = [0.0]\n",
      "        self.term_array = []\n",
      "        self.terms = 0\n",
      "        pass\n",
      "\n",
      "    # Method new_term to add a new term to the polynomial [ Refer Page 92 ]\n",
      "\n",
      "    def new_term(self,coef,exp):\n",
      "        NewTrm = Term()\n",
      "        NewTrm.coef = coef\n",
      "        NewTrm.exp = exp\n",
      "        pos = 0\n",
      "        # Compute the position of the new term ( sorted by exponents )\n",
      "        while ( pos < self.terms ) and ( self.term_array[pos].exp < NewTrm.exp ):\n",
      "            pos += 1\n",
      "            \n",
      "        # If there is already a term with the given exponent, add the coefficient\n",
      "        if ( pos < self.terms ) and ( self.term_array[pos].exp == NewTrm.exp ):\n",
      "            self.term_array[pos].coef += coef\n",
      "            return\n",
      "                \n",
      "        self.term_array.insert(pos, NewTrm)\n",
      "        self.terms += 1\n",
      "        self.degree = max(self.degree, exp)        \n",
      "        \n",
      "    # Method Add to add two polynomials\n",
      "\n",
      "    def add(self,Polynomial_b):\n",
      "        if isinstance(Polynomial_b, Polynomial):\n",
      "            c = Polynomial()\n",
      "            a_pos = 0\n",
      "            b_pos = 0\n",
      "            while ( a_pos < self.terms ) and ( b_pos < Polynomial_b.terms ) :\n",
      "                # Similar Power terms\n",
      "                if self.term_array[a_pos].exp == Polynomial_b.term_array[b_pos].exp :\n",
      "                    t = float(term_array[a_pos].coef) + float(Polynomial_b.term_array[b_pos].coef)\n",
      "                    if t != 0 :\n",
      "                        c.new_term(t, self.term_array[a_pos].exp)\n",
      "                        a_pos += 1\n",
      "                        b_pos += 1\n",
      "                        \n",
      "                # Dissimilar Power terms\n",
      "                elif self.term_array[a_pos].exp < Polynomial_b.term_array[b_pos].exp:\n",
      "                    c.new_term(Polynomial_b.term_array[b_pos].coef, Polynomial_b.term_array[b_pos].exp)\n",
      "                    b_pos += 1\n",
      "                else:\n",
      "                    c.new_term(self.term_array[a_pos].coef, self.term_array[a_pos].exp)\n",
      "                    c.display()\n",
      "                    a_pos += 1\n",
      "                    \n",
      "            # Leftover terms of a\n",
      "            while a_pos < self.terms:\n",
      "                c.new_term(self.term_array[a_pos].coef, self.term_array[a_pos].exp)\n",
      "                a_pos += 1\n",
      "                \n",
      "            # Leftover terms of b\n",
      "            while b_pos < Polynomial_b.terms:\n",
      "                c.new_term(Polynomial_b.term_array[b_pos].coef, Polynomial_b.term_array[b_pos].exp)\n",
      "                b_pos += 1\n",
      "                \n",
      "            # C contains the resulting polynomial\n",
      "            return c\n",
      "        else:\n",
      "            raise(TypeError)\n",
      "\n",
      "    # Overloading Operator + to do the same funcition as Polynomial_a.add(Polynomial_b)\n",
      "\n",
      "    def __add__(self,Polynomial_b):\n",
      "        return Polynomial.add(self,Polynomial_b)\n",
      "    \n",
      "    def display(self):\n",
      "        \"\"\"Display the polynomial using the latex display in IPython notebook. \n",
      "        Note that this works only inside IPython notebook\"\"\"\n",
      "        \n",
      "        from IPython.display import display, Math, Latex\n",
      "        \n",
      "        latex = \"{\"\n",
      "        \n",
      "        for t in reversed(self.term_array):\n",
      "            if t.coef >= 0 and latex != \"{\" :\n",
      "                latex += \" + \"\n",
      "                \n",
      "            if t.exp == 0:\n",
      "                latex += \" {coef} \".format(coef=t.coef)\n",
      "            elif t.exp == 1:\n",
      "                latex += \" {coef}x \".format(coef=t.coef)\n",
      "            else:\n",
      "                latex += \" {coef}x^{exp} \".format(coef=t.coef, exp=t.exp)\n",
      "            \n",
      "        latex += \"}\"\n",
      "        \n",
      "        display(Math(latex))"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 12
    },
    {
     "cell_type": "markdown",
     "metadata": {},
     "source": [
      "### Example Usage\n",
      "$f = {2.5x^2 - 3x + 5}$<br>\n",
      "$g = {3.2x^3 - 4x}$<br><br>\n",
      "$h = f + g$<br><br>\n",
      "$h = {3.2x^3 + 2.5x^2 - 7x + 5}$<br>"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Example Usage :\n",
      "\n",
      "f = Polynomial()\n",
      "f.new_term(2.5, 2); f.new_term(-3, 1); f.new_term(5,0)\n",
      "f .display()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "latex": [
        "$${ 2.5x^2  -3x  +  5 }$$"
       ],
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "<IPython.core.display.Math at 0x7f4c4e95c4d0>"
       ]
      }
     ],
     "prompt_number": 13
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "g = Polynomial()\n",
      "g.new_term(3.2, 3); g.new_term(-4, 1);\n",
      "g.display()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "latex": [
        "$${ 3.2x^3  -4x }$$"
       ],
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "<IPython.core.display.Math at 0x7f4c4e9b8910>"
       ]
      }
     ],
     "prompt_number": 14
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "h = f + g\n",
      "h.display()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "latex": [
        "$${ 3.2x^3  +  2.5x^2  -7x  +  5 }$$"
       ],
       "metadata": {},
       "output_type": "display_data",
       "text": [
        "<IPython.core.display.Math at 0x7f4c4e9b8fd0>"
       ]
      }
     ],
     "prompt_number": 15
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "ADT 2.4, PAGE 97  "
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Abstract Data Type SparseMatrix\n",
      "\n",
      "class MatrixTerm(object):\n",
      "    def __init__(self,row=None,col=None,value=None):\n",
      "        self.row = row\n",
      "        self.col = col\n",
      "        self.value = value\n",
      "    def set_value(self, row=None, col=None, value=None):\n",
      "        if row is not None:\n",
      "            self.row = row\n",
      "        if col is not None:\n",
      "            self.col = col\n",
      "        if value is not None:\n",
      "            self.value = value                \n",
      "\n",
      "class SparseMatrix(object):\n",
      "    '''A Set of triples <row, column, value>, where row and column are non-negative integers\n",
      "       and form a unique combination; value is also an integer '''\n",
      "    def __init__(self, rows, cols, terms):\n",
      "        '''The constructor function creates a SparseMatrix with\n",
      "           r rows c columns and a capacity of t nonzero terms.'''\n",
      "        self._rows = rows # No of rows\n",
      "        self._cols = cols # No of cols\n",
      "        self._terms = terms # No of terms\n",
      "        # self._capacity = t # This term is not used since in python lists can be extended\n",
      "        self._sm_array = [ MatrixTerm() for i in range(terms) ] # List which stores the <row, col, value> triplet\n",
      "        \n",
      "    def Transpose(self):\n",
      "        '''Returns the transpose of the SparseMatrix'''\n",
      "        # self is comparable with *this in c++\n",
      "        pass\n",
      "    \n",
      "    def add(self, b):\n",
      "        '''Performs matrix addition of self with the b SpareMatrix'''\n",
      "        pass\n",
      "    \n",
      "    def Multiply(self, b):\n",
      "        '''\n",
      "        If the number of columns in self equals the number of rows in b, then returns the\n",
      "        multiplication matrix of self and b.\n",
      "        If not an exception is thrown\n",
      "        '''\n",
      "        pass"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 16
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.10, PAGE 100"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Transposing a Matrix\n",
      "# Runs in O(terms*cols)\n",
      "# In comparison, the naive method runs in O(rows*cols)\n",
      "\n",
      "def transpose(self):\n",
      "    '''Returns the transpose of self'''\n",
      "    \n",
      "    tran = SparseMatrix(self._cols, self._rows, self._terms)\n",
      "    \n",
      "    if(self._terms < 0):\n",
      "        # If self is a zero matrix\n",
      "        return tran\n",
      "    \n",
      "    # If self is a Non Zero matrix\n",
      "    \n",
      "    tran_term_index = 0\n",
      "    \n",
      "    for c in range(self._cols):\n",
      "        for i in range(self._terms):\n",
      "            # Find and move terms in column c\n",
      "            if self._sm_array[i].col == c:\n",
      "                # Add the i-th term with row number and col number interchanged to the tran matrix\n",
      "                tran._sm_array[tran_term_index].set_value(row = c, \n",
      "                                                          col = self._sm_array[i].row,\n",
      "                                                          value = self._sm_array[i].value\n",
      "                                                          )\n",
      "                tran_term_index += 1\n",
      "    return tran\n",
      "\n",
      "SparseMatrix.transpose = transpose"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 17
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.11, PAGE 102"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# A faster method for transposing of Sparse Matrices\n",
      "# Runs in O(terms + cols)\n",
      "\n",
      "def fast_transpose(self):\n",
      "    \n",
      "    tran = SparseMatrix(self._cols, self._rows, self._terms)\n",
      "    \n",
      "    if self._terms>0:\n",
      "        cols = self._cols\n",
      "        terms = self._terms\n",
      "        sm_array = self._sm_array\n",
      "        \n",
      "        # No. of terms in the i-th column => row_size[i] => no of terms in the i-th row of transpose\n",
      "        row_size = [0]*cols\n",
      "        \n",
      "        # Starting index of the sm_array for row i of tran array => row_start[i]\n",
      "        row_start = [0]*cols\n",
      "        \n",
      "        for i in range(terms):\n",
      "            row_size[sm_array[i].col] += 1\n",
      "        \n",
      "        # Based on the no. of terms in the previous row the row start index table can\n",
      "        # be computed. This helps in speeding up the transpose method.\n",
      "        for i in range(1,cols):\n",
      "            row_start[i] = row_start[i-1] + row_size[i-1]\n",
      "        \n",
      "        for i in range(terms):\n",
      "            j = row_start[sm_array[i].col]\n",
      "            tran._sm_array[j].row = sm_array[i].col\n",
      "            tran._sm_array[j].col = sm_array[i].row\n",
      "            tran._sm_array[j].value = sm_array[i].value\n",
      "            row_start[sm_array[i].col] += 1\n",
      "            \n",
      "    return tran\n",
      "\n",
      "SparseMatrix.fast_transpose = fast_transpose"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 18
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "def get_matrix(self,array):\n",
      "    \"\"\"\n",
      "    Stores the <row, col, value> triplets in the array to self\n",
      "    \"\"\"\n",
      "    try:\n",
      "        for i in range(len(array)):\n",
      "            tupl = array[i]\n",
      "            a._sm_array[i] = MatrixTerm(tupl[0],tupl[1],tupl[2])\n",
      "    except Exception,e:\n",
      "        pass\n",
      "        \n",
      "def print_matrix(self):\n",
      "    bmat = numpy.zeros((self._rows,self._cols))\n",
      "    for term in self._sm_array:\n",
      "        try:\n",
      "            bmat[term.row][term.col] = term.value\n",
      "        except Exception, e:\n",
      "            pass\n",
      "    print bmat\n",
      "\n",
      "# Helper methods to input an array of <row, col, value> triplets and to print the sparse matrix\n",
      "SparseMatrix.get_matrix = get_matrix\n",
      "SparseMatrix.print_matrix = print_matrix\n",
      "\n",
      "a = SparseMatrix(6,6,8)\n",
      "get_matrix(a,[(0,0,-15),(0,3,12),(0,5,-5),(1,1,1),(1,2,13),(2,3,-16),(4,0,9),(5,2,12)])\n",
      "print  'Matrix a\\n'\n",
      "print_matrix(a)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Matrix a\n",
        "\n",
        "[[-15.   0.   0.  12.   0.  -5.]\n",
        " [  0.   1.  13.   0.   0.   0.]\n",
        " [  0.   0.   0. -16.   0.   0.]\n",
        " [  0.   0.   0.   0.   0.   0.]\n",
        " [  9.   0.   0.   0.   0.   0.]\n",
        " [  0.   0.  12.   0.   0.   0.]]\n"
       ]
      }
     ],
     "prompt_number": 19
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Technically timeit should be run on different sized / valued inputs but here the same matrix a\n",
      "# is transposed repetitively instead to avoid complexity of generating a random sparse matrix\n",
      "\n",
      "%timeit a.transpose()\n",
      "tra = a.transpose()\n",
      "print '\\nTranspose of a\\n'\n",
      "print_matrix(tra)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 17.8 \u00b5s per loop\n",
        "\n",
        "Transpose of a\n",
        "\n",
        "[[-15.   0.   0.   0.   9.   0.]\n",
        " [  0.   1.   0.   0.   0.   0.]\n",
        " [  0.  13.   0.   0.   0.  12.]\n",
        " [ 12.   0. -16.   0.   0.   0.]\n",
        " [  0.   0.   0.   0.   0.   0.]\n",
        " [ -5.   0.   0.   0.   0.   0.]]\n"
       ]
      }
     ],
     "prompt_number": 20
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "%timeit a.fast_transpose()\n",
      "tra = a.fast_transpose()\n",
      "print '\\nFast Transpose of a\\n'\n",
      "print_matrix(tra)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "100000 loops, best of 3: 13.8 \u00b5s per loop\n",
        "\n",
        "Fast Transpose of a\n",
        "\n",
        "[[-15.   0.   0.   0.   9.   0.]\n",
        " [  0.   1.   0.   0.   0.   0.]\n",
        " [  0.  13.   0.   0.   0.  12.]\n",
        " [ 12.   0. -16.   0.   0.   0.]\n",
        " [  0.   0.   0.   0.   0.   0.]\n",
        " [ -5.   0.   0.   0.   0.   0.]]\n"
       ]
      }
     ],
     "prompt_number": 21
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Note that the sm_array has all the triplets ordered by row number.\n",
      "print \"Row\\tCol\\tValue\"\n",
      "print \"=======================\"\n",
      "for t in tra._sm_array:\n",
      "    print \"%d\\t%d\\t%d\"%(t.row, t.col, t.value)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Row\tCol\tValue\n",
        "=======================\n",
        "0\t0\t-15\n",
        "0\t4\t9\n",
        "1\t1\t1\n",
        "2\t1\t13\n",
        "2\t5\t12\n",
        "3\t0\t12\n",
        "3\t2\t-16\n",
        "5\t0\t-5\n"
       ]
      }
     ],
     "prompt_number": 22
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.12, PAGE 103"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Storing a Matrix Term\n",
      "\n",
      "def add_term(self,val,r,c):\n",
      "    # If sum != 0, then it is stored along with r and c as last term in self\n",
      "    if val != 0:\n",
      "        # Compute the index where the new Term must be inserted into the \n",
      "        # sm_array which is ordered by row no\n",
      "        \n",
      "        i = 0\n",
      "        while i < self._terms:\n",
      "            if self._sm_array[i].row > r:\n",
      "                break\n",
      "            i += 1\n",
      "                \n",
      "        self._sm_array.insert(i, MatrixTerm(row = r, col = c, value = val))\n",
      "        self._terms += 1\n",
      "        \n",
      "SparseMatrix.add_term = add_term"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 23
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.14, PAGE 104 - 106"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Multiply Sparse Matrices\n",
      "# Works in O(b.cols * a.terms + a.rows * b.terms)\n",
      "# This outperforms the standard O(a.rows * a.cols * b.cols) time if b.terms and a.terms are relatively low\n",
      "\n",
      "def multiply(self,b):\n",
      "    '''Return the product of sparse matrices self and b'''\n",
      "    \n",
      "    if self._cols != b._rows:\n",
      "        raise Exception('Incompatible Matrices.')\n",
      "\n",
      "    # b transpose makes the sm_array contain terms ordered by columns of b ( rows of b\u1d40 )\n",
      "    bXpose = b.fast_transpose()\n",
      "    \n",
      "    # The product matrix\n",
      "    product = SparseMatrix(self._rows, b._cols, 0)\n",
      "    \n",
      "    curr_row_index = 0\n",
      "    curr_row_begin = 0\n",
      "    curr_row_a = self._sm_array[0].row   # Current row of a that is being multiplied with the col of b\n",
      "    \n",
      "    # Introducing terms to help deal with the end condition\n",
      "    self._sm_array.append(MatrixTerm(row = self._rows, col = -1, value = None))\n",
      "    bXpose._sm_array.append(MatrixTerm(row = b._cols, col = -1, value = None))\n",
      "    \n",
      "    Sum = 0\n",
      "    \n",
      "    while curr_row_index < self._terms :\n",
      "        # Generate row current_row_a of d\n",
      "        curr_col_b = bXpose._sm_array[0].row\n",
      "        curr_col_index = 0\n",
      "        \n",
      "        while curr_col_index <= b._terms:\n",
      "            # Multiply row curr_row_a of self by column curr_col_b of b\n",
      "            \n",
      "            if self._sm_array[curr_row_index].row != curr_row_a:\n",
      "                # End of row curr_row_a\n",
      "                \n",
      "                # Add the sum to the product matrix at position { curr_row_a, curr_col_b }\n",
      "                product.add_term(Sum,curr_row_a,curr_col_b)\n",
      "                \n",
      "                Sum = 0 # Reset sum to 0\n",
      "                \n",
      "                # Reset to the beginning of current row ( of a ) for multiplication with next column ( of b )\n",
      "                curr_row_index = curr_row_begin\n",
      "                \n",
      "                # Advance to next column ( of b )\n",
      "                while bXpose._sm_array[curr_col_index].row == curr_col_b:\n",
      "                    curr_col_index += 1\n",
      "                \n",
      "                # Note that in Sparse Matrix the terms are arranged in rows\n",
      "                # bXpose's terms are arranged in columns of b ( or rows of bXpose )\n",
      "                curr_col_b = bXpose._sm_array[curr_col_index].row\n",
      "                \n",
      "            elif bXpose._sm_array[curr_col_index].row != curr_col_b :\n",
      "                # End of column curr_col_b of b\n",
      "                \n",
      "                # Add the sum to the product matrix at position { curr_row_a, curr_col_b }\n",
      "                product.add_term(Sum,curr_row_a,curr_col_b)\n",
      "                \n",
      "                Sum = 0 # Reset sum to 0\n",
      "                \n",
      "                # Reset to the beginning of current row ( of a ) for multiplication with next column ( of b )\n",
      "                curr_row_index = curr_row_begin\n",
      "                \n",
      "                # Advance to the next column in b \n",
      "                # ( note that bXpose._sm_array[curr_col_index].row points to the next column already )\n",
      "                curr_col_b = bXpose._sm_array[curr_col_index].row\n",
      "                \n",
      "            elif self._sm_array[curr_row_index].col < bXpose._sm_array[curr_col_index].col :\n",
      "                curr_row_index += 1 # Advance to the next term in row\n",
      "            \n",
      "            # FOLLOWING EXPLANATION DIAGRAMS NOT IN TEXTBOOK\n",
      "            #\n",
      "            # ( If the following  diagrams appear in two lines shrink your page size to below 100% )\n",
      "            #\n",
      "            # In the row curr_row_a, if the current column of the current term is \n",
      "            # same as the current row of b ( col of bXpose ) in the curr_col_b column\n",
      "            # multiply the terms and add to the Sum\n",
      "            #\n",
      "            #\n",
      "            #      a                      b               bXpose            product\n",
      "            #   \n",
      "            #   . . 0 .                 . . . 0          . . 0 .            . . . .\n",
      "            #   0 x . 0 \u25c0\u2015\u2015 curr_row_a  . 0 0 .          . 0 . 0            . . x .  \u25c0\u2015\u2015 Result row\n",
      "            #   . 0 . .                 0 . . .          . 0 . x \u25c0\u2500\u2510        . . . .\n",
      "            #   0 . 0 .                 . 0 x .          0 . . .   \u2502        . . . . \n",
      "            #                               \u25b2                      \u2502            \u25b2\n",
      "            #                               \u2502                curr_col_b         \u2502 \n",
      "            #                          curr_col_b                           Result col\n",
      "            #      \n",
      "            #    in a       : x = a._sm_matrix[curr_row_index]\n",
      "            #    in b       : x = b._sm_matrix[curr_col_index]\n",
      "            #    in product : x is the new term to be added for which the Sum is being computed\n",
      "            #\n",
      "            \n",
      "            elif self._sm_array[curr_row_index].col == bXpose._sm_array[curr_col_index].col :\n",
      "                # Add to sum\n",
      "                Sum += self._sm_array[curr_row_index].value * bXpose._sm_array[curr_col_index].value\n",
      "                curr_row_index += 1\n",
      "                curr_col_index += 1\n",
      "                \n",
      "            else: \n",
      "                curr_col_index += 1\n",
      "                # Next term in curr_col_b\n",
      "                \n",
      "        while self._sm_array[curr_row_index].row == curr_row_a :\n",
      "            # Advance to next row ( of a )\n",
      "            curr_row_index += 1\n",
      "            \n",
      "        curr_row_begin = curr_row_index\n",
      "        curr_row_a = self._sm_array[curr_row_index].row\n",
      "        \n",
      "    # To remove the last terms in a and d since the terms are empty:\n",
      "    del product._sm_array[-1]\n",
      "    del self._sm_array[-1]\n",
      "    del b._sm_array [-1]\n",
      "    \n",
      "    return product\n",
      "\n",
      "SparseMatrix.multiply = multiply"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 24
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "mult = a.multiply(tra)\n",
      "print 'Matrix a is \\n'\n",
      "print_matrix(a)\n",
      "print \"\\nMatrix a . a' is :\\n\"\n",
      "print_matrix(mult)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "Matrix a is \n",
        "\n",
        "[[-15.   0.   0.  12.   0.  -5.]\n",
        " [  0.   1.  13.   0.   0.   0.]\n",
        " [  0.   0.   0. -16.   0.   0.]\n",
        " [  0.   0.   0.   0.   0.   0.]\n",
        " [  9.   0.   0.   0.   0.   0.]\n",
        " [  0.   0.  12.   0.   0.   0.]]\n",
        "\n",
        "Matrix a . a' is :\n",
        "\n",
        "[[ 394.    0. -192.    0. -135.    0.]\n",
        " [   0.  170.    0.    0.    0.  156.]\n",
        " [-192.    0.  256.    0.    0.    0.]\n",
        " [   0.    0.    0.    0.    0.    0.]\n",
        " [-135.    0.    0.    0.   81.    0.]\n",
        " [   0.  156.    0.    0.    0.    0.]]\n"
       ]
      }
     ],
     "prompt_number": 25
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "ADT 2.5, PAGE 114"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Abstract Datatype String\n",
      "class String(object):\n",
      "    def __init__(self,init):\n",
      "        # Constructor that initializes self to string init of length of m\n",
      "        self._str = init\n",
      "        self._length = len(init)\n",
      "        self.failure_function()\n",
      "        \n",
      "    def __eq__(self,t):\n",
      "        # overloading == operators\n",
      "        return self._str == t._str\n",
      "    \n",
      "    def __not__(self):\n",
      "        if self._length <= 0:\n",
      "            print True\n",
      "        else:\n",
      "            print False\n",
      "            \n",
      "    def length(self):\n",
      "        return self._length\n",
      "    \n",
      "    def concat(self,left):\n",
      "        self._str += t\n",
      "        return self\n",
      "    \n",
      "    def substr(self,i,j):\n",
      "        \"\"\"\n",
      "        Return a substring whose starting index is i and length is j\n",
      "        \"\"\"\n",
      "        try:\n",
      "            substr = self._str[i:i+j]\n",
      "            return substr\n",
      "        \n",
      "        except IndexError:\n",
      "            print 'Invalid index / length to get Substring'\n",
      "        \n",
      "    def find(self, pat):\n",
      "        '''Returns an index i such that pat matches the substring of self that begins at position of i\n",
      "           Returns -1 if pat is either empty or not a substring'''\n",
      "        pass    "
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 26
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.15, PAGE 115"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Exhaustive Pattern Matching\n",
      "\n",
      "def find(self,pat):\n",
      "    '''Return -1 if pat does not occur in self\n",
      "       otherwise return the first position in self, where pat begins'''\n",
      "    \n",
      "    for start in range(self.length()-pat.length()+1) :\n",
      "        # Check for match beginning at str[start]\n",
      "        for j in range(pat.length()) :\n",
      "            # Character by character checking\n",
      "            \n",
      "            if self._str[start + j] != pat._str[j]:\n",
      "                break\n",
      "                \n",
      "            if j == pat.length()-1:\n",
      "                # Match found\n",
      "                return start\n",
      "    \n",
      "    # Pat is empty or does not occur in string\n",
      "    return -1  \n",
      "\n",
      "# NOTE : The entire program can be implemented using python string function as follows: \n",
      "# self._str.find(pat)\n",
      "\n",
      "String.find = find"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 27
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.16, PAGE 117"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Faster implementation of the find method using the failure array and failure function to \n",
      "# allow resuming search at partial matches. The failure vector is stored at String.f\n",
      "\n",
      "# Runs in O( LengthP + LengthS )\n",
      "\n",
      "def fast_find(self, pat):\n",
      "    posP = 0\n",
      "    posS = 0\n",
      "\n",
      "    lengthP = pat.length()\n",
      "    lengthS = self.length()\n",
      "    \n",
      "    while ( posP < lengthP ) and ( posS < lengthS ):\n",
      "        if pat._str[posP] == self._str[posS] :\n",
      "            posP += 1\n",
      "            posS += 1\n",
      "            \n",
      "        elif posP == 0:\n",
      "            posS += 1\n",
      "            \n",
      "        else:\n",
      "            posP = pat.f[posP - 1] + 1\n",
      "            \n",
      "    if posP < lengthP :\n",
      "        return -1\n",
      "    else:\n",
      "        return posS-lengthP\n",
      "    \n",
      "String.fast_find = fast_find"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 28
    },
    {
     "cell_type": "heading",
     "level": 2,
     "metadata": {},
     "source": [
      "PROGRAM 2.17, PAGE 118"
     ]
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Computing the failure function\n",
      "\n",
      "def failure_function(self):\n",
      "    lengthP = self.length()\n",
      "    self.f = [0]*lengthP\n",
      "    self.f[0] = -1\n",
      "    for j in range(1,lengthP):\n",
      "        i = self.f[j-1]\n",
      "        while ( self._str[j] != self._str[i+1] ) and  ( i >= 0 ):\n",
      "            i = self.f[i]\n",
      "        if self._str[j] == self._str[i+1]:\n",
      "            self.f[j] = i + 1\n",
      "        else:\n",
      "            self.f[j-1] = -1\n",
      "            \n",
      "String.failure_function = failure_function"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [],
     "prompt_number": 29
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str1 = String('hello world')\n",
      "str2 = String('sdf')\n",
      "print str1.find(str2), str1.fast_find(str2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "-1 -1\n"
       ]
      }
     ],
     "prompt_number": 30
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "str2 = String('ell')\n",
      "print str1.find(str2), str1.fast_find(str2)"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "output_type": "stream",
       "stream": "stdout",
       "text": [
        "1 1\n"
       ]
      }
     ],
     "prompt_number": 31
    },
    {
     "cell_type": "code",
     "collapsed": false,
     "input": [
      "# Analysing the above two find methods\n",
      "x_axis = range(10, 1000, 50)\n",
      "find_run_time = []\n",
      "fast_find_run_time = []\n",
      "\n",
      "\n",
      "for i in x_axis:\n",
      "    string = String(''.join(choice(ascii_letters) for _ in range(i))) # Generates a random string of i chars\n",
      "    pattern = String(''.join(choice(ascii_letters) for _ in range(i/2))) # Generates a random pattern string of i chars\n",
      "    start = time()\n",
      "    for i in range(10):\n",
      "        string.find(pattern)\n",
      "    find_run_time.append((time() - start) / 10) # Takes average over 10 runs\n",
      "    start = time()\n",
      "    for i in range(10):\n",
      "        string.fast_find(pattern)\n",
      "    fast_find_run_time.append((time() - start) / 10)\n",
      "    \n",
      "\n",
      "# NOTE: All these are typically failure / worst case run times, \n",
      "# since the probability of a random pattern matching with a random string is very low\n",
      "\n",
      "# Note the quadratic run time of find and linear run time of fast_find\n",
      "    \n",
      "%matplotlib inline    \n",
      "plt.figure().set_size_inches(10,10)\n",
      "plt.xlabel(\"Size of the input string : n \")\n",
      "plt.ylabel(\"Time in ms for the find operation\")\n",
      "\n",
      "plt.plot(x_axis, find_run_time, marker = \"o\", linestyle = \"--\", c=\"b\", label=\"find\")\n",
      "plt.plot(x_axis, fast_find_run_time, marker = \"o\", linestyle = \"--\", c=\"r\", label=\"fast_find\")\n",
      "plt.legend()\n",
      "plt.show()"
     ],
     "language": "python",
     "metadata": {},
     "outputs": [
      {
       "metadata": {},
       "output_type": "display_data",
       "png": "iVBORw0KGgoAAAANSUhEUgAAAnwAAAJeCAYAAAAuidhrAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n",
       "text": [
        "<matplotlib.figure.Figure at 0x7f4c4e92c9d0>"
       ]
      }
     ],
     "prompt_number": 32
    }
   ],
   "metadata": {}
  }
 ]
}