L02_Basic_Linear_Algebra.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "toc_visible": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    }
  },
  "cells": [
    {
      "cell_type": "markdown",
      "source": [
        "# numpy "
      ],
      "metadata": {
        "id": "ZWJXSdgU9nOB"
      }
    },
    {
      "cell_type": "code",
      "execution_count": 3,
      "metadata": {
        "id": "o1u_886r0tAq",
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "outputId": "52d0585c-c5d9-42e5-ede3-4f3b439b4167"
      },
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[3 5 7]\n",
            "[-1 -1 -1]\n",
            "[ 4  8 12]\n",
            "[ 2  6 12]\n",
            "20\n",
            "20\n",
            "[[1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]\n",
            " [1. 1. 1. 1.]]\n",
            "[[0. 0. 0. 0. 0.]\n",
            " [0. 0. 0. 0. 0.]]\n"
          ]
        }
      ],
      "source": [
        "import numpy as np\n",
        "\n",
        "a = np.array([1, 2 ,3])\n",
        "b = np.array([2, 3, 4])\n",
        "\n",
        "print(a + b)\n",
        "print(a - b)\n",
        "print(a * 4)\n",
        "print(a * b)\n",
        "print(a.dot(b))\n",
        "print(sum(a*b))  # 내적 (각각의 값을 곱해서 다 더한다)\n",
        "\n",
        "# ones는 1로 채워진 array를 만드는 것\n",
        "c = np.ones([3, 4])\n",
        "print(c)\n",
        "\n",
        "# zeros는 0으로 채워진 array를 만드는 것\n",
        "d = np.zeros([2, 5])\n",
        "print(d)\n",
        "\n"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "A = np.array([[1, 2, 3], [4, 5, 6]])\n",
        "B = np.array([[3, 2, 1], [1, 2, 3]])\n",
        "\n",
        "print(A+B)\n",
        "print(A-B)\n",
        "print(A*B)  #원소곱\n",
        "print(B.T)  # 전치\n",
        "print(A.dot(B.T)) #행렬곱"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "94jx8kIo3XhZ",
        "outputId": "9cfd09ba-388f-4c06-a1b4-ffb3f9ee319c"
      },
      "execution_count": 4,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[4 4 4]\n",
            " [5 7 9]]\n",
            "[[-2  0  2]\n",
            " [ 3  3  3]]\n",
            "[[ 3  4  3]\n",
            " [ 4 10 18]]\n",
            "[[3 1]\n",
            " [2 2]\n",
            " [1 3]]\n",
            "[[10 14]\n",
            " [28 32]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 벡터 (vector)"
      ],
      "metadata": {
        "id": "CEot4GZF83fG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "class Vector :\n",
        "\n",
        "    # *이 있으면 튜플의 형태로 들어간다 -> 리스트는 벡터가 아니기 때문에 사용\n",
        "    def __init__(self, *lst):\n",
        "        self.data = lst\n",
        "\n",
        "\n",
        "    def __str__(self):\n",
        "        return str(self.data)   # f\"Vec{self.data}\"도 가능\n",
        "\n",
        "\n",
        "    # 이렇게 구현을 했지만 __add__를 쓰는게 좋음\n",
        "    def add(self, other):\n",
        "        # 값들을 더해서 새로운 리스트를 만듬\n",
        "        tmp = [a + b for a, b in zip(self.data, other.data)]\n",
        "        # 위에서 만든 리스트를 백터로 리턴\n",
        "        # *을 하지 않으면 Vector([ ,  , ]) 이렇게 들어감. 우리는 그냥 Vector( , , ) 이 필요하므로 * 적용\n",
        "        return Vector(*tmp)\n",
        "\n",
        "        # == return Vector(*[a+b for a, b in zip(self.data, other.data)]) 이렇게 한 번에 써도 됨\n",
        "\n",
        "    def __add__(self, other):\n",
        "        return Vector(*[a+b for a, b in zip(self.data, other.data)])\n",
        "\n",
        "    def __sub__(self, other):\n",
        "        return Vector(*[a-b for a, b in zip(self.data, other.data)])\n",
        "\n",
        "    \n",
        "    def __mul__(self, other):\n",
        "        # 벡터 * 벡터 면 내적한다.\n",
        "        if type(other) == Vector:\n",
        "            return sum(a * b for a, b in zip(self.data, other.data))\n",
        "        # 벡터 * 숫자인 경우 곱한다. \n",
        "        else:\n",
        "            return Vector(*[a * other for a in self.data])\n",
        "\n",
        "\n",
        "    # 숫자 * 벡터의 경우 (순서가 다를경우)\n",
        "    def __rmul__(self, other):\n",
        "        return Vector(*[a * other for a in self.data])\n",
        "\n",
        "\n",
        "\n",
        "a = Vector(1, 2, 3)\n",
        "b = Vector(2, 3, 4)\n",
        "\n",
        "c = a + b\n",
        "d = b - a\n",
        "e = b * 4\n",
        "f = 3 * b\n",
        "g = a * b\n",
        "\n",
        "print(a, b, c, d, e, f, g)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "OT5hO2Ey30N6",
        "outputId": "e1d15cf4-05ab-4463-9837-74e0553fc521"
      },
      "execution_count": 5,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "(1, 2, 3) (2, 3, 4) (3, 5, 7) (1, 1, 1) (8, 12, 16) (6, 9, 12) 20\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "v1 = Vector(1,2,3)\n",
        "v2 = Vector(3,1,5)\n",
        "\n",
        "sum_of_squares = v1 * v1\n",
        "length = (v1 * v1) ** 0.5 # 벡터의 크기 -> 제곱에 루트 씌우기\n",
        "distance = ((v1 - v2) * (v1 - v2)) ** 0.5 # 두 벡터사이의 거리\n",
        "\n",
        "print(sum_of_squares)\n",
        "print(length)\n",
        "print(distance)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "9vRMpxe334n1",
        "outputId": "5ff8414d-d2a3-402f-e042-77501e32c432"
      },
      "execution_count": 7,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "14\n",
            "3.7416573867739413\n",
            "3.0\n"
          ]
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "# 행렬 (matrix)"
      ],
      "metadata": {
        "id": "1xHscAke9KvF"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "import numpy as np\n",
        "\n",
        "A = np.array([[1,2,3], [2,3,4]])\n",
        "B = np.array([[2,3,4], [3,4,5]])\n",
        "\n",
        "print(A)\n",
        "print(B)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "dF6Du5xr8n1d",
        "outputId": "15e8de9c-30a3-488b-d54e-b9148d6e0725"
      },
      "execution_count": 8,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "[[1 2 3]\n",
            " [2 3 4]]\n",
            "[[2 3 4]\n",
            " [3 4 5]]\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [],
      "metadata": {
        "id": "7HofeLb69fDd"
      },
      "execution_count": null,
      "outputs": []
    }
  ]
}  