notebook/ch04_linear_algebra.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "from __future__ import division # want 3 / 2 == 1.5\n",
    "import re, math, random # regexes, math functions, random numbers\n",
    "import matplotlib.pyplot as plt # pyplot\n",
    "from collections import defaultdict, Counter\n",
    "from functools import partial, reduce # For python3, \"reduce\" function is added\n",
    "\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vector_add(v, w):\n",
    "    \"\"\"adds two vectors componentwise\"\"\"\n",
    "    return [v_i + w_i for v_i, w_i in zip(v,w)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "v = [x for x in range(1, 11,2)]\n",
    "w = [y for y in range(11, 21,2)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[12, 16, 20, 24, 28]"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_add(v, w)\n",
    "\n",
    "# [v for v in range(1, 11, 2)] == [1, 3, 5, 7, 9]\n",
    "# [w for w in range(10, 21, 2)] == [11, 13, 15, 17, 19]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([12, 16, 20, 24, 28])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.array(v) + np.array(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "The slowest run took 4.92 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 2.47 µs per loop\n",
      "The slowest run took 7.45 times longer than the fastest. This could mean that an intermediate result is being cached.\n",
      "100000 loops, best of 3: 3.07 µs per loop\n"
     ]
    }
   ],
   "source": [
    "# 벡터 덧셈의 속도 비교, Numpy의 속도가 더 빠른 것을 확인할 수 있음\n",
    "\n",
    "%timeit vector_add(v, w)\n",
    "%timeit np.array(v) + np.array(w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def vector_subtract(v, w):\n",
    "    \"\"\"subtracts two vectors componentwise\"\"\"\n",
    "    return [v_i - w_i for v_i, w_i in zip(v,w)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[-10, -10, -10, -10, -10]"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vector_subtract(v, w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-10, -10, -10, -10, -10])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version (Not in Book)\n",
    "np.array(v) - np.array(w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 여러개의 Vector를 list로 만들어서 sum 연산을 하는 경우"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Original book version \n",
    "def vector_sum(vectors):\n",
    "    return reduce(vector_add, vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[36, 48, 60, 72, 84]"
      ]
     },
     "execution_count": 11,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectors = [v,w,v,w,v,w]\n",
    "vector_sum(vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Modified version by sc82.choi at Gachon - *은 여러개의 argument를 list로 전환해줌\n",
    "def vector_sum_modified(vectors):\n",
    "    return [sum(value) for value in zip(*vectors)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[36, 48, 60, 72, 84]"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "vectors = [v,w,v,w,v,w]\n",
    "vector_sum_modified(vectors)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([36, 48, 60, 72, 84])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy operation\n",
    "np.sum([v,w,v,w,v,w], axis=0) \n",
    "# axis=0 는 row [v,w,v,w,v,w]를 하나의 matrix로 생각했을 때, column별로 sum operation을 하라는 의미\n",
    "# axis=1 는 row [v,w,v,w,v,w]를 하나의 matrix로 생각했을 때, row별로 sum operation을 하라는 의미"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Scalar * Vector의 연산 ex) 2 * [1,2,3,4] = [2,4,6,8]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Original book verstion\n",
    "def scalar_multiply(c, v):\n",
    "    return [c * v_i for v_i in v]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[15, 18, 21, 24]"
      ]
     },
     "execution_count": 16,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [5, 6, 7, 8]\n",
    "scalar = 3\n",
    "\n",
    "scalar_multiply(scalar, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([15, 18, 21, 24])"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version: Numpy는 배열의 크기가 다르더라도 기본적인 vector연산을 가능하도록 지원해준다. 이를 broadcasting이라고 함\n",
    "\n",
    "scalar * np.array(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### vector 의 평균 구하기: 크기가 같은 vector를 matrix형태로 입력했을 경우, 각 row별 평균을 구함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Original book version\n",
    "\n",
    "def vector_mean(vectors):\n",
    "    \"\"\"compute the vector whose i-th element is the mean of the\n",
    "    i-th elements of the input vectors\"\"\"\n",
    "    n = len(vectors)\n",
    "    return scalar_multiply(1/n, vector_sum(vectors))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1.0, 2.0, 3.0, 4.0]"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [1,2,3,4]\n",
    "w = [-4,-3,-2,-1]\n",
    "\n",
    "vector_mean([v,v,v,v])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1.,  2.,  3.,  4.])"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Original book version\n",
    "np.mean([v,v,v,v], axis=0)\n",
    "# axis=0 는 row [v,w,v,w,v,w]를 하나의 matrix로 생각했을 때, column별로 mean operation을 하라는 의미\n",
    "# axis=1 는 row [v,w,v,w,v,w]를 하나의 matrix로 생각했을 때, row별로 mean operation을 하라는 의미"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Vector dot product: 크기가 같은 두개의 vector가 있으면, 같은 column에 해당하는 값을 곱한 후 모든 값을 더함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Original book version\n",
    "def dot(v, w):\n",
    "    \"\"\"v_1 * w_1 + ... + v_n * w_n\"\"\"\n",
    "    return sum(v_i * w_i for v_i, w_i in zip(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-20"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [1,2,3,4]\n",
    "w = [-4,-3,-2,-1]\n",
    "\n",
    "dot(v, w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-20"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.dot(v,w)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### 하나의 vector에서 값 element들을 제곱하여 더한 후 값을 반환함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "# Original book version\n",
    "def sum_of_squares(v):\n",
    "    \"\"\"v_1 * v_1 + ... + v_n * v_n\"\"\"\n",
    "    return dot(v, v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [1,2,3,4]\n",
    "sum_of_squares(v) # v * v = [1,4,9,16]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "30"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.dot(v,v) # or sum(np.square(v))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### magnitude: 하나의 vector를 dot_product한 후 양의 제곱근을 구함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "collapsed": false
   },
   "outputs": [],
   "source": [
    "# Orginal book version\n",
    "def magnitude(v):\n",
    "    return math.sqrt(sum_of_squares(v))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.477225575051661"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "magnitude(v)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5.4772255750516612"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.linalg.norm(v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Distance 구하기: vector간의 거리를 구하는 공식 \n",
    "- 파타고라스의 정리 처럼, 두 점(두 벡터) 사이의 거리는 (x1 - y1)^2 + (x2 - y2)^2 의 제곱근을 구해주면 됨\n",
    "- 피타고라스의 정리 처럼 두 점이 이차원 평면이 아닌 n차원의 vector로 구성되는 차이점이 있음\n",
    "- 정식 명칭은 Eculidian distance 라고 함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "#original version\n",
    "def squared_distance(v, w):\n",
    "    return sum_of_squares(vector_subtract(v, w))\n",
    "\n",
    "def distance(v, w):\n",
    "   return math.sqrt(squared_distance(v, w))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "100"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "v = [1,2,3,4]\n",
    "w = [-4,-3,-2,-1]\n",
    "\n",
    "squared_distance(v,w) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 32,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "distance(v,w)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.0"
      ]
     },
     "execution_count": 33,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.linalg.norm(np.subtract(v,w)) # or np.sqrt(np.sum(np.subtract(v,w)**2))\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matrix  indexing\n",
    "- shape: matrix의 크기를 구함\n",
    "- get_row: matrix에서 하나의 row을 추출함\n",
    "- get_column: matrix에서 하나의 column을 추출함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def shape(A):\n",
    "    num_rows = len(A)\n",
    "    num_cols = len(A[0]) if A else 0\n",
    "    return num_rows, num_cols\n",
    "\n",
    "def get_row(A, i):\n",
    "    return A[i]\n",
    "\n",
    "def get_column(A, j):\n",
    "    return [A_i[j] for A_i in A]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 35,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_matrix = [[1,2,3,4,5], [11,12,13,14,15], [21,22,23,24,25]]\n",
    "\n",
    "shape(example_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[1, 2, 3, 4, 5]"
      ]
     },
     "execution_count": 36,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_row(example_matrix, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[4, 14, 24]"
      ]
     },
     "execution_count": 37,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "get_column(example_matrix,3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 5)"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version \n",
    "np.shape(example_matrix)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4, 5])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_matrix = np.array(example_matrix)\n",
    "example_matrix[0] #row slicing"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 4, 14, 24])"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "example_matrix[:,3] #row slicing"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Matrix  operation\n",
    "- make_matirx: entry_fn을 기준으로 num_rows와 num_cols을 생성함\n",
    "- id_diagonal: 대각행렬이 1 matrix를 만들기 위해, row와 column 의 값이 같으면 1 아니면 0을 반환\n",
    "- matrix_add: matrix간 덧셈"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_matrix(num_rows, num_cols, entry_fn):\n",
    "    \"\"\"returns a num_rows x num_cols matrix \n",
    "    whose (i,j)-th entry is entry_fn(i, j)\"\"\"\n",
    "    return [[entry_fn(i, j) for j in range(num_cols)]\n",
    "            for i in range(num_rows)]  "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def is_diagonal(i, j):\n",
    "    \"\"\"1's on the 'diagonal', 0's everywhere else\"\"\"\n",
    "    return 1 if i == j else 0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[1, 0, 0, 0, 0],\n",
       " [0, 1, 0, 0, 0],\n",
       " [0, 0, 1, 0, 0],\n",
       " [0, 0, 0, 1, 0],\n",
       " [0, 0, 0, 0, 1]]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "identity_matrix = make_matrix(5, 5, is_diagonal)\n",
    "\n",
    "identity_matrix"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "collapsed": false,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 1.,  0.,  0.,  0.,  0.],\n",
       "       [ 0.,  1.,  0.,  0.,  0.],\n",
       "       [ 0.,  0.,  1.,  0.,  0.],\n",
       "       [ 0.,  0.,  0.,  1.,  0.],\n",
       "       [ 0.,  0.,  0.,  0.,  1.]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "np.identity(5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "friendships = [[0, 1, 1, 0, 0, 0, 0, 0, 0, 0], # user 0\n",
    "               [1, 0, 1, 1, 0, 0, 0, 0, 0, 0], # user 1\n",
    "               [1, 1, 0, 1, 0, 0, 0, 0, 0, 0], # user 2\n",
    "               [0, 1, 1, 0, 1, 0, 0, 0, 0, 0], # user 3\n",
    "               [0, 0, 0, 1, 0, 1, 0, 0, 0, 0], # user 4\n",
    "               [0, 0, 0, 0, 1, 0, 1, 1, 0, 0], # user 5\n",
    "               [0, 0, 0, 0, 0, 1, 0, 0, 1, 0], # user 6\n",
    "               [0, 0, 0, 0, 0, 1, 0, 0, 1, 0], # user 7\n",
    "               [0, 0, 0, 0, 0, 0, 1, 1, 0, 1], # user 8\n",
    "               [0, 0, 0, 0, 0, 0, 0, 0, 1, 0]] # user 9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def matrix_add(A, B):\n",
    "    if shape(A) != shape(B):\n",
    "        raise ArithmeticError(\"cannot add matrices with different shapes\")\n",
    "        \n",
    "    num_rows, num_cols = shape(A)\n",
    "    def entry_fn(i, j): return A[i][j] + B[i][j]\n",
    "        \n",
    "    return make_matrix(num_rows, num_cols, entry_fn)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[[6.0, 4.0, 3.0], [2.0, 3.0, 4.0]]"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = [[ 1., 0., 0.], [ 0., 1., 2.]]\n",
    "B = [[ 5., 4., 3.], [ 2., 2., 2.]]\n",
    "\n",
    "matrix_add(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 6.,  4.,  3.],\n",
       "       [ 2.,  3.,  4.]])"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# Numpy version\n",
    "\n",
    "np.add(A,B) # vector 마찬가지로 크기 같은 matrix 형태의 list가 돌아오면 자동으로 변환함"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": [
    "def make_graph_dot_product_as_vector_projection(plt):\n",
    "    v = [2, 1]\n",
    "    w = [math.sqrt(.25), math.sqrt(.75)]\n",
    "    c = dot(v, w)\n",
    "    vonw = scalar_multiply(c, w)\n",
    "    o = [0,0]\n",
    "\n",
    "    plt.arrow(0, 0, v[0], v[1], \n",
    "              width=0.002, head_width=.1, length_includes_head=True)\n",
    "    plt.annotate(\"v\", v, xytext=[v[0] + 0.1, v[1]])\n",
    "    plt.arrow(0 ,0, w[0], w[1], \n",
    "              width=0.002, head_width=.1, length_includes_head=True)\n",
    "    plt.annotate(\"w\", w, xytext=[w[0] - 0.1, w[1]])\n",
    "    plt.arrow(0, 0, vonw[0], vonw[1], length_includes_head=True)\n",
    "    plt.annotate(u\"(v•w)w\", vonw, xytext=[vonw[0] - 0.1, vonw[1] + 0.1])\n",
    "    plt.arrow(v[0], v[1], vonw[0] - v[0], vonw[1] - v[1], \n",
    "              linestyle='dotted', length_includes_head=True)\n",
    "    plt.scatter(*zip(v,w,o),marker='.')\n",
    "    plt.axis([0,2,0,2]) # 짤리는 부분이 있어서 변경\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "collapsed": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Populating the interactive namespace from numpy and matplotlib\n"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "WARNING: pylab import has clobbered these variables: ['random', 'shape', 'dot']\n",
      "`%matplotlib` prevents importing * from pylab and numpy\n"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYcAAAEACAYAAABYq7oeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nAAAASUVORK5CYII=\n",
      "text/plain": [
       "<matplotlib.figure.Figure at 0x10c774250>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "%pylab inline\n",
    "make_graph_dot_product_as_vector_projection(plt)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "collapsed": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 2",
   "language": "python",
   "name": "python2"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 2
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython2",
   "version": "2.7.12"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 0
}