13_classes_instances.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Classes & Instances"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Definition\n",
    "\n",
    "In contrast to all the built-in data types introduced so far, *classes* are **user-defined data types** that allow the programmer to create new and **abstract** ways to look at data **and its associated behavior** and to manage the **state encapsulated** in **concrete** *instances* of these custom data types.\n",
    "\n",
    "Classes enable the **[object-oriented programming](https://en.wikipedia.org/wiki/Object-oriented_programming)** (OOP) paradigm where **large programs** are broken down into many **small components** and **code** is **re-used**. This way, a program that is too big for a programmer to fully understand directly becomes maintainable via its easier to comprehend individual pieces."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Approximate Simplified Definition\n",
    "\n",
    "Classes are user-defined types that enable a programming style where different components of a computer program are modeled after real world objects. In this sense, classes are abstract blueprints for concrete instances in the real world."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this latter definition is often true, advanced programmers highlight primarily the **managing state** and **code maintainability and re-use** aspects when it comes to object-orientation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Often times, we see the terminology \"classes & objects\" instead of \"classes & instances\" used by programmers on forums like [Stack Overflow](https://stackoverflow.com) but also in books on Python. In this notebook, we will be more precise as both classes and instances are actually objects (i.e., they have an identity or memory address, a type that specifies the behavior, and a value)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example: Vectors and Matrices\n",
    "\n",
    "Neither core Python nor the Standard Library offer an implementation of common [linear algebra](https://en.wikipedia.org/wiki/Linear_algebra) functionalities. While the popular third-party library [numpy](http://www.numpy.org/) is the de-facto standard and is recommended to be used for real-life production scenarios, we will showcase how one could use Python's object-oriented language features to implement common matrix and vector operations throughout this notebook."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Naively, we could model a vector $\\vec{y} = \\begin{pmatrix} 1 \\\\ 2 \\\\ 3 \\end{pmatrix}$ using a tuple or a list depending on if we wish the vector to be a mutable object or not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = (1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 2, 3)"
      ]
     },
     "execution_count": 2,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can extend this approach and model a matrix $\\bf{X} = \\begin{bmatrix} 1 & 2 & 3 \\\\ 4 & 5 & 6 \\\\ 7 & 8 & 9 \\end{bmatrix}$ as either a tuple of tuples or a list of lists or a mixture thereof.\n",
    "\n",
    "Observe that we need to decide if we wish to use a list of rows or a list of columns (the same with tuples) and go with the former, which is a popular convention."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [],
   "source": [
    "X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "While this way of representing vectors and matrices in memory keeps things simple, Python's object-oriented features allow us to model their inherent semantics and eventually to create a new **[domain-specific language](https://en.wikipedia.org/wiki/Domain-specific_language)** (DSL) that simplifies working with vectors and matrices."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, semantically we should be able to multiply a matrix with a vector. However, Python does not know how to multiply a list of lists with a tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'tuple'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-5-c494e576a745>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'tuple'"
     ]
    }
   ],
   "source": [
    "X * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the next section we will introduce two user-defined data types `Vector` and `Matrix` that are then iteratively refined throughout this notebook to build up more and more behavior around the tuple and list of lists approaches that remain at the heart of the new data types representing the encapsulated state (i.e., the entries of the vectors and matrices)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Class Definition\n",
    "\n",
    "The `class` statement creates a new variable that points to a so-called **class object** in memory."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Following the **header** line, the indented **body** syntactically consists of function definitions (i.e., the `def` statements) and variable assignments (the `dummy_class_variable`). Any code put here is executed just as if it would be without the `class` statement but the class now acts as a **namespace**, i.e., we can access the resulting names with the dot operator `.` on the class object. These names are also called **class attributes**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Within this context, a function is referred to as a **method** that will be **bound** to future **instance objects** created from the class object. The binding process means that Python implicitly inserts a reference to a specific instance object as the first argument to any method invocation that we have to capture in the `def` statement. By convention, we name this first parameter of every method `self` as it references the concrete instance object on which the method is invoked. Then, within the scope of this method we can set and access attributes via the dot operator `.` on `self`."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python allows us to define so-called **magic methods** (named in the \"dunder\" style) on a class that make the new data type fit into Python's language features seaminglessly. While some important magic methods are discussed in detail in this notebook, see the [Language Reference](https://docs.python.org/3/reference/datamodel.html) for an exhaustive list of all such methods and the arguments they expect. Magic methods not defined on a class are implicitly replaced by their default implementation as mentionend in the Reference."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The example below shows three magic methods. `__init__()` is the one responsible for **initializing** a new instance object, which usually means setting **instance attributes**. The example expects a new vector to be created from some iterable object (e.g., a list or tuple) passed in as the `data` argument and then stores its elements in a list `_entries` on the new instance referenced as `self` after converting them to floats. The other two magic methods `__repr__()` and `__str__()` are discussed further below."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A best practice is to **seperate** the **usage** of a new data type **from its implementation**. By convention, attributes (both on classes and instances) that should not be accessed from anywhere outside of methods have a name starting with an underscore \"\\_\" (many other programming languages use the keywords *private* or *protected* instead of this convention). On the contrary, attributes not starting with an underscore \"\\_\", can safely be accessed from anywhere in a program. In the example, the instance attribute `self._entries` is such an implementation detail: we could have decided to store a vector's entries in a tuple instead of a list which should not affect how we use a vector instance later. This concept is also known as **information hiding** in the software engineering literature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Lastly, as indicated by [PEP 257](https://www.python.org/dev/peps/pep-0257/) and also section 3.8.4 of the [Google Python Style Guide](https://github.com/google/styleguide/blob/gh-pages/pyguide.md), we should use docstrings to document relevant parts of the new data type. With respect to naming, classes are named according to the CamelCase convention while instances are treated like normal variables and named in snake\\_case. Note that after this first example of `Vector` and `Matrix` classes we do not always repeat all the magic methods such as `__repr__()` or `__str__()` and leave out the docstrings for brevity."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    \"\"\"A standard one-dimensional vector from linear algebra.\n",
    "\n",
    "    Note that all the entries are converted to floats.\n",
    "    \"\"\"\n",
    "\n",
    "    dummy_class_variable = \"I am a vector\"\n",
    "\n",
    "    def __init__(self, data):\n",
    "        \"\"\"Initiate a new vector.\n",
    "\n",
    "        Args:\n",
    "            data (iterable): The vector's entries.\n",
    "                Must have at least one element.\n",
    "        Raises:\n",
    "            ValueError: If the provided data do not have enough entries.\n",
    "        \"\"\"\n",
    "        self._entries = list(float(x) for x in data)\n",
    "        if len(self._entries) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"Vector((\" + \", \".join(\"{:.3f}\".format(x) for x in self._entries) + \"))\"\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Vector({:.1f}, ..., {:.1f})[{:d}]\".format(\n",
    "                   self._entries[0], self._entries[-1], len(self._entries))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`Vector` is a full-fledged object on its own. Its type `type` indicates that it represents a user-defined data type and it evaluates to its fully qualified name."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51519944"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(Vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Vector"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The docstrings are transformed into nice help texts."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [],
   "source": [
    "Vector?"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the built-in function [vars()](https://docs.python.org/3/library/functions.html#vars) as an alternative to [dir()](https://docs.python.org/3/library/functions.html#dir) to obtain a brief summary of the attributes on `Vector`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "mappingproxy({'__module__': '__main__',\n",
       "              '__doc__': 'A standard one-dimensional vector from linear algebra.\\n\\n    Note that all the entries are converted to floats.\\n    ',\n",
       "              'dummy_class_variable': 'I am a vector',\n",
       "              '__init__': <function __main__.Vector.__init__(self, data)>,\n",
       "              '__repr__': <function __main__.Vector.__repr__(self)>,\n",
       "              '__str__': <function __main__.Vector.__str__(self)>,\n",
       "              '__dict__': <attribute '__dict__' of 'Vector' objects>,\n",
       "              '__weakref__': <attribute '__weakref__' of 'Vector' objects>})"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vars(Vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The dot operator `.` can be used to access class attributes and also the methods which are ordinary function objects."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'I am a vector'"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector.dummy_class_variable"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "<function __main__.Vector.__init__(self, data)>"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector.__init__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every class object also comes with a special hidden `__name__` attribute that tells us the name of the class. This is usually the same as the variable `Vector` which points at the class object. At first, this seems kind of redundant but we will see a usage for it at the end of this notebook when we learn about inheritance."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vector'"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Vector.__name__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To **create an instance** object of type `Vector`, we **call a class** object just like a function with the `(...)` operator. This is forwarded to the `__init__()` magic method behind the scenes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that although the `__init__()` method above defines two parameters, we have to call it with exactly one argument (that must be an iterable of at least one element) as Python implicitly inserts the newly created instance object (i.e., `v`) as the first argument."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 1 required positional argument: 'data'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-16-bcda4006949f>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'data'"
     ]
    }
   ],
   "source": [
    "Vector()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() takes 2 positional arguments but 4 were given",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-17-e00314c6a560>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() takes 2 positional arguments but 4 were given"
     ]
    }
   ],
   "source": [
    "Vector(1, 2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "A vector must have at least one entry!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-18-07c486490158>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mVector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-6-03bcc9cb43bb>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m     18\u001b[0m         \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mlist\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mfloat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mdata\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     19\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 20\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"A vector must have at least one entry!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     21\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: A vector must have at least one entry!"
     ]
    }
   ],
   "source": [
    "Vector(())"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`v` is a full-fledged object as well. In general, as the overarching storyline of all notebooks so far indiciates, everything in Python is an object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140709439399080"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Vector"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Every instance object comes with a special instance attribute `__class__` that also references the corresponding class object."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Vector"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.__class__"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "When we evaluate `v` in the command line, we actually see the return value of the `__repr__()` magic method. How we should use it, is specified in the [Language Reference](https://docs.python.org/3/reference/datamodel.html#object.__repr__). In brief, `__repr__()` should return a string that when entered in the Python command line, creates a new instance object with the same state as the original one we evaluated. In other words, it should return a string representation of the object optimized for direct consumption by a machine. This is often useful in debugging or logging scenarios in large applications."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((1.000, 2.000, 3.000))"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To make this magic more explicit, we could alternatively call the [repr()]( https://docs.python.org/3/library/functions.html#repr) built-in function with `v` as the argument (Note that the quotes in the previous cell are removed by Jupyter)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vector((1.000, 2.000, 3.000))'"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "repr(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "On the contrary, the `__str__()` magic method should return a human-readable representation of the object according to the [Language Reference](https://docs.python.org/3/reference/datamodel.html#object.__str__). We can use the built-ins [str()](https://docs.python.org/3/library/functions.html#func-str) or [print()](https://docs.python.org/3/library/functions.html#print) to retrieve this string explicitly. As implemented above, this representation only shows a vector's first and last entries followed by the vector's length in brackets."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Vector(1.0, ..., 3.0)[3]'"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "str(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that the [print()](https://docs.python.org/3/library/functions.html#print) function by default does not show the enclosing quotes."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector(1.0, ..., 3.0)[3]\n"
     ]
    }
   ],
   "source": [
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Below is a first implementation of the `Matrix` class that stores the data internally as a list of lists."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "    \"\"\"A standard m-by-n-dimensional matrix from linear algebra.\n",
    "\n",
    "    Note that all the entries are converted to floats.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, data):\n",
    "        \"\"\"Initiate a new matrix.\n",
    "\n",
    "        Args:\n",
    "            data (iterable of iterables): The matrix's entries.\n",
    "                Must be provided with rows first, then columns.\n",
    "                The number of column entries must be consistent per row\n",
    "                    while the first row sets the correct number.\n",
    "                Must have at least one element in total.\n",
    "        Raises:\n",
    "            TypeError: If the number of columns is inconsistent across the rows.\n",
    "            ValueError: If the provided data do not have enough entries.\n",
    "        \"\"\"\n",
    "        self._entries = list(list(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  len(self._entries[0]):\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if len(self._entries) == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (\"Matrix((\" + \", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row)\n",
    "                                       + \",)\" for row in self._entries) + \"))\")\n",
    "\n",
    "    def __str__(self):\n",
    "        return \"Matrix(({:.1f}, ...), ..., (..., {:.1f}))[{:d}x{:d}]\".format(\n",
    "                   self._entries[0][0], self._entries[-1][-1],\n",
    "                   len(self._entries), len(self._entries[0]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51448216"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(Matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "type"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(Matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Matrix"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "Matrix"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's create a new `Matrix` instance from a list of tuples. The string representations work as above."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 2, 3), (4, 5, 6), (7, 8, 9)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "140709439473984"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "id(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "__main__.Matrix"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,), (4.000, 5.000, 6.000,), (7.000, 8.000, 9.000,)))"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix((1.0, ...), ..., (..., 9.0))[3x3]\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Wrong usage of `Matrix` results in the documented exceptions."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "__init__() missing 1 required positional argument: 'data'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-35-9d6cd6032399>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: __init__() missing 1 required positional argument: 'data'"
     ]
    }
   ],
   "source": [
    "Matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "A matrix must have at least one entry!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-36-87c8bd55bdc1>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-26-1c7109fcd552>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m     23\u001b[0m                 \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Each row must have the same number of entries!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 25\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"A matrix must have at least one entry!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     26\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     27\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m__repr__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: A matrix must have at least one entry!"
     ]
    }
   ],
   "source": [
    "Matrix(())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "Each row must have the same number of entries!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-37-359f87edecdf>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mMatrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m5\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-26-1c7109fcd552>\u001b[0m in \u001b[0;36m__init__\u001b[0;34m(self, data)\u001b[0m\n\u001b[1;32m     21\u001b[0m         \u001b[0;32mfor\u001b[0m \u001b[0mrow\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     22\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mrow\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m  \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 23\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mTypeError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Each row must have the same number of entries!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     24\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_entries\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     25\u001b[0m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"A matrix must have at least one entry!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: Each row must have the same number of entries!"
     ]
    }
   ],
   "source": [
    "Matrix([(1, 2, 3), (4, 5)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Computed Properties\n",
    "\n",
    "After creation an instance may exhibit certain properties that depend on the concrete data it represents but are not captured explicitly by the defined class or instance attributes. For example, a `Matrix` instance can be thought of having `n_rows` and `n_cols` properties that result from the individual entries passed to it upon creation and are integers representing its dimensions $m$ and $n$."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Python provides a [property()](https://docs.python.org/3/library/functions.html#property) built-in that can be used together with a special `@` syntax (covered in a later notebook on so-called decorators) to create **derived** attributes that are computed from an object's current state as shown below. Note that we already use the new properties in the `__init__()` method."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = list(list(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if self.n_rows == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (\"Matrix((\" + \", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row)\n",
    "                                       + \",)\" for row in self._entries) + \"))\")\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 2, 3), (4, 5, 6)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`m` is a $2$ by $3$ matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 3)"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.n_rows, m.n_cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In its basic form, properties are read-only attributes. This makes sense for `Matrix` instances as we cannot just define how many rows and columns there are while keeping the entries unchanged."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "ename": "AttributeError",
     "evalue": "can't set attribute",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-41-f4cc4767ae11>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_rows\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mAttributeError\u001b[0m: can't set attribute"
     ]
    }
   ],
   "source": [
    "m.n_rows = 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A later notebook on so-called descriptors will extend the nature of properties into managed attributes."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Instance Methods & Class Methods\n",
    "\n",
    "In addition to the magic methods so far, we can define normal **instance methods** and **class methods** (the latter using the `@` syntax from above with the [classmethod()](https://docs.python.org/3/library/functions.html#classmethod) built-in)."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Instance methods depend on the state (i.e., entries) of a concrete instance object. We can see this as instance methods usually need to access some attributes on the `self` variable in order to perform their work. If a method does not need access to `self`, it might conceptually not be an instance method to start with. An example of an instance method is `transpose()` below that switches the rows and columns of a matrix and returns a new `Matrix` instance based off that. It is implemented by using the [zip()](https://docs.python.org/3/library/functions.html#zip) built-in function in a \"tricky\" way."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Class methods on the contrary do not depend on the state of a concrete instance but on the class object instead. Python implicitly inserts a reference to the latter whenever such a method is invoked. By convention, we name this parameter `cls`. Class methods are commonly used to provide an alternative way to create new instance objects. In the example below, `from_columns()` expects an iterable of columns (instead of rows) and creates a new `Matrix` instance."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "There is also a [staticmethod()](https://docs.python.org/3/library/functions.html#staticmethod) built-in to define methods that are independent from both the class and instance objects but nevertheless are related semantically to the class somehow."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = list(list(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if self.n_rows == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (\"Matrix((\" + \", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row)\n",
    "                                       + \",)\" for row in self._entries) + \"))\")\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])\n",
    "\n",
    "    def transpose(self):\n",
    "        return self.__class__(zip(*self._entries))\n",
    "\n",
    "    @classmethod\n",
    "    def from_columns(cls, data):\n",
    "        return cls(data).transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 2, 3), (4, 5, 6)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,), (4.000, 5.000, 6.000,)))"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `transpose()` method returns a new instance object where rows and columns are switched. This method can be \n",
    "chained which negates the effect of the switching."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 4.000,), (2.000, 5.000,), (3.000, 6.000,)))"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = m.transpose().transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,), (4.000, 5.000, 6.000,)))"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "However, the instance `n` is a different object than the original instance `m`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m is n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Surprisingly, the equality operator `==` returns a wrong result as `m` and `n` are actually matrices with the exact same entries. We will correct this in the section on operator overloading below."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m == n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can use the alternative constructor `from_columns()` to create an equivalent matrix from a list of columns instead of rows."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix.from_columns([(1, 4), (2, 5), (3, 6)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,), (4.000, 5.000, 6.000,)))"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Sequence Emulation\n",
    "\n",
    "A *sequence* type $s$ is any type that allows indexing for an integer $i$ where $0 \\le i \\lt$ [len($s$)](https://docs.python.org/3/library/functions.html#len).\n",
    "\n",
    "In order to make `Vector` and `Matrix` instances sequentially iterable, we need to define the `__len()__` and `__getitem__()` magic methods that are part of the [Language Reference](https://docs.python.org/3/reference/datamodel.html#emulating-container-types)'s documentation on container types. While the former calculates the number of elements in a container type, the latter implements the indexing operator `[...]`.\n",
    "\n",
    "Note that we use the [isinstance()](https://docs.python.org/3/library/functions.html#isinstance) built-in function to validate the type of the `index` parameter and that more background on this function is given in the section on inheritance further below. Also, we implicitly use the `__len__()` method inside the `__init__()` method already with `len(self)`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = list(float(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Now we can obtain the number of elements with the [len()](https://docs.python.org/3/library/functions.html#len) built-in function, index into `Vector` objects, and also iterate over them with a `for` statement."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0  2.0  3.0  4.0  "
     ]
    }
   ],
   "source": [
    "for entry in v:\n",
    "    print(entry, end=\"  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that indexing so far is a read-only operation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "'Vector' object does not support item assignment",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-57-ac550dc2349d>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m]\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0;36m99\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: 'Vector' object does not support item assignment"
     ]
    }
   ],
   "source": [
    "v[0] = 99"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Observe that as a matrix is two-dimensional, we need to choose if we first flatten the rows or columns. We choose the approach where we first iterate over the first row, then the second, and so on, which is called a **[row major approach](https://en.wikipedia.org/wiki/Row-_and_column-major_order)** in the software engineering literature.\n",
    "\n",
    "In addition to indexing by integer, we also implement indexing by tuples of integers for the `Matrix` class where the first item is an integer representing the row and the second representing the column. Deciding what to do inside a function or method dependent on the type of an argument is known as **type dispatching**."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, note how the `__len__()` method depends on the properties `n_rows` and `n_cols`. In general, it is often the case that the (magic) methods are interwoven."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = list(list(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_rows * self.n_cols\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if isinstance(index, int):\n",
    "            if index < 0:\n",
    "                index += len(self)\n",
    "            if not (0 <= index < len(self)):\n",
    "                raise IndexError(\"integer index out of range!\")\n",
    "            row, col = divmod(index, self.n_cols)\n",
    "            return self._entries[row][col]\n",
    "        elif (isinstance(index, tuple) and len(index) == 2\n",
    "            and isinstance(index[0], int) and isinstance(index[1], int)\n",
    "        ):\n",
    "            return self._entries[index[0]][index[1]]\n",
    "        raise TypeError(\"index must be either an integer or a tuple of two integers!\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 1), (4, 4)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4"
      ]
     },
     "execution_count": 60,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.0"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[-1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "4.0"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m[1, 1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0  1.0  4.0  4.0  "
     ]
    }
   ],
   "source": [
    "for entry in m:\n",
    "    print(entry, end=\"  \")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Mutability vs. Immutability\n",
    "\n",
    "In the above implementation we store the entries of a `Vector` or `Matrix` instance in either a list or a list of lists in the instance attribute `_entries`, which is by the convention of the leading underscore an implementation detail and should not be directly accessed via the dot operator `.` from the outside of the instance (i.e., anything but `self._entries` is not allowed).\n",
    "\n",
    "So long as we adhere to this convention, `Vector` and `Matrix` instances are immutable. If we do not want to rely on the users of our classes to just adhere to our \"soft\" rules, we could use tuples or tuples of tuples instead and thereby enforce the immutable nature."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In line with that, we implemented the `transpose()` method such that it creates and returns a new instance. We could have chosen a different path and make the method change the `self._entries` attribute in place behind the scenes. Such decisions are better made consciously when designing a new data type. The main trade-off in the context of data science applications is that immutable data types are typically easier to reason about when it comes to issues such as code correctness whereas mutable data types are more memory efficient and make algorithms faster as less copying operations take place in memory. However, this trade-off only becomes critical when we deal with big amounts of data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Customizing Indexing & Slicing\n",
    "\n",
    "Analogous to the `__getitem__()` magic method above, there are also the `__setitem__()` and `__delitem__()` magic methods that either assign to or delete (with the `del` statement) an index of a container type (see the full documentation in the [Language Reference](https://docs.python.org/3/reference/datamodel.html#emulating-container-types)). Whereas deleting an individual entry in a `Vector` or `Matrix` instance does not make sense semantically, we could allow changing an entry like in the example below (only shown for the `Vector` case for brevity). While the example only shows the indexing case, everything described in this sub-section can also be generalized to the slicing case.\n",
    "\n",
    "Consequently, we can design user-defined data types to be explicitly mutable as well."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the example, `__setitem__()` just \"forwards\" the assignment to the embedded list after casting the assigned value as a `float`. This is a design principle known as [delegation](https://en.wikipedia.org/wiki/Delegation_%28object-oriented_programming%29) in the software engineering literature."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = list(float(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]\n",
    "\n",
    "    def __setitem__(self, index, value):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        self._entries[index] = float(value)\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"Vector((\" + \", \".join(\"{:.3f}\".format(x) for x in self) + \"))\""
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector([99, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((99.000, 2.000, 3.000, 4.000))"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`v` can now we changed in place."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[0] = 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((1.000, 2.000, 3.000, 4.000))"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Customizing Attribute Access\n",
    "\n",
    "Analogous to the previous sub-section, Python also allows us to customize the way getting, setting, and deleting an instance attribute via the dot operator `.` works. This is achieved with the `__getattr__()`, `__setattr__()`, `__delattr__()`, and `__getattribute__()` magic methods as described in the [Language Reference](https://docs.python.org/3/reference/datamodel.html#customizing-attribute-access) but not covered here due to its similarity with the content in the previous sub-section. [getattr()](https://docs.python.org/3/library/functions.html#getattr), [hasattr()](https://docs.python.org/3/library/functions.html#hasattr), and [delattr()](https://docs.python.org/3/library/functions.html#delattr) are the corresponding built-in functions that deal with the aforementioned magic methods on instances similar as the indexing operator `[...]` does in the previous sub-section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Polymorphic Functions\n",
    "\n",
    "A function is considered **polymorphic** if it can work with several data types. The main advantage is re-use of the function's code.\n",
    "\n",
    "We know such functions already: The [sum()](https://docs.python.org/3/library/functions.html#sum) built-in is a trivial example that works on all kinds of iterables. As we implemented the `Vector` and `Matrix` classes to be iterable, we can use them here too."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum((1, 2, 3, 4))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum([1, 2, 3, 4])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum({1, 2, 3, 4})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum({1: 996, 2: 997, 3: 998, 4: 999})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "sum(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "A polymorphic function with a semantic meaning in the context of linear algebra would be one that calculates the [Euclidean norm](https://en.wikipedia.org/wiki/Norm_%28mathematics%29#Euclidean_norm) for vectors, which is basically a generalization of the popular [Pythagorean theorem](https://en.wikipedia.org/wiki/Pythagorean_theorem). Extending the same computation to a matrix results in the even more general [Frobenius norm](https://en.wikipedia.org/wiki/Matrix_norm#Frobenius_norm):\n",
    "\n",
    "$$\\lVert \\bf{X} \\rVert_F = \\sqrt{ \\sum_{i=1}^m \\sum_{j=1}^n x_{ij}^2 }$$\n",
    "\n",
    "The `norm` function below can handle both a `Vector` and a `Matrix` object and is therefore polymorphic."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "def norm(vector_or_matrix):\n",
    "    \"\"\"Calculate the Frobenius or Euclidean norm of a matrix or vector.\"\"\"\n",
    "    return sqrt(sum(x ** 2 for x in vector_or_matrix))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.477225575051661"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.830951894845301"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "norm(m)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "An important criterion if different classes are compatible with each other in the sense that they can be used by the same polymorphic function is that they implement the same **interface**. Whereas many other programming languages formalize this [concept](https://en.wikipedia.org/wiki/Protocol_%28object-oriented_programming%29), in core Python the term refers to the rather loose idea that different classes define the same (public) attributes and methods and implement the various protocols behind the magic methods in the same way. However, the [abc](https://docs.python.org/3/library/abc.html) module in the Standard Library adds the possibility to force different classes to implement a pre-defined interface."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Representations of Data\n",
    "\n",
    "> \"If you change the way you look at things, the things you look at change.\"\n",
    "> -- philosopher and personal coach [Dr. Wayne Dyer](https://en.wikipedia.org/wiki/Wayne_Dyer)\n",
    "\n",
    "Sometimes it is helpful to view a vector as a matrix with either one row or one column. On the contrary, such a matrix can always be interpreted as a vector again. Changing the representation of data can be viewed as changing an object's type in Python. To be precise, the `as_matrix()` and `as_vector()` methods below create new `Matrix` or `Vector` instances out of existing `Vector` or `Matrix` instances, respectively.\n",
    "\n",
    "Note that from now on we use tuples and tuples of tuples to store the entries in the `self._entries` instance attribute to make our instances fully immutable."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = tuple(float(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"Vector((\" + \", \".join(\"{:.3f}\".format(x) for x in self) + \"))\"\n",
    "\n",
    "    def as_matrix(self, column=True):\n",
    "        if column:\n",
    "            return Matrix([x] for x in self)\n",
    "        return Matrix([(x for x in self)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = tuple(tuple(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_rows * self.n_cols\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if isinstance(index, int):\n",
    "            if index < 0:\n",
    "                index += len(self)\n",
    "            if not (0 <= index < len(self)):\n",
    "                raise IndexError(\"integer index out of range!\")\n",
    "            row, col = divmod(index, self.n_cols)\n",
    "            return self._entries[row][col]\n",
    "        elif (isinstance(index, tuple) and len(index) == 2\n",
    "            and isinstance(index[0], int) and isinstance(index[1], int)\n",
    "        ):\n",
    "            return self._entries[index[0]][index[1]]\n",
    "        raise TypeError(\"index must be either an integer or a tuple of two integers!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (\"Matrix((\" + \", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row)\n",
    "                                       + \",)\" for row in self._entries) + \"))\")\n",
    "\n",
    "    def as_vector(self):\n",
    "        if not (self.n_rows == 1 or self.n_cols == 1):\n",
    "            raise TypeError(\"One dimension (m or n) must be 1 so that the \"\n",
    "                            \"matrix can be converted into a vector!\")\n",
    "        return Vector(x for x in self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector([1, 2, 3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((1.000, 2.000, 3.000))"
      ]
     },
     "execution_count": 82,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's interpret `v` as a column vector and create a matrix of dimension $3$ by $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = v.as_matrix()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000,), (2.000,), (3.000,)))"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 1)"
      ]
     },
     "execution_count": 85,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.n_rows, m.n_cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "By chaining `as_matrix()` and `as_vector()` we get a new `Vector` instance back that is equivalent to the given `v`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((1.000, 2.000, 3.000))"
      ]
     },
     "execution_count": 86,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.as_matrix().as_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In the same way, we can also interpret `v` as a row vector and create a $1$ by $3$ matrix."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = v.as_matrix(column=False)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,)))"
      ]
     },
     "execution_count": 88,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 3)"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m.n_rows, m.n_cols"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((1.000, 2.000, 3.000))"
      ]
     },
     "execution_count": 90,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v.as_matrix(column=False).as_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Interpreting a matrix as a vector only works if one of the two dimensions $m$ or $n$ is $1$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 2), (3, 4)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "One dimension (m or n) must be 1 so that the matrix can be converted into a vector!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-92-625d8ddab141>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mm\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_vector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-80-7c5f0bcb1ec5>\u001b[0m in \u001b[0;36mas_vector\u001b[0;34m(self)\u001b[0m\n\u001b[1;32m     40\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0mas_vector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     41\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0;32mnot\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_rows\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m \u001b[0;32mor\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_cols\u001b[0m \u001b[0;34m==\u001b[0m \u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m             raise TypeError(\"One dimension (m or n) must be 1 so that the \"\n\u001b[0m\u001b[1;32m     43\u001b[0m                             \"matrix can be converted into a vector!\")\n\u001b[1;32m     44\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mVector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0mx\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mTypeError\u001b[0m: One dimension (m or n) must be 1 so that the matrix can be converted into a vector!"
     ]
    }
   ],
   "source": [
    "m.as_vector()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Operator Overloading\n",
    "\n",
    "Using magic methods such as `__add__()`, `__sub__()`, `__mul__()`, or others, user-defined data types can emulate [numeric types](https://docs.python.org/3/reference/datamodel.html#emulating-numeric-types) in that instance objects can be added to or subtracted from one another or be multiplied together. We will use this to implement all the arithmetic rules from linear algebra.\n",
    "\n",
    "The OOP concept behind this is **operator overloading** as first mentioned in the context of string concatenation. This is not limited to arithmetic operators as we will see in the sub-section on relational operators at the end of this section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The expression `1 + 2.0` is translated by Python into an implicit method invocation of the form `1.__add__(2.0)`. This is why all the magic methods behind binary operators take two arguments `self` and, by convention, `other`. To allow a binary operator to work with objects of different data types, Python expects the `1` object here to return `NotImplemented` (not to raise a `NotImplementedError`) if it does not know how to deal with the `2.0` object as an argument and then proceeds by invoking the *reverse* special method `2.0.__radd__(1)`. With this protocol, one can create new data types that know how to execute arithmetic operators with old data types without having to change the old types."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Note that to implement [scalar multiplication](https://en.wikipedia.org/wiki/Scalar_multiplication) for our `Vector` and `Matrix` classes we need to be able to verify that the scalar is some sort of numeric value. We have seen `int` and `float` so far but Python knows a lot more numeric types. The Standard Library provides a [Number](https://docs.python.org/3/library/numbers.html#numbers.Number) class in the [numbers](https://docs.python.org/3/library/numbers.html#numbers) module that we can use for this validation."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {},
   "outputs": [],
   "source": [
    "from numbers import Number"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = tuple(float(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"Vector((\" + \", \".join(\"{:.3f}\".format(x) for x in self) + \"))\"\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if len(self) != len(other):\n",
    "                raise ValueError(\"The vectors need to be of the same length!\")\n",
    "            return self.__class__(x + y for (x, y) in zip(self, other))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        return self + other\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if len(self) != len(other):\n",
    "                raise ValueError(\"The vectors need to be of the same length!\")\n",
    "            return self.__class__(x - y for (x, y) in zip(self, other))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        return self - other\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__(x * other for x in self)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        return self * other\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__(x / other for x in self)\n",
    "        return NotImplemented\n",
    "\n",
    "    def as_matrix(self, column=True):\n",
    "        if column:\n",
    "            return Matrix([x] for x in self)\n",
    "        return Matrix([(x for x in self)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector([1, 2, 3])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__mul__()` and `__rmul__()` implement scalar multiplication. Vectors, however, cannot be multiplied with each other mathematically. In that case the magic method returns `NotImplemented` which raises a `TypeError` eventually."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((2.000, 4.000, 6.000))"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "2 * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((3.000, 6.000, 9.000))"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v * 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 98,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "unsupported operand type(s) for *: 'Vector' and 'Vector'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-98-934b9809fae4>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mv\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: unsupported operand type(s) for *: 'Vector' and 'Vector'"
     ]
    }
   ],
   "source": [
    "v * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__truediv__()` implements the division operator `/` while `__floordiv__()` would implement the floor division operator `//`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 99,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((0.333, 0.667, 1.000))"
      ]
     },
     "execution_count": 99,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v / 3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "`__add__()`, `__radd__()`, `__sub__()`, and `__rsub__()` implement vector addition and subtraction according to standard linear algebra rules (i.e., both vectors must have the same length)."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 100,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((2.000, 4.000, 6.000))"
      ]
     },
     "execution_count": 100,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v + v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 101,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((0.000, 0.000, 0.000))"
      ]
     },
     "execution_count": 101,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v - v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 102,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = Vector([8, 9])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 103,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The vectors need to be of the same length!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-103-490ee3f2b9e8>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mw\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-94-9532e5506242>\u001b[0m in \u001b[0;36m__add__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     20\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     21\u001b[0m             \u001b[0;32mif\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mlen\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 22\u001b[0;31m                 \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The vectors need to be of the same length!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     23\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0my\u001b[0m \u001b[0;32mfor\u001b[0m \u001b[0;34m(\u001b[0m\u001b[0mx\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m)\u001b[0m \u001b[0;32min\u001b[0m \u001b[0mzip\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     24\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mValueError\u001b[0m: The vectors need to be of the same length!"
     ]
    }
   ],
   "source": [
    "v + w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For `Matrix` objects the implementation is a bit more involved as we need to distinguish between matrix-matrix, matrix-vector, vector-matrix, and scalar multiplication and check for correct dimensions. To review the underlying rules, check this [article](https://en.wikipedia.org/wiki/Matrix_multiplication) or watch the video next."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 104,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/jpeg": "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\n",
      "text/html": [
       "\n",
       "        <iframe\n",
       "            width=\"60%\"\n",
       "            height=\"300\"\n",
       "            src=\"https://www.youtube.com/embed/OMA2Mwo0aZg\"\n",
       "            frameborder=\"0\"\n",
       "            allowfullscreen\n",
       "        ></iframe>\n",
       "        "
      ],
      "text/plain": [
       "<IPython.lib.display.YouTubeVideo at 0x7ff97828e128>"
      ]
     },
     "execution_count": 104,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "from IPython.display import YouTubeVideo\n",
    "YouTubeVideo(\"OMA2Mwo0aZg\", width=\"60%\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Basically, a matrix-matrix multiplication of two matrices $\\bf{A}$ and $\\bf{B}$ with dimensions $m$ by $n$ and $n$ by $p$ can be described as follows: $\\bf{C} = \\bf{A} * \\bf{B}$ , where $c_{ij} = \\sum_{k=1}^{n} a_{ik} * b_{kj}$. The $c_{ij}$, $a_{ij}$, and $b_{ij}$ refer to the entries in row $i$ and column $j$ in the respective matrices. Note that it does make a difference if we multiply $\\bf{A}$ with $\\bf{B}$ from the right or left. For more background on how to implement this summation as an algorithm, check this [article](https://en.wikipedia.org/wiki/Matrix_multiplication_algorithm).\n",
    "\n",
    "In case of multiplying a matrix with a vector we follow the common convention that a vector on the left is interpreted as a row vector and a vector on the right as a column vector. The vectors' length have to match the matrix's corresponding dimension."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 105,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = tuple(tuple(float(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_rows * self.n_cols\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if isinstance(index, int):\n",
    "            if index < 0:\n",
    "                index += len(self)\n",
    "            if not (0 <= index < len(self)):\n",
    "                raise IndexError(\"integer index out of range!\")\n",
    "            row, col = divmod(index, self.n_cols)\n",
    "            return self._entries[row][col]\n",
    "        elif (isinstance(index, tuple) and len(index) == 2\n",
    "            and isinstance(index[0], int) and isinstance(index[1], int)\n",
    "        ):\n",
    "            return self._entries[index[0]][index[1]]\n",
    "        raise TypeError(\"index must be either an integer or a tuple of two integers!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        return (\"Matrix((\" + \", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row)\n",
    "                                       + \",)\" for row in self._entries) + \"))\")\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if (self.n_rows != other.n_rows) or (self.n_cols != other.n_cols):\n",
    "                raise ValueError(\"The matrices need to be of the same dimension!\")\n",
    "            return self.__class__((s_col + o_col for (s_col, o_col) in zip(s_row, o_row))\n",
    "                                  for (s_row, o_row) in zip(self._entries, other._entries))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if isinstance(other, Vector):  # needed to break an infinite recursion\n",
    "            raise TypeError(\"Vectors and matrices cannot be added!\")\n",
    "        return self + other\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if (self.n_rows != other.n_rows) or (self.n_cols != other.n_cols):\n",
    "                raise ValueError(\"The matrices need to be of the same dimension!\")\n",
    "            return self.__class__((s_col - o_col for (s_col, o_col) in zip(s_row, o_row))\n",
    "                                  for (s_row, o_row) in zip(self._entries, other._entries))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        if isinstance(other, Vector):  # needed to break an infinite recursion\n",
    "            raise TypeError(\"Vectors and matrices cannot be subtracted!\")\n",
    "        return self - other\n",
    "\n",
    "    def _matrix_multiply(self, other):\n",
    "        if self.n_cols != other.n_rows:\n",
    "            raise ValueError(\"The matrices need to have compatible dimensions!\")\n",
    "        return Matrix((sum(((self[i,k] * other[k,j]) for k in range(self.n_cols)))\n",
    "                       for j in range(other.n_cols)) for i in range(self.n_rows))\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__((x * other for x in row) for row in self._entries)\n",
    "        elif isinstance(other, Vector):\n",
    "            return self._matrix_multiply(other.as_matrix()).as_vector()\n",
    "        elif isinstance(other, self.__class__):\n",
    "            return self._matrix_multiply(other)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self * other\n",
    "        elif isinstance(other, Vector):\n",
    "            return other.as_matrix(column=False)._matrix_multiply(self).as_vector()\n",
    "        return NotImplemented\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__((x / other for x in row) for row in self._entries)\n",
    "        return NotImplemented\n",
    "\n",
    "    def as_vector(self):\n",
    "        if not (self.n_rows == 1 or self.n_cols == 1):\n",
    "            raise TypeError(\"One dimension (m or n) must be 1 so that the \"\n",
    "                            \"matrix can be converted into a vector!\")\n",
    "        return Vector(x for x in self)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 106,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix([(1, 2, 3), (4, 5, 6)])\n",
    "n = Matrix([(7, 8, 9), (10, 11, 12), (13, 14, 15)])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scalar multiplication, addition, and subtraction work as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 107,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((10.000, 20.000, 30.000,), (40.000, 50.000, 60.000,)))"
      ]
     },
     "execution_count": 107,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 108,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((1.000, 2.000, 3.000,), (4.000, 5.000, 6.000,)))"
      ]
     },
     "execution_count": 108,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "(2 * m + m * 3) / 5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 109,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((0.000, 0.000, 0.000,), (0.000, 0.000, 0.000,)))"
      ]
     },
     "execution_count": 109,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m - m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Matrix-matrix multiplication works if the dimensions are compatible."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 110,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((66.000, 72.000, 78.000,), (156.000, 171.000, 186.000,)))"
      ]
     },
     "execution_count": 110,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 111,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The matrices need to have compatible dimensions!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-111-6bfcb26efe24>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mn\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-105-926387f04e5c>\u001b[0m in \u001b[0;36m__mul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     76\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_matrix_multiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_vector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     77\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m__class__\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 78\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_matrix_multiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     79\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     80\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-105-926387f04e5c>\u001b[0m in \u001b[0;36m_matrix_multiply\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     66\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_matrix_multiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_cols\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_rows\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The matrices need to have compatible dimensions!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     69\u001b[0m         return Matrix((sum(((self[i,k] * other[k,j]) for k in range(self.n_cols)))\n\u001b[1;32m     70\u001b[0m                        for j in range(other.n_cols)) for i in range(self.n_rows))\n",
      "\u001b[0;31mValueError\u001b[0m: The matrices need to have compatible dimensions!"
     ]
    }
   ],
   "source": [
    "n * m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The same holds for matrix-vector and vector-matrix multiplication. These operations always return `Vector` instances in line with standard linear algebra."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 112,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((14.000, 32.000))"
      ]
     },
     "execution_count": 112,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 113,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((66.000, 72.000, 78.000))"
      ]
     },
     "execution_count": 113,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v * n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 114,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "The matrices need to have compatible dimensions!",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-114-302e9bce1e68>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mv\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mm\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;32m<ipython-input-105-926387f04e5c>\u001b[0m in \u001b[0;36m__rmul__\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     83\u001b[0m             \u001b[0;32mreturn\u001b[0m \u001b[0mself\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     84\u001b[0m         \u001b[0;32melif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mother\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mVector\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 85\u001b[0;31m             \u001b[0;32mreturn\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_matrix\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mcolumn\u001b[0m\u001b[0;34m=\u001b[0m\u001b[0;32mFalse\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0m_matrix_multiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mas_vector\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     86\u001b[0m         \u001b[0;32mreturn\u001b[0m \u001b[0mNotImplemented\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     87\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;32m<ipython-input-105-926387f04e5c>\u001b[0m in \u001b[0;36m_matrix_multiply\u001b[0;34m(self, other)\u001b[0m\n\u001b[1;32m     66\u001b[0m     \u001b[0;32mdef\u001b[0m \u001b[0m_matrix_multiply\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mself\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m     67\u001b[0m         \u001b[0;32mif\u001b[0m \u001b[0mself\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_cols\u001b[0m \u001b[0;34m!=\u001b[0m \u001b[0mother\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mn_rows\u001b[0m\u001b[0;34m:\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 68\u001b[0;31m             \u001b[0;32mraise\u001b[0m \u001b[0mValueError\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"The matrices need to have compatible dimensions!\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m     69\u001b[0m         return Matrix((sum(((self[i,k] * other[k,j]) for k in range(self.n_cols)))\n\u001b[1;32m     70\u001b[0m                        for j in range(other.n_cols)) for i in range(self.n_rows))\n",
      "\u001b[0;31mValueError\u001b[0m: The matrices need to have compatible dimensions!"
     ]
    }
   ],
   "source": [
    "v * m"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Relational Operators\n",
    "\n",
    "As we have seen above, two different `Vector` instances with the exact same entries do not compare equal. The reason is that for user-defined types Python by default only assumes two instances to be equal if they are actually the same object in memory. This is, of course, semantically wrong for vectors and matrices."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 115,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector((1, 2, 3))\n",
    "w = Vector((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 116,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 116,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v == w"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 117,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 117,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v == v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As with the [Python Reference](https://docs.python.org/3/reference/datamodel.html#object.__eq__), we can implement the `__eq__()` magic method to control how the equality comparison is carried out. For brevity, we do this only for the `Vector` class below. It would be the exact same code in the `Matrix` case. Note that the `__eq__()` method exits early if the first pair of entries does not match."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 118,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "\n",
    "    def __init__(self, data):\n",
    "        self._entries = tuple(float(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]\n",
    "\n",
    "    def __repr__(self):\n",
    "        return \"Vector((\" + \", \".join(\"{:.3f}\".format(x) for x in self) + \"))\"\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            for x, y in zip(self, other):\n",
    "                if x != y:\n",
    "                    return False\n",
    "            return True\n",
    "        return NotImplemented"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 119,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector((1, 2, 3))\n",
    "w = Vector((1, 2, 3))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 120,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 120,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v == w"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## The whole Picture\n",
    "\n",
    "Below are the two final implementations of the `Vector` and `Matrix` classes that integrate all of the implementations introduced above. The code is cleaned up and fully documented as we should always do. Furthermore, both classes are adapted to make it easier to **sub-class** them as we will see in detail in the next section."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What that means is that the `storage` and `typing` **class attributes** are added referencing the [tuple()](https://docs.python.org/3/library/functions.html#func-tuple) and [float()](https://docs.python.org/3/library/functions.html#float) built-ins. These class attributes are then used in the `__init__()` magic methods. Surprisingly, they can be used just like instance attributes on the `self` object directly. The reason for that is how **lexical scoping** works for variables in the context of classes and instances. If a variable is not defined on an instance object, Python first checks if it can fall back to the same name on the corresponding class object before it raises an `AttributeError`. If we want to refer to a class attribute right away, we could replace the `self.storage` and `self.typing` with `self.__class__.storage` and `self.__class__.typing` respectively."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "In addtion to the new class attributes, we replace the text strings \"Vector\" and \"Matrix\" in the `__repr__()` and `__str__()` magic methods with `self.__class__.__name__` which is implicitly replaced again into the class names as text strings by Python. This way, we only use the names of the classes in the `class` statement header line, which avoids a bit of redundancy."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 121,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Vector:\n",
    "    \"\"\"A standard one-dimensional vector from linear algebra.\n",
    "\n",
    "    The class is designed for sub-classing in such a way that\n",
    "    the user can adapt the typing class attribute to change,\n",
    "    for example, how the entries are stored (e.g., as integers).\n",
    "\n",
    "    Attributes:\n",
    "        storage (callable): Must return an iterable that is used\n",
    "            to store the entries of the vector. Defaults to tuple.\n",
    "        typing (callable): Type conversion applied to all vector\n",
    "            entries upon creation. Defaults to float.\n",
    "    \"\"\"\n",
    "\n",
    "    storage = tuple\n",
    "    typing = float\n",
    "\n",
    "    def __init__(self, data):\n",
    "        \"\"\"Initiate a new vector.\n",
    "\n",
    "        Args:\n",
    "            data (iterable): The vector's entries in the correct order.\n",
    "                Must have at least one element.\n",
    "        Raises:\n",
    "            ValueError: If the provided data do not have enough entries.\n",
    "        \"\"\"\n",
    "        self._entries = self.storage(self.typing(x) for x in data)\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A vector must have at least one entry!\")\n",
    "\n",
    "    def __repr__(self):\n",
    "        args = \", \".join(\"{:.3f}\".format(x) for x in self)\n",
    "        return \"{}(({}))\".format(self.__class__.__name__, args)\n",
    "\n",
    "    def __str__(self):\n",
    "        entries = \"({:.1f}, ..., {:.1f})\".format(self[0], self[-1])\n",
    "        length = \"[{:d}]\".format(len(self))\n",
    "        return self.__class__.__name__ + entries + length\n",
    "\n",
    "    def __len__(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        return self._entries[index]\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if len(self) != len(other):\n",
    "                raise ValueError(\"The vectors need to be of the same length!\")\n",
    "            return self.__class__(x + y for (x, y) in zip(self, other))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        return self + other\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if len(self) != len(other):\n",
    "                raise ValueError(\"The vectors need to be of the same length!\")\n",
    "            return self.__class__(x - y for (x, y) in zip(self, other))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        return self - other\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__(x * other for x in self)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        return self * other\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__(x / other for x in self)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __eq__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            for x, y in zip(self, other):\n",
    "                if x != y:\n",
    "                    return False\n",
    "            return True\n",
    "        return NotImplemented\n",
    "\n",
    "    def as_matrix(self, column=True):\n",
    "        \"\"\"Convert the vector into a matrix.\n",
    "\n",
    "        Args:\n",
    "            column (bool): If the vector should be interpreted as\n",
    "                as a column vector or not. Defaults to True.\n",
    "        Returns:\n",
    "            Matrix\n",
    "        \"\"\"\n",
    "        if column:\n",
    "            return Matrix([x] for x in self)\n",
    "        return Matrix([(x for x in self)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 122,
   "metadata": {},
   "outputs": [],
   "source": [
    "class Matrix:\n",
    "    \"\"\"A standard m-by-n-dimensional matrix from linear algebra.\n",
    "\n",
    "    The class is designed for sub-classing in such a way that\n",
    "    the user can adapt the typing class attribute to change,\n",
    "    for example, how the entries are stored (e.g., as integers).\n",
    "\n",
    "    Attributes:\n",
    "        storage (callable): Must return an iterable that is used\n",
    "            to store the entries of the matrix. Defaults to tuple.\n",
    "        typing (callable): Type conversion applied to all vector\n",
    "            entries upon creation. Defaults to float.\n",
    "    \"\"\"\n",
    "\n",
    "    storage = tuple\n",
    "    typing = float\n",
    "\n",
    "    def __init__(self, data):\n",
    "        \"\"\"Initiate a new matrix.\n",
    "\n",
    "        Args:\n",
    "            data (iterable of iterables): The matrix's entries in row-major order.\n",
    "                The number of column entries must be consistent per row\n",
    "                    while the first row sets the correct number.\n",
    "                Must have at least one element in total.\n",
    "        Raises:\n",
    "            TypeError: If the number of columns is inconsistent across the rows.\n",
    "            ValueError: If the provided data do not have enough entries.\n",
    "        \"\"\"\n",
    "        self._entries = self.storage(self.storage(self.typing(col) for col in row) for row in data)\n",
    "        for row in self._entries[1:]:\n",
    "            if len(row) !=  self.n_cols:\n",
    "                raise TypeError(\"Each row must have the same number of entries!\")\n",
    "        if len(self) == 0:\n",
    "            raise ValueError(\"A matrix must have at least one entry!\")\n",
    "\n",
    "    @classmethod\n",
    "    def from_columns(cls, data):\n",
    "        \"\"\"Initiate a new matrix.\n",
    "\n",
    "        Args:\n",
    "            data (iterable of iterables): The matrix's entries in column-major order.\n",
    "                The number of column entries must be consistent per row\n",
    "                    while the first row sets the correct number.\n",
    "                Must have at least one element in total.\n",
    "        Raises:\n",
    "            TypeError: If the number of columns is inconsistent across the rows.\n",
    "            ValueError: If the provided data do not have enough entries.\n",
    "        \"\"\"\n",
    "        return cls(data).transpose()\n",
    "\n",
    "    def __repr__(self):\n",
    "        args = (\", \".join(\"(\" + \", \".join(\"{:.3f}\".format(col) for col in row) + \",)\"\n",
    "                          for row in self._entries))\n",
    "        return \"{}(({}))\".format(self.__class__.__name__, args)\n",
    "\n",
    "    def __str__(self):\n",
    "        entries = \"(({:.1f}, ...), ..., (..., {:.1f}))\".format(self[0], self[-1])\n",
    "        dims = \"[{:d}x{:d}]\".format(self.n_rows, self.n_cols)\n",
    "        return self.__class__.__name__ + entries + dims\n",
    "\n",
    "    @property\n",
    "    def n_rows(self):\n",
    "        return len(self._entries)\n",
    "\n",
    "    @property\n",
    "    def n_cols(self):\n",
    "        return len(self._entries[0])\n",
    "\n",
    "    def __len__(self):\n",
    "        return self.n_rows * self.n_cols\n",
    "\n",
    "    def __getitem__(self, index):\n",
    "        if isinstance(index, int):\n",
    "            if index < 0:\n",
    "                index += len(self)\n",
    "            if not (0 <= index < len(self)):\n",
    "                raise IndexError(\"integer index out of range!\")\n",
    "            row, col = divmod(index, self.n_cols)\n",
    "            return self._entries[row][col]\n",
    "        elif (isinstance(index, tuple) and len(index) == 2\n",
    "            and isinstance(index[0], int) and isinstance(index[1], int)\n",
    "        ):\n",
    "            return self._entries[index[0]][index[1]]\n",
    "        raise TypeError(\"index must be either an integer or a tuple of two integers!\")\n",
    "\n",
    "\n",
    "    def __add__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if (self.n_rows != other.n_rows) or (self.n_cols != other.n_cols):\n",
    "                raise ValueError(\"The matrices need to be of the same dimension!\")\n",
    "            return self.__class__((s_col + o_col for (s_col, o_col) in zip(s_row, o_row))\n",
    "                                  for (s_row, o_row) in zip(self._entries, other._entries))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __radd__(self, other):\n",
    "        if isinstance(other, Vector):  # needed to break an infinite recursion\n",
    "            raise TypeError(\"Vectors and matrices cannot be added!\")\n",
    "        return self + other\n",
    "\n",
    "    def __sub__(self, other):\n",
    "        if isinstance(other, self.__class__):\n",
    "            if (self.n_rows != other.n_rows) or (self.n_cols != other.n_cols):\n",
    "                raise ValueError(\"The matrices need to be of the same dimension!\")\n",
    "            return self.__class__((s_col - o_col for (s_col, o_col) in zip(s_row, o_row))\n",
    "                                  for (s_row, o_row) in zip(self._entries, other._entries))\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rsub__(self, other):\n",
    "        if isinstance(other, Vector):  # needed to break an infinite recursion\n",
    "            raise TypeError(\"Vectors and matrices cannot be subtracted!\")\n",
    "        return self - other\n",
    "\n",
    "    def _matrix_multiply(self, other):\n",
    "        if self.n_cols != other.n_rows:\n",
    "            raise ValueError(\"The matrices need to have compatible dimensions!\")\n",
    "        return self.__class__((sum(((self[i,k] * other[k,j]) for k in range(self.n_cols)))\n",
    "                               for j in range(other.n_cols)) for i in range(self.n_rows))\n",
    "\n",
    "    def __mul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__((x * other for x in row) for row in self._entries)\n",
    "        elif isinstance(other, Vector):\n",
    "            return self._matrix_multiply(other.as_matrix()).as_vector()\n",
    "        elif isinstance(other, self.__class__):\n",
    "            return self._matrix_multiply(other)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __rmul__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self * other\n",
    "        elif isinstance(other, Vector):\n",
    "            return other.as_matrix(column=False)._matrix_multiply(self).as_vector()\n",
    "        return NotImplemented\n",
    "\n",
    "    def __truediv__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__((x / other for x in row) for row in self._entries)\n",
    "        return NotImplemented\n",
    "\n",
    "    def __floordiv__(self, other):\n",
    "        if isinstance(other, Number):\n",
    "            return self.__class__((x // other for x in row) for row in self._entries)\n",
    "        return NotImplemented\n",
    "\n",
    "    def as_vector(self):\n",
    "        \"\"\"Convert the matrix into a vector.\n",
    "\n",
    "        Returns:\n",
    "            Vector\n",
    "        Raises:\n",
    "            TypeError: If not one of the two dimensions is 1.\n",
    "        \"\"\"\n",
    "        if not (self.n_rows == 1 or self.n_cols == 1):\n",
    "            raise TypeError(\"One dimension (m or n) must be 1 so that the \"\n",
    "                            \"matrix can be converted into a vector!\")\n",
    "        return Vector(x for x in self)\n",
    "\n",
    "    def transpose(self):\n",
    "        \"\"\"Transpose the rows and columns of the matrix.\n",
    "\n",
    "        Returns:\n",
    "            Matrix\n",
    "        \"\"\"\n",
    "        return self.__class__(zip(*self._entries))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's do some math with bigger matrices and vectors."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 123,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 124,
   "metadata": {},
   "outputs": [],
   "source": [
    "random.seed(42)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We populize the matrix with random numbers in the range between $0$ and $1000$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 125,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = Matrix((1000 * random.random() for _ in range(50)) for _ in range(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We quickly lose track with all the numbers in the matrix, which is why we implemented the `__str__()` method as a summary representation. Observe that the name \"Matrix\" is printed although we do not explicitly use it in `__repr__()` and `__str__()`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 126,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Matrix(((639.427, 25.011, 275.029, 223.211, 736.471, 676.699, 892.180, 86.939, 421.922, 29.797, 218.638, 505.355, 26.536, 198.838, 649.884, 544.941, 220.441, 589.266, 809.430, 6.499, 805.819, 698.139, 340.251, 155.479, 957.213, 336.595, 92.746, 96.716, 847.494, 603.726, 807.128, 729.732, 536.228, 973.116, 378.534, 552.041, 829.405, 618.520, 861.707, 577.352, 704.572, 45.824, 227.898, 289.388, 79.792, 232.791, 101.001, 277.974, 635.684, 364.832,), (370.181, 209.507, 266.978, 936.655, 648.035, 609.131, 171.139, 729.127, 163.402, 379.455, 989.523, 640.000, 556.950, 684.614, 842.852, 776.000, 229.048, 32.100, 315.453, 267.741, 210.983, 942.910, 876.368, 314.678, 655.439, 395.632, 914.548, 458.852, 264.880, 246.628, 561.368, 262.742, 584.586, 897.823, 399.401, 219.321, 997.538, 509.526, 90.909, 47.116, 109.649, 627.446, 792.079, 422.160, 63.528, 381.619, 996.121, 529.114, 971.078, 860.780,), (11.481, 720.722, 681.710, 536.970, 266.825, 640.962, 111.552, 434.765, 453.724, 953.816, 875.853, 263.389, 500.586, 178.652, 912.628, 870.519, 298.445, 638.949, 608.970, 152.839, 762.511, 539.379, 778.626, 530.354, 0.572, 324.156, 19.477, 929.099, 878.722, 831.666, 307.514, 57.925, 878.010, 946.949, 85.653, 485.990, 69.213, 760.602, 765.834, 128.391, 475.282, 549.804, 265.057, 872.433, 423.138, 211.798, 539.296, 729.931, 201.151, 311.716,), (995.149, 649.878, 438.100, 517.576, 121.004, 224.697, 338.086, 588.309, 230.115, 220.217, 70.993, 631.103, 228.942, 905.420, 859.635, 70.857, 238.005, 668.978, 214.237, 132.312, 935.514, 571.043, 472.671, 784.619, 807.497, 190.410, 96.931, 431.051, 423.579, 467.025, 729.076, 673.365, 984.165, 98.418, 402.621, 339.303, 861.673, 248.656, 190.209, 448.614, 421.882, 278.545, 249.806, 923.266, 443.131, 861.349, 550.325, 50.588, 999.282, 836.028,), (968.996, 926.367, 848.696, 166.311, 485.641, 213.747, 401.040, 58.635, 378.973, 985.309, 265.203, 784.071, 455.008, 423.007, 957.318, 995.423, 555.768, 718.408, 154.797, 296.708, 968.709, 579.180, 542.195, 747.976, 57.165, 584.178, 502.850, 852.720, 157.433, 960.779, 80.111, 185.825, 595.035, 675.213, 235.204, 119.887, 890.287, 246.215, 594.519, 619.382, 419.225, 583.672, 522.783, 934.706, 204.259, 716.192, 238.686, 395.786, 671.690, 299.997,), (316.177, 751.864, 72.543, 458.286, 998.454, 996.096, 73.261, 213.154, 265.200, 933.259, 880.864, 879.270, 369.527, 157.747, 833.745, 703.540, 611.678, 987.233, 653.976, 7.823, 817.104, 299.379, 663.389, 938.930, 134.291, 115.429, 107.036, 553.224, 272.348, 604.830, 717.612, 203.597, 634.238, 263.984, 488.532, 905.336, 846.104, 92.298, 423.576, 276.680, 3.546, 771.119, 637.113, 261.955, 741.231, 551.680, 427.687, 9.670, 75.244, 883.106,), (903.929, 545.590, 834.595, 582.510, 148.094, 127.446, 308.258, 898.981, 796.122, 860.703, 898.925, 210.077, 249.530, 102.794, 780.116, 884.135, 406.377, 620.662, 154.553, 929.881, 864.606, 976.206, 810.772, 881.416, 24.786, 736.564, 332.185, 930.816, 802.235, 864.064, 810.749, 266.806, 787.375, 108.096, 872.167, 858.593, 222.434, 816.587, 460.303, 305.191, 795.345, 227.595, 23.664, 193.130, 328.262, 864.353, 966.889, 279.125, 641.482, 399.678,), (981.150, 536.216, 939.237, 115.342, 970.401, 178.568, 962.534, 265.466, 108.403, 434.564, 728.545, 313.677, 606.209, 511.423, 385.195, 576.588, 254.723, 708.785, 1.691, 925.575, 538.452, 719.430, 741.950, 670.629, 364.221, 69.974, 664.238, 330.200, 313.916, 848.015, 719.754, 300.322, 309.285, 408.393, 402.400, 295.655, 127.288, 420.446, 940.364, 677.318, 902.806, 615.515, 300.950, 547.937, 0.406, 286.914, 429.888, 579.985, 654.706, 464.988,), (442.160, 213.701, 473.186, 901.181, 796.025, 169.691, 84.796, 515.452, 632.941, 335.188, 818.423, 751.138, 672.796, 224.641, 199.130, 24.425, 244.843, 475.136, 849.738, 72.828, 414.441, 629.765, 194.435, 696.354, 494.377, 243.984, 656.058, 5.545, 750.964, 770.046, 106.587, 425.146, 175.887, 957.966, 517.958, 50.218, 249.198, 848.336, 456.462, 801.417, 667.578, 987.892, 595.452, 950.040, 891.426, 612.652, 719.274, 504.778, 830.569, 547.872,), (897.208, 743.655, 474.674, 259.192, 247.240, 637.661, 765.814, 521.300, 626.748, 274.597, 77.483, 285.728, 271.715, 319.710, 540.152, 138.374, 231.261, 693.950, 706.419, 64.229, 407.599, 542.611, 415.774, 206.834, 420.144, 904.838, 584.079, 695.523, 856.732, 765.595, 380.381, 5.896, 351.759, 753.475, 853.448, 953.430, 419.021, 747.516, 546.132, 603.253, 220.539, 219.422, 435.836, 29.025, 336.130, 679.142, 404.317, 165.045, 467.390, 127.628,), (622.257, 26.966, 394.020, 564.392, 27.102, 642.750, 135.699, 461.698, 50.285, 379.104, 211.660, 326.846, 761.230, 379.126, 752.010, 831.924, 252.272, 81.906, 19.383, 539.419, 999.908, 349.960, 650.144, 781.233, 651.755, 754.233, 949.612, 199.361, 20.380, 152.382, 126.221, 669.459, 563.970, 217.965, 699.465, 766.898, 167.789, 607.247, 747.926, 114.533, 819.301, 964.721, 108.099, 25.678, 311.957, 677.347, 958.173, 396.654, 715.015, 75.996,), (690.614, 627.242, 101.901, 772.481, 850.293, 600.412, 121.055, 983.844, 782.635, 347.204, 428.378, 370.571, 505.961, 341.231, 849.576, 822.331, 105.539, 960.788, 635.585, 828.707, 707.309, 435.487, 733.795, 965.474, 270.082, 808.199, 538.173, 483.498, 435.574, 731.026, 268.396, 851.713, 830.731, 86.663, 881.631, 243.863, 464.708, 610.332, 378.989, 28.700, 850.953, 181.840, 212.120, 797.832, 340.339, 880.320, 701.184, 276.269, 10.151, 948.063,), (85.613, 720.075, 488.578, 758.165, 690.609, 645.903, 490.821, 792.933, 93.053, 221.596, 691.787, 306.206, 581.556, 473.260, 530.922, 425.504, 745.935, 330.791, 702.855, 270.916, 251.404, 120.656, 192.584, 119.555, 535.864, 762.190, 185.150, 216.385, 484.199, 724.585, 976.607, 524.637, 282.999, 100.526, 194.118, 227.483, 179.442, 14.148, 534.135, 274.311, 974.295, 553.359, 697.417, 126.279, 868.461, 490.879, 872.720, 574.064, 469.397, 440.469,), (184.364, 51.377, 941.064, 477.729, 822.116, 400.707, 74.082, 629.446, 53.609, 149.198, 562.840, 303.836, 993.918, 118.452, 764.443, 606.318, 790.741, 225.687, 522.573, 450.514, 442.721, 860.167, 990.031, 305.380, 621.027, 609.631, 740.089, 947.590, 207.788, 211.025, 660.428, 157.057, 173.814, 75.065, 2.676, 450.504, 593.811, 291.259, 231.476, 706.956, 702.988, 454.031, 687.385, 923.911, 787.828, 625.058, 661.183, 933.668, 425.139, 544.562,), (647.635, 908.411, 826.631, 71.410, 165.923, 307.612, 748.958, 569.207, 288.611, 124.354, 688.678, 699.734, 942.676, 500.472, 493.795, 80.442, 39.861, 432.029, 322.322, 250.368, 91.327, 961.911, 835.959, 575.199, 950.786, 999.572, 672.282, 269.511, 40.232, 756.269, 470.501, 651.509, 916.073, 181.489, 585.330, 634.785, 491.726, 91.242, 347.961, 333.308, 670.134, 857.733, 329.804, 693.674, 288.218, 945.194, 813.566, 550.097, 454.826, 314.517,), (323.274, 970.185, 404.175, 514.596, 988.119, 657.660, 542.594, 413.248, 187.583, 361.779, 756.443, 625.409, 759.991, 203.558, 549.220, 927.673, 438.116, 698.250, 121.426, 973.147, 608.872, 239.297, 158.378, 550.839, 552.251, 93.209, 992.257, 912.930, 461.448, 117.466, 832.143, 498.376, 716.603, 508.872, 273.425, 834.724, 980.245, 243.731, 551.265, 383.586, 921.868, 508.241, 879.326, 864.027, 276.247, 790.006, 414.942, 934.248, 507.738, 820.549,), (282.839, 298.556, 586.938, 998.902, 489.640, 148.595, 538.581, 345.124, 551.917, 543.430, 455.345, 321.777, 188.652, 697.498, 571.798, 233.562, 775.544, 43.647, 744.705, 705.228, 811.409, 386.079, 663.689, 820.748, 980.818, 495.329, 37.020, 502.291, 590.180, 869.700, 874.190, 440.306, 525.951, 456.928, 722.444, 409.979, 654.781, 154.361, 469.491, 969.204, 338.561, 692.705, 649.837, 851.765, 852.341, 859.342, 380.009, 316.661, 718.717, 759.402,), (872.383, 35.899, 68.421, 631.161, 920.929, 997.426, 746.766, 433.971, 98.443, 633.748, 872.579, 443.679, 694.001, 903.424, 45.991, 796.143, 293.368, 374.841, 145.570, 531.166, 565.928, 792.519, 169.984, 78.968, 870.840, 619.710, 240.830, 912.829, 143.118, 461.150, 253.977, 255.327, 9.397, 804.633, 901.209, 677.611, 157.976, 441.730, 345.566, 587.572, 638.939, 424.309, 250.098, 845.304, 199.217, 384.693, 483.208, 237.206, 571.923, 574.812,), (992.692, 295.231, 977.944, 658.230, 274.480, 565.929, 685.799, 744.669, 49.044, 606.406, 496.727, 904.155, 286.194, 798.860, 607.065, 352.321, 636.618, 620.891, 677.764, 720.928, 659.182, 838.337, 628.248, 903.404, 646.341, 308.933, 440.823, 579.574, 732.360, 90.133, 295.110, 747.481, 175.640, 132.160, 539.408, 971.490, 530.852, 913.487, 830.473, 256.970, 824.690, 481.848, 806.488, 746.559, 338.715, 115.170, 962.893, 140.757, 966.500, 860.141,), (724.217, 979.942, 967.270, 804.588, 365.775, 790.682, 13.919, 536.572, 454.786, 672.828, 672.341, 584.560, 822.417, 940.292, 108.346, 233.822, 25.025, 884.235, 561.407, 915.256, 221.367, 63.217, 823.855, 909.388, 302.190, 408.296, 139.777, 946.262, 304.365, 492.625, 97.192, 887.259, 135.664, 453.644, 670.486, 743.140, 945.974, 419.127, 742.269, 154.523, 414.885, 99.022, 489.347, 408.116, 951.522, 32.716, 370.530, 443.383, 950.555, 855.450,), (99.355, 685.680, 544.466, 977.843, 358.674, 398.140, 189.809, 122.160, 848.033, 454.717, 662.769, 641.704, 597.146, 21.357, 786.795, 243.569, 125.924, 564.578, 68.610, 765.157, 207.157, 215.951, 869.695, 328.560, 147.554, 900.531, 2.836, 858.406, 144.688, 129.992, 250.654, 174.497, 661.058, 25.780, 14.860, 789.985, 237.932, 323.771, 174.246, 52.399, 741.718, 526.086, 745.665, 476.246, 778.017, 513.238, 109.054, 503.839, 945.416, 43.365,), (783.227, 866.981, 521.451, 458.043, 964.026, 60.825, 478.982, 401.617, 686.097, 490.269, 909.701, 73.491, 80.790, 608.297, 65.682, 275.016, 633.077, 548.356, 325.185, 994.628, 530.557, 453.715, 605.427, 99.178, 701.779, 852.793, 650.917, 768.963, 720.840, 215.023, 451.555, 228.494, 338.932, 453.499, 415.990, 95.086, 426.764, 665.108, 374.301, 152.639, 922.985, 67.133, 831.772, 93.230, 96.564, 738.796, 811.769, 556.371, 586.465, 561.586,), (329.646, 122.231, 353.598, 665.341, 750.284, 868.092, 721.061, 968.399, 600.410, 351.646, 577.919, 212.739, 656.736, 224.245, 108.218, 845.373, 367.561, 762.606, 574.100, 807.221, 845.155, 974.547, 818.427, 613.573, 642.699, 26.254, 929.084, 829.461, 267.448, 180.416, 702.699, 308.985, 339.825, 6.106, 869.863, 566.321, 400.784, 141.875, 633.172, 30.657, 746.112, 215.133, 419.832, 340.896, 370.053, 721.596, 776.836, 567.594, 84.957, 52.609,), (157.410, 617.838, 673.969, 272.103, 661.939, 485.662, 442.044, 273.167, 754.943, 113.818, 429.914, 283.246, 678.486, 486.633, 667.133, 45.417, 395.263, 599.325, 7.687, 301.419, 211.234, 137.235, 255.520, 328.122, 7.730, 747.014, 175.695, 380.207, 703.671, 500.262, 833.354, 806.200, 72.075, 861.764, 42.302, 18.742, 921.162, 862.110, 575.759, 573.400, 709.499, 417.694, 115.173, 20.857, 324.768, 801.322, 618.125, 832.026, 919.770, 88.130,), (844.484, 243.316, 588.871, 523.963, 395.767, 310.275, 339.513, 333.069, 168.133, 510.483, 114.027, 509.952, 905.923, 349.375, 727.379, 818.949, 815.037, 236.269, 146.444, 197.272, 602.399, 760.215, 655.509, 177.146, 772.848, 494.117, 754.446, 759.877, 448.905, 924.154, 564.492, 635.298, 624.522, 864.247, 627.217, 150.957, 68.286, 442.208, 302.820, 274.674, 56.172, 507.337, 310.408, 451.914, 56.890, 831.697, 76.731, 864.250, 855.293, 615.008,), (507.068, 462.712, 554.316, 791.818, 895.877, 449.734, 809.816, 651.837, 321.527, 475.629, 150.861, 61.874, 103.502, 899.127, 343.438, 714.316, 504.549, 172.559, 247.744, 437.758, 439.422, 522.748, 158.746, 372.852, 282.894, 408.769, 338.367, 597.886, 789.227, 647.305, 65.912, 94.506, 678.379, 284.147, 723.734, 656.564, 906.343, 873.280, 333.362, 582.740, 141.428, 349.821, 967.697, 698.480, 391.958, 595.041, 938.002, 309.582, 376.679, 791.662,), (813.185, 670.116, 828.959, 738.775, 685.414, 526.393, 646.025, 423.406, 361.828, 362.598, 180.263, 214.193, 947.668, 486.271, 226.543, 137.565, 77.165, 844.428, 101.141, 770.875, 835.120, 883.682, 37.747, 336.764, 766.308, 131.049, 376.720, 162.247, 831.345, 771.098, 809.044, 165.539, 437.673, 410.859, 676.363, 237.530, 444.199, 284.928, 748.537, 448.928, 534.011, 309.468, 808.624, 469.016, 835.113, 367.841, 947.130, 984.440, 461.680, 281.772,), (381.872, 527.460, 966.268, 816.891, 801.259, 138.399, 250.003, 641.179, 874.117, 554.541, 102.590, 845.892, 851.166, 285.063, 763.117, 272.791, 905.306, 147.349, 437.473, 946.413, 222.038, 451.128, 349.585, 26.670, 53.257, 502.007, 235.778, 994.525, 374.913, 28.188, 930.826, 839.176, 649.961, 791.381, 137.600, 286.879, 829.762, 696.072, 138.793, 705.536, 448.601, 5.251, 79.226, 255.924, 834.963, 548.804, 727.235, 527.772, 111.187, 288.102,), (301.151, 47.749, 419.826, 793.899, 457.114, 110.858, 905.147, 596.739, 16.435, 515.376, 241.938, 143.577, 429.239, 614.810, 240.564, 416.568, 664.371, 85.614, 974.654, 67.679, 526.059, 507.328, 988.331, 554.152, 390.454, 470.135, 635.671, 981.039, 253.650, 16.242, 788.520, 344.802, 732.941, 628.257, 771.501, 735.187, 332.519, 44.336, 546.014, 813.509, 175.089, 779.143, 464.623, 695.389, 631.736, 811.498, 63.101, 776.190, 457.680, 293.443,), (43.806, 199.470, 41.906, 933.371, 515.384, 989.123, 543.031, 253.314, 753.291, 191.103, 356.974, 780.842, 865.798, 331.925, 124.475, 368.019, 889.487, 743.308, 894.637, 386.645, 973.724, 496.203, 497.523, 924.310, 519.276, 801.148, 727.081, 78.927, 602.453, 822.341, 545.474, 321.211, 80.069, 660.919, 306.496, 602.622, 426.116, 689.765, 351.547, 42.355, 870.037, 352.559, 998.151, 274.555, 980.027, 947.904, 75.041, 637.513, 363.311, 801.096,), (679.411, 952.789, 142.779, 607.573, 781.312, 34.799, 67.233, 778.515, 366.328, 382.854, 567.245, 605.095, 679.062, 948.824, 372.013, 763.084, 573.922, 529.460, 398.034, 649.561, 249.612, 113.449, 735.675, 499.044, 386.987, 561.673, 261.777, 260.290, 446.273, 996.365, 285.577, 916.479, 491.200, 122.637, 852.826, 452.043, 898.679, 445.111, 87.791, 681.929, 845.521, 319.588, 347.425, 64.939, 542.171, 891.332, 851.362, 711.809, 927.324, 637.700,), (793.696, 508.756, 121.362, 200.980, 138.877, 790.373, 26.284, 554.021, 368.911, 803.662, 551.647, 611.948, 86.215, 309.291, 999.595, 718.870, 525.696, 769.165, 823.339, 73.751, 972.380, 642.339, 449.974, 680.109, 344.515, 877.960, 780.263, 639.794, 181.963, 966.265, 432.618, 910.712, 55.413, 124.161, 153.015, 164.657, 322.661, 709.332, 346.023, 940.904, 894.926, 845.934, 250.605, 635.057, 550.841, 125.170, 302.825, 533.478, 502.573, 168.636,), (941.607, 154.194, 658.733, 720.633, 605.139, 842.530, 563.618, 825.236, 28.373, 45.462, 641.454, 576.771, 651.130, 766.959, 416.587, 638.991, 498.038, 627.164, 289.672, 956.650, 482.945, 804.688, 684.991, 297.434, 72.973, 59.913, 439.605, 484.251, 204.023, 606.660, 312.582, 718.363, 734.200, 860.777, 975.374, 130.766, 370.540, 561.651, 319.116, 466.473, 267.472, 247.919, 96.812, 290.212, 384.150, 615.377, 248.270, 865.308, 159.700, 327.436,), (577.687, 312.715, 763.121, 498.266, 514.725, 498.760, 308.540, 23.176, 945.233, 505.444, 966.687, 215.144, 352.895, 50.540, 494.894, 882.339, 654.260, 470.587, 536.691, 847.172, 430.928, 882.456, 727.508, 763.857, 365.937, 400.582, 570.282, 194.655, 553.223, 73.532, 504.256, 764.404, 279.721, 989.091, 680.399, 118.811, 975.083, 393.904, 794.897, 339.085, 938.949, 754.965, 199.058, 509.123, 500.078, 45.303, 137.036, 333.041, 473.744, 456.989,), (606.261, 515.506, 327.966, 613.068, 162.502, 990.616, 739.319, 299.234, 336.373, 828.289, 532.340, 708.740, 299.791, 815.749, 368.358, 673.806, 979.898, 583.702, 796.755, 725.324, 688.044, 26.647, 474.590, 967.071, 782.904, 776.162, 577.634, 721.400, 583.523, 170.512, 629.025, 619.736, 841.167, 147.776, 680.727, 31.571, 948.205, 109.896, 18.937, 313.692, 151.431, 690.500, 410.377, 774.972, 920.521, 872.818, 735.837, 62.281, 138.082, 207.342,), (325.050, 662.227, 525.477, 313.753, 173.182, 912.124, 342.327, 354.287, 771.990, 720.925, 643.309, 693.313, 610.077, 192.264, 246.519, 558.087, 224.867, 972.911, 297.615, 289.004, 207.278, 704.988, 317.041, 348.803, 933.700, 795.405, 273.458, 121.874, 676.622, 379.694, 980.161, 818.377, 954.609, 804.616, 290.453, 287.630, 714.141, 346.364, 442.376, 256.444, 479.079, 202.068, 538.578, 933.024, 696.171, 137.273, 615.677, 586.830, 242.458, 669.834,), (531.041, 637.945, 52.491, 413.301, 717.358, 100.545, 770.766, 5.181, 550.353, 929.100, 406.907, 935.032, 878.400, 477.449, 199.456, 963.914, 321.168, 645.898, 907.937, 89.461, 574.133, 535.152, 723.118, 936.669, 913.230, 175.065, 882.245, 175.789, 919.635, 997.172, 396.995, 495.384, 936.609, 962.131, 926.040, 876.743, 9.267, 567.962, 107.301, 982.994, 284.562, 989.099, 543.300, 493.912, 938.561, 851.060, 468.021, 192.811, 112.647, 162.494,), (458.914, 257.265, 186.199, 736.618, 790.768, 567.781, 757.283, 175.495, 856.147, 897.043, 826.990, 515.281, 86.738, 669.256, 184.781, 140.612, 323.602, 248.047, 260.785, 235.521, 753.757, 954.035, 301.946, 722.883, 11.436, 653.683, 692.769, 62.124, 118.225, 306.806, 405.417, 502.520, 895.118, 703.557, 310.978, 117.416, 916.130, 295.038, 614.625, 219.129, 133.569, 153.186, 747.735, 605.739, 415.846, 549.235, 470.828, 537.518, 664.094, 218.412,), (247.465, 754.740, 873.135, 81.870, 446.748, 703.766, 78.103, 564.169, 61.758, 547.649, 505.487, 572.702, 149.852, 328.118, 520.342, 116.240, 205.401, 583.148, 90.942, 510.375, 808.692, 453.432, 513.248, 456.798, 57.737, 462.378, 806.915, 723.280, 395.949, 816.453, 745.804, 578.311, 45.290, 344.529, 63.760, 994.124, 934.583, 69.019, 933.776, 31.735, 408.867, 768.972, 765.828, 978.333, 645.881, 420.362, 992.857, 382.480, 869.620, 906.767,), (375.646, 682.730, 661.793, 539.300, 653.534, 347.770, 178.474, 537.258, 528.843, 727.858, 222.690, 3.473, 22.735, 298.363, 673.500, 544.445, 531.934, 823.360, 247.512, 346.160, 275.650, 937.410, 725.024, 112.845, 809.478, 419.241, 766.053, 883.757, 15.646, 206.082, 100.897, 33.576, 597.785, 703.286, 48.676, 740.541, 402.265, 234.339, 217.269, 863.730, 56.444, 503.896, 289.263, 815.786, 731.517, 318.904, 597.918, 672.532, 320.665, 301.764,), (143.260, 660.212, 221.043, 300.501, 60.958, 948.520, 879.714, 911.578, 625.993, 427.201, 495.621, 972.290, 941.586, 671.343, 785.805, 318.734, 416.325, 149.218, 376.460, 754.416, 473.519, 849.341, 300.736, 707.577, 805.776, 914.741, 562.386, 967.786, 557.287, 134.093, 242.859, 203.337, 646.706, 922.226, 847.133, 92.464, 724.585, 190.482, 268.462, 673.672, 602.922, 873.620, 188.163, 761.696, 724.305, 558.850, 479.394, 869.474, 332.964, 957.020,), (15.334, 937.160, 962.078, 117.316, 999.572, 478.921, 242.593, 604.402, 204.513, 915.126, 552.079, 775.514, 380.662, 533.650, 359.260, 261.562, 512.817, 497.277, 98.608, 981.318, 469.490, 839.731, 914.330, 370.705, 413.930, 562.525, 221.274, 145.923, 260.774, 934.758, 579.143, 417.578, 152.411, 329.865, 379.840, 833.363, 499.301, 654.608, 684.847, 257.327, 821.592, 966.508, 641.694, 490.596, 168.234, 794.976, 169.266, 720.314, 488.316, 916.899,), (542.137, 641.809, 58.732, 33.824, 846.697, 945.188, 668.216, 764.339, 412.392, 842.545, 231.433, 707.170, 9.141, 505.733, 373.201, 617.835, 666.755, 616.519, 483.204, 487.854, 6.612, 551.644, 11.851, 529.418, 274.741, 977.479, 17.143, 813.157, 674.033, 806.168, 909.773, 107.016, 96.314, 148.897, 191.932, 526.456, 815.214, 267.325, 396.896, 373.052, 406.027, 565.002, 990.233, 225.857, 684.042, 847.867, 653.736, 858.219, 759.586, 93.501,), (379.264, 552.701, 56.115, 9.450, 171.384, 499.858, 433.910, 784.376, 565.857, 857.960, 95.362, 528.159, 42.552, 211.417, 868.117, 887.554, 475.500, 46.562, 74.348, 925.585, 899.312, 563.510, 32.902, 928.766, 314.485, 961.469, 587.036, 752.254, 712.711, 398.296, 76.937, 162.450, 240.472, 834.651, 389.157, 896.526, 331.730, 755.609, 139.951, 988.478, 724.164, 500.793, 974.323, 53.696, 437.088, 838.675, 340.593, 769.006, 954.858, 396.703,), (773.555, 29.626, 273.327, 992.586, 490.603, 355.811, 941.143, 431.848, 679.695, 660.672, 85.694, 618.616, 798.055, 713.109, 82.038, 154.221, 711.677, 633.901, 739.655, 316.678, 106.551, 5.195, 308.267, 359.917, 269.766, 132.507, 187.392, 448.844, 554.740, 408.044, 26.262, 353.914, 93.064, 598.044, 324.430, 385.238, 291.847, 387.800, 84.700, 901.136, 905.208, 978.173, 571.960, 169.583, 380.732, 138.840, 301.131, 493.124, 63.267, 434.676,), (421.102, 484.231, 76.921, 251.700, 246.590, 625.034, 593.806, 195.548, 106.972, 304.658, 948.823, 332.217, 620.192, 804.076, 329.542, 334.736, 815.475, 859.508, 974.225, 136.124, 320.665, 947.279, 200.851, 314.183, 964.575, 968.725, 291.448, 694.958, 491.007, 575.879, 242.424, 376.055, 816.495, 392.935, 113.888, 563.851, 592.227, 545.629, 681.713, 550.099, 953.005, 461.622, 708.367, 438.455, 291.331, 692.835, 818.966, 795.657, 409.142, 499.303,), (633.336, 242.021, 658.663, 715.236, 789.077, 73.965, 990.701, 479.235, 400.805, 506.613, 920.392, 691.709, 543.645, 790.721, 359.529, 895.502, 536.906, 638.180, 84.982, 768.954, 657.602, 355.009, 647.000, 44.297, 983.608, 677.472, 399.618, 752.683, 965.717, 430.456, 10.548, 258.738, 510.676, 518.798, 580.518, 575.235, 445.779, 391.134, 772.342, 588.590, 500.466, 344.967, 24.563, 104.549, 415.975, 961.728, 116.069, 940.676, 141.675, 311.890,), (455.333, 206.867, 482.926, 476.163, 438.166, 696.763, 318.909, 300.264, 810.186, 115.085, 849.180, 647.970, 677.139, 164.354, 983.900, 243.913, 174.453, 160.136, 559.849, 958.463, 231.856, 405.047, 184.452, 640.479, 432.134, 29.192, 614.107, 197.324, 592.203, 388.836, 704.736, 205.784, 752.325, 808.730, 62.564, 101.752, 871.979, 186.960, 325.985, 457.550, 262.353, 862.637, 527.715, 639.109, 596.971, 611.308, 587.005, 347.925, 845.518, 617.363,), (813.738, 705.988, 297.445, 614.485, 84.752, 133.948, 117.862, 305.380, 183.045, 693.437, 510.825, 418.239, 137.867, 383.710, 185.754, 635.502, 693.433, 645.260, 999.900, 554.913, 489.642, 140.297, 314.580, 451.001, 53.611, 359.039, 9.583, 136.535, 815.216, 963.829, 505.438, 494.970, 684.697, 415.630, 839.892, 488.700, 82.671, 30.861, 761.057, 292.090, 274.853, 537.609, 168.209, 457.321, 742.518, 765.920, 549.726, 113.211, 114.207, 775.113,), (823.283, 366.862, 822.611, 41.611, 718.980, 546.353, 989.776, 102.416, 830.071, 751.345, 297.709, 999.313, 449.732, 348.577, 816.729, 439.070, 993.958, 775.632, 236.946, 810.703, 587.924, 350.631, 710.754, 632.771, 165.982, 139.235, 206.620, 206.943, 59.358, 350.815, 281.085, 538.769, 323.654, 704.054, 289.333, 267.343, 858.017, 985.488, 679.299, 95.225, 962.772, 785.691, 918.769, 992.486, 867.048, 126.888, 866.079, 249.677, 711.395, 828.482,), (761.474, 676.235, 489.459, 577.426, 268.717, 414.225, 451.992, 633.628, 880.125, 93.095, 515.613, 278.226, 936.336, 369.071, 950.254, 327.289, 2.473, 774.135, 732.724, 730.932, 458.449, 664.144, 358.223, 63.331, 534.424, 217.830, 429.643, 211.851, 268.537, 828.344, 337.755, 577.934, 566.142, 485.338, 343.740, 682.552, 48.409, 99.575, 783.890, 459.582, 124.237, 857.652, 441.286, 0.676, 958.032, 202.318, 688.592, 131.913, 649.997, 158.977,), (932.726, 274.019, 654.588, 250.389, 371.844, 903.800, 165.525, 396.342, 305.509, 699.441, 234.144, 655.485, 703.698, 1.086, 476.807, 132.700, 226.191, 679.983, 9.287, 695.597, 817.109, 988.155, 422.314, 132.175, 70.828, 383.070, 730.763, 102.427, 313.351, 880.989, 137.129, 773.460, 753.158, 133.146, 992.940, 142.853, 530.508, 8.475, 650.020, 440.099, 722.432, 628.080, 151.374, 411.710, 686.566, 859.963, 86.688, 100.465, 752.446, 589.574,), (384.032, 963.249, 314.504, 139.830, 276.968, 84.249, 553.397, 600.008, 607.593, 778.970, 690.476, 847.892, 658.405, 301.649, 517.749, 509.523, 747.844, 295.542, 54.569, 897.913, 954.672, 494.888, 112.744, 499.583, 593.930, 528.287, 977.697, 986.883, 933.924, 131.983, 860.814, 568.380, 365.412, 682.942, 762.726, 954.453, 770.367, 16.689, 67.533, 262.185, 39.827, 60.469, 789.290, 506.611, 628.571, 501.049, 415.432, 701.811, 82.428, 536.565,), (616.047, 277.468, 309.907, 511.305, 203.197, 808.060, 536.390, 390.732, 634.294, 834.526, 681.056, 66.115, 698.676, 729.958, 846.468, 57.906, 86.213, 434.484, 453.372, 608.832, 309.290, 741.694, 740.658, 119.443, 707.901, 701.500, 163.833, 953.016, 523.005, 782.987, 720.766, 166.963, 126.931, 781.124, 268.764, 886.415, 771.430, 29.356, 807.108, 271.981, 63.872, 712.323, 576.652, 77.070, 455.198, 360.124, 499.610, 566.886, 367.688, 255.116,), (102.905, 573.912, 722.778, 228.404, 508.825, 44.038, 862.928, 244.551, 471.765, 382.979, 150.085, 931.160, 857.485, 552.865, 913.948, 740.666, 419.369, 321.802, 416.257, 720.288, 271.258, 77.887, 372.808, 502.041, 901.941, 179.344, 804.338, 981.414, 954.079, 68.926, 465.094, 282.307, 844.847, 327.301, 553.091, 7.969, 200.671, 563.807, 303.909, 622.718, 463.927, 591.691, 493.361, 772.613, 195.422, 900.443, 760.482, 245.127, 6.378, 410.036,), (232.998, 346.424, 839.574, 877.199, 950.990, 1.462, 657.304, 849.006, 727.215, 103.949, 529.814, 238.168, 492.029, 59.895, 996.959, 711.652, 93.027, 921.274, 897.287, 519.759, 700.847, 372.492, 974.555, 84.902, 95.577, 133.514, 819.963, 74.830, 567.821, 434.983, 964.218, 236.772, 260.991, 315.009, 800.817, 700.726, 735.353, 318.058, 271.956, 74.687, 202.713, 779.937, 584.708, 155.411, 164.375, 466.055, 406.513, 535.925, 964.635, 207.636,), (308.308, 265.008, 119.914, 157.615, 686.055, 826.387, 696.878, 40.330, 835.925, 327.794, 91.213, 248.219, 355.743, 513.460, 677.183, 260.167, 990.677, 31.082, 404.392, 452.201, 748.078, 249.853, 462.043, 803.897, 139.793, 11.957, 830.372, 982.567, 130.715, 823.673, 372.240, 630.298, 644.685, 582.324, 258.821, 812.747, 21.800, 64.472, 902.496, 443.431, 128.792, 905.078, 829.356, 331.550, 42.696, 460.995, 167.989, 573.884, 821.685, 394.999,), (29.482, 683.213, 172.807, 214.716, 187.151, 279.855, 883.424, 34.649, 619.177, 245.785, 295.105, 411.992, 550.689, 60.979, 279.776, 137.236, 199.458, 884.653, 525.814, 630.754, 802.168, 794.846, 989.404, 781.916, 359.112, 544.518, 484.679, 912.677, 502.393, 388.381, 179.816, 318.878, 219.020, 895.765, 778.538, 58.591, 991.531, 529.432, 766.842, 999.606, 973.980, 100.134, 656.864, 266.527, 816.285, 917.259, 55.909, 996.392, 219.412, 846.505,), (797.391, 354.805, 839.222, 845.221, 176.100, 592.520, 806.210, 697.627, 913.980, 28.207, 700.561, 947.559, 563.606, 563.109, 188.234, 988.006, 881.626, 492.227, 309.053, 490.436, 90.257, 232.623, 218.809, 526.449, 0.683, 917.896, 201.464, 130.490, 716.938, 918.781, 844.284, 323.589, 21.913, 586.609, 917.224, 774.366, 846.481, 860.669, 960.559, 373.591, 941.923, 395.596, 101.032, 301.765, 136.452, 157.504, 948.694, 791.843, 960.662, 649.180,), (174.203, 968.743, 693.560, 928.845, 786.992, 223.237, 588.950, 175.352, 306.823, 688.498, 127.348, 728.831, 948.788, 948.698, 391.601, 994.283, 965.184, 32.383, 602.389, 921.038, 967.532, 220.895, 565.550, 936.688, 140.643, 745.343, 237.996, 982.380, 167.887, 885.320, 88.726, 708.966, 639.103, 886.654, 446.630, 265.212, 249.541, 67.795, 256.658, 108.035, 1.281, 385.937, 732.584, 969.102, 884.552, 493.082, 378.713, 546.024, 101.429, 479.489,), (864.051, 650.970, 687.160, 162.657, 73.709, 845.762, 294.909, 318.717, 951.662, 74.200, 170.105, 375.458, 731.985, 547.046, 898.124, 93.105, 594.031, 613.645, 482.737, 30.993, 942.442, 164.997, 889.753, 157.104, 101.258, 205.550, 189.984, 697.197, 722.038, 729.974, 265.265, 281.523, 237.548, 49.635, 571.770, 839.855, 153.590, 360.829, 427.606, 294.549, 662.020, 600.216, 199.675, 25.736, 170.832, 291.811, 81.936, 843.769, 308.353, 397.467,), (489.097, 661.040, 91.137, 544.126, 184.881, 885.493, 369.402, 445.775, 263.296, 465.058, 226.242, 268.562, 61.639, 752.235, 667.468, 85.707, 343.791, 541.449, 970.706, 589.726, 553.602, 840.797, 818.405, 418.632, 535.514, 866.894, 474.824, 881.654, 476.262, 78.955, 902.777, 714.306, 502.101, 900.455, 800.450, 677.535, 620.273, 120.282, 757.189, 172.879, 984.368, 972.165, 808.461, 126.186, 423.375, 988.280, 435.393, 997.269, 627.226, 834.108,), (257.886, 910.804, 914.174, 67.012, 388.099, 397.355, 326.127, 276.201, 458.157, 873.466, 786.551, 623.058, 522.562, 419.594, 414.442, 148.200, 587.934, 758.377, 939.650, 924.928, 562.684, 100.990, 286.093, 535.633, 343.869, 410.890, 383.043, 485.585, 608.962, 37.466, 275.414, 143.853, 608.655, 693.661, 38.783, 889.574, 331.494, 237.579, 745.750, 920.835, 897.031, 20.233, 817.386, 303.055, 280.347, 491.619, 696.183, 98.217, 868.900, 134.386,), (974.219, 443.111, 825.823, 269.420, 416.773, 645.555, 187.936, 211.391, 823.969, 740.945, 759.493, 867.189, 821.017, 515.270, 158.972, 311.123, 506.795, 135.650, 851.295, 879.333, 28.948, 192.763, 832.930, 836.977, 249.490, 456.449, 918.031, 704.634, 273.977, 823.506, 505.126, 635.410, 123.873, 30.563, 372.467, 594.044, 177.584, 870.481, 586.880, 349.760, 163.514, 894.492, 748.961, 688.851, 285.069, 386.566, 162.907, 572.258, 964.918, 857.111,), (647.380, 677.695, 269.084, 409.507, 20.052, 780.304, 767.573, 8.898, 911.515, 647.372, 601.142, 8.464, 252.390, 805.086, 305.460, 967.024, 642.740, 423.807, 376.475, 348.709, 251.999, 466.698, 677.196, 824.311, 397.153, 102.312, 511.514, 662.355, 843.284, 374.230, 647.342, 609.050, 298.476, 108.105, 63.837, 988.361, 640.595, 861.492, 261.147, 711.094, 892.374, 298.791, 149.929, 765.474, 899.687, 805.430, 802.364, 600.033, 660.530, 680.756,), (721.283, 655.401, 997.469, 259.426, 418.566, 388.275, 35.319, 708.069, 572.042, 189.915, 726.550, 222.363, 534.635, 784.897, 906.527, 671.868, 507.315, 845.419, 840.639, 876.495, 181.136, 97.603, 127.944, 258.652, 808.344, 762.918, 183.068, 679.712, 335.632, 89.300, 355.283, 744.210, 307.085, 788.090, 331.317, 260.559, 294.051, 851.214, 470.537, 866.393, 583.575, 944.301, 71.216, 889.426, 500.477, 867.498, 381.669, 298.356, 54.062, 854.240,), (137.365, 200.297, 409.192, 569.404, 906.621, 457.571, 316.383, 715.668, 778.941, 487.581, 631.033, 176.824, 634.499, 4.714, 273.528, 761.193, 168.606, 764.484, 489.577, 763.569, 88.041, 614.480, 633.488, 403.393, 965.328, 383.316, 37.725, 199.414, 373.101, 14.077, 322.213, 833.229, 190.577, 676.748, 626.687, 248.823, 693.525, 344.350, 128.931, 383.550, 588.671, 167.020, 823.844, 298.202, 290.828, 727.832, 596.370, 337.835, 887.974, 995.472,), (342.733, 901.384, 359.251, 188.426, 948.084, 918.205, 403.392, 228.418, 727.169, 131.206, 734.077, 589.693, 168.985, 366.591, 650.540, 37.363, 876.544, 255.789, 534.733, 48.587, 994.680, 661.970, 653.568, 19.742, 689.750, 416.776, 380.254, 547.282, 474.396, 153.127, 695.192, 630.311, 301.116, 661.665, 662.483, 269.977, 605.634, 137.164, 830.653, 104.914, 718.766, 117.735, 114.013, 106.264, 198.647, 199.749, 262.994, 523.146, 201.673, 703.437,), (295.351, 39.406, 496.355, 207.694, 933.124, 330.604, 2.738, 671.633, 906.880, 835.232, 669.022, 149.144, 90.083, 511.705, 723.564, 101.290, 255.892, 231.160, 988.666, 296.022, 464.277, 99.809, 174.702, 39.445, 290.567, 801.596, 312.707, 738.540, 94.998, 758.204, 45.889, 851.999, 663.355, 170.512, 357.527, 437.715, 621.807, 878.476, 92.951, 814.964, 182.869, 400.778, 962.310, 271.833, 385.715, 850.672, 799.899, 648.846, 796.910, 113.057,), (696.170, 58.646, 942.467, 159.395, 416.028, 590.750, 802.265, 678.393, 181.261, 379.751, 358.599, 28.816, 684.464, 838.536, 973.445, 130.655, 920.398, 112.937, 411.284, 45.972, 261.613, 314.238, 704.568, 677.929, 767.529, 576.649, 565.012, 977.896, 669.844, 338.301, 523.103, 700.580, 95.242, 661.713, 248.577, 345.749, 676.296, 384.877, 839.033, 558.344, 987.792, 54.566, 643.399, 156.927, 848.846, 851.871, 869.416, 74.865, 491.648, 240.892,), (970.145, 50.351, 222.707, 643.317, 403.277, 235.000, 459.095, 801.261, 448.099, 856.589, 447.068, 118.707, 497.373, 653.373, 102.643, 412.339, 557.131, 0.170, 90.896, 604.203, 619.066, 304.598, 508.338, 206.851, 671.474, 950.355, 363.342, 54.275, 222.918, 454.460, 560.151, 619.758, 473.134, 657.167, 715.914, 114.023, 759.320, 221.747, 341.357, 829.884, 964.434, 291.984, 521.985, 702.096, 45.778, 164.155, 140.449, 716.856, 721.559, 106.962,), (610.852, 187.543, 930.216, 392.896, 457.046, 781.420, 716.788, 107.766, 414.470, 926.627, 837.466, 588.811, 772.145, 450.505, 658.457, 956.190, 134.636, 498.829, 530.364, 48.572, 935.308, 838.816, 482.932, 508.333, 921.162, 177.202, 578.554, 730.495, 128.382, 387.406, 600.546, 882.696, 504.110, 384.663, 979.501, 915.910, 762.375, 273.596, 963.594, 970.492, 452.846, 133.372, 412.745, 700.014, 748.427, 298.913, 701.494, 860.708, 711.874, 935.512,), (632.583, 200.889, 624.168, 290.579, 345.294, 672.374, 981.335, 650.086, 958.326, 503.893, 694.312, 322.381, 115.405, 352.238, 480.370, 570.638, 667.157, 417.478, 747.869, 841.389, 285.928, 847.301, 808.305, 522.730, 25.272, 145.327, 670.254, 199.902, 750.185, 160.935, 286.616, 250.561, 839.382, 690.595, 295.141, 753.594, 32.306, 814.026, 102.480, 868.035, 739.492, 864.841, 742.413, 561.271, 237.595, 784.307, 798.822, 287.639, 664.494, 926.485,), (387.555, 956.702, 975.823, 312.654, 552.125, 12.965, 251.341, 620.562, 780.925, 870.118, 829.983, 911.486, 704.629, 647.632, 755.108, 546.615, 603.387, 776.147, 964.290, 294.178, 177.426, 682.659, 186.977, 173.795, 513.847, 377.198, 428.508, 556.599, 130.067, 583.986, 255.016, 330.563, 709.689, 154.806, 153.703, 322.630, 50.855, 932.382, 615.609, 661.890, 490.551, 572.677, 358.086, 784.031, 317.859, 219.962, 183.869, 68.176, 505.140, 415.931,), (537.036, 91.946, 221.198, 213.354, 331.884, 360.798, 218.445, 752.656, 530.499, 996.631, 823.688, 981.133, 8.804, 668.938, 445.667, 904.496, 613.701, 621.132, 958.897, 682.551, 320.937, 915.932, 944.988, 385.876, 540.237, 282.829, 911.336, 822.109, 374.958, 802.817, 445.557, 43.852, 898.282, 192.512, 513.895, 948.212, 167.395, 956.276, 537.975, 7.331, 65.472, 670.335, 773.582, 864.951, 424.209, 103.927, 537.754, 702.743, 976.224, 775.207,), (646.561, 939.751, 746.891, 153.755, 459.225, 331.715, 87.521, 54.268, 794.215, 558.084, 574.962, 227.646, 258.648, 388.033, 630.217, 433.025, 16.891, 673.299, 534.834, 641.423, 618.349, 755.961, 585.608, 700.882, 72.589, 928.048, 106.136, 786.892, 301.351, 86.505, 765.274, 437.676, 395.113, 660.723, 473.988, 533.468, 136.381, 390.993, 797.485, 545.724, 960.134, 144.076, 677.289, 914.169, 795.017, 729.325, 373.131, 949.465, 553.524, 555.070,), (123.235, 5.030, 596.655, 537.152, 946.979, 304.691, 748.297, 903.546, 343.852, 412.654, 645.932, 512.553, 160.954, 220.788, 834.748, 194.326, 181.358, 799.660, 852.251, 851.388, 932.370, 994.313, 461.265, 549.665, 290.653, 67.363, 98.202, 725.589, 487.190, 330.851, 128.215, 655.473, 100.045, 619.516, 900.119, 317.786, 450.646, 616.342, 305.675, 584.170, 565.552, 364.493, 316.333, 428.307, 4.832, 246.175, 221.526, 739.816, 436.124, 840.110,), (134.306, 732.973, 877.886, 462.848, 358.742, 305.472, 551.672, 175.770, 606.628, 841.793, 858.714, 140.002, 538.618, 263.235, 886.336, 76.462, 75.400, 18.630, 507.178, 31.194, 581.890, 405.134, 590.036, 906.304, 551.594, 543.469, 998.728, 472.104, 775.197, 365.819, 223.307, 772.145, 733.227, 290.999, 464.701, 510.412, 396.785, 502.167, 662.678, 847.982, 806.540, 614.036, 165.844, 514.137, 446.220, 179.145, 948.712, 659.413, 967.736, 735.920,), (483.503, 358.796, 218.819, 487.642, 62.861, 369.435, 42.808, 206.774, 907.726, 361.251, 469.674, 454.643, 46.437, 980.590, 324.071, 703.736, 521.373, 829.647, 834.872, 263.316, 544.350, 173.850, 653.675, 365.297, 653.337, 835.469, 516.663, 376.329, 907.242, 516.372, 352.898, 867.719, 486.862, 482.110, 604.211, 501.837, 138.968, 165.606, 77.088, 643.477, 211.517, 186.906, 362.223, 717.303, 118.330, 230.346, 811.173, 720.256, 481.517, 478.815,), (210.704, 161.246, 833.365, 22.446, 43.144, 573.487, 161.129, 629.540, 39.191, 572.269, 55.912, 258.260, 180.038, 958.238, 599.358, 563.605, 18.620, 719.547, 661.745, 283.455, 85.749, 449.203, 992.776, 867.302, 170.567, 830.364, 600.839, 794.616, 820.453, 181.884, 659.649, 264.521, 724.187, 342.671, 453.470, 590.596, 229.814, 385.462, 108.570, 202.349, 859.592, 504.360, 419.795, 149.561, 96.299, 475.869, 614.748, 39.037, 783.868, 503.329,), (117.516, 482.241, 130.329, 603.475, 827.522, 896.969, 774.870, 649.232, 522.044, 370.377, 43.438, 529.817, 229.486, 802.300, 789.556, 381.236, 589.048, 741.394, 761.539, 696.708, 97.717, 133.883, 477.141, 232.513, 859.053, 283.267, 876.766, 408.647, 189.021, 709.149, 789.422, 577.987, 117.829, 7.194, 654.546, 687.767, 315.902, 362.270, 154.779, 651.576, 253.633, 854.977, 423.562, 365.644, 275.561, 680.606, 754.972, 413.228, 783.788, 482.468,), (370.213, 554.911, 253.778, 306.653, 344.356, 705.495, 735.782, 854.999, 659.283, 747.814, 446.595, 699.311, 161.795, 214.458, 400.561, 338.438, 550.576, 697.057, 706.790, 160.738, 964.570, 5.291, 91.089, 145.328, 925.862, 435.377, 64.080, 221.770, 80.040, 37.755, 384.326, 984.448, 613.966, 521.006, 711.606, 597.473, 945.716, 820.229, 640.291, 438.972, 201.707, 656.884, 803.910, 286.007, 33.609, 599.515, 515.814, 231.671, 169.483, 36.061,), (239.257, 0.287, 157.445, 996.817, 779.673, 353.128, 395.143, 586.080, 517.743, 736.926, 68.617, 90.166, 284.494, 829.765, 915.009, 348.095, 963.288, 276.508, 606.363, 194.525, 929.714, 574.907, 261.108, 407.135, 106.465, 72.386, 294.252, 947.015, 802.942, 956.709, 876.113, 813.147, 574.894, 694.192, 966.055, 563.169, 769.967, 757.473, 961.239, 458.848, 460.720, 586.827, 27.351, 116.268, 67.554, 633.662, 994.198, 676.913, 229.930, 315.731,), (955.446, 516.504, 9.723, 832.177, 248.258, 93.009, 673.698, 821.075, 76.029, 931.396, 476.555, 353.538, 894.316, 269.076, 947.118, 683.107, 909.927, 498.999, 199.667, 735.429, 872.742, 206.779, 202.767, 249.695, 618.597, 155.996, 106.689, 920.188, 675.812, 663.424, 613.827, 764.244, 541.474, 42.263, 482.292, 620.667, 492.340, 985.361, 897.000, 868.769, 490.805, 984.395, 916.007, 280.267, 222.093, 576.665, 54.148, 799.270, 478.320, 540.768,), (502.475, 393.717, 686.339, 174.800, 976.507, 698.245, 460.071, 689.211, 11.820, 210.752, 581.008, 325.436, 612.778, 259.701, 548.563, 237.139, 471.345, 613.084, 365.924, 498.770, 210.532, 700.713, 372.310, 854.326, 279.630, 179.889, 131.139, 575.893, 228.567, 99.870, 269.949, 235.805, 432.219, 380.883, 145.844, 959.148, 149.548, 805.668, 176.607, 499.598, 995.562, 849.390, 517.007, 720.560, 785.333, 300.034, 562.138, 567.835, 398.402, 690.543,), (60.036, 813.818, 476.539, 629.862, 449.855, 334.657, 360.962, 560.350, 931.845, 257.715, 19.835, 121.237, 867.369, 963.117, 198.958, 575.894, 649.131, 174.539, 780.309, 355.109, 673.193, 487.494, 736.526, 889.632, 381.071, 286.524, 631.712, 144.848, 167.576, 807.717, 337.388, 631.273, 571.638, 848.901, 71.344, 161.999, 228.218, 316.878, 291.356, 267.472, 644.644, 271.248, 444.898, 862.806, 363.165, 586.920, 965.526, 413.989, 183.886, 23.101,), (727.772, 662.023, 940.437, 700.697, 80.065, 166.910, 103.009, 63.792, 878.691, 548.434, 26.365, 397.013, 764.996, 83.251, 262.452, 155.274, 654.833, 885.471, 309.371, 247.397, 284.175, 626.481, 131.277, 838.518, 28.571, 663.549, 860.369, 325.201, 476.155, 974.982, 540.584, 272.414, 444.845, 969.542, 697.623, 177.037, 597.584, 631.048, 635.851, 563.984, 523.460, 639.528, 309.661, 347.168, 539.668, 804.708, 441.860, 365.783, 259.807, 303.573,), (0.092, 815.380, 847.946, 343.885, 469.198, 8.317, 922.088, 946.958, 477.067, 9.133, 430.435, 292.923, 231.215, 7.218, 373.644, 411.736, 560.554, 394.752, 163.269, 737.118, 389.723, 378.358, 262.980, 422.239, 239.562, 764.538, 909.954, 807.575, 684.640, 284.677, 742.927, 808.809, 412.904, 853.482, 182.407, 289.595, 636.893, 617.729, 272.134, 622.754, 187.789, 19.395, 49.632, 534.971, 185.938, 102.273, 269.195, 715.196, 727.107, 232.810,), (150.684, 493.580, 341.913, 311.577, 799.462, 997.963, 463.684, 791.425, 330.249, 843.546, 951.644, 56.038, 775.653, 71.385, 470.147, 192.192, 841.539, 817.251, 828.252, 121.962, 768.146, 248.962, 771.225, 442.961, 737.619, 33.510, 460.835, 770.996, 521.139, 982.116, 472.826, 681.442, 312.109, 323.063, 629.164, 42.186, 937.421, 520.926, 253.313, 638.520, 198.724, 887.520, 863.658, 217.788, 112.928, 632.909, 324.513, 167.360, 276.100, 119.650,), (789.144, 8.930, 41.993, 783.475, 475.271, 596.212, 371.399, 89.480, 157.698, 91.402, 618.645, 930.849, 996.973, 625.132, 59.775, 644.575, 701.328, 791.466, 125.827, 232.675, 981.676, 788.562, 756.698, 805.525, 438.719, 192.965, 689.250, 358.167, 134.732, 898.663, 485.302, 437.500, 294.715, 697.038, 189.776, 186.627, 347.665, 732.402, 275.324, 831.350, 914.474, 554.520, 68.877, 155.025, 295.673, 263.349, 367.113, 0.720, 638.026, 379.044,), (185.534, 18.720, 856.829, 776.017, 238.787, 721.004, 658.289, 538.957, 387.491, 524.070, 497.549, 551.468, 613.039, 322.600, 640.904, 110.464, 523.201, 66.680, 835.193, 129.774, 873.493, 202.079, 485.370, 98.754, 571.012, 836.300, 657.921, 525.821, 701.314, 255.939, 366.354, 605.954, 70.874, 930.211, 208.738, 491.406, 889.767, 79.957, 801.020, 60.700, 558.020, 938.244, 415.953, 369.069, 708.434, 823.643, 265.816, 40.653, 70.388, 303.905,), (944.603, 960.587, 97.119, 725.172, 531.661, 189.460, 526.192, 248.763, 625.325, 178.898, 749.194, 415.185, 105.514, 638.624, 357.963, 458.721, 665.242, 882.824, 166.809, 180.397, 401.557, 337.513, 158.176, 998.434, 443.012, 352.324, 315.155, 991.463, 324.654, 371.720, 764.184, 430.588, 725.868, 608.413, 563.145, 213.928, 765.708, 926.147, 254.089, 961.652, 447.500, 397.091, 726.313, 982.956, 595.763, 517.609, 993.412, 301.842, 300.334, 221.887,), (855.720, 21.701, 821.940, 689.719, 275.957, 553.663, 556.323, 925.922, 154.715, 37.736, 355.656, 138.408, 367.083, 582.156, 232.994, 811.074, 91.905, 399.798, 917.882, 734.266, 723.581, 792.904, 172.902, 825.705, 689.595, 576.232, 907.656, 595.231, 300.393, 730.789, 576.284, 78.477, 55.923, 770.902, 347.930, 817.142, 416.522, 867.831, 869.787, 226.718, 652.779, 602.302, 11.434, 777.419, 382.487, 304.783, 41.182, 539.930, 149.580, 502.402,), (220.797, 50.520, 731.579, 392.883, 445.616, 595.132, 504.729, 222.086, 289.783, 394.322, 132.189, 82.545, 571.441, 49.311, 399.191, 85.079, 501.823, 773.825, 130.375, 134.871, 559.296, 487.861, 652.248, 196.099, 615.997, 735.668, 246.246, 71.644, 776.772, 323.412, 924.138, 89.595, 671.748, 423.541, 348.308, 320.738, 593.877, 24.207, 304.819, 987.652, 616.221, 990.159, 442.210, 145.818, 44.878, 818.172, 199.685, 373.821, 757.734, 852.764,), (112.372, 54.538, 948.941, 926.730, 868.752, 820.134, 13.733, 693.795, 111.278, 450.062, 22.748, 209.010, 538.005, 203.801, 523.266, 258.658, 483.026, 729.924, 141.347, 698.755, 18.389, 583.005, 663.528, 43.482, 170.320, 284.014, 789.188, 617.965, 53.085, 654.758, 8.334, 388.645, 271.310, 852.083, 660.100, 864.282, 19.078, 867.410, 649.411, 231.169, 380.701, 976.612, 99.604, 315.456, 866.773, 531.561, 186.417, 500.651, 457.986, 926.350,), (21.488, 247.392, 529.415, 333.570, 393.400, 157.005, 346.780, 351.913, 625.231, 236.205, 978.244, 501.251, 811.893, 625.792, 878.677, 890.402, 814.859, 29.466, 554.939, 280.194, 151.708, 897.175, 656.932, 87.795, 382.207, 960.606, 612.448, 625.525, 227.428, 240.361, 152.749, 970.537, 909.735, 329.285, 542.234, 206.757, 138.577, 541.354, 800.105, 862.588, 308.998, 705.136, 523.805, 135.252, 995.686, 975.777, 145.152, 933.030, 917.112, 317.496,), (557.340, 948.602, 118.387, 317.598, 879.638, 727.080, 765.435, 880.132, 414.040, 411.252, 443.004, 933.769, 894.130, 933.250, 273.796, 779.108, 106.771, 184.746, 762.447, 611.982, 266.863, 567.043, 230.911, 232.183, 687.378, 359.261, 688.141, 476.602, 502.325, 604.712, 712.019, 373.959, 852.129, 491.446, 137.513, 193.260, 32.230, 764.539, 15.014, 269.859, 413.044, 742.367, 988.243, 757.777, 66.136, 927.103, 985.628, 867.129, 489.943, 324.896,), (457.545, 246.784, 404.867, 41.826, 735.332, 380.374, 312.897, 611.505, 742.468, 593.806, 525.231, 875.783, 786.920, 520.649, 451.610, 827.010, 42.416, 995.836, 518.703, 395.611, 735.170, 557.701, 516.127, 630.649, 49.295, 291.179, 398.040, 304.554, 827.621, 461.347, 422.462, 613.134, 54.547, 516.970, 142.240, 829.894, 451.698, 722.647, 113.172, 778.731, 937.842, 696.114, 135.307, 413.559, 450.886, 178.879, 590.315, 712.634, 201.932, 454.683,), (250.082, 691.717, 907.162, 796.486, 718.375, 123.544, 114.165, 449.398, 362.943, 523.817, 384.087, 791.067, 511.666, 949.754, 378.679, 380.607, 768.260, 912.253, 565.492, 659.530, 150.090, 868.819, 178.867, 712.047, 419.582, 309.518, 768.630, 446.258, 626.453, 117.554, 131.571, 202.852, 622.560, 253.111, 458.643, 855.411, 543.501, 5.751, 882.703, 237.878, 588.862, 475.712, 410.151, 79.405, 600.102, 244.713, 547.342, 619.766, 557.549, 825.253,), (48.919, 148.256, 653.277, 36.721, 853.829, 666.997, 838.014, 298.442, 920.385, 49.031, 416.957, 178.248, 672.090, 611.090, 691.514, 594.969, 787.308, 177.419, 455.338, 578.966, 931.480, 93.126, 299.294, 368.569, 378.939, 67.667, 427.324, 550.471, 292.833, 134.546, 694.619, 274.419, 527.053, 524.646, 695.829, 612.054, 109.302, 729.729, 628.979, 987.189, 483.663, 688.654, 933.892, 986.278, 287.187, 608.845, 316.489, 525.391, 995.024, 353.853,)))"
      ]
     },
     "execution_count": 126,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 127,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix((639.4, ...), ..., (..., 353.9))[100x50]\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 128,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = Vector(1000 * random.random() for _ in range(50))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 129,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "Vector((129.713, 562.634, 519.706, 631.858, 492.504, 179.907, 609.406, 708.587, 979.258, 1.581, 23.987, 625.461, 117.926, 848.070, 799.564, 998.987, 414.041, 333.792, 560.416, 637.504, 11.297, 201.187, 281.627, 790.196, 307.773, 506.690, 323.924, 6.131, 685.836, 341.362, 724.397, 615.993, 29.117, 175.629, 330.515, 337.937, 672.473, 916.163, 797.254, 645.652, 481.496, 627.200, 892.058, 536.968, 335.110, 783.989, 413.953, 742.585, 835.106, 299.344))"
      ]
     },
     "execution_count": 129,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 130,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector(129.7, ..., 299.3)[50]\n"
     ]
    }
   ],
   "source": [
    "print(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arithmetic works as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 131,
   "metadata": {},
   "outputs": [],
   "source": [
    "w = m * v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 132,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Vector(11378937.3, ..., 13593029.3)[100]\n"
     ]
    }
   ],
   "source": [
    "print(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We can multiply `m` with its transpose or the other way round."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 133,
   "metadata": {},
   "outputs": [],
   "source": [
    "n = m * m.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 134,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix((14370711.3, ...), ..., (..., 16545418.2))[100x100]\n"
     ]
    }
   ],
   "source": [
    "print(n)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 135,
   "metadata": {},
   "outputs": [],
   "source": [
    "o = m.transpose() * m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 136,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Matrix((32618511.5, ...), ..., (..., 32339164.8))[50x50]\n"
     ]
    }
   ],
   "source": [
    "print(o)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Inheritance\n",
    "\n",
    "The last important OOP building block is the ability to create new **child** classes that **inherit** their attributes and methods from **parent** classes. This idea is also often called **sub-classing**. The main advantage here is re-use of code. A second benefit is the ability to get a clearer picture as how different parts of an application relate to each other from an generalization vs. specialization point of view."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "For example, let us create new child classes `IntegerVector` and `IntegerMatrix` that can only store integers. The following instances will thus need less memory for its entries. The syntax for this is easy: All we have to do is to reference the parent class in parenthesis in the `class` statement's header line. Then, we adjust the `typing` class attributes that control how the new classes work. To also make the string representations a bit nicer, we replace the `{:.1f}` and `{:.3f}` with `{:d}` in the `__repr__()` and `__str__()` methods so that all the entries are shown as pure integers (i.e., without the \".000\"s). Generally, if we define an attribute or method on a child class that is also defined on its parent class, it is overwritten by the child. Lastly, we need to also overwrite the `as_matrix()` and `as_vector()` methods so that they return instances of the new child classes as well."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 137,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IntegerVector(Vector):\n",
    "    \"\"\"A standard one-dimensional vector from linear algebra.\n",
    "\n",
    "    Instances of this class store all entries as integers.\n",
    "    \"\"\"\n",
    "\n",
    "    typing = int\n",
    "\n",
    "    def __repr__(self):\n",
    "        args = \", \".join(\"{:d}\".format(x) for x in self)\n",
    "        return \"{}(({}))\".format(self.__class__.__name__, args)\n",
    "\n",
    "    def __str__(self):\n",
    "        entries = \"({:d}, ..., {:d})\".format(self[0], self[-1])\n",
    "        length = \"[{:d}]\".format(len(self))\n",
    "        return self.__class__.__name__ + entries + length\n",
    "\n",
    "    def as_matrix(self, column=True):\n",
    "        \"\"\"Convert the vector into a matrix.\n",
    "\n",
    "        Args:\n",
    "            column (bool): If the vector should be interpreted as\n",
    "                as a column vector or not. Defaults to True.\n",
    "        Returns:\n",
    "            Matrix\n",
    "        \"\"\"\n",
    "        if column:\n",
    "            return IntegerMatrix([x] for x in self)\n",
    "        return IntegerMatrix([(x for x in self)])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 138,
   "metadata": {},
   "outputs": [],
   "source": [
    "class IntegerMatrix(Matrix):\n",
    "    \"\"\"A standard two-dimensional matrix from linear algebra.\n",
    "\n",
    "    Instances of this class store all entries as integers.\n",
    "    \"\"\"\n",
    "\n",
    "    typing = int\n",
    "\n",
    "    def __repr__(self):\n",
    "        args = (\", \".join(\"(\" + \", \".join(\"{:d}\".format(col) for col in row) + \",)\"\n",
    "                          for row in self._entries))\n",
    "        return \"{}(({}))\".format(self.__class__.__name__, args)\n",
    "\n",
    "    def __str__(self):\n",
    "        entries = \"(({:d}, ...), ..., (..., {:d}))\".format(self[0], self[-1])\n",
    "        dims = \"[{:d}x{:d}]\".format(self.n_rows, self.n_cols)\n",
    "        return self.__class__.__name__ + entries + dims\n",
    "\n",
    "    def as_vector(self):\n",
    "        \"\"\"Convert the matrix into a vector.\n",
    "\n",
    "        Returns:\n",
    "            Vector\n",
    "        Raises:\n",
    "            TypeError: If not one of the two dimensions is 1.\n",
    "        \"\"\"\n",
    "        if not (self.n_rows == 1 or self.n_cols == 1):\n",
    "            raise TypeError(\"One dimension (m or n) must be 1 so that the \"\n",
    "                            \"matrix can be converted into a vector!\")\n",
    "        return IntegerVector(x for x in self)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Here we also see the generalizing effect of the `self.__class__.__name__` in the parents' classes' `__repr__()` and `__str__()` methods."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 139,
   "metadata": {},
   "outputs": [],
   "source": [
    "m = IntegerMatrix((1000 * random.random() for _ in range(5)) for _ in range(10))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 140,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerMatrix(((724, 315, 535, 208, 685,), (799, 888, 353, 969, 280,), (31, 983, 626, 842, 570,), (389, 595, 864, 751, 705,), (314, 31, 413, 497, 237,), (451, 950, 216, 302, 112,), (784, 777, 913, 443, 24,), (482, 500, 190, 923, 732,), (523, 775, 143, 871, 822,), (938, 676, 132, 724, 459,)))"
      ]
     },
     "execution_count": 140,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 141,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "IntegerMatrix((724, ...), ..., (..., 459))[10x5]\n"
     ]
    }
   ],
   "source": [
    "print(m)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 142,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = IntegerVector(1000 * random.random() for _ in range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 143,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerVector((713, 522, 4, 932, 687))"
      ]
     },
     "execution_count": 143,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The arithmetic operations work as before."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 144,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerVector((1347233, 2130103, 1714067, 1775670, 867739, 1176735, 1397602, 1968546, 2154507, 2012295))"
      ]
     },
     "execution_count": 144,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "m * v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "If we are ever in doubt if a class is a sub-class or child of another class, we can use the [issubclass()](https://docs.python.org/3/library/functions.html#issubclass) built-in and check."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 145,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 145,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(IntegerVector, Vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 146,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 146,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "issubclass(IntegerMatrix, Vector)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Also, the [isinstance()](https://docs.python.org/3/library/functions.html#isinstance) built-in is aware of the inheritance when validating an instance's type wheras the [type()](https://docs.python.org/3/library/functions.html#type) built-in is not."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 147,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 147,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(v, IntegerVector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 148,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 148,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "isinstance(v, Vector)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 149,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 149,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v) is IntegerVector"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 150,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "False"
      ]
     },
     "execution_count": 150,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "type(v) is Vector"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Another sub-classing example is to adapt the `storage` class attributes and create mutable versions of vectors. Here, we also need to add a new method `__setitem__()` that is not used in our final version of `Vector`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 151,
   "metadata": {},
   "outputs": [],
   "source": [
    "class MutableVector(Vector):\n",
    "    \"\"\"A standard one-dimensional vector from linear algebra.\n",
    "\n",
    "    Instances of this class are mutable objects via the indexing operator.\n",
    "    \"\"\"\n",
    "\n",
    "    storage = list\n",
    "\n",
    "    def __setitem__(self, index, value):\n",
    "        if not isinstance(index, int):\n",
    "            raise TypeError(\"index must be an integer!\")\n",
    "        self._entries[index] = self.typing(value)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 152,
   "metadata": {},
   "outputs": [],
   "source": [
    "v = MutableVector(1000 * random.random() for _ in range(5))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 153,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MutableVector((594.288, 87.076, 466.876, 46.140, 520.578))"
      ]
     },
     "execution_count": 153,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 154,
   "metadata": {},
   "outputs": [],
   "source": [
    "v[0] = -1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 155,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "MutableVector((-1.000, 87.076, 466.876, 46.140, 520.578))"
      ]
     },
     "execution_count": 155,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Example revisited: Comparison with numpy\n",
    "\n",
    "We started out by realizing that Python (incl. the Standard Library) provides us no good data type to model a vector $\\vec{v}$ or a matrix $\\bf{X}$. Then, we built up two custom data types `Vector` and `Matrix` that basically wrap a simple tuple (for $\\vec{v}$) and a list of lists (for $\\bf{X}$) so that we can interact with these values in a \"natural\" and Pythonic way. By doing this, we extended Python with our own little \"dialect\" or DSL.\n",
    "\n",
    "If we feel like sharing our linear algebra toolbox with the world, we could easily do so on either [GitHub](https://github.com) or [PyPI](https://pypi.org). However, for the domain of linear algebra this would be rather pointless as there is already a widely adopted library with [numpy](http://www.numpy.org/) that not only has a lot more features than ours but also is implemented in C, which makes it a lot faster with big data."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let's take a quick look at numpy and compare it with our DSL using the example from the top."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 156,
   "metadata": {},
   "outputs": [],
   "source": [
    "y = (1, 2, 3)\n",
    "X = [[1, 2, 3], [4, 5, 6], [7, 8, 9]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 157,
   "metadata": {},
   "outputs": [
    {
     "ename": "TypeError",
     "evalue": "can't multiply sequence by non-int of type 'tuple'",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-157-c494e576a745>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0my\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mTypeError\u001b[0m: can't multiply sequence by non-int of type 'tuple'"
     ]
    }
   ],
   "source": [
    "X * y"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The creation of vectors and matrices is similar to our DSL. However, numpy uses the more general concept of an **n-dimensional array** where a vector is only a special case of a matrix and a matrix is yet another special case of an even higher dimensional structure."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 158,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 159,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_arr = np.array(y)\n",
    "X_arr = np.array(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 160,
   "metadata": {},
   "outputs": [],
   "source": [
    "y_vec = IntegerVector(y)\n",
    "X_mat = IntegerMatrix(X)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The string representations are very similar. numpy scores a bonus point by making the matrix a bit clearer."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 161,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3])"
      ]
     },
     "execution_count": 161,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 162,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerVector((1, 2, 3))"
      ]
     },
     "execution_count": 162,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 163,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 163,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 164,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerMatrix(((1, 2, 3,), (4, 5, 6,), (7, 8, 9,)))"
      ]
     },
     "execution_count": 164,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "numpy arrays come with a `shape` instance attribute that returns a tuple with the dimensions, even for \"vectors\"."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 165,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3,)"
      ]
     },
     "execution_count": 165,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 166,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 166,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_arr.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 167,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 167,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_mat.n_rows, X_mat.n_cols"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "[len()](https://docs.python.org/3/library/functions.html#len) built-in function does not return the number of entries in the array but of the rows instead. This is equivalent to the first item in the `shape` tuple."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 168,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 168,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 169,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 169,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(y_vec)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 170,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "3"
      ]
     },
     "execution_count": 170,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 171,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 171,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "len(X_mat)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "The `transpose()` method also exists for arrays."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 172,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4, 7],\n",
       "       [2, 5, 8],\n",
       "       [3, 6, 9]])"
      ]
     },
     "execution_count": 172,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_arr.transpose()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 173,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerMatrix(((1, 4, 7,), (2, 5, 8,), (3, 6, 9,)))"
      ]
     },
     "execution_count": 173,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_mat.transpose()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "To perform matrix-matrix, matrix-vector, or vector-matrix multiplication, we need to use the `dot()` method and pass the right multiplicant in as an argument. If we use the `*` operator on arrays, a different type of \"multiplication\" is performed."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 174,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([14, 32, 50])"
      ]
     },
     "execution_count": 174,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_arr.dot(y_arr)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 175,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1,  4,  9],\n",
       "       [ 4, 10, 18],\n",
       "       [ 7, 16, 27]])"
      ]
     },
     "execution_count": 175,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_arr * y_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 176,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerVector((14, 32, 50))"
      ]
     },
     "execution_count": 176,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "X_mat * y_vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Scalar multiplication, however, works as expected."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 177,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([10, 20, 30])"
      ]
     },
     "execution_count": 177,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * y_arr"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 178,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "IntegerVector((10, 20, 30))"
      ]
     },
     "execution_count": 178,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "10 * y_vec"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Because we implemented our classes to support the sequence protocol, numpy's one-dimensional arrays are actually able to work with them. Note that the `*` operator is applied on a per-entry basis."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 179,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6])"
      ]
     },
     "execution_count": 179,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_arr + y_vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 180,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 4, 9])"
      ]
     },
     "execution_count": 180,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "y_arr * y_vec"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 181,
   "metadata": {},
   "outputs": [
    {
     "ename": "ValueError",
     "evalue": "operands could not be broadcast together with shapes (3,3) (9,) ",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m                                Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-181-89dcd380b2e7>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[0;32m----> 1\u001b[0;31m \u001b[0mX_arr\u001b[0m \u001b[0;34m+\u001b[0m \u001b[0mX_mat\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m",
      "\u001b[0;31mValueError\u001b[0m: operands could not be broadcast together with shapes (3,3) (9,) "
     ]
    }
   ],
   "source": [
    "X_arr + X_mat"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "We conclude that it is rather easy to extend Python in a way that makes the resulting application code read like core Python again. As there are many well established third-party packages out there, it is unlikely that we have to implement a fundamental library ourselves. Rather, we are more likely to use, for example, numpy arrays in the same way as we used tuples and lists of lists here to built up a higher level of abstraction."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}