7장_행렬(데이터를 편리하게 다룰 도구).ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "f8642bc7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import matplotlib as mpl\n",
    "import matplotlib.font_manager as mfm\n",
    "from matplotlib.patches import Rectangle, Circle, PathPatch, Arc\n",
    "from mpl_toolkits.mplot3d import Axes3D \n",
    "import mpl_toolkits.mplot3d.art3d as art3d\n",
    "\n",
    "np.set_printoptions(precision=4, linewidth=150)\n",
    "\n",
    "mpl.style.use('bmh')\n",
    "mpl.style.use('seaborn-whitegrid')\n",
    "style = plt.style.library['bmh']\n",
    "\n",
    "style_colors = [ c['color'] for c in style['axes.prop_cycle'] ]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "69cccb91",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.text import Text, TextPath\n",
    "from matplotlib.transforms import Affine2D\n",
    "\n",
    "# https://matplotlib.org/3.1.1/gallery/mplot3d/pathpatch3d.html\n",
    "def text3d(ax, xyz, s, zdir=\"z\", size=None, angle=0, usetex=False, **kwargs):\n",
    "    '''\n",
    "    Plots the string 's' on the axes 'ax', with position 'xyz', size 'size',\n",
    "    and rotation angle 'angle'.  'zdir' gives the axis which is to be treated\n",
    "    as the third dimension.  usetex is a boolean indicating whether the string\n",
    "    should be interpreted as latex or not.  Any additional keyword arguments\n",
    "    are passed on to transform_path.\n",
    "\n",
    "    Note: zdir affects the interpretation of xyz.\n",
    "    '''\n",
    "    x, y, z = xyz\n",
    "    if zdir == \"y\":\n",
    "        xy1, z1 = (x, z), y\n",
    "    elif zdir == \"x\":\n",
    "        xy1, z1 = (y, z), x\n",
    "    else:\n",
    "        xy1, z1 = (x, y), z\n",
    "\n",
    "    text_path = TextPath((0, 0), s, size=size)\n",
    "    trans = Affine2D().rotate(angle).translate(xy1[0], xy1[1])\n",
    "\n",
    "    p1 = PathPatch(trans.transform_path(text_path), **kwargs)\n",
    "    ax.add_patch(p1)\n",
    "    art3d.pathpatch_2d_to_3d(p1, z=z1, zdir=zdir)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "00ef5327",
   "metadata": {},
   "outputs": [],
   "source": [
    "from matplotlib.patches import FancyArrowPatch\n",
    "from mpl_toolkits.mplot3d import proj3d\n",
    "\n",
    "class Arrow3D(FancyArrowPatch):\n",
    "    \"\"\"\n",
    "    https://stackoverflow.com/questions/22867620/putting-arrowheads-on-vectors-in-matplotlibs-3d-plot\n",
    "    \"\"\"\n",
    "    def __init__(self, xs, ys, zs, *args, **kwargs):\n",
    "        FancyArrowPatch.__init__(self, (0,0), (0,0), *args, **kwargs)\n",
    "        self._verts3d = xs, ys, zs\n",
    "\n",
    "    def draw(self, renderer):\n",
    "        xs3d, ys3d, zs3d = self._verts3d\n",
    "        xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)\n",
    "        self.set_positions((xs[0],ys[0]),(xs[1],ys[1]))\n",
    "        FancyArrowPatch.draw(self, renderer)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "9c5534b0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[11, 22],\n",
       "        [33, 44]])"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.matrix([[1,2],[3,4]])\n",
    "B = np.matrix([[10,20],[30,40]])\n",
    "\n",
    "A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "ca59c143",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 30,  60],\n",
       "        [ 90, 120]])"
      ]
     },
     "execution_count": 5,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "3*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "63c1d124",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 7,  8],\n",
       "       [19, 20]])"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([[1,2,3], [4,5,6]]) #-----[1]\n",
    "B = np.array([[2,1], [1,2], [1,1]])\n",
    "\n",
    "np.dot(A,B) #-----[2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c5db87a6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 70, 100],\n",
       "        [150, 220]])"
      ]
     },
     "execution_count": 7,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.matrix([[1,2],[3,4]])\n",
    "B = np.matrix([[10,20],[30,40]])\n",
    "\n",
    "A*B\n",
    "A.T * B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "28e430af",
   "metadata": {},
   "outputs": [],
   "source": [
    "A = np.arange(1, 7).reshape(2, 3)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "ce6c76c3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "771b2d02",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.transpose(1, 0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "id": "d37f3951",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[2. 4.]\n",
      " [4. 2.]]\n",
      "[[2. 4.]\n",
      " [4. 2.]]\n"
     ]
    }
   ],
   "source": [
    "A = np.matrix([[2, 4], [4, 2]])\n",
    "I = np.matrix(np.eye(2))\n",
    "\n",
    "print(A*I)\n",
    "print(I*A)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "id": "6fade8af",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[0.5 , 0.  , 0.  ],\n",
       "        [0.  , 1.  , 0.  ],\n",
       "        [0.  , 0.  , 0.25]])"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = np.matrix(np.eye(3)*np.array([2,1,4]))\n",
    "D.I"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "id": "fbdd4212",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[1., 0., 0.],\n",
       "        [0., 1., 0.],\n",
       "        [0., 0., 1.]])"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D.I*D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "id": "1805d148",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "matrix([[ 6.,  0.],\n",
       "        [ 0., -2.]])"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.matrix([[2, 4], [4, 2]])\n",
    "X = np.matrix([[ 0.7071, -0.7071], [ 0.7071,  0.7071]])\n",
    "D = X.I*A*X\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "id": "7e54208b",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\user\\AppData\\Local\\Temp/ipykernel_8348/518509758.py:14: MatplotlibDeprecationWarning: \n",
      "The M attribute was deprecated in Matplotlib 3.4 and will be removed two minor releases later. Use self.axes.M instead.\n",
      "  xs, ys, zs = proj3d.proj_transform(xs3d, ys3d, zs3d, renderer.M)\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x360 with 3 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "from matplotlib import cm\n",
    "\n",
    "fig = plt.figure()\n",
    "fig.set_size_inches((15,5))\n",
    "\n",
    "ax1 = fig.add_subplot(1, 3, 1, projection='3d')\n",
    "ax2 = fig.add_subplot(1, 3, 2, projection='3d')\n",
    "ax3 = fig.add_subplot(1, 3, 3, projection='3d')\n",
    "\n",
    "ax1.xaxis.set_tick_params(labelsize=15)\n",
    "ax1.yaxis.set_tick_params(labelsize=15)\n",
    "ax1.zaxis.set_tick_params(labelsize=15)\n",
    "\n",
    "ax2.xaxis.set_tick_params(labelsize=15)\n",
    "ax2.yaxis.set_tick_params(labelsize=15)\n",
    "ax2.zaxis.set_tick_params(labelsize=15)\n",
    "\n",
    "ax3.xaxis.set_tick_params(labelsize=15)\n",
    "ax3.yaxis.set_tick_params(labelsize=15)\n",
    "ax3.zaxis.set_tick_params(labelsize=15)\n",
    "\n",
    "x, y, z = 0, 1, 2\n",
    "P = np.array([1.5, 1.8, 1])\n",
    "\n",
    "Q = np.array([2.1, 3.2, 3])\n",
    "O = (0, 0, 0)\n",
    "\n",
    "axis_length = Q + 0.5\n",
    "\n",
    "def draw_vector(ax, P, Q, elev, azim, title=''):\n",
    "    \n",
    "    arrow = Arrow3D([P[x], Q[x]], [P[y], Q[y]], [P[z], Q[z]], lw=2, color='k',\n",
    "                   mutation_scale=20, arrowstyle=\"-|>\" )\n",
    "    ax.add_artist(arrow)\n",
    "    ax.axis('off')\n",
    "    \n",
    "    ax.plot3D([Q[x], Q[x]], [0, Q[y]], [0,0], '--', color=\"gray\")\n",
    "    ax.plot3D([P[x], P[x]], [0, P[y]], [0,0], '--', color=\"gray\")\n",
    "\n",
    "    ax.plot3D([0, Q[x]], [Q[y], Q[y]], [0,0], '--', color=\"gray\")\n",
    "    ax.plot3D([0, P[x]], [P[y], P[y]], [0,0], '--', color=\"gray\")\n",
    "\n",
    "    ax.plot3D([P[x], P[x]], [P[y], P[y]], [0, P[z]], '--', color=\"gray\") #p로의 세로선\n",
    "    ax.plot3D([Q[x], Q[x]], [Q[y], Q[y]], [0, Q[z]], '--', color=\"gray\") #p로의 세로선\n",
    "\n",
    "    ax.plot3D([0, P[x]], [0, P[y]], [0,0], '--', color=\"gray\")\n",
    "    ax.plot3D([0, Q[x]], [0, Q[y]], [0,0], '--', color=\"gray\")\n",
    "\n",
    "    ax.plot3D([0, P[x]], [0, P[y]], [P[z], P[z]], '--', color=\"gray\")\n",
    "    ax.plot3D([0, Q[x]], [0, Q[y]], [Q[z], Q[z]], '--', color=\"gray\")\n",
    "\n",
    "    ax.plot3D([P[x], Q[x]], [0, 0], [0,0], lw=2, color='k')\n",
    "    ax.plot3D([0,0], [P[y], Q[y]], [0,0],  lw=2, color='k')\n",
    "    ax.plot3D([0,0], [0, 0], [P[z], Q[z]], lw=2, color='k')\n",
    "\n",
    "    # 축 그리기 \n",
    "    ax.plot3D([O[x], axis_length[0]], [0, 0], [0, 0], color='k', alpha=0.2)\n",
    "    ax.text(axis_length[0]+0.5, 0, 0, '$x$', fontsize=18)\n",
    "    \n",
    "    ax.plot3D([0,0], [O[y], axis_length[1]], [0, 0], color='k', alpha=0.2)\n",
    "    ax.text(0, axis_length[1]+0.2, 0, '$y$', fontsize=18)\n",
    "    \n",
    "    ax.plot3D([O[x], 0], [O[y], 0], [O[z], axis_length[2]], color='k', alpha=0.2)\n",
    "    ax.text(0, 0, axis_length[2]+0.1, '$z$', fontsize=18)\n",
    "    \n",
    "    ax.plot([O[x]], [O[y]], [O[z]], 'o', color='k')\n",
    "\n",
    "    # 콤포넌트 그리기\n",
    "    ax.text(P[x]+(Q[x]-P[x])-0.3, -0.4, 0, '$v_1$', fontsize=18)\n",
    "    ax.text(-0.4, P[y]+(Q[y]-P[y])-0.8, 0, '$v_2$', fontsize=18)\n",
    "    ax.text(0, 0.1,  P[z]+(Q[y]-P[z])/2,   '$v_3$', fontsize=18)\n",
    "\n",
    "    #ax.set_title(title, fontproperties=fontprop)\n",
    "    ax.set_xlabel('$x$', fontsize=20)\n",
    "    ax.set_ylabel('$y$', fontsize=20)\n",
    "    ax.set_zlabel('$z$', fontsize=20)\n",
    "    \n",
    "    ax.set_xlim((0, 2.5))\n",
    "    ax.set_ylim((0, 3.5))\n",
    "    ax.set_zlim((0, 3.5))\n",
    "    \n",
    "    ax.view_init(elev, azim)\n",
    "    \n",
    "draw_vector(ax1, P, Q, 20, 30, '벡터와 벡터의 요소')  \n",
    "draw_vector(ax2, P-0.5, Q-0.5, 20, 30, '이동된 벡터와 벡터의 요소') \n",
    "draw_vector(ax3, O, Q, 20, 30, '위치 벡터') \n",
    "\n",
    "plt.subplots_adjust(hspace=0.05, wspace=0.0)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "id": "8d5648d3",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 벡터 덧셈\n",
    "\n",
    "fig = plt.figure(figsize=(7,7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.xaxis.set_tick_params(labelsize=18)\n",
    "ax.yaxis.set_tick_params(labelsize=18)\n",
    "ax.set_xlabel(r'$x$', fontsize=25)\n",
    "ax.set_ylabel(r'$y$', fontsize=25)\n",
    "ax.grid(False)\n",
    "\n",
    "a = np.array( [[1, 1],[2, 3]] )\n",
    "da = a[1]-a[0]\n",
    "\n",
    "b = np.array( [[1, 1],[3, 2]] )\n",
    "db = b[1]-b[0]\n",
    "\n",
    "\n",
    "vec_a = FancyArrowPatch(a[0], a[1], lw=2, color='k', mutation_scale=20, arrowstyle=\"-|>\")\n",
    "ax.add_patch(vec_a)\n",
    "\n",
    "vec_b = FancyArrowPatch(b[0], b[1], lw=2, color='k', mutation_scale=20, arrowstyle=\"-|>\")\n",
    "ax.add_patch(vec_b)\n",
    "\n",
    "a_ = a + db # + db[1]\n",
    "vec_a_ = FancyArrowPatch(a_[0], a_[1], lw=1, color='k', mutation_scale=20, arrowstyle=\"-|>\", ls='--')\n",
    "ax.add_patch(vec_a_)\n",
    "\n",
    "b_ = b + da\n",
    "vec_b_ = FancyArrowPatch(b_[0], b_[1], lw=1, color='k', mutation_scale=20, arrowstyle=\"-|>\", ls='--')\n",
    "ax.add_patch(vec_b_)\n",
    "\n",
    "dc = da+db\n",
    "c = a.copy()\n",
    "c[1,:] = c[0,:]+dc\n",
    "vec_c = FancyArrowPatch(c[0], c[1], lw=2, color='white', mutation_scale=30, arrowstyle=\"-|>\", ec='gray')\n",
    "ax.add_patch(vec_c)\n",
    "\n",
    "# 가로 선\n",
    "ax.plot( (0, a[0,0]),(a[0,1], a[0,1]), lw=1, color='k' )\n",
    "ax.plot( (0, a[1,0]),(a[1,1], a[1,1]), lw=1, color='k' )\n",
    "ax.plot( (0, a_[1,0]),(a_[1,1], a_[1,1]), lw=1, color='k' )\n",
    "\n",
    "# 세로 선\n",
    "ax.plot( (a[0,0], a[0,0]), (0, a[0,1]), lw=1, color='k' )\n",
    "ax.plot( (b[1,0], b[1,0]), (0, b[1,1]), lw=1, color='k' )\n",
    "ax.plot( (b_[1,0], b_[1,0]), (0, b_[1,1]), lw=1, color='k' )\n",
    "\n",
    "vec_ay = FancyArrowPatch((0.0, a[0,1]), (0.0, a[1,1]), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_ay)\n",
    "\n",
    "vec_by = FancyArrowPatch((0.0, a[1,1]), (0.0, a[1,1]+db[1]), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_by)\n",
    "\n",
    "vec_cy = FancyArrowPatch((0.5,c[0,1]), (0.5,c[1,1]), lw=1, color='white', mutation_scale=20, arrowstyle=\"<|-|>\", ec='gray')\n",
    "ax.add_patch(vec_cy)\n",
    "\n",
    "vec_ax = FancyArrowPatch((a[0,0], 0.0), (b[1,0], 0.0), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_ax)\n",
    "\n",
    "vec_bx = FancyArrowPatch((b[1,0], 0.0), (a[1,1]+da[0], 0.0), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_bx)\n",
    "\n",
    "vec_cx = FancyArrowPatch((c[0,0],0.5), (c[1,0],0.5), lw=1, color='white', mutation_scale=20, arrowstyle=\"<|-|>\", ec='gray')\n",
    "ax.add_patch(vec_cx)\n",
    "\n",
    "ax.text(1.2, 2, r\"$\\mathbf{a}$\", fontsize=25)\n",
    "ax.text(3.5, 2.9, r\"$\\mathbf{a}'$\", fontsize=25)\n",
    "ax.text(2, 1.2, r\"$\\mathbf{b}$\", fontsize=25)\n",
    "ax.text(2.8, 3.5, r\"$\\mathbf{b}'$\", fontsize=25)\n",
    "ax.text(2.5, 2.3, r\"$\\mathbf{c}$\", fontsize=25)\n",
    "\n",
    "ax.text(0.5, 2.5, r\"$c_2$\", fontsize=20)\n",
    "ax.text(0.0, 2.0, r\"$a_2$\", fontsize=20)\n",
    "ax.text(0.0, 3.5, r\"$b_2$\", fontsize=20)\n",
    "\n",
    "ax.text(2.5, 0.5, r\"$c_1$\", fontsize=20)\n",
    "ax.text(2.0, 0.0, r\"$b_1$\", fontsize=20)\n",
    "ax.text(3.5, 0.0, r\"$a_1$\", fontsize=20)\n",
    "\n",
    "plt.axis('equal')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "id": "d854e260",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 벡터 뺄셈\n",
    "\n",
    "fig = plt.figure(figsize=(7,7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.xaxis.set_tick_params(labelsize=18)\n",
    "ax.yaxis.set_tick_params(labelsize=18)\n",
    "ax.set_xlabel(r'$x$', fontsize=25)\n",
    "ax.set_ylabel(r'$y$', fontsize=25)\n",
    "ax.grid(False)\n",
    "\n",
    "a = np.array( [[1, 1],[2, 3]] )\n",
    "da = a[1]-a[0]\n",
    "\n",
    "b = np.array( [[1, 1],[3, 2]] )\n",
    "db = b[1]-b[0]\n",
    "\n",
    "vec_a = FancyArrowPatch(a[0], a[1], lw=2, color='k', mutation_scale=20, arrowstyle=\"-|>\")\n",
    "ax.add_patch(vec_a)\n",
    "\n",
    "vec_b = FancyArrowPatch(b[0], b[1], lw=2, color='k', mutation_scale=20, arrowstyle=\"-|>\")\n",
    "ax.add_patch(vec_b)\n",
    "\n",
    "minus_b = b.copy()\n",
    "minus_b[1,:] = minus_b[0,:]-db\n",
    "vec_minus_b = FancyArrowPatch(minus_b[0], minus_b[1], ls='--', lw=1, color='k', mutation_scale=20, arrowstyle=\"-|>\")\n",
    "ax.add_patch(vec_minus_b)\n",
    "\n",
    "a_ = a - db # + db[1]\n",
    "vec_a_ = FancyArrowPatch(a_[0], a_[1], lw=1, color='k', mutation_scale=20, arrowstyle=\"-|>\", ls='--')\n",
    "ax.add_patch(vec_a_)\n",
    "\n",
    "b_ = minus_b + da\n",
    "vec_b_ = FancyArrowPatch(b_[0], b_[1], lw=1, color='k', mutation_scale=20, arrowstyle=\"-|>\", ls='--')\n",
    "ax.add_patch(vec_b_)\n",
    "\n",
    "db_ = minus_b[1]-minus_b[0]\n",
    "dc_ = da+db_\n",
    "c_ = a.copy()\n",
    "c_[1,:] = c_[0,:]+dc_\n",
    "vec_c_ = FancyArrowPatch(c_[0], c_[1], lw=2, color='white', mutation_scale=30, arrowstyle=\"-|>\", ec='gray', ls='--')\n",
    "ax.add_patch(vec_c_)\n",
    "\n",
    "dc = da-db\n",
    "c = b.copy()\n",
    "c[0,:] = c[1,:]\n",
    "c[1,:] = c[0,:]+dc\n",
    "\n",
    "vec_c = FancyArrowPatch(c[0], c[1], lw=2, color='white', mutation_scale=30, arrowstyle=\"-|>\", ec='gray')\n",
    "ax.add_patch(vec_c)\n",
    "\n",
    "# 세로 선\n",
    "ax.plot( (a[0,0], a[0,0]), (-0.5, a[0,1]), lw=1, color='k' )\n",
    "ax.plot( (a[1,0], a[1,0]), (-0.5, a[1,1]), lw=1, color='k' )\n",
    "ax.plot( (b[1,0], b[1,0]), (-0.5, b[1,1]), lw=1, color='k' )\n",
    "\n",
    "# 가로 선\n",
    "ax.plot( (a[0,0], 4), (a[0,1], a[0,1]), lw=1, color='k' )\n",
    "ax.plot( (b[1,0], 4), (b[1,1], b[1,1]), lw=1, color='k' )\n",
    "ax.plot( (a[1,0], 4), (a[1,1], a[1,1]), lw=1, color='k' )\n",
    "\n",
    "vec_ay = FancyArrowPatch((4.0, a[0,1]), (4.0, a[1,1]), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_ay)\n",
    "\n",
    "vec_by = FancyArrowPatch((3.5, b[0,1]), (3.5, b[1,1]), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_by)\n",
    "\n",
    "vec_cy = FancyArrowPatch((3.5, c[0,1]), (3.5,c[1,1]), lw=1, color='white', mutation_scale=20, arrowstyle=\"<|-|>\", ec='gray')\n",
    "ax.add_patch(vec_cy)\n",
    "\n",
    "vec_bx = FancyArrowPatch((a[0,0], -0.5), (b[1,0], -0.5), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_bx)\n",
    "\n",
    "vec_ax = FancyArrowPatch((a[0,0], 0.0), (a[1,0], 0.0), lw=1, mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(vec_ax)\n",
    "\n",
    "vec_cx = FancyArrowPatch((c[0,0],0.0), (c[1,0],0.0), lw=1, color='white', mutation_scale=20, arrowstyle=\"<|-|>\", ec='gray')\n",
    "ax.add_patch(vec_cx)\n",
    "\n",
    "ax.text(1.2, 2, r\"$\\mathbf{a}$\", fontsize=25)\n",
    "ax.text(-0.7, 1.0, r\"$\\mathbf{a}'$\", fontsize=25)\n",
    "ax.text(2, 1.2, r\"$\\mathbf{b}$\", fontsize=25)\n",
    "ax.text(0, 0.3, r\"$-\\mathbf{b}$\", fontsize=25)\n",
    "ax.text(0.5, 2.5, r\"$-\\mathbf{b}'$\", fontsize=25)\n",
    "\n",
    "ax.text(2.4, 0.1, r\"$c_1$\", fontsize=20)\n",
    "ax.text(1.4, 0.1, r\"$a_1$\", fontsize=20)\n",
    "ax.text(1.9, -0.8, r\"$b_1$\", fontsize=20)\n",
    "\n",
    "ax.text(3.2, 2.5, r\"$c_2$\", fontsize=20)\n",
    "ax.text(4.0, 2.0, r\"$a_2$\", fontsize=20)\n",
    "ax.text(3.2, 1.5, r\"$b_2$\", fontsize=20)\n",
    "\n",
    "ax.text(0, 1.5, r\"$\\mathbf{a}+(-\\mathbf{b})$\", fontsize=20)\n",
    "ax.text(2.5, 2.5, r\"$\\mathbf{c}$\", fontsize=25)\n",
    "\n",
    "plt.axis('equal')\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "id": "267a49d7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# norm ㅣ2, ㅣ1\n",
    "\n",
    "fig = plt.figure(figsize=(15,7))\n",
    "ax1 = fig.add_subplot(1, 2, 1)\n",
    "ax2 = fig.add_subplot(1, 2, 2)\n",
    "\n",
    "ax1.xaxis.set_tick_params(labelsize=18)\n",
    "ax1.yaxis.set_tick_params(labelsize=18)\n",
    "ax1.set_xlabel(r'$x$', fontsize=25)\n",
    "ax1.set_ylabel(r'$y$', fontsize=25)\n",
    "\n",
    "ax2.xaxis.set_tick_params(labelsize=18)\n",
    "ax2.yaxis.set_tick_params(labelsize=18)\n",
    "ax2.set_xlabel(r'$x$', fontsize=25)\n",
    "ax2.set_ylabel(r'$y$', fontsize=25)\n",
    "\n",
    "a = np.array([0, 0])\n",
    "b = np.array([3, 3])\n",
    "vec_a = FancyArrowPatch((0, 0), (3, 0) , lw=1, mutation_scale=20, arrowstyle=\"-\", color='k', ls='--')\n",
    "ax1.add_patch(vec_a)\n",
    "\n",
    "vec_b = FancyArrowPatch((3, 0), (3, 3) , lw=1, mutation_scale=20, arrowstyle=\"-\", color='k', ls='--')\n",
    "ax1.add_patch(vec_b)\n",
    "\n",
    "c = np.array( [a, b] )\n",
    "dc = c[1]-c[0]\n",
    "vec_c = FancyArrowPatch(c[0], c[1], lw=2, mutation_scale=20, arrowstyle=\"-|>\", color='gray')\n",
    "ax1.add_patch(vec_c)\n",
    "\n",
    "ax1.plot(*a, 'o', color='k')\n",
    "ax1.plot(*b, 'o', color='k')\n",
    "\n",
    "ax1.text(-0.2,-0.2, r\"$\\mathbf{a}$\", fontsize=20)\n",
    "ax1.text(3.1, 3.1, r\"$\\mathbf{b}$\", fontsize=20)\n",
    "ax1.text(1.5, 1.7, r\"$\\mathbf{c}$\", fontsize=20)\n",
    "#ax1.set_title(\"L2 거리\", fontsize=20, fontproperties=fontprop)\n",
    "ax1.set_xlim(-1, 4)\n",
    "ax1.set_ylim(-1, 4)\n",
    "\n",
    "ax2.plot((0, 0), (0, 1), lw=2, color='gray')\n",
    "ax2.plot((0, 1), (1, 1), lw=2, color='gray')\n",
    "ax2.plot((1, 1), (1, 3), lw=2, color='gray')\n",
    "# ax2.plot((1, 3), (3, 3), lw=2, color='gray')\n",
    "vec_a = FancyArrowPatch((1, 3), (3, 3) , lw=2, mutation_scale=20, arrowstyle=\"-|>\", color='gray')\n",
    "ax2.add_patch(vec_a)\n",
    "\n",
    "ax2.plot((0, 2), (0, 0), lw=2, ls='--', color='gray')\n",
    "ax2.plot((2, 2), (0, 1), lw=2, ls='--', color='gray')\n",
    "ax2.plot((2, 3), (1, 1), lw=2, ls='--', color='gray')\n",
    "vec_b = FancyArrowPatch((3, 1), (3, 3) , lw=2, mutation_scale=20, ls='--', arrowstyle=\"-|>\", color='gray')\n",
    "ax2.add_patch(vec_b)\n",
    "\n",
    "ax2.plot(*a, 'o', color='k')\n",
    "ax2.plot(*b, 'o', color='k')\n",
    "ax2.text(-0.2,-0.2, r\"$\\mathbf{a}$\", fontsize=20)\n",
    "ax2.text(3.1, 3.1, r\"$\\mathbf{b}$\", fontsize=20)\n",
    "#ax2.set_title(\"L1 거리\", fontsize=20, fontproperties=fontprop)\n",
    "ax2.set_xlim(-1, 4)\n",
    "ax2.set_ylim(-1, 4)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "9876cc7c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(-1.0, 1.0, -1.0, 1.0)"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1080x504 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "# 거리함수 L1, L2\n",
    "\n",
    "fig, (ax1, ax2) = plt.subplots(1, 2, sharey=True)\n",
    "fig.set_size_inches((15,7))\n",
    "\n",
    "ax1.xaxis.set_tick_params(labelsize=18)\n",
    "ax1.yaxis.set_tick_params(labelsize=18)\n",
    "ax1.set_xlabel(r'$x$', fontsize=25)\n",
    "ax1.set_ylabel(r'$y$', fontsize=25)\n",
    "ax1.grid(False)\n",
    "\n",
    "ax2.xaxis.set_tick_params(labelsize=18)\n",
    "ax2.yaxis.set_tick_params(labelsize=18)\n",
    "ax2.set_xlabel(r'$x$', fontsize=25)\n",
    "ax2.set_ylabel(r'$y$', fontsize=25)\n",
    "ax2.grid(False)\n",
    "\n",
    "l1 = lambda x1, x2 : np.abs(x1) + np.abs(x2)\n",
    "l2 = lambda x1, x2 : np.sqrt(x1**2 + x2**2)\n",
    "\n",
    "x = np.linspace(-1, 1, 100)\n",
    "X1, X2 = np.meshgrid(x, x)\n",
    "\n",
    "L1 = l1(X1,X2)\n",
    "L2 = l2(X1,X2)\n",
    "\n",
    "ax1.contour(X1, X2, L1)\n",
    "#ax1.set_title(\"L1 거리 함수\", fontsize=20, fontproperties=fontprop)\n",
    "ax1.axis('equal')\n",
    "\n",
    "ax2.contour(X1, X2, L2)\n",
    "#ax2.set_title(\"L2 거리 함수\", fontsize=20, fontproperties=fontprop)\n",
    "ax2.axis('equal')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "81c18362",
   "metadata": {},
   "outputs": [],
   "source": [
    "def cube2d(ax, origin, dx=1, dy=1, dc=0.1, axis='off', hidden=False):\n",
    "    x0, y0 = origin\n",
    "    \n",
    "    if hidden==False:\n",
    "        ax.plot((x0, x0+dx), (y0, y0), lw=2, color='k')\n",
    "        ax.plot((x0+dx, x0+dx), (y0, y0+dy), lw=2, color='k')\n",
    "        ax.plot((x0+dx, x0), (y0+dy, y0+dy), lw=2, color='k')\n",
    "        ax.plot((x0, x0), (y0+dy, y0), lw=2, color='k')\n",
    "\n",
    "    ax.plot((x0, x0+dc), (y0+dy, y0+dy+dc), lw=2, color='k')\n",
    "    ax.plot((x0+dx, x0+dx+dc), (y0+dy, y0+dy+dc), lw=2, color='k')\n",
    "    ax.plot((x0+dx, x0+dx+dc), (y0, y0+dc), lw=2, color='k')\n",
    "    \n",
    "    ax.plot((x0+dc, x0+dx+dc), (y0+dy+dc, y0+dy+dc), lw=2, color='k')\n",
    "    ax.plot((x0+dc, x0+dx+dc), (y0+dy+dc, y0+dy+dc), lw=2, color='k')\n",
    "    ax.plot((x0+dx+dc, x0+dx+dc), (y0+dy+dc, y0+dc), lw=2, color='k')\n",
    "    \n",
    "    ax.axis(axis)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "91e09cfb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 504x504 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(7,7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "    \n",
    "cube2d(ax, (0, 0))\n",
    "cube2d(ax, (0.1, 0.1), hidden=True)\n",
    "cube2d(ax, (0.2, 0.2), hidden=True)\n",
    "\n",
    "width = FancyArrowPatch((0, -0.1), (1, -0.1), lw=2,  mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(width)\n",
    "\n",
    "height = FancyArrowPatch((-0.1, 0), (-0.1, 1), lw=2,  mutation_scale=20, arrowstyle=\"<|-|>\", color='k')\n",
    "ax.add_patch(height)\n",
    "\n",
    "ax.text(0.4, -0.2, \"width\", fontsize=25)\n",
    "ax.text(-0.25, 0.4, \"height\", fontsize=25, rotation=90)\n",
    "\n",
    "ax.text(-0.03, 1.05, \"R\", fontsize=25)\n",
    "ax.text(0.07, 1.15, \"G\", fontsize=25)\n",
    "ax.text(0.17, 1.25, \"B\", fontsize=25)\n",
    "\n",
    "ax.set_xlim(-0.3, 1.4)\n",
    "ax.set_ylim(-0.3, 1.4)\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "id": "c08bf4ac",
   "metadata": {},
   "outputs": [
    {
     "ename": "FileNotFoundError",
     "evalue": "[Errno 2] No such file or directory: 'noviceml/img/old_python.png'",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mFileNotFoundError\u001b[0m                         Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_8348/2044899946.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      1\u001b[0m \u001b[1;32mimport\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mpyplot\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      2\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 3\u001b[1;33m \u001b[0mim\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mplt\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"noviceml/img/old_python.png\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      4\u001b[0m \u001b[0mprint\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mim\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mshape\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\matplotlib\\pyplot.py\u001b[0m in \u001b[0;36mimread\u001b[1;34m(fname, format)\u001b[0m\n\u001b[0;32m   2405\u001b[0m \u001b[1;33m@\u001b[0m\u001b[0m_copy_docstring_and_deprecators\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2406\u001b[0m \u001b[1;32mdef\u001b[0m \u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mformat\u001b[0m\u001b[1;33m=\u001b[0m\u001b[1;32mNone\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 2407\u001b[1;33m     \u001b[1;32mreturn\u001b[0m \u001b[0mmatplotlib\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mformat\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   2408\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   2409\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\matplotlib\\image.py\u001b[0m in \u001b[0;36mimread\u001b[1;34m(fname, format)\u001b[0m\n\u001b[0;32m   1499\u001b[0m                     \u001b[0mresponse\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mio\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mBytesIO\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresponse\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m   1500\u001b[0m                 \u001b[1;32mreturn\u001b[0m \u001b[0mimread\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mresponse\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mformat\u001b[0m\u001b[1;33m=\u001b[0m\u001b[0mext\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m-> 1501\u001b[1;33m     \u001b[1;32mwith\u001b[0m \u001b[0mimg_open\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfname\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32mas\u001b[0m \u001b[0mimage\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m   1502\u001b[0m         return (_pil_png_to_float_array(image)\n\u001b[0;32m   1503\u001b[0m                 \u001b[1;32mif\u001b[0m \u001b[0misinstance\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mimage\u001b[0m\u001b[1;33m,\u001b[0m \u001b[0mPIL\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPngImagePlugin\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mPngImageFile\u001b[0m\u001b[1;33m)\u001b[0m \u001b[1;32melse\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;32m~\\anaconda3\\lib\\site-packages\\PIL\\ImageFile.py\u001b[0m in \u001b[0;36m__init__\u001b[1;34m(self, fp, filename)\u001b[0m\n\u001b[0;32m    107\u001b[0m         \u001b[1;32mif\u001b[0m \u001b[0misPath\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfp\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    108\u001b[0m             \u001b[1;31m# filename\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m--> 109\u001b[1;33m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mopen\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mfp\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;34m\"rb\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m    110\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mfilename\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfp\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m    111\u001b[0m             \u001b[0mself\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0m_exclusive_fp\u001b[0m \u001b[1;33m=\u001b[0m \u001b[1;32mTrue\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mFileNotFoundError\u001b[0m: [Errno 2] No such file or directory: 'noviceml/img/old_python.png'"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "im = plt.imread(\"noviceml/img/old_python.png\")\n",
    "print(im.shape)\n",
    "\n",
    "fig = plt.figure(figsize=(7,7))\n",
    "ax = fig.add_subplot(1, 1, 1)\n",
    "\n",
    "ax.xaxis.set_tick_params(labelsize=18)\n",
    "ax.yaxis.set_tick_params(labelsize=18)\n",
    "\n",
    "ax.imshow(im)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "a80a48d2",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'im' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_8348/3808460434.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[1;32m----> 1\u001b[1;33m \u001b[0mR\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m0\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      2\u001b[0m \u001b[0mG\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      3\u001b[0m \u001b[0mB\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m2\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      4\u001b[0m \u001b[0mA\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mim\u001b[0m\u001b[1;33m[\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;33m:\u001b[0m\u001b[1;33m,\u001b[0m\u001b[1;36m3\u001b[0m\u001b[1;33m]\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'im' is not defined"
     ]
    }
   ],
   "source": [
    "R = im[:,:,0]\n",
    "G = im[:,:,1]\n",
    "B = im[:,:,2]\n",
    "A = im[:,:,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "id": "a7e81c4c",
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'R' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[1;31mNameError\u001b[0m                                 Traceback (most recent call last)",
      "\u001b[1;32m~\\AppData\\Local\\Temp/ipykernel_8348/945667686.py\u001b[0m in \u001b[0;36m<module>\u001b[1;34m\u001b[0m\n\u001b[0;32m      5\u001b[0m \u001b[0max4\u001b[0m \u001b[1;33m=\u001b[0m \u001b[0mfig\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0madd_subplot\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;36m1\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m,\u001b[0m \u001b[1;36m4\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      6\u001b[0m \u001b[1;33m\u001b[0m\u001b[0m\n\u001b[1;32m----> 7\u001b[1;33m \u001b[0max1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mR\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0m\u001b[0;32m      8\u001b[0m \u001b[0max1\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mset_title\u001b[0m\u001b[1;33m(\u001b[0m\u001b[1;34m\"Red\"\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n\u001b[0;32m      9\u001b[0m \u001b[0max2\u001b[0m\u001b[1;33m.\u001b[0m\u001b[0mimshow\u001b[0m\u001b[1;33m(\u001b[0m\u001b[0mG\u001b[0m\u001b[1;33m)\u001b[0m\u001b[1;33m\u001b[0m\u001b[1;33m\u001b[0m\u001b[0m\n",
      "\u001b[1;31mNameError\u001b[0m: name 'R' is not defined"
     ]
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAA2sAAAGaCAYAAACR5NsFAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjQuMywgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy/MnkTPAAAACXBIWXMAAAsTAAALEwEAmpwYAAAZlklEQVR4nO3dX2iVh/0G8K9JGmsbq5SWgqwKTU1veuGf3hQJc91C6ewGbViPddNeFKS3w431RhFpbTZ7MdB10MGKE1Yj0otGaAepLYJsF4paZGjBusAWwcKUmmQ1DXl/F8UD/mz7+ud9T76Nn8+V57ynbx54z8Ph8dQ3c4qiKAIAAIBU2mY6AAAAANcy1gAAABIy1gAAABIy1gAAABIy1gAAABIy1gAAABK6rrF24sSJWL9+/TXPHzx4MPr7+6PRaMS+ffsqDwe3G12D+ukZ1E/PoBodZS/405/+FO+++27Mmzfvque//PLLeO2112L//v0xb968eP755+MHP/hB3H///bWFhdlM16B+egb10zOoTuk3a4sXL46dO3de8/yZM2di8eLFsWDBgujs7IyVK1fGkSNHagkJtwNdg/rpGdRPz6A6pd+sPfnkk/Hvf//7mufHxsZi/vz5zcd33313jI2Nfe05jh49egsRIa+VK1dWdq5b7ZqeMVvpGdQvU88idI3Z60a7VjrWvklXV1eMj483H4+Pj19VwFsNVqfR0dFYtGjRTMdoypYnIl+mbHkiWvdBciNd07Nvly1TtjwR+TLpWbls1yxbnoh8mbLlydiziFxdy3bNIvJlkqfczXTtpu8G2d3dHSMjI3Hx4sWYnJyMI0eOxPLly2/2dMA30DWon55B/fQMbtwNf7M2NDQUExMT0Wg04uWXX44XX3wxiqKI/v7+eOCBB+rICLclXYP66RnUT8/g5l3XWPve977XvL3qT37yk+bzTzzxRDzxxBP1JIPbkK5B/fQM6qdnUA2/FBsAACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACAhYw0AACCh0rE2PT0dW7ZsiUajEevXr4+RkZGrjr/77rvxzDPPRH9/f/z1r3+tLSjMZnoG9dMzaA1dg+p0lL1geHg4JicnY3BwMI4fPx4DAwPxxz/+sXn8d7/7XRw4cCDuuuuuWLNmTaxZsyYWLFhQa2iYbfQM6qdn0Bq6BtUpHWtHjx6N3t7eiIhYtmxZnDx58qrjjzzySFy6dCk6OjqiKIqYM2dOPUlhFtMzqJ+eQWvoGlSndKyNjY1FV1dX83F7e3tMTU1FR8dX/+nSpUujv78/5s2bF319fXHPPfd87XlGR0crinzrLl26JE+JbJmy5amanrVGtkzZ8kTkzFSV2diziHzXLFueiHyZsuWp2mzsWsZrli2TPPUoHWtdXV0xPj7efDw9Pd0s26lTp+Kjjz6KDz74IO6666749a9/He+991489dRT15xn0aJFFca+NaOjo/KUyJYpW56IiHPnzlV2Lj1rjWyZsuWJyJdJz8plu2bZ8kTky5QtT5U9i5idXct2zSLyZZKn3M10rfQGIytWrIhDhw5FRMTx48ejp6eneWz+/Plx5513xty5c6O9vT3uvffe+Pzzz284BNzu9Azqp2fQGroG1Sn9Zq2vry8OHz4ca9eujaIoYvv27TE0NBQTExPRaDSi0WjEunXr4o477ojFixfHM88804rcMKvoGdRPz6A1dA2qUzrW2traYtu2bVc9193d3fzz888/H88//3z1yeA2omdQPz2D1tA1qI5fig0AAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJCQsQYAAJBQR9kLpqenY+vWrXH69Ono7OyMV155JZYsWdI8/vHHH8fAwEAURRH3339/7NixI+bOnVtraJht9Azqp2fQGroG1Sn9Zm14eDgmJydjcHAwNm3aFAMDA81jRVHE5s2b47XXXou33347ent74z//+U+tgWE20jOon55Ba+gaVKf0m7WjR49Gb29vREQsW7YsTp482Tx29uzZWLhwYezevTs++eST+P73vx8PPfRQfWlhltIzqJ+eQWvoGlSndKyNjY1FV1dX83F7e3tMTU1FR0dHXLhwIY4dOxabN2+OJUuWxEsvvRSPPvpoPP7449ecZ3R0tNrkt+DSpUvylMiWKVuequlZa2TLlC1PRM5MVZmNPYvId82y5YnIlylbnqrNxq5lvGbZMslTj9Kx1tXVFePj483H09PT0dHx1X+2cOHCWLJkSTz88MMREdHb2xsnT5782sItWrSoqsy3bHR0VJ4S2TJlyxMRce7cucrOpWetkS1TtjwR+TLpWbls1yxbnoh8mbLlqbJnEbOza9muWUS+TPKUu5mulf6btRUrVsShQ4ciIuL48ePR09PTPPbggw/G+Ph4jIyMRETEkSNHYunSpTccAm53egb10zNoDV2D6pR+s9bX1xeHDx+OtWvXRlEUsX379hgaGoqJiYloNBrx6quvxqZNm6Ioili+fHmsXr26BbFhdtEzqJ+eQWvoGlSndKy1tbXFtm3brnquu7u7+efHH3889u/fX30yuI3oGdRPz6A1dA2q45diAwAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJGSsAQAAJFQ61qanp2PLli3RaDRi/fr1MTIy8rWv27x5c7z++uuVB4TbgZ5B/fQMWkPXoDqlY214eDgmJydjcHAwNm3aFAMDA9e8Zu/evfHJJ5/UEhBuB3oG9dMzaA1dg+p0lL3g6NGj0dvbGxERy5Yti5MnT151/NixY3HixIloNBrx6aeffuN5RkdHbzFqdS5duiRPiWyZsuWpmp61RrZM2fJE5MxUldnYs4h81yxbnoh8mbLlqdps7FrGa5Ytkzz1KB1rY2Nj0dXV1Xzc3t4eU1NT0dHREefPn49du3bFrl274r333vvW8yxatOjW01ZkdHRUnhLZMmXLExFx7ty5ys6lZ62RLVO2PBH5MulZuWzXLFueiHyZsuWpsmcRs7Nr2a5ZRL5M8pS7ma6VjrWurq4YHx9vPp6eno6Ojq/+s/fffz8uXLgQGzdujM8++yy++OKLeOihh+LZZ5+94SBwO9MzqJ+eQWvoGlSndKytWLEiPvzww/jxj38cx48fj56enuaxDRs2xIYNGyIi4p133olPP/1U2eAm6BnUT8+gNXQNqlM61vr6+uLw4cOxdu3aKIoitm/fHkNDQzExMRGNRqMVGWHW0zOon55Ba+gaVKd0rLW1tcW2bduueq67u/ua1/lbEbh5egb10zNoDV2D6vil2AAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAkZawAAAAl1lL1geno6tm7dGqdPn47Ozs545ZVXYsmSJc3jBw4ciN27d0d7e3v09PTE1q1bo63NBoQboWdQPz2D1tA1qE5pM4aHh2NycjIGBwdj06ZNMTAw0Dz2xRdfxO9///v4y1/+Env37o2xsbH48MMPaw0Ms5GeQf30DFpD16A6pd+sHT16NHp7eyMiYtmyZXHy5Mnmsc7Ozti7d2/MmzcvIiKmpqZi7ty5X3ue0dHRKvJW4tKlS/KUyJYpW56q6VlrZMuULU9EzkxVmY09i8h3zbLliciXKVueqs3GrmW8ZtkyyVOP0rE2NjYWXV1dzcft7e0xNTUVHR0d0dbWFvfdd19EROzZsycmJiZi1apVX3ueRYsWVRT51o2OjspTIlumbHkiIs6dO1fZufSsNbJlypYnIl8mPSuX7ZplyxORL1O2PFX2LGJ2di3bNYvIl0mecjfTtdKx1tXVFePj483H09PT0dHRcdXjHTt2xNmzZ2Pnzp0xZ86cGw4Btzs9g/rpGbSGrkF1Sv/N2ooVK+LQoUMREXH8+PHo6em56viWLVvi8uXL8cYbbzS/0gZujJ5B/fQMWkPXoDql36z19fXF4cOHY+3atVEURWzfvj2GhoZiYmIiHn300di/f3889thj8cILL0RExIYNG6Kvr6/24DCb6BnUT8+gNXQNqlM61tra2mLbtm1XPdfd3d3886lTp6pPBbcZPYP66Rm0hq5BdfxSCwAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgISMNQAAgIRKx9r09HRs2bIlGo1GrF+/PkZGRq46fvDgwejv749GoxH79u2rLSjMZnoG9dMzaA1dg+qUjrXh4eGYnJyMwcHB2LRpUwwMDDSPffnll/Haa6/Fn//859izZ08MDg7GZ599VmtgmI30DOqnZ9AaugbV6Sh7wdGjR6O3tzciIpYtWxYnT55sHjtz5kwsXrw4FixYEBERK1eujCNHjsRTTz31tefJ5Ny5czMd4SrZ8kTky5QtT5X0rHWyZcqWJyJnpirM1p5F5Ltm2fJE5MuULU+VZmvXMl6zbJnkqV7pWBsbG4uurq7m4/b29piamoqOjo4YGxuL+fPnN4/dfffdMTY2ds05Vq5cWVFcmJ30DOqnZ9AaugbVKf3fILu6umJ8fLz5eHp6Ojo6Or722Pj4+FUFBK6PnkH99AxaQ9egOqVjbcWKFXHo0KGIiDh+/Hj09PQ0j3V3d8fIyEhcvHgxJicn48iRI7F8+fL60sIspWdQPz2D1tA1qM6coiiKb3vB9PR0bN26NT755JMoiiK2b98e//znP2NiYiIajUYcPHgw/vCHP0RRFNHf3x8///nPW5UdZg09g/rpGbSGrkF1Ssfa9bpSzNOnT0dnZ2e88sorsWTJkubxK8Xs6OiI/v7+eO6556r4sTed58CBA7F79+5ob2+Pnp6e2Lp1a7S11ftr58oyXbF58+ZYsGBB/OpXv5rRPB9//HEMDAxEURRx//33x44dO2Lu3Lkzmundd9+Nt956K9ra2qK/vz/WrVtXa54rTpw4Ea+//nrs2bPnquezva9bned6MrW6a9l6dj2ZWt01PSuXrWvZenY9ma64XT/T9Kxctp5dT6bb/TMtW8+uJ9N3vmtFRf72t78Vv/nNb4qiKIpjx44VL730UvPY5ORk8aMf/ai4ePFicfny5eLZZ58tzp8/X9WPvuE8//vf/4of/vCHxcTERFEURfHLX/6yGB4erjVPWaYr3n777eK5554rduzYMaN5pqeni5/+9KfFv/71r6IoimLfvn3FmTNnZjRTURTFqlWrigsXLhSXL19uvqfq9uabbxZPP/108bOf/eyq57O9r2ciT1mmmehatp6VZZqJrulZuWxdy9azskxX3M6faXpWLlvPyjL5TMvXs7JMRfHd71plfxVwvbdp7ezsbN6mtU7flqezszP27t0b8+bNi4iIqamp2ld/WaaIiGPHjsWJEyei0WjUnqUsz9mzZ2PhwoWxe/fu+MUvfhEXL16Mhx56aEYzRUQ88sgjcenSpZicnIyiKGLOnDm1Z1q8eHHs3Lnzmuezva9nIk9ZppnoWraelWWaia7pWblsXcvWs7JMET7T9Kxctp6VZfKZlq9nZZkivvtdq2ysfdNtWq8cu57btFbp2/K0tbXFfffdFxERe/bsiYmJiVi1alWtecoynT9/Pnbt2hVbtmypPcf15Llw4UIcO3Ys1q1bF2+99Vb84x//iL///e8zmikiYunSpdHf3x9r1qyJ1atXxz333FN7pieffLJ5F6v/nzXT+3om8pRlmomuZetZWaaZ6JqelcvWtWw9K8vkM03Prke2npVl8pmWr2dlmSK++12rbKxlu03rt+W58vi3v/1tHD58OHbu3NmSlf1tmd5///24cOFCbNy4Md588804cOBAvPPOOzOWZ+HChbFkyZJ4+OGH44477oje3t5r/qai1ZlOnToVH330UXzwwQdx8ODB+O9//xvvvfde7Zm+Sbb39UzdDjlb17L1rCzTTHRNz278585017L1rCyTzzQ9u5mfO9M9K8t05fHt/JmWrWdlmWZD1yoba9lu0/pteSIitmzZEpcvX4433nij+XV23b4t04YNG+Kdd96JPXv2xMaNG+Ppp5+OZ599dsbyPPjggzE+Ph4jIyMREXHkyJFYunRprXnKMs2fPz/uvPPOmDt3brS3t8e9994bn3/+ee2Zvkm29/VM3Q45W9ey9aws00x0Tc/KZetatp6VZfKZpmfXI1vPyjJF+EzL1rOyTLOha9d+P3eT+vr64vDhw7F27drmbVqHhoaat2l9+eWX48UXX2zepvWBBx6o6kffcJ5HH3009u/fH4899li88MILEfHVG76vr2/GMrXy389cb55XX301Nm3aFEVRxPLly2P16tUznqnRaMS6devijjvuiMWLF8czzzxTe6b/L+v7eibylGWaia5l69n1ZGp11/SsXLauZetZWSafaXp2PbL1rCyTz7R8PbueTN/1rlV2634AAACqU+8vYQEAAOCmGGsAAAAJGWsAAAAJGWsAAAAJGWsAAAAJGWsAAAAJGWsAAAAJ/R+yP6ciG/VbSQAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 1080x504 with 4 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "fig = plt.figure(figsize=(15,7))\n",
    "ax1 = fig.add_subplot(1, 4, 1)\n",
    "ax2 = fig.add_subplot(1, 4, 2)\n",
    "ax3 = fig.add_subplot(1, 4, 3)\n",
    "ax4 = fig.add_subplot(1, 4, 4)\n",
    "\n",
    "ax1.imshow(R)\n",
    "ax1.set_title(\"Red\")\n",
    "ax2.imshow(G)\n",
    "ax2.set_title(\"Green\")\n",
    "ax3.imshow(B)\n",
    "ax3.set_title(\"Blue\")\n",
    "ax4.imshow(A)\n",
    "ax4.set_title(\"Alpha\")\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "id": "88b7c001",
   "metadata": {},
   "outputs": [],
   "source": [
    "docs = [\n",
    "'This is the first document',\n",
    "'This is the second document',\n",
    "'And the third one',\n",
    "'Is this the first document']\n",
    "\n",
    "V = ['<NULL>', 'and', 'document', 'first', 'is', 'one', 'second', 'the', 'third', 'this']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "id": "c8508092",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "['This is the first document',\n",
       " 'This is the second document',\n",
       " 'And the third one',\n",
       " 'Is this the first document']"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "id": "8a4469fd",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[9, 4, 7, 3, 2], [9, 4, 7, 6, 2], [1, 7, 8, 5], [4, 9, 7, 3, 2]]\n"
     ]
    }
   ],
   "source": [
    "pre_docs = list(map(lambda x : x.lower().split(), docs))\n",
    "pre_docs\n",
    "\n",
    "D = [[V.index(w) for w in doc] for doc in pre_docs ]\n",
    "\n",
    "print(D)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "id": "a875532c",
   "metadata": {},
   "outputs": [],
   "source": [
    "N = max([len(doc) for doc in pre_docs])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "id": "3152c91c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "[['this', 'is', 'the', 'first', 'document'],\n",
       " ['this', 'is', 'the', 'second', 'document'],\n",
       " ['and', 'the', 'third', 'one', '<NULL>'],\n",
       " ['is', 'this', 'the', 'first', 'document']]"
      ]
     },
     "execution_count": 43,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "N = max([len(doc) for doc in pre_docs]) #-----[1]\n",
    "pre_docs = [doc + ['<NULL>']*(N-len(doc)) for doc in pre_docs] #-----[2]\n",
    "pre_docs"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "id": "01c1709c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9, 4, 7, 3, 2],\n",
       "       [9, 4, 7, 6, 2],\n",
       "       [1, 7, 8, 5, 0],\n",
       "       [4, 9, 7, 3, 2]])"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "D = [[V.index(w) for w in doc] for doc in pre_docs ]\n",
    "D = np.array(D)\n",
    "D"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "id": "1e418619",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 2, 3, 4])"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3,4])\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "id": "6f91b4f7",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2],\n",
       "       [3, 4]])"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B = np.array([[1,2],[3,4]])\n",
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "id": "7280bd00",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4,)"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "e8d4f3d4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(2, 2)"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "011bc70b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4]])"
      ]
     },
     "execution_count": 49,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.reshape(1,4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "23942798",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1, 4)"
      ]
     },
     "execution_count": 50,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.reshape(1,4).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "0684059e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1],\n",
       "       [2],\n",
       "       [3],\n",
       "       [4]])"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.reshape(4,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "ca031af6",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(4, 1)"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.reshape(4,1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "3be21361",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0.6415, 0.1181],\n",
       "       [0.9453, 0.9015],\n",
       "       [0.4276, 0.0218]])"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.random.rand(3,2) # 0에서 1사이의 무작위 소수로 채워진 3행 2열 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "c44cd09c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1.],\n",
       "       [1., 1.],\n",
       "       [1., 1.]])"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones((3,2)) # 모두 1로 채워진 3행 2열 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "id": "4e7e991d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1, 1, 1, 1])"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.ones_like(A) # A라는 ndarray와 모양은 같고 모두 1로 채워진 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "id": "402be395",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 56,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros((3,2)) # 모두 0으로 채워진 3행 2열 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "id": "7359ef34",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 0, 0, 0])"
      ]
     },
     "execution_count": 57,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.zeros_like(A) # A라는 ndarray와 모양은 같고 모두 0으로 채워진 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "id": "2fb32439",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10, 10],\n",
       "       [10, 10],\n",
       "       [10, 10]])"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.full((3,2), 10) # 모두 10으로 채워진 3행 2열 ndarray 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "id": "1d436192",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([0, 1, 2, 3, 4, 5, 6, 7, 8, 9])"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.arange(10) # 0부터 9까지 순차적인 자연수로 ndarray를 생성"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "id": "fd118379",
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.seed(12)\n",
    "\n",
    "A = np.random.randint(0,9,4).reshape(2,2)\n",
    "B = np.random.randint(0,9,4).reshape(2,2)+1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "id": "435a49a4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[6, 1],\n",
       "       [2, 3]])"
      ]
     },
     "execution_count": 61,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "id": "6c5dcf3a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[4, 1],\n",
       "       [7, 2]])"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "id": "45e1f406",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[10,  2],\n",
       "       [ 9,  5]])"
      ]
     },
     "execution_count": 63,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A+B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "id": "f2705b7b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 2,  0],\n",
       "       [-5,  1]])"
      ]
     },
     "execution_count": 64,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A-B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "id": "e67d079c",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1.5   , 1.    ],\n",
       "       [0.2857, 1.5   ]])"
      ]
     },
     "execution_count": 65,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A/B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "id": "f5c2a884",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[24,  1],\n",
       "       [14,  6]])"
      ]
     },
     "execution_count": 66,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A*B"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "id": "af02760d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[31,  8],\n",
       "       [29,  8]])"
      ]
     },
     "execution_count": 67,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.dot(A,B)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "id": "200d5807",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6]])"
      ]
     },
     "execution_count": 68,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(1, 7).reshape(2, 3) \n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "id": "408078b4",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 4],\n",
       "       [2, 5],\n",
       "       [3, 6]])"
      ]
     },
     "execution_count": 69,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.transpose(1, 0) "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "id": "a8765bd9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3],\n",
       "        [ 4,  5,  6]],\n",
       "\n",
       "       [[ 7,  8,  9],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 70,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(1, 13).reshape(2, 2, -1)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "id": "b00dcd9b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  7],\n",
       "        [ 4, 10]],\n",
       "\n",
       "       [[ 2,  8],\n",
       "        [ 5, 11]],\n",
       "\n",
       "       [[ 3,  9],\n",
       "        [ 6, 12]]])"
      ]
     },
     "execution_count": 71,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A.T"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "id": "49205346",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[[ 1,  2,  3],\n",
       "        [ 7,  8,  9]],\n",
       "\n",
       "       [[ 4,  5,  6],\n",
       "        [10, 11, 12]]])"
      ]
     },
     "execution_count": 72,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(1, 13).reshape(2, 2, -1)\n",
    "A.transpose(1,0,2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "id": "23179624",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  1,  2,  3,  4,  5],\n",
       "       [ 6,  7,  8,  9, 10, 11],\n",
       "       [12, 13, 14, 15, 16, 17],\n",
       "       [18, 19, 20, 21, 22, 23],\n",
       "       [24, 25, 26, 27, 28, 29]])"
      ]
     },
     "execution_count": 73,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.arange(30).reshape(5,6)\n",
    "A"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "id": "d2f92578",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "2"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[0,2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "id": "9b151f4a",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "15"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[2,3]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "id": "8a398aa9",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [ 6,  8, 10],\n",
       "       [12, 14, 16],\n",
       "       [18, 20, 22],\n",
       "       [24, 26, 28]])"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[:, 0::2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "id": "ec67d8fd",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[ 0,  2,  4],\n",
       "       [ 6,  8, 10],\n",
       "       [12, 14, 16]])"
      ]
     },
     "execution_count": 92,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[ :3 , : : 2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "id": "5c2b558b",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  8, 15, 19, 24])"
      ]
     },
     "execution_count": 93,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.array([A[0,1], A[1,2], A[2,3], A[3,1], A[4,0]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "id": "3e85ecdb",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([ 1,  8, 15, 19, 24])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[[0,1,2,3,4], [1,2,3,1,0]] # A[np.arange(4), [1,2,3,1,0]]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 95,
   "id": "881cb8f0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[False, False, False, False, False, False],\n",
       "       [False, False, False, False, False, False],\n",
       "       [False, False, False, False, False, False],\n",
       "       [False, False, False,  True,  True,  True],\n",
       "       [ True,  True,  True,  True,  True,  True]])"
      ]
     },
     "execution_count": 95,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A > 20"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 96,
   "id": "cc19c1a0",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([21, 22, 23, 24, 25, 26, 27, 28, 29])"
      ]
     },
     "execution_count": 96,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A[A > 20]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 97,
   "id": "2892127d",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([2, 4, 6])"
      ]
     },
     "execution_count": 97,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "A = np.array([1,2,3])\n",
    "A * 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "0386a528",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}