4 [Modul] Module dalam Python.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: #28a745 !important; color: white; min-height: 50px; padding: 10px; margin: auto;\">\n",
    "    <p style=\"text-align: right; font-style: italic\">Praktikum Metode Komputasi-4</p>\n",
    "    <h1>Modul dalam Python</h1>\n",
    "</div>\n",
    "<div style=\"background-color: whitesmoke; padding: 10px \">\n",
    "    <ul>\n",
    "        <li>Tujuan: Memperkenalkan metode untuk memasukkan dan membaca file di Python</li>\n",
    "        <li>Keluaran: Mahasiswa dapat memahami tentang bagaimana menginput file di dalam Python</li>\n",
    "        <li>Pertemuan: 4</li>\n",
    "        <li>Waktu/Tempat: Jumat, 27 Maret 2020/ Youtube</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Prerequisites:\n",
    "\n",
    "Install dahulu **numpy** dan ***matplotlib*** lewat anaconda prompt atau command prompt.\n",
    "\n",
    "`conda install numpy`\n",
    "\n",
    "kalau sudah\n",
    "\n",
    "`conda install matplotlib`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Mengimpor Module\n",
    "\n",
    "Modul merupakan kumpulan dari fungsi-fungsi yang memiliki perintah yang spesifik, di pertemuan-pertemuan kemarin kita sudah pernah menggunakan beberapa modul yang ada di dalam Python, salah satunya adalah modul `math` yang memiliki kumpulan fungsi yang berhubungan dengan matematika. Jadi secara sederhana dapat kita sebut bahwa modul=kumpulan fungsi-fungsi. Nah jadi nanti teman-teman bisa membuat modul sendiri dan menggunakannya, karena kan kemarin sudah membuat fungsi, tinggal digabung-gabung saja :D.\n",
    "\n",
    "## Modul `math`\n",
    "\n",
    "Contoh cara memanggil modul matematika adalah dengan menggunakan perintah:\n",
    "\n",
    "```python\n",
    "import math\n",
    "```\n",
    "\n",
    "Perintah ini mengimpor module `math` dari Python, contoh penggunaannya adalah sebagai berikut:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "121.0\n"
     ]
    }
   ],
   "source": [
    "import math\n",
    "\n",
    "# memanggil fungsi pow\n",
    "def kuadrat(angka, pangkat):\n",
    "    return math.pow(angka, pangkat)\n",
    "\n",
    "a = kuadrat(11, 2)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Pada contoh di atas digunakan fungsi `pow` dari modul ` math`, dalam hal ini untuk menggunakan fungsi ini kita memanggilnya dengan `math.pow`, yaitu nama modul diikuti nama fungsi. Nah kadang kita tidak tahu bagaimana menggunakan fungsi `pow`, maka kita dapat menggunakan perintah `help(math.pow)` untuk memanggil bantuan atau dokumentais dari fungsi `pow`."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math.pow)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Dari contoh di atas kita mendapatkan informasi bahwa `pow` memiliki 2 argumen yaitu `x` dan `y`, dan mengembalikan `x**y` yang merupakan *x to the power of y*, atau x pangkat y.\n",
    "\n",
    "### Melihat kumpulan fungsi yang ada di dalam sebuah modul\n",
    "\n",
    "Nah kadang kita tidak tau, di dalam modul `math` itu ada fungsi apa saja sih? Kita bisa menggunakan perintah `help(math)` untuk melihat fungsi apa saja yang bisa kita gunakan."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in module math:\n",
      "\n",
      "NAME\n",
      "    math\n",
      "\n",
      "DESCRIPTION\n",
      "    This module provides access to the mathematical functions\n",
      "    defined by the C standard.\n",
      "\n",
      "FUNCTIONS\n",
      "    acos(x, /)\n",
      "        Return the arc cosine (measured in radians) of x.\n",
      "    \n",
      "    acosh(x, /)\n",
      "        Return the inverse hyperbolic cosine of x.\n",
      "    \n",
      "    asin(x, /)\n",
      "        Return the arc sine (measured in radians) of x.\n",
      "    \n",
      "    asinh(x, /)\n",
      "        Return the inverse hyperbolic sine of x.\n",
      "    \n",
      "    atan(x, /)\n",
      "        Return the arc tangent (measured in radians) of x.\n",
      "    \n",
      "    atan2(y, x, /)\n",
      "        Return the arc tangent (measured in radians) of y/x.\n",
      "        \n",
      "        Unlike atan(y/x), the signs of both x and y are considered.\n",
      "    \n",
      "    atanh(x, /)\n",
      "        Return the inverse hyperbolic tangent of x.\n",
      "    \n",
      "    ceil(x, /)\n",
      "        Return the ceiling of x as an Integral.\n",
      "        \n",
      "        This is the smallest integer >= x.\n",
      "    \n",
      "    copysign(x, y, /)\n",
      "        Return a float with the magnitude (absolute value) of x but the sign of y.\n",
      "        \n",
      "        On platforms that support signed zeros, copysign(1.0, -0.0)\n",
      "        returns -1.0.\n",
      "    \n",
      "    cos(x, /)\n",
      "        Return the cosine of x (measured in radians).\n",
      "    \n",
      "    cosh(x, /)\n",
      "        Return the hyperbolic cosine of x.\n",
      "    \n",
      "    degrees(x, /)\n",
      "        Convert angle x from radians to degrees.\n",
      "    \n",
      "    erf(x, /)\n",
      "        Error function at x.\n",
      "    \n",
      "    erfc(x, /)\n",
      "        Complementary error function at x.\n",
      "    \n",
      "    exp(x, /)\n",
      "        Return e raised to the power of x.\n",
      "    \n",
      "    expm1(x, /)\n",
      "        Return exp(x)-1.\n",
      "        \n",
      "        This function avoids the loss of precision involved in the direct evaluation of exp(x)-1 for small x.\n",
      "    \n",
      "    fabs(x, /)\n",
      "        Return the absolute value of the float x.\n",
      "    \n",
      "    factorial(x, /)\n",
      "        Find x!.\n",
      "        \n",
      "        Raise a ValueError if x is negative or non-integral.\n",
      "    \n",
      "    floor(x, /)\n",
      "        Return the floor of x as an Integral.\n",
      "        \n",
      "        This is the largest integer <= x.\n",
      "    \n",
      "    fmod(x, y, /)\n",
      "        Return fmod(x, y), according to platform C.\n",
      "        \n",
      "        x % y may differ.\n",
      "    \n",
      "    frexp(x, /)\n",
      "        Return the mantissa and exponent of x, as pair (m, e).\n",
      "        \n",
      "        m is a float and e is an int, such that x = m * 2.**e.\n",
      "        If x is 0, m and e are both 0.  Else 0.5 <= abs(m) < 1.0.\n",
      "    \n",
      "    fsum(seq, /)\n",
      "        Return an accurate floating point sum of values in the iterable seq.\n",
      "        \n",
      "        Assumes IEEE-754 floating point arithmetic.\n",
      "    \n",
      "    gamma(x, /)\n",
      "        Gamma function at x.\n",
      "    \n",
      "    gcd(x, y, /)\n",
      "        greatest common divisor of x and y\n",
      "    \n",
      "    hypot(x, y, /)\n",
      "        Return the Euclidean distance, sqrt(x*x + y*y).\n",
      "    \n",
      "    isclose(a, b, *, rel_tol=1e-09, abs_tol=0.0)\n",
      "        Determine whether two floating point numbers are close in value.\n",
      "        \n",
      "          rel_tol\n",
      "            maximum difference for being considered \"close\", relative to the\n",
      "            magnitude of the input values\n",
      "          abs_tol\n",
      "            maximum difference for being considered \"close\", regardless of the\n",
      "            magnitude of the input values\n",
      "        \n",
      "        Return True if a is close in value to b, and False otherwise.\n",
      "        \n",
      "        For the values to be considered close, the difference between them\n",
      "        must be smaller than at least one of the tolerances.\n",
      "        \n",
      "        -inf, inf and NaN behave similarly to the IEEE 754 Standard.  That\n",
      "        is, NaN is not close to anything, even itself.  inf and -inf are\n",
      "        only close to themselves.\n",
      "    \n",
      "    isfinite(x, /)\n",
      "        Return True if x is neither an infinity nor a NaN, and False otherwise.\n",
      "    \n",
      "    isinf(x, /)\n",
      "        Return True if x is a positive or negative infinity, and False otherwise.\n",
      "    \n",
      "    isnan(x, /)\n",
      "        Return True if x is a NaN (not a number), and False otherwise.\n",
      "    \n",
      "    ldexp(x, i, /)\n",
      "        Return x * (2**i).\n",
      "        \n",
      "        This is essentially the inverse of frexp().\n",
      "    \n",
      "    lgamma(x, /)\n",
      "        Natural logarithm of absolute value of Gamma function at x.\n",
      "    \n",
      "    log(...)\n",
      "        log(x, [base=math.e])\n",
      "        Return the logarithm of x to the given base.\n",
      "        \n",
      "        If the base not specified, returns the natural logarithm (base e) of x.\n",
      "    \n",
      "    log10(x, /)\n",
      "        Return the base 10 logarithm of x.\n",
      "    \n",
      "    log1p(x, /)\n",
      "        Return the natural logarithm of 1+x (base e).\n",
      "        \n",
      "        The result is computed in a way which is accurate for x near zero.\n",
      "    \n",
      "    log2(x, /)\n",
      "        Return the base 2 logarithm of x.\n",
      "    \n",
      "    modf(x, /)\n",
      "        Return the fractional and integer parts of x.\n",
      "        \n",
      "        Both results carry the sign of x and are floats.\n",
      "    \n",
      "    pow(x, y, /)\n",
      "        Return x**y (x to the power of y).\n",
      "    \n",
      "    radians(x, /)\n",
      "        Convert angle x from degrees to radians.\n",
      "    \n",
      "    remainder(x, y, /)\n",
      "        Difference between x and the closest integer multiple of y.\n",
      "        \n",
      "        Return x - n*y where n*y is the closest integer multiple of y.\n",
      "        In the case where x is exactly halfway between two multiples of\n",
      "        y, the nearest even value of n is used. The result is always exact.\n",
      "    \n",
      "    sin(x, /)\n",
      "        Return the sine of x (measured in radians).\n",
      "    \n",
      "    sinh(x, /)\n",
      "        Return the hyperbolic sine of x.\n",
      "    \n",
      "    sqrt(x, /)\n",
      "        Return the square root of x.\n",
      "    \n",
      "    tan(x, /)\n",
      "        Return the tangent of x (measured in radians).\n",
      "    \n",
      "    tanh(x, /)\n",
      "        Return the hyperbolic tangent of x.\n",
      "    \n",
      "    trunc(x, /)\n",
      "        Truncates the Real x to the nearest Integral toward 0.\n",
      "        \n",
      "        Uses the __trunc__ magic method.\n",
      "\n",
      "DATA\n",
      "    e = 2.718281828459045\n",
      "    inf = inf\n",
      "    nan = nan\n",
      "    pi = 3.141592653589793\n",
      "    tau = 6.283185307179586\n",
      "\n",
      "FILE\n",
      "    (built-in)\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nah di atas kita bisa lihat ada banyak sekali fungsi yang dapat kita panggil dari modul `math`, beserta petunjuk pengunaannya."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Mengimpor modul dengan nama alias\n",
    "\n",
    "Kita dapat menambahkan statmen `as` untuk membuat alias penamaan modul untuk diimpor, pada contoh di atas kita memanggil `math` dan menamainya menjadi `matematika`. Sehingga ketika memanggil fungsi tersebut kita menggunakan `matematika`:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import math as matematika\n",
    "\n",
    "akar = matematika.sqrt(9)\n",
    "print(akar)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kita juga dapat menggunakan `matematika` di dalam sebuah fungsi:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def akar(angka):\n",
    "    return matematika.sqrt(angka)\n",
    "\n",
    "print(akar(100))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Memanggil fungsi tertentu dalam sebuah modul\n",
    "\n",
    "Pada perintah ini kita hanya memanggil fungsi `sqrt` saja dari modul `math`"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from math import sqrt\n",
    "\n",
    "a = sqrt(100)\n",
    "print(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "#### Contoh menggunakan modul `math` yang lain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Di sini kita akan mencari nilai sinus dari sebuah sudut, nah kita bisa menggunakan fungsi `sin()`, namun sebelum itu kita gunakan dulu fungsi `radians` untuk mengubah sudut dari radian ke derajat. Hal ini dilakukan karena sudut dalam Python secara default adalah memiliki format radian. "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function sin in module math:\n",
      "\n",
      "sin(x, /)\n",
      "    Return the sine of x (measured in radians).\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(math.sin)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "1.0\n"
     ]
    }
   ],
   "source": [
    "b = math.sin(math.radians(90))\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.8939966636005579\n"
     ]
    }
   ],
   "source": [
    "b = math.sin(90)\n",
    "print(b)"
   ]
  },
  {
   "attachments": {},
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Modul NumPy¶\n",
    "\n",
    "Nah salah satu modul lain yang sering digunakan alah modul numpy yang memiliki kumpulan fungsi untuk melakukan analisis dengan `array`, mudahnya kalau belum paham: biasanya untuk mengurusi matriks (2D array), list (1D), dan yang lebih kompleks: 3D array, tenang jangan pusing dulu, itu akan kita pelajari nanti-nanti lagi wehehehe.\n",
    "\n",
    "![array](https://www.w3resource.com/w3r_images/numpy-1d2d3d-array.png \"w2resource.com\")\n",
    "\n",
    "![array2](https://image.slidesharecdn.com/2013-11-14-20enterthematrix-131207071455-phpapp02/95/enter-the-matrix-10-638.jpg?cb=1386400624  \"slideshare\")\n",
    "\n",
    "Kalau dari website numpy kegunaan numpy adalah sebagai berikut:\n",
    "\n",
    "NumPy is the fundamental package for scientific computing with Python. It contains among other things:\n",
    "\n",
    "1. a powerful N-dimensional array object\n",
    "2. sophisticated (broadcasting) functions\n",
    "3. tools for integrating C/C++ and Fortran code\n",
    "4. useful linear algebra, Fourier transform, and random number capabilities\n",
    "\n",
    "Besides its obvious scientific uses, NumPy can also be used as an efficient multi-dimensional container of generic data. Arbitrary data-types can be defined. This allows NumPy to seamlessly and speedily integrate with a wide variety of databases."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Contoh penggunaan numpy untuk membuat 1D-array"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Membuat array secara manual:  [1 2 3 4 5 6]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "deret0 = np.array([1,2,3,4,5,6])\n",
    "print('Membuat array secara manual: ', deret0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mencetak deret dari 1 sampai 10 dengan kelipatan 1:  [1 2 3 4 5 6 7 8 9]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "deret1 = np.arange(1,10,1)\n",
    "print('Mencetak deret dari 1 sampai 10 dengan kelipatan 1: ', deret1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on built-in function arange in module numpy:\n",
      "\n",
      "arange(...)\n",
      "    arange([start,] stop[, step,], dtype=None)\n",
      "    \n",
      "    Return evenly spaced values within a given interval.\n",
      "    \n",
      "    Values are generated within the half-open interval ``[start, stop)``\n",
      "    (in other words, the interval including `start` but excluding `stop`).\n",
      "    For integer arguments the function is equivalent to the Python built-in\n",
      "    `range` function, but returns an ndarray rather than a list.\n",
      "    \n",
      "    When using a non-integer step, such as 0.1, the results will often not\n",
      "    be consistent.  It is better to use `numpy.linspace` for these cases.\n",
      "    \n",
      "    Parameters\n",
      "    ----------\n",
      "    start : number, optional\n",
      "        Start of interval.  The interval includes this value.  The default\n",
      "        start value is 0.\n",
      "    stop : number\n",
      "        End of interval.  The interval does not include this value, except\n",
      "        in some cases where `step` is not an integer and floating point\n",
      "        round-off affects the length of `out`.\n",
      "    step : number, optional\n",
      "        Spacing between values.  For any output `out`, this is the distance\n",
      "        between two adjacent values, ``out[i+1] - out[i]``.  The default\n",
      "        step size is 1.  If `step` is specified as a position argument,\n",
      "        `start` must also be given.\n",
      "    dtype : dtype\n",
      "        The type of the output array.  If `dtype` is not given, infer the data\n",
      "        type from the other input arguments.\n",
      "    \n",
      "    Returns\n",
      "    -------\n",
      "    arange : ndarray\n",
      "        Array of evenly spaced values.\n",
      "    \n",
      "        For floating point arguments, the length of the result is\n",
      "        ``ceil((stop - start)/step)``.  Because of floating point overflow,\n",
      "        this rule may result in the last element of `out` being greater\n",
      "        than `stop`.\n",
      "    \n",
      "    See Also\n",
      "    --------\n",
      "    numpy.linspace : Evenly spaced numbers with careful handling of endpoints.\n",
      "    numpy.ogrid: Arrays of evenly spaced numbers in N-dimensions.\n",
      "    numpy.mgrid: Grid-shaped arrays of evenly spaced numbers in N-dimensions.\n",
      "    \n",
      "    Examples\n",
      "    --------\n",
      "    >>> np.arange(3)\n",
      "    array([0, 1, 2])\n",
      "    >>> np.arange(3.0)\n",
      "    array([ 0.,  1.,  2.])\n",
      "    >>> np.arange(3,7)\n",
      "    array([3, 4, 5, 6])\n",
      "    >>> np.arange(3,7,2)\n",
      "    array([3, 5])\n",
      "\n"
     ]
    }
   ],
   "source": [
    "help(np.arange)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Mencetak deret 1 sampai 10 dengna jumlah anggota 10: [ 1.  2.  3.  4.  5.  6.  7.  8.  9. 10.]\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "\n",
    "deret2 = np.linspace(1,10,10)\n",
    "print('Mencetak deret 1 sampai 10 dengna jumlah anggota 10:', deret2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Beberapa fungsi untuk melihat atribut dari array yang telah kita buat:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(10,)"
      ]
     },
     "execution_count": 20,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deret2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deret2.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('float64')"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deret2.dtype"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "dtype('int64')"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "deret1.dtype"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Membuat 2D array\n",
    "\n",
    "Coba perhatikan contoh di bawah ini, untuk membuat 2D array:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[7 1 3]\n",
      " [3 5 7]\n",
      " [1 8 3]]\n"
     ]
    }
   ],
   "source": [
    "matriks2 = np.array([[7,1,3], [3,5,7], [1,8,3]])\n",
    "print(matriks2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Kita juga dapat membuat array dengan `arange` atau `linspace` kemudian mengubah `shape` nya menjadi dalam contoh ini 3 x 3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3],\n",
       "       [4, 5, 6],\n",
       "       [7, 8, 9]])"
      ]
     },
     "execution_count": 25,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks = np.arange(1,10).reshape(3,3)\n",
    "matriks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9"
      ]
     },
     "execution_count": 26,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks.size"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(3, 3)"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks.shape"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Nah untuk memanggil anggota matriks tertentu kita dapat menggunakan indexing, dengan indeks pertama merupakan baris dan indeks kedua merupakan kolom:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![Indexing](http://swcarpentry.github.io/python-novice-inflammation/fig/python-zero-index.png \"swcarpenty\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3]\n",
      "------\n",
      "[3 5 7]\n"
     ]
    }
   ],
   "source": [
    "print(matriks[0])\n",
    "print(\"------\")\n",
    "print(matriks2[1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1"
      ]
     },
     "execution_count": 30,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "5"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks[1][1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Coba pahami beberapa indexing di bawah ini:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([7, 8, 9])"
      ]
     },
     "execution_count": 38,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks[1:][1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3]])"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks[:][:1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Terdapat bebrapa fungsi bawaan untuk membuat array-array tertentu:"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[0., 0.],\n",
       "       [0., 0.]])"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks_zeros = np.zeros((2,2))\n",
    "matriks_zeros"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[1., 1., 1.],\n",
       "       [1., 1., 1.],\n",
       "       [1., 1., 1.]])"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks_one = np.ones((3,3))\n",
    "matriks_one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([[9., 9., 9.],\n",
       "       [9., 9., 9.],\n",
       "       [9., 9., 9.]])"
      ]
     },
     "execution_count": 42,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "matriks_one * 9"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operasi array sederhana"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "matriksA: \n",
      " [[1 2 3]\n",
      " [4 5 6]\n",
      " [7 8 9]]\n",
      "matriksB: \n",
      " [[9. 9. 9.]\n",
      " [9. 9. 9.]\n",
      " [9. 9. 9.]]\n"
     ]
    }
   ],
   "source": [
    "matriksA = np.array([[1,2,3], [4,5,6], [7,8,9]])\n",
    "matriksB = np.ones((3,3)) * 9 # membuat array ones kemudian mengkalikan dengan 9\n",
    "\n",
    "print(\"matriksA: \\n\", matriksA)\n",
    "print(\"matriksB: \\n\", matriksB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Penjumlahan matriks: \n",
      " [[10. 11. 12.]\n",
      " [13. 14. 15.]\n",
      " [16. 17. 18.]]\n"
     ]
    }
   ],
   "source": [
    "penjumlahan_matriks = matriksA + matriksB\n",
    "print(\"Penjumlahan matriks: \\n\", penjumlahan_matriks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pengurangan matriks: \n",
      " [[-8. -7. -6.]\n",
      " [-5. -4. -3.]\n",
      " [-2. -1.  0.]]\n"
     ]
    }
   ],
   "source": [
    "pengurangan_matriks = matriksA - matriksB\n",
    "print(\"Pengurangan matriks: \\n\", pengurangan_matriks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Bagaimana dengan pengkalian dan pembaggian?\n",
    "Apa perbedaan pengkalian dengan operasi dot?"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pengkalian matriks: \n",
      " [[ 9. 18. 27.]\n",
      " [36. 45. 54.]\n",
      " [63. 72. 81.]]\n"
     ]
    }
   ],
   "source": [
    "pengkalian_matriks = matriksA * matriksB\n",
    "print(\"Pengkalian matriks: \\n\", pengkalian_matriks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Pembagian matriks: \n",
      " [[0.11111111 0.22222222 0.33333333]\n",
      " [0.44444444 0.55555556 0.66666667]\n",
      " [0.77777778 0.88888889 1.        ]]\n"
     ]
    }
   ],
   "source": [
    "pembagian_matriks = matriksA / matriksB\n",
    "print(\"Pembagian matriks: \\n\", pembagian_matriks)\n",
    "\n",
    "# matriks tidak dapat dibagi, benar\n",
    "# ini bukan pembagian matriks, tetapi membagi setiap elemen dengan elemen yang lain"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Operasi dot"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[ 54.  54.  54.]\n",
      " [135. 135. 135.]\n",
      " [216. 216. 216.]]\n"
     ]
    }
   ],
   "source": [
    "dot_matriksAB = matriksA.dot(matriksB)\n",
    "print(dot_matriksAB)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[108. 135. 162.]\n",
      " [108. 135. 162.]\n",
      " [108. 135. 162.]]\n"
     ]
    }
   ],
   "source": [
    "dot_matriksBA = matriksB.dot(matriksA)\n",
    "print(dot_matriksBA)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3. 9. 9. 9.]\n",
      " [4. 5. 6. 9. 9. 9.]\n",
      " [7. 8. 9. 9. 9. 9.]]\n"
     ]
    }
   ],
   "source": [
    "append_matriks = np.hstack([matriksA, matriksB])\n",
    "print(append_matriks)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1. 2. 3.]\n",
      " [4. 5. 6.]\n",
      " [7. 8. 9.]\n",
      " [9. 9. 9.]\n",
      " [9. 9. 9.]\n",
      " [9. 9. 9.]]\n"
     ]
    }
   ],
   "source": [
    "append_matriks = np.vstack([matriksA, matriksB])\n",
    "print(append_matriks)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Modul `matplotlib`"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Modul ini biasanya yang paling asik, karena kita akan mengeplot."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Masukkan nilai gradien (m): 2\n",
      "Masukkan nilai intersep (c): 1\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "x = np.array([-1,0,1,2,3,4])\n",
    "\n",
    "m = float(input(\"Masukkan nilai gradien (m): \"))\n",
    "c = float(input(\"Masukkan nilai intersep (c): \"))\n",
    "\n",
    "def persamaan_linear(m,c,x):\n",
    "    return (m * x) + c\n",
    "\n",
    "y = persamaan_linear(m,c,x)\n",
    "\n",
    "plt.plot(x,y)\n",
    "plt.grid(True) # menampilkan kotak-kotak\n",
    "plt.title(\"Fungsi Linear\")\n",
    "plt.xlabel(\"x\")\n",
    "plt.ylabel(\"y\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEWCAYAAABIVsEJAAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADh0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uMy4yLjEsIGh0dHA6Ly9tYXRwbG90bGliLm9yZy+j8jraAAAgAElEQVR4nO3df5wddX3v8debGGDrKgtC17CkEBRp1bSBrKCN1SyCRGoNpVFjKYZeaW6tcNuqXENzq4Aoq/ij9daqFClRrKvlYsw10AgkW69ahMREwg8jEVBZEBSSQGSFJHzuHzMHZnfP2T07e87O+fF+Ph7nsTPf+fU53zPkw8x35vtVRGBmZjZZ+xUdgJmZNScnEDMzy8UJxMzMcnECMTOzXJxAzMwsFycQMzPLxQnErGCS/k7SFTm3vV7SslrHZFYN+T0Qa0eS7gO6gX2Z4pdExAPFRFSZpL8D/gI4DNgJfCci3lpsVGa+ArH29kcR0Zn5NGLyWAacBZwcEZ1AL3BTsVGZJZxAzDIk3Sfp5Mz8hZKuTqePkhSSlkn6qaRfSlqZWbdD0ipJOyTdJel/Sro/s/x9koYkPS5pm6TXjT5GGa8A1kXEjwEi4ucRcXlmn4OSzkmnz5b0bUkfS2O4V9IbqvxuB0q6WtIjknZKulVS99Rq01rdc4oOwKwJvRo4FngJcIukayPiLuADwFHA0cBzgetKG0g6FjgXeEVEPCDpKGBGFce6GfiUpCFgA7A5IvaNs/6JwCrgUGA58HlJPTHxveplwEHAbOBJYB4wXEV81sZ8BWLtbHX6f9s7Ja2exHYXRcRwRPwA+AHwe2n5W4APR8SOiLgf+FRmm33AAcBLJc2MiPtKVxXjiYirgfOAU4H/BB6W9L5xNvlJRPxLmmRWAbNI2nomsgd4AfDiiNgXEZsi4rEqtrM25gRi7ez0iOhKP6dPYrufZ6afADrT6cOBn2WWPTMdEduBvwEuJEkCA5IOr+ZgEfGliDgZ6AL+EvigpFMnii0inkgnOyusm/VFYB0wIOkBSR+VNLOa+Kx9OYGYjfQr4Dcy8y+cxLYPAkdk5mdnF0bEv0XEq4EjgQA+MpnAImJPRPw7cBvw8slsm6r43dJ9XxQRLwV+H3gj8PYcx7A24gRiNtIWYKmkmZJ6gSWT2ParwAWSDpbUQ9LmASRtIJJOknQA8GuS9oWnJ9ph2jD+h5KeJ2m/tFH8ZcD3JvOlUhW/m6Q+SXMlzQAeI7mlNWF81t6cQMxG+nvgRcAO4CLg3yax7cXA/cC9wI3ANSQN0pC0f/QDvyS5zfSbwAVV7PMx4O+An5K8A/JR4J0R8e1JxFUy3nd7YRrvY8BdJO0tX8xxDGsjfpHQrE4kvRNYGhGvLToWs3rwFYhZjUiaJWlBeqvpWOA9wNeKjsusXvweiFnt7A98DphDcrtpAPjnQiMyqyPfwjIzs1x8C8vMzHJpq1tYhx56aBx11FG5tv3Vr37Fc5/73NoGVEfNFK9jrZ9mireZYoXmineqsW7atOmXEXHYmAUR0Taf+fPnR14bNmzIvW0Rmilex1o/zRRvM8Ua0VzxTjVWYGOU+TfVt7DMzCwXJxAzM8vFCcTMzHJxAjEzs1ycQMzMLJdCE4ikKyU9LOn2Cssl6VOStku6TdLxmWXLJN2dfpZNX9RWjdWbh1jQv545K9ayoH89qzcPFR2SmdVY0VcgVwGLxln+BuCY9LMc+AyApENIhg89ETgB+ICkg+saqVVt9eYhLrh2K0M7hwlgaOcwF1y71UnErMUUmkAi4lvAo+Osshj4Qvoo8s1Al6RZJMN73hARj0bEDuAGxk9EVmPjXWFctm4bw3tGDts9vGcfl63bVnYfW4d2+SrFrAkV3heWpKOAb0TEmBHWJH0D6I907ANJNwHvAxYCB0bEJWn53wPDEfGxMvtYTnL1Qnd39/yBgYFcce7evZvOzmpGBm0M9Yx35/AehnYM83Tm3NlPoufgDro6ZrJ1aFfFbef2HDRmH90d8NDwyH00Kp8H9dNMsUJzxTvVWPv6+jZFRO/o8pbvyiQiLgcuB+jt7Y2FCxfm2s/g4CB5ty1CPeNd0L+eoZ0zxpT3dM3gOysWsrJ/PUM7h8ss7+C8MxeO2cd75u7l41ufM2IfjcrnQf00U6zQXPHWK9ai20AmMsTIcaWPSMsqlds0eKBMcsiWn3/qsXTMHJlgOmbO4PxTj616H2bW+Br9CmQNcK6kAZIG810R8aCkdcCHMw3nr6e64UGtCqs3D3HZum08sHOYw7s6OP/UYzn9uJ5nlh/e1VH2CuPwrg6AZ9adyj6qjcXMilNoApH0ZZL2jEMl3U/yZNVMgIj4LHAdcBqwHXgC+PN02aOSPgjcmu7q4ogYrzHeqlR6gqrUCF56ggqeTQznn3rsiHVg7BXG6cf1jPsPfTX7qCYWMytOoQkkIt42wfIA3lVh2ZXAlfWIq52N9wRV6R/taq4wJpLdBzxOT5l9VBOLmRWn0W9h2TSrtm1ioiuMapT2MTg4+Ezjep5YzKwYjd6IbtNsdBvEROX11EixmNlYTiA2QjVPULVjLGY2lm9h2Qi1aN9oxVjMbCwnkDZTzWOxtWjfqJWJYvFjvmbFcQJpI632WGyrfR+zZuM2kDZSbSeHzaLVvo9Zs3ECaSOt9lhsq30fs2bjBNJGWu2x2Fb7PmbNxgmkjbTaY7Gt9n3Mmo0b0dtIqz0W22rfx6zZOIG0mUZ6RLcWWu37mDUT38IyM7NcnEDMzCwXJ5AWs3rzEAv617N1aBcL+tezerMHaizVyZwVa10nZjXkNpAWMuLN7Nl+Mxv8trpZPRV6BSJpkaRtkrZLWlFm+SclbUk/P5K0M7NsX2bZmumNvDH5zeyxXCdm9VPYFYikGcCngVOA+4FbJa2JiDtL60TE32bWPw84LrOL4YiYN13xNgO/mT2W68Ssfoq8AjkB2B4R90TEU8AAsHic9d8GfHlaImtSfjN7LNeJWf0oGXa8gANLS4BFEXFOOn8WcGJEnFtm3SOBm4EjImJfWrYX2ALsBfojYnWF4ywHlgN0d3fPHxgYyBXv7t276ezszLXtdNk5vIehHcM8HUF3Bzw0DPtJ9BzcQVfHzKLDq6iedZutk5Kp1EkznAdZzRRvM8UKzRXvVGPt6+vbFBG9o8ubpRF9KXBNKXmkjoyIIUlHA+slbY2IH4/eMCIuBy4H6O3tjYULF+YKYHBwkLzbTqfS+BhLZz/OwM+e1xRvZte7bms5ZkiznAclzRRvM8UKzRVvvWItMoEMAbMz80ekZeUsBd6VLYiIofTvPZIGSdpHxiSQdlN6M3twcJDzzlxYdDgNwW+rm9VHkW0gtwLHSJojaX+SJDHmaSpJvw0cDPxXpuxgSQek04cCC4A7R29rZmb1U9gVSETslXQusA6YAVwZEXdIuhjYGBGlZLIUGIiRjTW/A3xO0tMkSbA/+/SWmZnVX6FtIBFxHXDdqLL3j5q/sMx23wXm1jU4MzMbl7syMTOzXJxAzMwsl2Z5jNeo7eOoNpLr1mzynECahDsFrB/XrVk+voXVJNwpYP24bs3ycQJpEu4UsH5ct2b5OIE0CXcKWD+uW7N8nECaxPmnHkvHzBkjyjpmzuD8U48tKKLW4bo1y8eN6E2i1JjrJ4Vqz3Vrlo8TSBNxp4D147o1mzzfwjIzs1ycQMzMLBcnEDMzy8UJxMzMcnECMTOzXJxAzMwsl0ITiKRFkrZJ2i5pRZnlZ0v6haQt6eeczLJlku5OP8umN/LaW715iAX965mzYi0L+tezenOl4eGtCKXfZ+vQLv8+ZqnC3gORNAP4NHAKcD9wq6Q1ZYam/UpEnDtq20OADwC9QACb0m13TEPoNefeYBvbiN9ntn8fs5Iir0BOALZHxD0R8RQwACyucttTgRsi4tE0adwALKpTnHXn3mAbm38fs/IUEcUcWFoCLIqIc9L5s4ATs1cbks4GLgV+AfwI+NuI+Jmk9wIHRsQl6Xp/DwxHxMfKHGc5sBygu7t7/sDAQK54d+/eTWdnZ65tJ7J1aFfFZXN7Dsq1z3rGW2uNHmv29+nugIcynfTm/X2mS6PXbVYzxQrNFe9UY+3r69sUEb2jyxu9K5P/C3w5Ip6U9N+BVcBJk9lBRFwOXA7Q29sbCxcuzBXI4OAgebedyMr+9QyV6Tq8p6uD887Md8x6xltrjR5r9vd5z9y9fHxr8p/NVH6f6dLodZvVTLFCc8Vbr1iLvIU1BMzOzB+Rlj0jIh6JiCfT2SuA+dVu20zcG2xj8+9jVl6RCeRW4BhJcyTtDywF1mRXkDQrM/sm4K50eh3wekkHSzoYeH1a1pROP66HS8+YS09XByL5P9tLz5jrBtoGkf19wL+PWUlht7AiYq+kc0n+4Z8BXBkRd0i6GNgYEWuA/yHpTcBe4FHg7HTbRyV9kCQJAVwcEY9O+5eoIfcG29hKv8/g4GDD37Yymy6FtoFExHXAdaPK3p+ZvgC4oMK2VwJX1jVAMzOryG+im5lZLk4gZmaWixOImZnl4gRiZma5OIGYmVkuTiBmZpZLo3dl0hJWbx7isnXbeGDnMId3dXD+qcf6nY8W5N/Z2o0TSJ25q/b24N/Z2pFvYdWZuwJvD/6drR05gdTZA2V62R2v3JqTf2drR04gdXZ42gFfteXWnPw7WztyAqkzdwXeHvw7WztyI3qdlRpQ/XROa/PvbO3ICWQauKv29uDf2dqNb2GZmVkuhSYQSYskbZO0XdKKMsvfLelOSbdJuknSkZll+yRtST9rRm9rZmb1VdgtLEkzgE8DpwD3A7dKWhMRd2ZW2wz0RsQTkt4JfBR4a7psOCLmTWvQZmb2jCKvQE4AtkfEPRHxFDAALM6uEBEbIuKJdPZm4IhpjtHMzCpQRBRzYGkJsCgizknnzwJOjIhzK6z/T8DPI+KSdH4vsIVkvPT+iFhdYbvlwHKA7u7u+QMDA7ni3b17N52dnbm2LUIzxetY66eZ4m2mWKG54p1qrH19fZsionfMgogo5AMsAa7IzJ8F/FOFdf+M5ArkgExZT/r3aOA+4EUTHXP+/PmR14YNG3JvW4Rmitex1k8zxdtMsUY0V7xTjRXYGGX+TS3yFtYQMDszf0RaNoKkk4GVwJsi4slSeUQMpX/vAQaB4+oZrJmZjTRhI7qkA4E3An8AHA4MA7cDayPijikc+1bgGElzSBLHUuBPRx37OOBzJLe6Hs6UHww8ERFPSjoUWEDSwG5mZtNk3AQi6SKS5DEIfA94GDgQeAnQnyaX90TEbZM9cETslXQusA6YAVwZEXdIupjkcmkNcBnQCfy7JICfRsSbgN8BPifpaZIHAfpj5NNbZmZWZxNdgdwSER+osOwTkn4T+K28B4+I64DrRpW9PzN9coXtvgvMzXvcWvNAQlYtnyvWSsZtA4mItQCS3jx6maQ3R8TDEbGxXsE1g9JAQkM7hwmeHUho9eYxzTnW5nyuWKupthH9girL2o4HErJq+VyxVjNRG8gbgNOAHkmfyix6Psn7F23PAwlZtXyuWKuZ6ArkAWAj8GtgU+azBji1vqE1Bw8kZNXyuWKtZqI2kB9ExCqSl/RWZT7XRsSOaYqxoXkgIauWzxVrNdV2pni3pDF9nkTE0TWOp+l4ICGrls8VazXVJpBsHygHAm8GDql9OM3JAwlZtXyuWCup6imsiHgk8xmKiH8A/rDOsZmZWQOr6gpE0vGZ2f1Irkg8HK6ZWRurNgl8PDO9l6T327fUPBozM2saVSWQiOirdyBmZtZcJnqR8N3jLY+IT9Q2HDMzaxYTXYE8L/17LPAKkhcIAf4IuKVeQZmZWeMbN4FExEUAkr4FHB8Rj6fzFwJr6x6dmZk1rGo7U+wGnsrMP5WWmZlZm6r2KawvALdI+lo6fzqwqj4hmZlZM6j2RcIPAX8O7Eg/fx4RH57qwSUtkrRN0nZJK8osP0DSV9Ll35N0VGbZBWn5Nkl169hx9eYhFvSvZ+vQLhb0r/fYDVZ3pXNuzoq1PuesoVX7IuFvAb8EvpYti4if5j2wpBnAp4FTgPuBWyWtGTU07TuAHRHxYklLgY8Ab5X0UpIx1F9GMk77jZJeEhEjB1uYotIAQMN79sHsZwcAAtwdhdXFiHMOn3PW2KptA1kLfCP93ATcA1w/xWOfAGyPiHsi4ilgAFg8ap3FPHur7BrgdUoGR18MDETEkxFxL7A93V9NeQAgm24+56yZKGJMJ7sTb5R0bfJXEXFO7gNLS4BFpX1IOgs4MSLOzaxze7rO/en8j4ETgQuBmyPi6rT888D1EXFNmeMsB5YDdHd3zx8YGKg6xq1Du56Z7u6AhzLj/sztOajq/RRh9+7ddHZ2Fh1GVRzrs7Ln3Gh5zjnXbf00U7xTjbWvr29TRPSOLs/Vn1VEfF/SibmjmUYRcTlwOUBvb28sXLiw6m1X9q9nKB0t7j1z9/LxrUl19XR1cN6Z1e+nCIODg0zmuxbJsT4re85l5T3nXLf100zx1ivWqm5hSXp35vNeSV8mGa1wKoaA2Zn5I9KysutIeg5wEPBIldtOmQcAsunmc86aSbVtIM/LfA4gaQsZ3V4xWbcCx0iaI2l/kkbxNaPWWQMsS6eXAOsjuee2BliaPqU1BziGOrwZf/pxPVx6xlx60iFHe7o6uPSMuW7MtLrJnnPC55w1tmo7U7yoNC1pP6AzIn49lQNHxF5J5wLrgBnAlRFxh6SLgY0RsQb4PPBFSduBR0mSDOl6XwXuJOkd+F21fgKrpDQA0ODgYMPftrLW4EGnrFlU+xjvvwF/CewjuXJ4vqR/jIjLpnLwiLgOuG5U2fsz078mGf2w3LYfAj40leObmVl+1d7CemlEPEbyBvr1wBzgrLpFZWZmDa/aBDJT0kySBLImIvYAk3/+18zMWka1CeRzJKMQPhf4lqQjgcfqFZSZmTW+avvC+lRE9ETEaelTUD8FPEqhmVkbGzeBSPqz9KmrESKxV9KLJL26fuGZmVmjmugprBcAmyVtAjYBvwAOBF4MvJakg8UxveiamVnrm2hEwn+U9E/AScAC4HeBYeAu4Kyp9MZrZmbNbcL3QNIX9G5IP2ZmZkD1LxIeBvwFcFR2m4j4b/UJy8wqWb15iMvWbeOBncMc3tXB+ace6zfXrazSubJ09uOs7F9f83Ol2t54vw78P+BGkrfRzawAHnDKqjUdA+JVm0B+IyLeV5Mjmllu4w045QRiWdNxrlT7IuE3JJ1WkyOaWW4PlBkrZLxya1/Tca5Um0D+miSJDEt6TNLjkvwmutk0OzwdWqDacmtf03GuVPsm+vMiYr+I6IiI56fzz69ZFGZWFQ84ZdWajnNl3DYQSb8dET9Mx0AfIyK+X7NIzGxCpXvXfgrLJpI9V+BxeupwrkzUiP5uYDnw8UxZthfek2oWiZlVxQNOWbXqPSDeuLewImJ5OvkZYHFE9AEbgF3Ae/MeVNIhkm6QdHf69+Ay68yT9F+S7pB0m6S3ZpZdJeleSVvSz7y8sZiZWT7VNqL/r4h4LO048STgCpKkktcK4KaIOAa4ifL9aT0BvD0iXgYsAv5BUldm+fkRMS/9bJlCLGZmlkO1CaT0MPEfAv8SEWuB/adw3MXAqnR6FclAVSNExI8i4u50+gHgYeCwKRzTzMxqSMnwHhOsJH0DGAJOAY4n6VDxloj4vVwHlXZGRFc6LWBHab7C+ieQJJqXRcTTkq4CXgU8SXoFExFPVth2OUk7Dt3d3fMHBgbyhMzu3bvp7OzMtW0Rmilex1o/zRRvM8UKzRXvVGPt6+vbFBG9YxZExIQf4DeAM4Bj0vlZwOsn2OZG4PYyn8XAzlHr7hhnP7OAbcArR5UJOIAksby/mu8xf/78yGvDhg25ty1CM8XrWOunmeJtplgjmiveqcYKbIwy/6ZW1ZVJRDwBXJuZfxB4cIJtTq60TNJDkmZFxIOSZpHcniq33vOBtcDKiLh51PEBnpT0r0yhQd/MzPKptg2k1tYAy9LpZSSdNY4gaX/ga8AXIuKaUctmpX9F0n5ye12jNTOzMYpKIP3AKZLuBk5O55HUK+mKdJ23AK8Bzi7zuO6XJG0FtgKHApdMb/hmZlZtb7w1FRGPAK8rU74ROCedvhq4usL2foHRzKxgRV2BmFkdrd48xIL+9Wwd2sWC/vWs3jxUdEhWB6Xfec6KtYX8zoVcgZhZ/UzHQEJWvEYYXMxXIGYtZryBhKx1NMLv7ARi1mI86FR7aITf2QnErMV40Kn20Ai/sxOIWYvxoFPtoRF+Zzeim7WY6RhIyIrXCIOLOYGYtaB6DyRkjaHowcV8C8vMzHJxAjEzs1ycQMzMLBcnEDMzy8UJxMzMcnECMTOzXJxAzMwsl0LeA5F0CPAV4CjgPuAtEbGjzHr7SAaNAvhpRLwpLZ8DDAAvADYBZ0XEU/WP3Kx1rN48VOhLaDa+Zvh9iroCWQHcFBHHADel8+UMR8S89POmTPlHgE9GxIuBHcA76huuWWspdQU+tHOY4NmuwD1uSGNolt+nqASyGFiVTq8iGde8Kuk46CcBpXHSJ7W9mTVGV+BWWbP8PoqI6T+otDMiutJpATtK86PW2wtsAfYC/RGxWtKhwM3p1QeSZgPXR8TLKxxrObAcoLu7e/7AwECumHfv3k1nZ2eubYvQTPE61vqpFO/WoV0Vt5nbc1A9Q6qoVeq2Fmr9+0w11r6+vk0R0Tu6vG5tIJJuBF5YZtHK7ExEhKRKWezIiBiSdDSwXtJWoHLNlhERlwOXA/T29sbChQsns/kzBgcHybttEZopXsdaP5XiXdm/nqEy40b0dHUU1ndWq9RtLdT696lXrHW7hRURJ0fEy8t8vg48JGkWQPr34Qr7GEr/3gMMAscBjwBdkkrJ7wigsW4MmjW4RugK3Cprlt+nqDaQNcCydHoZ8PXRK0g6WNIB6fShwALgzkjuuW0Aloy3vZlVdvpxPVx6xlx6ujoQyf/ZXnrG3IZ7yqddNcvvU1R37v3AVyW9A/gJ8BYASb3AX0bEOcDvAJ+T9DRJouuPiDvT7d8HDEi6BNgMfH66v4BZsyu6K3AbXzP8PoUkkIh4BHhdmfKNwDnp9HeBuRW2vwc4oZ4xmpnZ+PwmupmZ5eIEYmZmuTiBmJlZLk4gZmaWixOImZnl4gRiZma5FPUeiJk1uGboTrxZtUrdOoGY2Ril7sRLPcKWuhMHmvIfukbSSnXrW1hmNkazdCfejFqpbp1AzGyMB8r0BDteuVWvlerWCcTMxji8q2NS5Va9VqpbJxAzG6NZuhNvRq1Ut25EN7MxSo25rfCkUKNppbp1AjGzspqhO/Fm1Sp161tYZmaWixOImZnlUkgCkXSIpBsk3Z3+PbjMOn2StmQ+v5Z0errsKkn3ZpbNm/5vYWbW3oq6AlkB3BQRxwA3pfMjRMSGiJgXEfOAk4AngG9mVjm/tDwitkxL1GZm9oyiGtEXAwvT6VXAIMk455UsAa6PiCfqG5aZTUar9OlUa+1SL4qI6T+otDMiutJpATtK8xXWXw98IiK+kc5fBbwKeJL0CiYinqyw7XJgOUB3d/f8gYGBXDHv3r2bzs7OXNsWoZnidaz1U894dw7vYWjHME9n/g3ZT6Ln4A66OmZOen+tUre1rpdamGrd9vX1bYqI3tHldUsgkm4EXlhm0UpgVTZhSNoREWPaQdJls4DbgMMjYk+m7OfA/sDlwI8j4uKJYurt7Y2NGzdO+rsADA4OsnDhwlzbFqGZ4nWs9VPPeBf0r2eoTPcbPV0dfGfFSZPeX6vUba3rpRamWreSyiaQut3CioiTxwnmIUmzIuLBNBk8PM6u3gJ8rZQ80n0/mE4+KelfgffWJGgzq1or9elUS+1UL0U1oq8BlqXTy4Cvj7Pu24AvZwvSpFO6/XU6cHsdYjSzcbRSn0611E71UlQC6QdOkXQ3cHI6j6ReSVeUVpJ0FDAb+M9R239J0lZgK3AocMk0xGxmGa3Up1MttVO9FPIUVkQ8AryuTPlG4JzM/H3AmEcXIqKYG4lm9oxW6tOpltqpXtwXlpnl1ip9OtVau9SLuzIxM7NcnEDMzCwXJxAzq6vVm4dY0L+eOSvWsqB/Pas3DxUd0pSUvs/WoV0t8X2mwm0gZlY3qzcPccG1Wxnesw+AoZ3DXHDtVoCmbCMY8X1mN//3mSpfgZhZ3Vy2btszyaNkeM8+Llu3raCIpqbVvs9UOYGYWd202lvZrfZ9psoJxMzqptXeym617zNVTiBmVjet9lZ2q32fqXIjupnVTau9lZ39PvA4PU3+fabKCcTM6mqit7JLgy8tnf04K/vXF/oPcjUDQZW+z+DgIOedubCQOBuFE4iZFaaRHotttUeOp4PbQMysMI30WGwjxdIsnEDMrDCN9FhsI8XSLHwLy8wKc3hXR9nhX0c/FltN20Q1xttPtbHYs3wFYmaFqeax2FLbxNDOYYJn2yYm2wfVRPvxI7qTV0gCkfRmSXdIelrSmIHaM+stkrRN0nZJKzLlcyR9Ly3/iqT9pydyM6ul04/r4dIz5tKT/l9+T1cHl54xd8TVRbVtExN12jjRfrKxqEIsNlJRt7BuB84APldpBUkzgE8DpwD3A7dKWhMRdwIfAT4ZEQOSPgu8A/hM/cM2s1qb6LHYatomqnmCqpr9tMtAULVSyBVIRNwVERM92nACsD0i7omIp4ABYLEkAScB16TrrQJOr1+0ZlakaroPqeYqxd2Q1J4ioriDS4PAe9Ox0EcvWwIsiohz0vmzgBOBC4GbI+LFafls4PqIeHmFYywHlgN0d3fPHxgYyBXr7t276ezszLVtEZopXsdaP80Ub6VYdw7vYWjHME9n/q3aT6Ln4A66OmYCsHVoV8X9zu05qOr91CLeRjTVWPv6+jZFxJjmhrrdwpJ0I/DCMotWRsTX63Xc0SLicuBygN7e3li4cGGu/QwODpJ32yI0U7yOtX6aKd7xYp3oKayV/evLPkHV09Ux4rZYrZ7mmijeRlOvWOuWQCLi5CnuYgiYnZk/Ii17BOiS9JyI2JspN7MWNVHbxPmnHjuiDQTKP0HlNo7aauTHeG8FjkmfuNofWAqsieSe2wZgSbreMmDarmjMrPH4CapiFPIUlqQ/Bp/W4VcAAAh7SURBVP43cBiwVtKWiDhV0uHAFRFxWkTslXQusA6YAVwZEXeku3gfMCDpEmAz8PkCvoaZNRBfXUy/QhJIRHwN+FqZ8geA0zLz1wHXlVnvHpKntMzMrCCNfAvLzMwamBOImZnl4gRiZma5OIGYmVkuhb6JPt0k/QL4Sc7NDwV+WcNw6q2Z4nWs9dNM8TZTrNBc8U411iMj4rDRhW2VQKZC0sZyr/I3qmaK17HWTzPF20yxQnPFW69YfQvLzMxycQIxM7NcnECqd3nRAUxSM8XrWOunmeJtplihueKtS6xuAzEzs1x8BWJmZrk4gZiZWS5OIFWQtEjSNknbJa0oOp7RJN0naaukLZI2pmWHSLpB0t3p34MLjO9KSQ9Luj1TVjY+JT6V1vVtko5vgFgvlDSU1u8WSadlll2QxrpN0qnTHOtsSRsk3SnpDkl/nZY3at1Wirfh6lfSgZJukfSDNNaL0vI5kr6XxvSVdKgJJB2Qzm9Plx81XbFOEO9Vku7N1O28tLw250JE+DPOh6Qr+R8DRwP7Az8AXlp0XKNivA84dFTZR4EV6fQK4CMFxvca4Hjg9oniI+mN+XpAwCuB7zVArBeSDL08et2XpufDAcCc9DyZMY2xzgKOT6efB/wojalR67ZSvA1Xv2kddabTM4HvpXX2VWBpWv5Z4J3p9F8Bn02nlwJfmea6rRTvVcCSMuvX5FzwFcjETgC2R8Q9EfEUMAAsLjimaiwGVqXTq4DTiwokIr4FPDqquFJ8i4EvROJmktEnZ01PpBVjrWQxMBART0bEvcB2pnGYgYh4MCK+n04/DtwF9NC4dVsp3koKq9+0jnanszPTTwAnAdek5aPrtlTn1wCvk6TpiBXGjbeSmpwLTiAT6wF+lpm/n/FP+iIE8E1JmyQtT8u6I+LBdPrnQHcxoVVUKb5Gre9z00v9KzO3Axsm1vSWyXEk/+fZ8HU7Kl5owPqVNEPSFuBh4AaSK6CdkQylPTqeZ2JNl+8CXjBdsZaLNyJKdfuhtG4/KemA0fGmctWtE0hreHVEHA+8AXiXpNdkF0Zyzdqwz2s3enzAZ4AXAfOAB4GPFxvOSJI6gf8D/E1EPJZd1oh1WybehqzfiNgXEfOAI0iufH674JDGNTpeSS8HLiCJ+xXAISSjudaME8jEhoDZmfkj0rKGERFD6d+HSUZ6PAF4qHRJmv59uLgIy6oUX8PVd0Q8lP7H+TTwLzx7G6XwWCXNJPnH+EsRcW1a3LB1Wy7eRq7fNL6dwAbgVSS3ekojuWbjeSbWdPlBwCPTHCowIt5F6W3DiIgngX+lxnXrBDKxW4Fj0qcv9idpIFtTcEzPkPRcSc8rTQOvB24niXFZutoy4OvFRFhRpfjWAG9PnxJ5JbArczumEKPuDf8xSf1CEuvS9AmcOcAxwC3TGJeAzwN3RcQnMosasm4rxduI9SvpMEld6XQHcApJm80GYEm62ui6LdX5EmB9evU3LSrE+8PM/0iIpL0mW7dTPxem80mBZv2QPLHwI5J7oCuLjmdUbEeTPKnyA+COUnwk919vAu4GbgQOKTDGL5PcmthDcq/1HZXiI3kq5NNpXW8Fehsg1i+msdyW/oc3K7P+yjTWbcAbpjnWV5PcnroN2JJ+Tmvguq0Ub8PVL/C7wOY0ptuB96flR5Mkse3AvwMHpOUHpvPb0+VHT3PdVop3fVq3twNX8+yTWjU5F9yViZmZ5eJbWGZmlosTiJmZ5eIEYmZmuTiBmJlZLk4gZmaWixOItR1JK9MeS29Leyg9cZLb3yfp0AnWOVvS4eMs/4fRPQak5QslfWMy8UwQx3cnWN4l6a8y84dJ+o9aHd9amxOItRVJrwLeSNIr7O8CJzOyT6BaORsom0AkvQB4ZSQdN05J5q3osiLi9yfYRRdJT7Kl9X8BPChpwVRjs9bnBGLtZhbwy0i6diAifhkRD8DIKwtJvZIG0+kXSPpmetVyBclLWEg6SiPHDXmvkrEtlgC9wJfSK5yOUTH8CfAfme0WSfqhpO8DZ2TKn5t2LniLpM2SFqflZ0taI2k9cJOkTkk3Sfq+knFhFmf2sTv9W2mdfuBFaZyXpWWrgTOnUMfWJpxArN18E5gt6UeS/lnSa6vY5gPAtyPiZSR9jf3WeCtHxDXARuDMiJgXEcOjVlkAbIJkICCS/p/+CJgPvDCz3kqSLjFOAPqAy9LuaiAZs2RJRLwW+DXwx5F0qNkHfDztuiKr0jorgB+ncZ6frrsR+IMJa8XanhOItZVIxkyYDywHfgF8RdLZE2z2GpJuIIiItcCOKYYxKz02JD2l3hsRd0fSLcTVmfVeD6xQ0kX3IEl3GaXkdUNElMYtEfBhSbeRdF3Sw9ju+6tZp+RhKtx+M8sa9/6pWSuKiH0k/yAPStpK0gneVcBenv2fqgOr2FV2/Wq3ARiucl0BfxIR20YUJo3+v8oUnQkcBsyPiD2S7iuz/2rWKTkwjdFsXL4CsbYi6VhJx2SK5gE/SafvI7k6gaSdouRbwJ+m278BKA149BDwm2kbyQEkjfMlj5MM21rOXcCL0+kfAkdJelE6/7bMeuuA80q3oyQdV2F/BwEPp4mhDzhyEuuUi/MlPNtrq1lFTiDWbjqBVZLuTG/nlMbkBrgI+EdJG4F9mW0uAl4j6Q6SRu6fAkTEHuBikt5XbyBJBiVXAZ+t0Ii+FliY7uPXJLfT1qaN6NlxWz5IMjTpbemxP1jhO30J6E2vpt4+Ko4Yb52IeAT4jqTbM43ofWmMZuNyb7xmBZD0beCNkQz+U69jvAD4fkSUuyIZb7tvAYsjYqptPdbifAViVoz3MMHTXFORvsT4X8DHJrndYcAnnDysGr4CMTOzXHwFYmZmuTiBmJlZLk4gZmaWixOImZnl4gRiZma5/H9JXQywHwQmwwAAAABJRU5ErkJggg==\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "sudut = np.arange(0, 360, 10)\n",
    "\n",
    "sin = np.sin(np.radians(sudut))\n",
    "\n",
    "plt.scatter(sudut, sin)\n",
    "plt.grid(True)\n",
    "plt.title(\"Fungsi Sinus\")\n",
    "plt.xlabel(\"Sudut (derajat)\")\n",
    "plt.ylabel(\"sin(sudut)\")\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[  0  10  20  30  40  50  60  70  80  90 100 110 120 130 140 150 160 170\n",
      " 180 190 200 210 220 230 240 250 260 270 280 290 300 310 320 330 340 350]\n"
     ]
    }
   ],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "help(math.pow)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"Modul untuk menghitung GLB\n",
    "\n",
    "Modul ini berfungsi untuk menghitung beberapa parameter dalam gerak lurus beraturan\n",
    "\"\"\"\n",
    "\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "\n",
    "\n",
    "def glb_v(x, t):\n",
    "    \"\"\"\n",
    "    Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
    "    \"\"\"\n",
    "    return (x/t)\n",
    "\n",
    "def glb_x(v, t):\n",
    "    \"\"\"\n",
    "    Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
    "    \"\"\"\n",
    "    return (v*t)\n",
    "\n",
    "def glb_t(v, x):\n",
    "    \"\"\"\n",
    "    Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
    "    \"\"\"\n",
    "    return (x/v)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "1. copy kode di atas\n",
    "2. buat file namanya metkom_glb.py di folder notebook kalian\n",
    "3. paste kode\n",
    "4. simpan"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Help on module metkom_glb:\n",
      "\n",
      "NAME\n",
      "    metkom_glb - Modul untuk menghitung GLB\n",
      "\n",
      "DESCRIPTION\n",
      "    Modul ini berfungsi untuk menghitung beberapa parameter dalam gerak lurus beraturan\n",
      "\n",
      "FUNCTIONS\n",
      "    glb_t(v, x)\n",
      "        Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
      "    \n",
      "    glb_v(x, t)\n",
      "        Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
      "    \n",
      "    glb_x(v, t)\n",
      "        Mengembalikan nilai kecepatan v dari gerak lurus beraturan dengan jarak x dan waktu t\n",
      "\n",
      "FILE\n",
      "    /media/anangsahroni/CADC45ABDC45929D/Academic/Metkom2020/2020_Praktikum-Metode-Komputasi/metkom_glb.py\n",
      "\n",
      "\n"
     ]
    }
   ],
   "source": [
    "import metkom_glb as mglb\n",
    "help(mglb)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "30\n"
     ]
    }
   ],
   "source": [
    "x = mglb.glb_x(10,3)\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {},
   "outputs": [
    {
     "ename": "NameError",
     "evalue": "name 'DSHM' is not defined",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m----------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mNameError\u001b[0m                            Traceback (most recent call last)",
      "\u001b[0;32m<ipython-input-76-c1996250a89c>\u001b[0m in \u001b[0;36m<module>\u001b[0;34m\u001b[0m\n\u001b[1;32m      3\u001b[0m \u001b[0mtime\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0marange\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m100\u001b[0m\u001b[0;34m,\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      4\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m----> 5\u001b[0;31m \u001b[0mamplitudo\u001b[0m \u001b[0;34m=\u001b[0m \u001b[0mDSHM\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m4\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mtime\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0.01\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m10\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0m\u001b[1;32m      6\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m      7\u001b[0m \u001b[0mplt\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mplot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mtime\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mamplitudo\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n",
      "\u001b[0;31mNameError\u001b[0m: name 'DSHM' is not defined"
     ]
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "\n",
    "time = np.arange(0,100,1)\n",
    "\n",
    "amplitudo = DSHM(4, time, 0.01, 10, 10, 0)\n",
    "\n",
    "plt.plot(time, amplitudo)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div style=\"background-color: #ffc107  !important; color: grey; min-height: 50px; padding: 10px; margin: auto;\">\n",
    "    <p style=\"text-align: right; font-style: italic\">Praktikum Metode Komputasi-4</p>\n",
    "    <h1>Tugas 4: Module dalam Python</h1>\n",
    "</div>\n",
    "<div style=\"background-color: whitesmoke; padding: 10px; padding-bottom: 0px; \">\n",
    "    <ul>\n",
    "        <li>Praktikum Metode Komputasi</li>\n",
    "        <li>Pertemuan: 4</li>\n",
    "        <li>Format file: Portable Document Format (PDF)</li>\n",
    "        <li>Template:<a href=\"./material/report_template.docx\"> Download Template Laporan</a></li>\n",
    "        <li>Link Pengumpulan: Google Classroom</li>\n",
    "        <li>Format Nama File: 4-[NIM]-Nama, contoh: 4-362705-Anang Sahroni</li>\n",
    "    </ul>\n",
    "</div>\n",
    "<div style=\"background-color: #dc3545; color: white \">\n",
    "    <ul>\n",
    "        <li>Deadline: Minggu, 4 April 2020 17.00 WIB</li>\n",
    "    </ul>\n",
    "</div>"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Buatlah modul bernama `metkom_shm` yang berfungsi untuk membuat plot dari Simple Harmonic Motion dan Damped Simple Harmonic Motion seperti pada di bawah ini:"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "![module_help](./material/module_help.png)\n",
    "![module_plot](./material/module_plot.png)"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.7.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}