{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/python_with_Birds.gif)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Numpy เบื้องต้น - 1D\n", "\n", "**30** minutes\n", "\n", " **วัตถุประสงค์**\n", "\n", "\n", " หลังจากทำทำแล็บ นศ.จะสามารถ \n", "\n", "* Import ไลบรารี่ (Library) `numpy` และใช้งานไลบรารี่เบื้องต้นได้\n", "* ดำเนินการทางคณิตศาสตร์กับข้อมูล `NumPy arrays` (อาร์เรย์ 1 มิติ) ได้\n", "* Import ไลบรารี่ (Library) `matplotlib` และพล็อตกราฟอย่างง่ายได้\n", "\n", "Ref:\n", "- https://docs.scipy.org/doc/numpy/user/quickstart.html\n", "- https://docs.scipy.org/doc/numpy/user/basics.html\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## import ไลบรารี่ NumPy" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "หนึ่งในจุดเด่นของภาษาไพธอนคือ มีไลบรารีเสริมมากมายครอบคลุมการใช้งานที่หลากหลาย\n", "\n", "ในบรรดาไลบรารีต่างๆ **numpy** และ **matplotlib** เป็น 2 ไลบรารีที่มีความสำคัญและใช้กันอย่างแพร่หลายที่สุด\n", "\n", "เรามักจะใช้ numpy คำนวณและวิเคราะห์ข้อมูลเชิงตัวเลข จากนั้นนำข้อมูลออกมาแสดงผลเป็นกราฟและแผนภาพต่างๆ ให้เห็นภาพชัดเจนยิ่งขึ้นโดยใช้ matplotlib\n", "\n", "(หากใช้ไลบรารี numpy + matplotlib + scipy จะทำให้ไพธอนทัดเทียมกับโปรแกรม matlab (แมตแล็บ) โดยที่ไม่ต้องเสียค่าใช้จ่าย และเมื่อใช้ร่วมกับไลบรารี pandas + scikit-learn + ฯลฯ ก็จะทำให้ไพธอนเหนือกว่า matlab ขึ้นไปอีก)\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "การ Import ไลบรารี่\n", "\n", " \n", "* __แบบที่ 1:__ \n", " `import as ` \n", "* __แบบที่ 2:__ \n", " `import ` \n", "* __แบบที่ 3:__ \n", " `from import `
\n", "               `from import as ` \n", "* __แบบที่ 4:__ \n", " `from import *` \n", "\n", " \n", "
" ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Import the libraries\n", "\n", "import time \n", "import sys\n", "import numpy as np # To define an alias for an imported module\n", "\n", "# import the pyplot module of the matplotlib library under the alias plt.\n", "import matplotlib.pyplot as plt\n", "%matplotlib inline " ] }, { "cell_type": "code", "execution_count": 2, "metadata": {}, "outputs": [], "source": [ "# Plotting functions using matplotlib\n", "\n", "def Plotvec1(u, z, v):\n", " \n", " ax = plt.axes() # Creating a new full window axes\n", " ax.arrow(0, 0, *u, head_width=0.1, color='r', head_length=0.1) # Axes.arrow(x, y, dx, dy, **kwargs)[source] : This draws an arrow from (x, y) to (x+dx, y+dy)\n", " plt.text(*(u + 0.1), 'u') # matplotlib.pyplot.text(x, y, s, fontdict=None, **kwargs)[source] : Add the text s to the Axes at location x, y in data coordinates.\n", " ax.arrow(0, 0, *v, head_width=0.1, color='b', head_length=0.1)\n", " plt.text(*(v + 0.1), 'v')\n", " ax.arrow(0, 0, *z, head_width=0.1, head_length=0.1)\n", " plt.text(*(z + 0.1), 'z')\n", " #plt.ylim(-2, 2) # Fixed Y-scale\n", " #plt.xlim(-2, 2) # Fixed X-scale\n", " ax.autoscale() # Auto-scale\n", " ax.set_aspect('equal')\n", "\n", "def Plotvec2(a,b):\n", " ax = plt.axes() # Creating a new full window axes\n", " ax.arrow(0, 0, *a, head_width=0.1, color ='r', head_length=0.1)\n", " plt.text(*(a + 0.1), 'a')\n", " ax.arrow(0, 0, *b, head_width=0.1, color ='b', head_length=0.1)\n", " plt.text(*(b + 0.1), 'b')\n", " plt.ylim(-2, 2)\n", " #plt.ylim(-2, 2)\n", " #plt.xlim(-2, 2) \n", " ax.autoscale() # Auto-scale\n", " ax.set_aspect('equal')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "สร้างลิสต์ (List) ขึ้นมา" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "# Create a python list using square brackets.\n", "a = [\"0\", 1, \"two\", \"3\", 4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถเข้าถึงสมาชิกภายในได้โดยใช้ index" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/NumOneList.png)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เข้าถึงสมาชิกแต่ละตัวในลิสต์โดยใช้เครื่องหมายวงเล็บเหลี่ยม **[ ]** (square brackets) ดังนี้\n" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a[0]: 0\n", "a[1]: 1\n", "a[2]: two\n", "a[3]: 3\n", "a[4]: 4\n" ] } ], "source": [ "# Print each element\n", "\n", "print(\"a[0]:\", a[0])\n", "print(\"a[1]:\", a[1])\n", "print(\"a[2]:\", a[2])\n", "print(\"a[3]:\", a[3])\n", "print(\"a[4]:\", a[4])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ลิสต์ไม่ได้ถูกทำมาเพื่อใช้ในการคำนวณโดยเฉพาะ ทำให้ไม่สามารถคำนวณได้โดยตรง หากเราต้องการจะนำอาร์เรย์มาบวกลบหรือทำอะไรก็ตาม จะพบว่าผลลัพธ์ไม่เป็นไปอย่างที่ต้องการ" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราลองสร้าง List ขึ้นมาสองตัวแปร x และ y" ] }, { "cell_type": "code", "execution_count": 5, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0, 1, 2, 3, 4, 9, 8, 7, 6, 5]\n" ] } ], "source": [ "x = [0, 1, 2, 3, 4]\n", "y = [9, 8, 7, 6, 5]\n", "\n", "print(x+y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ผลที่ได้ไม่ใช่การนำอาร์เรย์มาบวกกัน ซึ่งผลควรจะได้เป็น [9, 9, 9, 9, 9] แต่กลับกลายเป็นการเอามาต่อกัน\n", "\n", "หากต้องการให้บวกเมทริกซ์จะต้องทำการวนซ้ำเพื่อให้มีการคำนวณที่ตัวส่วนประกอบแต่ละตัว\n" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[9, 9, 9, 9, 9]\n" ] } ], "source": [ "#z = [0, 0, 0, 0, 0]\n", "z = [0 for i in x]\n", "\n", "for i in range(len(x)):\n", " z[i] = x[i]+y[i]\n", "print(z) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "จะเห็นว่ามีความยุ่งยาก หากสามารถทำให้เขียนแค่ x+y แล้วบวกกันได้เลย ชีวิตก็คงจะง่ายขึ้น!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "สิ่งที่จะตอบโจทย์นี้ได้ก็คือ numpy นั่นเอง \n", "\n", "ถ้า x และ y ไม่ใช่ลิสต์แต่เป็นออบเจ็กต์ ndarray ของ numpy แล้วละก็ x+y ก็จะเป็นการบวกอาร์เรย์ทันที นี่คือความสะดวกของ numpy\n", "\n", "แต่ไม่ใช่แค่นั้น นอกจากจะทำให้เขียนโค้ดสะดวกขึ้นแล้ว ยังทำให้การคำนวณเร็วขึ้นมากด้วย \n", "\n", "ไพธอนเป็นภาษาที่ถูกออกแบบมาเพื่อให้เขียนง่ายต่อการเขียนและมีความยืดหยุ่นสูง แต่ก็มีข้อเสียคือทำงานช้าเมื่อเทียบกับภาษาระดับที่สูงไม่มากอย่างภาษา C หรือ Fortan\n", "\n", "\n", "numpy เป็นไลบรารีที่มีเบื้องหลังการทำงานเป็นภาษาซี ดังนั้นจึงมีความเร็วสูงในการคำนวณมากกว่า" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## NumPy คืออะไร?" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy (Numerical Python) เป็นไลบรารีที่สำคัญมากที่สุดในไพธอนเลยก็ว่าได้ เนื่องจากใช้สำหรับการคำนวณทางคณิตศาสตร์ที่ซับซ้อนได้อย่างมีประสิทธิภาพ เช่นการเขียนชุดตัวเลขให้อยู่ในรูปแมทริกซ์ ซึ่งทำให้สะดวกต่อการเขียนโค้ดและการคำนวณอย่างมากมาก\n", "\n", "NumPy มีออบเจ็กต์พิเศษชนิดหนึ่งที่ชื่อว่า **ndarray** (*N-d* Array; \n", "**N-d**imensional **array** (multidimensional, homogeneous array)) ซึ่งเป็นออบเจ็กต์ที่เก็บข้อมูลเป็นกลุ่มเป็นแถว สามารถเก็บเป็นหลายมิติได้และสามารถนำข้อมูลภายในมาคำนวณได้อย่างรวดเร็ว\n", "\n", "\n", "![](images/Numpy_guide.png)\n", "\n", "\n", "อาร์เรย์ (Arrays) เป็นคุณสมบัติหลักของ NumPy NumPy Arrays มีลักษณะคล้ายกับ List (เก็บข้อมูลเป็นชุดของข้อมูลที่มีลำดับของข้อมูล) ยกเว้น สมาชิกทุกตัวในอาร์เรย์จะต้องเป็นข้อมูลชนิดเดียวกัน โดยทั่วไปแล้วข้อมูลที่เก็บในอาร์เรย์จะเป็นตัวเลขเช่น int หรือ float\n", "\n", "เนื่องจาก NumPy เป็นไลบรารี่ 3rd-party จึงต้องติดตั้งก่อนใช้งาน และตอนเขียนโค้ดต้อง import ไลบรารี่ก่อน" ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [], "source": [ "# Let’s install the Numpy library\n", "# !pip install numpy\n", "\n", "# import numpy library\n", "\n", "\n", "import numpy as np " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เวลาที่เรียกชื่อฟังก์ชันต่างๆใน Numpy จะเรียกโดยขึ้นต้นด้วย np." ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n", "\n", "**
\"Module\", \"Package\", \"Library\" ??
**\n", "\n", "**Module (โมดูล)** คือ Python File (.py files) ที่เก็บฟังก์ชั่น คลาสต่างๆ และตัวแปรโกบอลที่ใช้เป็นตัวชี้บ่งสถานะ (Flag). ตัวอย่างของโมดูล เช่น math \n", " \n", "**Package (แพ็คเกจ)** ก็คือ โฟลเดอร์ (Folder/Directory) ที่เก็บไพธอนโมดูลต่างๆ โดยภายในแพ็คเกจจะมีไฟล์ __init__.py กำหนดไว้ในโฟลเดอร์ เพื่อบ่งบอกว่าเป็นโฟลเดอร์ของแพ็คเกจ (ไฟล์นี้สามารถเป็นไฟล์ว่าง (Empty file) ได้) ตัวอย่างของแพ็คเกจ เช่น numpy, Requests, Matplotlib\n", " \n", "**Library (ไลบรารี)** คือ แพ็คเกจต่างๆ ที่ถูกรวบรวมไว้ โดยทั่วไปแล้ว ไพธอนแพ็คเกจกับไพธอนไลบรารีไม่ต่างกัน\n", " \n", "
" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การสร้างชุดข้อมูลอาร์เรย์ (1D Numpy Array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "การสร้างอาเรย์มีอยู่หลายวิธี แต่วิธีที่พื้นฐานที่สุดคือสร้างขึ้นมาจาก List, Tuple หรือ Range โดยใช้ np.array\n", "\n", "\n", "เราลองเปลี่ยนชุดข้อมูล List ข้างต้นให้เป็นอาร์เรย์" ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Help on built-in function array in module numpy:\n", "\n", "array(...)\n", " array(object, dtype=None, *, copy=True, order='K', subok=False, ndmin=0,\n", " like=None)\n", " \n", " Create an array.\n", " \n", " Parameters\n", " ----------\n", " object : array_like\n", " An array, any object exposing the array interface, an object whose\n", " __array__ method returns an array, or any (nested) sequence.\n", " dtype : data-type, optional\n", " The desired data-type for the array. If not given, then the type will\n", " be determined as the minimum type required to hold the objects in the\n", " sequence.\n", " copy : bool, optional\n", " If true (default), then the object is copied. Otherwise, a copy will\n", " only be made if __array__ returns a copy, if obj is a nested sequence,\n", " or if a copy is needed to satisfy any of the other requirements\n", " (`dtype`, `order`, etc.).\n", " order : {'K', 'A', 'C', 'F'}, optional\n", " Specify the memory layout of the array. If object is not an array, the\n", " newly created array will be in C order (row major) unless 'F' is\n", " specified, in which case it will be in Fortran order (column major).\n", " If object is an array the following holds.\n", " \n", " ===== ========= ===================================================\n", " order no copy copy=True\n", " ===== ========= ===================================================\n", " 'K' unchanged F & C order preserved, otherwise most similar order\n", " 'A' unchanged F order if input is F and not C, otherwise C order\n", " 'C' C order C order\n", " 'F' F order F order\n", " ===== ========= ===================================================\n", " \n", " When ``copy=False`` and a copy is made for other reasons, the result is\n", " the same as if ``copy=True``, with some exceptions for `A`, see the\n", " Notes section. The default order is 'K'.\n", " subok : bool, optional\n", " If True, then sub-classes will be passed-through, otherwise\n", " the returned array will be forced to be a base-class array (default).\n", " ndmin : int, optional\n", " Specifies the minimum number of dimensions that the resulting\n", " array should have. Ones will be pre-pended to the shape as\n", " needed to meet this requirement.\n", " like : array_like\n", " Reference object to allow the creation of arrays which are not\n", " NumPy arrays. If an array-like passed in as ``like`` supports\n", " the ``__array_function__`` protocol, the result will be defined\n", " by it. In this case, it ensures the creation of an array object\n", " compatible with that passed in via this argument.\n", " \n", " .. note::\n", " The ``like`` keyword is an experimental feature pending on\n", " acceptance of :ref:`NEP 35 `.\n", " \n", " .. versionadded:: 1.20.0\n", " \n", " Returns\n", " -------\n", " out : ndarray\n", " An array object satisfying the specified requirements.\n", " \n", " See Also\n", " --------\n", " empty_like : Return an empty array with shape and type of input.\n", " ones_like : Return an array of ones with shape and type of input.\n", " zeros_like : Return an array of zeros with shape and type of input.\n", " full_like : Return a new array with shape of input filled with value.\n", " empty : Return a new uninitialized array.\n", " ones : Return a new array setting values to one.\n", " zeros : Return a new array setting values to zero.\n", " full : Return a new array of given shape filled with value.\n", " \n", " \n", " Notes\n", " -----\n", " When order is 'A' and `object` is an array in neither 'C' nor 'F' order,\n", " and a copy is forced by a change in dtype, then the order of the result is\n", " not necessarily 'C' as expected. This is likely a bug.\n", " \n", " Examples\n", " --------\n", " >>> np.array([1, 2, 3])\n", " array([1, 2, 3])\n", " \n", " Upcasting:\n", " \n", " >>> np.array([1, 2, 3.0])\n", " array([ 1., 2., 3.])\n", " \n", " More than one dimension:\n", " \n", " >>> np.array([[1, 2], [3, 4]])\n", " array([[1, 2],\n", " [3, 4]])\n", " \n", " Minimum dimensions 2:\n", " \n", " >>> np.array([1, 2, 3], ndmin=2)\n", " array([[1, 2, 3]])\n", " \n", " Type provided:\n", " \n", " >>> np.array([1, 2, 3], dtype=complex)\n", " array([ 1.+0.j, 2.+0.j, 3.+0.j])\n", " \n", " Data-type consisting of more than one element:\n", " \n", " >>> x = np.array([(1,2),(3,4)],dtype=[('a','>> x['a']\n", " array([1, 3])\n", " \n", " Creating an array from sub-classes:\n", " \n", " >>> np.array(np.mat('1 2; 3 4'))\n", " array([[1, 2],\n", " [3, 4]])\n", " \n", " >>> np.array(np.mat('1 2; 3 4'), subok=True)\n", " matrix([[1, 2],\n", " [3, 4]])\n", "\n" ] } ], "source": [ "help(np.array)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**Syntax ของการสร้างชุดข้อมูลอาร์เรย์ (nampy.array Syntax)**\n", "\n", "```python\n", "np.array(object, dtype=None)\n", "```" ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 9, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array (integer array)\n", "\n", "np.array([0, 1, 2, 3, 4])" ] }, { "cell_type": "code", "execution_count": 10, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 10, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array\n", "\n", "a = np.array([0, 1, 2, 3, 4])\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "สมาชิกแต่ละตัวในอาร์เรย์ต้องเป็นข้อมูลชนิดเดียวกัน ในกรณีคือ int" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/NumOneNp.png)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เช่นเดียวกับ List เราสามารถเข้าถึงข้อมูลภายในโดยอ้างถึงหมายเลขดัชนี (index) ผ่านเครื่องหมายวงเล็บเหลี่ยม **[ ]** (square brackets)" ] }, { "cell_type": "code", "execution_count": 11, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "a[0]: 0\n", "a[1]: 1\n", "a[2]: 2\n", "a[3]: 3\n", "a[4]: 4\n" ] } ], "source": [ "# Print each element\n", "\n", "print(\"a[0]:\", a[0])\n", "print(\"a[1]:\", a[1])\n", "print(\"a[2]:\", a[2])\n", "print(\"a[3]:\", a[3])\n", "print(\"a[4]:\", a[4])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถเข้าถึงสมาชิกทีละหลายๆ ตัวได้ด้วยการใช้โคลอน **:** เช่นเดียวกับลิสต์" ] }, { "cell_type": "code", "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 1 2]\n" ] } ], "source": [ "print(a[0:3])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "หากมี **:** เพิ่มมาอีกตัว แล้ววางตัวเลขไว้ทางขวาของ **:** จะเป็นการกำหนดระยะเว้นช่วง (เหมือน List)" ] }, { "cell_type": "code", "execution_count": 13, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0 2 4]\n" ] } ], "source": [ "print(a[::2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "และหากใส่เลขติดลบ ก็จะกลายเป็นการไล่ถอยหลัง (เหมือน List)" ] }, { "cell_type": "code", "execution_count": 14, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4 2 0]\n" ] } ], "source": [ "print(a[::-2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "จะเห็นว่า หากต้องการกลับลำดับสมาชิกในอาเรย์ทั้งหมด (เรียงจากหลังไปหน้า) ก็แค่ใส่ [::-1] ไปเท่านั้น เป็นการใช้งานที่สะดวกมาก\n" ] }, { "cell_type": "code", "execution_count": 15, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[4 3 2 1 0]\n" ] } ], "source": [ "# Reverse\n", "print(a[::-1])" ] }, { "cell_type": "code", "execution_count": 16, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 4, 2, 5, 3])" ] }, "execution_count": 16, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.array([1, 4, 2, 5, 3])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**เราสามารถสร้างอาเรย์โดยใช้ List Comprehension ได้** เช่น" ] }, { "cell_type": "code", "execution_count": 17, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])" ] }, "execution_count": 17, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# nested lists result in 1-dimensional array\n", "np.array([i*2 for i in range(10)])" ] }, { "cell_type": "code", "execution_count": 18, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0, 4, 16, 36, 64, 100, 144, 196, 256, 324, 400,\n", " 484, 576, 676, 784, 900, 1024, 1156, 1296, 1444, 1600, 1764,\n", " 1936, 2116, 2304])" ] }, "execution_count": 18, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.array([i*i for i in range(50) if i%2!=1])\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy arange() เป็นอีกวิธีหนึ่งในการสร้าง array (เรียกว่า NumPy routines สำหรับสร้าง array) โดยมี\n", "\n", "Syntax:\n", "\n", "```python\n", "numpy.arange(start, stop, step, dtype)\n", "```\n", "\n", "โดย dtype คือ ชนิดข้อมูลของสมาชิกใน array หากไม่ระบุจะประเมินให้อัตโนมัติโดยพิจารณาจากชนิดข้อมูล start stop และ step" ] }, { "cell_type": "code", "execution_count": 19, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 0, 2, 4, 6, 8, 10, 12, 14, 16, 18])" ] }, "execution_count": 19, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create an array filled with a linear sequence\n", "# Starting at 0, ending at 20, stepping by 2\n", "# (this is similar to the built-in range() function)\n", "np.arange(0, 20, 2)" ] }, { "cell_type": "code", "execution_count": 20, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4, 6, 8])" ] }, "execution_count": 20, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Boolean Indexing\n", "# We can also set conditionals inside square brackets to filter elements out.\n", "q = np.arange(0, 20, 2)\n", "q[q<10]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "สิ่งที่แตกต่างระหว่าง NumPy arange() กับฟังก์ชั่น range() อีกอย่างก็คือ **NumPy arange() สามารถเป็นเลขชุดทศนิยมได้ ในขณะที่ range() เป็นเฉพาะจำนวนเต็มเท่านั้น**" ] }, { "cell_type": "code", "execution_count": 21, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0.0\n", "2.5\n", "5.0\n", "7.5\n" ] } ], "source": [ "for i in np.arange(0, 10, 2.5):\n", " print(i)" ] }, { "cell_type": "code", "execution_count": 22, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "0\n", "2\n", "4\n", "6\n", "8\n" ] } ], "source": [ "for i in range(0,10, 2):\n", " print(i)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### ชนิดของข้อมูลในอาร์เรย์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ถ้าเราตรวจสอบชนิดของข้อมูล จะพบว่าเป็นชนิด (ออบเจ็กต์) numpy.ndarray (*N-d* Array; \n", "**N-d**imensional **array** (multidimensional, homogeneous array))\n" ] }, { "cell_type": "code", "execution_count": 23, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 23, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check the type of the array\n", "\n", "type(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "**สมาชิกทุกตัวในอาร์เรย์ต้องเป็นข้อมูลชนิดเดียวกัน** เราสามารถตรวจสอบชนิดของข้อมูลที่เก็บในอาร์เรย์ได้โดยเรียกแอตทริบิวต์ (attribute) dtype ในกรณีนี้เป็นชนิดจำนวนเต็ม 64-bit)" ] }, { "cell_type": "code", "execution_count": 24, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('int64')" ] }, "execution_count": 24, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check the type of the values stored in numpy array\n", "\n", "a.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ตอนสร้างสร้างอาร์เรย์ หากมีสมาชิกที่มีทศนิยมแม้แต่ตัวเดียวทั้งหมดก็จะกลายเป็น *float64* ทันที" ] }, { "cell_type": "code", "execution_count": 30, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 1. , 2. , 3. , 4. , 3.14])" ] }, "execution_count": 30, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array with real numbers \n", "\n", "b = np.array([0, 1, 2, 3, 4, 3.14])\n", "b" ] }, { "cell_type": "code", "execution_count": 31, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 1. , 2. , 3. , 4. ,\n", " 3.14159265])" ] }, "execution_count": 31, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array with real numbers \n", "\n", "b = np.array([0, 1, 2, 3, 4, 3.14159265359])\n", "b" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "จะเห็นว่าข้อมูลในอาเรย์จะต้องเป็นข้อมูลที่มีชนิดเดียวกันและมีขนาดเท่ากันหมดทุกตัว หากตอนที่สร้างอาเรย์มีสมาชิกที่ชนิดต่างกันจะถูกทำให้เหมือนกันหมด!" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ถ้าเราตรวจสอบชนิดของข้อมูล จะพบว่าเป็นชนิด numpy.ndarray" ] }, { "cell_type": "code", "execution_count": 32, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "numpy.ndarray" ] }, "execution_count": 32, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check the type of array\n", "\n", "type(b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถตรวจสอบชนิดของข้อมูลโดยเรียกแอตทริบิวต์ (attribute) dtype ในกรณีนี้เป็นชนิด float 64\n", " ไม่ใช่จำนวนเต็ม" ] }, { "cell_type": "code", "execution_count": 33, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "dtype('float64')" ] }, "execution_count": 33, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Check the value type\n", "\n", "b.dtype" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การกำหนดค่าใหม่ให้กับอาร์เรย์ (เขียนทับข้อมูล)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เช่นเดียวกับ List เราสามารถเปลี่ยนค่าอาร์เรย์เมื่อไหร่ก็ได้โดยการใส่ค่าใหม่ทับลงไป\n", "\n", "ตัวอย่าง เราสร้างอาร์เรย์ c ขึ้นมาก่อนโดยใช้ลิสต์" ] }, { "cell_type": "code", "execution_count": 34, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([20, 1, 2, 3, 4])" ] }, "execution_count": 34, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create numpy array\n", "\n", "c = np.array([20, 1, 2, 3, 4])\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถเปลี่ยนค่าของสมาชิกตัวแรกให้เป็น 100" ] }, { "cell_type": "code", "execution_count": 35, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([100, 1, 2, 3, 4])" ] }, "execution_count": 35, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Assign the first element to 100\n", "\n", "c[0] = 100\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถเปลี่ยนสมาชิกตัวสุดท้ายให้มีค่าเป็น 0 ได้โดยใช้ดัชนีเชิงลบ (Negative indexing) เหมือนกับ List" ] }, { "cell_type": "code", "execution_count": 36, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([100, 1, 2, 3, 100])" ] }, "execution_count": 36, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Assign the last element to 0\n", "\n", "c[-1] = 100\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถกำหนดค่าให้กับสมาชิกมากกว่าหนึ่งตัวได้โดยระบุช่วงของข้อมูล ดังนี้ (ทำได้เหมือนกับ List)" ] }, { "cell_type": "code", "execution_count": 40, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([100, 500, 2, 300, 400])" ] }, "execution_count": 40, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Set the fourth element and fifth element to 300 and 400\n", "\n", "c[3:5] = 300, 400\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "หากต้องการเปลี่ยนค่าของสมาชิกทุกตัวให้เป็น 100 ก็สามารถทำได้ (List ใชรูปแบบคำสั่งแบบนี้ทำไม่ได้)\n" ] }, { "cell_type": "code", "execution_count": 41, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([100, 100, 100, 100, 100])" ] }, "execution_count": 41, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c[:] = 100\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การกำหนดค่าด้วยลิสต์ดัชนี (Integer array indexing)\n" ] }, { "cell_type": "code", "execution_count": 42, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 2, 3, 4])" ] }, "execution_count": 42, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Recreate numpy array\n", "\n", "c = np.array([0, 1, 2, 3, 4])\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถใช้ลิสต์เป็นดัชนีเพื่อกำหนดเฉพาะดัชนีที่ต้องการได้\n", "\n", "เราจะสร้างลิสต์ `select` ขึ้นมา ซึ่งภายในมีเลขดัชนีหลายค่า" ] }, { "cell_type": "code", "execution_count": 43, "metadata": {}, "outputs": [], "source": [ "# Create the index list\n", "\n", "select = [0, 2, 4]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถใช้ลิสต์ดัชนีเป็นอาร์กิวเมนต์ในวงเล็บสี่เหลี่ยมได้\n" ] }, { "cell_type": "code", "execution_count": 44, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4])" ] }, "execution_count": 44, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Use List to select elements\n", "\n", "d = c[select]\n", "d" ] }, { "cell_type": "code", "execution_count": 45, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 2, 4])" ] }, "execution_count": 45, "metadata": {}, "output_type": "execute_result" } ], "source": [ "c[[0, 2, 4]]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากนี้ยังสามารถใช้ลิสต์ดัชนีแก้ไขค่าของสมาชิกได้อีกด้วย ยกตัวอย่างเช่น เปลี่ยนค่าเป็น\n", "100000" ] }, { "cell_type": "code", "execution_count": 46, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([100000, 1, 100000, 3, 100000])" ] }, "execution_count": 46, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Assign the specified elements to new value\n", "\n", "c[select] = 100000\n", "c" ] }, { "cell_type": "code", "execution_count": 47, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0, 1, 0, 3, 0])" ] }, "execution_count": 47, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# c[0, 2, 4] = 0\n", "c[[0, 2, 4]] = 0\n", "c" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### แอตทริบิวต์และเมธอดอื่นๆ ของอาร์เรย์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากแอตทริบิวต์ dtype แล้ว ยังมีแอตทริบิวต์อื่นๆ อีกที่สามารถให้ข้อมูลของตัวอาเรย์นั้นๆ ได้ เช่น\n", "\n", "size\tจำนวนสมาชิกในอาเรย์, ndim\tจำนวนมิติของอาเรย์, shape\tรูปร่างของอาเรย์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราจะเรียนรู้แอตทริบิวต์อื่นๆ ของอาร์เรย์โดยผ่านอาร์เรย์ a\n", "\n", "ก่อนอื่น สร้างอาร์เรย์ a เลขจำนวนเต็ม จำนวน 100 ตัวเลข โดยการเรียกใช้ฟังก์ชั่น randint()\n", "\n", "ฟังก์ชั่น randint() ใช้สุ่ม (Random) ตัวเลขจำนวนเต็ม โดยจะทำการสุ่มจำนวนเต็มที่อยู่ในช่วงที่กำหนด (low - high) ออกมาตามจำนวน size ที่กำหนด\n", "\n", "```python\n", "numpy.random.randint(low, high=None, size=None, dtype=int)\n", "```" ] }, { "cell_type": "code", "execution_count": 48, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 24, -25, -44, -98, 86, 91, -83, 23, -26, -20, -95,\n", " 17, -14, 45, 16, 32, 49, -86, -90, 51, -12, 69,\n", " -57, -45, 17, 75, -1, 96, 69, -26, -98, -22, 53,\n", " 24, 43, -27, 15, -10, 23, -6, 92, 73, 15, 60,\n", " -6, 72, 63, 94, 60, -26, 78, 10, -48, 29, -58,\n", " -31, -26, -33, -54, 31, 90, -64, 36, 62, -32, -40,\n", " -76, 90, -100, -33, -96, -35, 20, 33, -10, 21, -78,\n", " 48, 94, -74, 4, 85, 2, -92, 97, 18, 95, 21,\n", " 81, 94, 29, -24, 53, -13, -51, 26, 81, 66, 64,\n", " 38])" ] }, "execution_count": 48, "metadata": {}, "output_type": "execute_result" } ], "source": [ "a = np.random.randint(-100,100,100)\n", "a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ดูข้อมูลกันก่อน โดยการพล็อตกราฟอย่างง่าย" ] }, { "cell_type": "code", "execution_count": 49, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 49, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(a)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "แอตทริบิวต์ size จำนวนสมาชิกในอาร์เรย์\n" ] }, { "cell_type": "code", "execution_count": 50, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "100" ] }, "execution_count": 50, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the size of numpy array\n", "\n", "a.size" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ndim\t(number of dimensions) จำนวนมิติของอาเรย์\n" ] }, { "cell_type": "code", "execution_count": 51, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "1" ] }, "execution_count": 51, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the number of dimensions of numpy array\n", "\n", "a.ndim" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "shape\tรูปร่างของอาเรย์ (จำนวนสามาชิกในแต่ละมิติ (dimension))\n", "\n", "ตอนนี้อาร์เรย์ที่สร้างขึ้นเป็นแค่ 1 มิติ" ] }, { "cell_type": "code", "execution_count": 52, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(100,)" ] }, "execution_count": 52, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the shape/size of numpy array\n", "\n", "a.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "แค่ถ้าเป็นอาร์เรย์ที่สร้างขึ้นเป็น 2 มิติ (2-dimension)" ] }, { "cell_type": "code", "execution_count": 53, "metadata": {}, "outputs": [], "source": [ "k = np.array([[1,2,3],\n", " [4,5,6],\n", " [7,8,9] \n", " ])" ] }, { "cell_type": "code", "execution_count": 54, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "2" ] }, "execution_count": 54, "metadata": {}, "output_type": "execute_result" } ], "source": [ "k.ndim" ] }, { "cell_type": "code", "execution_count": 55, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "(3, 3)" ] }, "execution_count": 55, "metadata": {}, "output_type": "execute_result" } ], "source": [ "k.shape" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "NumPy ยังมีเมธอด (Method) สำหรับการคำนวณค่าทางสถิติสำหรับชุดข้อมูลที่เก็บในอาร์เรย์ เช่น \n", "Mean, Max, Min, SD (Standard deviation) และ Var โดยเรียกด้วย mean(), max(), min(), std() และ var() ตามลำดับ เป็นต้น\n", "\n", "\n", "ค่าเฉลี่ย (Mean) คือ ค่ากลางที่ได้จากการนำเอาข้อมูลแต่ละตัวมารวมกัน แล้วนำผลรวมที่ได้มาหารด้วยจำนวนข้อมูลทั้งหมด\n", "\n", "\n", "ส่วนเบี่ยงเบนมาตรฐาน (SD; Standard Deviation) คือ ค่ารากที่สองของผลรวมของความแตกต่างระหว่างข้อมูลดิบกับค่าเฉลี่ยยกกำลังสอง (sum of squares ของผลต่าง) หารด้วยจำนวนข้อมูลทั้งหมด\n", "\n", "ค่าความแปรปรวน (Variance) คือ ค่าที่คำนวณมาจาก ค่าเบี่ยงเบนมาตรฐาน หรือ ส่วนเบี่ยงเบนมาตรฐาน ยกกำลัง 2" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าสูงสุด (max) ค่าต่ำสุด (min)" ] }, { "cell_type": "code", "execution_count": 56, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "97" ] }, "execution_count": 56, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the biggest value in the numpy array\n", "\n", "max_a = a.max()\n", "max_a" ] }, { "cell_type": "code", "execution_count": 57, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-100" ] }, "execution_count": 57, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the smallest value in the numpy array\n", "\n", "min_a = a.min()\n", "min_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าเฉลี่ย (Mean)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ถ้าหาแบบ Manual ค่าเฉลี่ย (Mean) จะสามารถหาได้จาก ผลรวมทั้งหมด/จำนวน" ] }, { "cell_type": "code", "execution_count": 58, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "-57" ] }, "execution_count": 58, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Cal by manual\n", "sum_a = a[0]+a[1]+a[2]+a[3]+a[4] # +... หมดแรงก่อน \n", "sum_a" ] }, { "cell_type": "code", "execution_count": 59, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "958" ] }, "execution_count": 59, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum_a = 0\n", "for n in a:\n", " sum_a += n\n", "sum_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ใช้คำสั่งที่สั้นกว่านั้น" ] }, { "cell_type": "code", "execution_count": 60, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "958" ] }, "execution_count": 60, "metadata": {}, "output_type": "execute_result" } ], "source": [ "sum_a = sum(a[:])\n", "sum_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "แต่ถ้าใช้ Numpy" ] }, { "cell_type": "code", "execution_count": 61, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "958" ] }, "execution_count": 61, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# numpy.ndarray.sum: Return the sum of the array elements over the given axis.\n", "sum_a = a.sum()\n", "sum_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "หาค่าเฉลี่ย (Mean) จาก ผลรวมทั้งหมด/จำนวน" ] }, { "cell_type": "code", "execution_count": 62, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9.58" ] }, "execution_count": 62, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Cal by manual\n", "mean_a = sum_a/a.shape[0]\n", "mean_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "แต่ถ้าใช้ Numpy" ] }, { "cell_type": "code", "execution_count": 63, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "9.58" ] }, "execution_count": 63, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the mean of numpy array\n", "\n", "mean_a = a.mean()\n", "mean_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าเบี่ยงเบนมาตรฐาน (Standard deviation)" ] }, { "cell_type": "code", "execution_count": 64, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "56.78735422609509" ] }, "execution_count": 64, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the standard deviation of numpy array\n", "\n", "std_a=a.std()\n", "std_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าความแปรปรวน (Variance)" ] }, { "cell_type": "code", "execution_count": 65, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3224.8035999999997" ] }, "execution_count": 65, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Get the smallest value in the numpy array\n", "\n", "var_a = a.var()\n", "var_a" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากการเรียกใช้เมธอดแล้ว เรายังสามารถเรียกใช้งานในรูปแบบฟังก์ชันก็ได้ (ใช้ชื่อฟังก์ชั่นเหมือนกับชื่อเมธอด) เช่น\n" ] }, { "cell_type": "code", "execution_count": 66, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3224.8035999999997" ] }, "execution_count": 66, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.var(a)" ] }, { "cell_type": "code", "execution_count": 67, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0., 1., 2., 3., 4., 3.])" ] }, "execution_count": 67, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.floor(b)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ตัวดำเนินการสำหรับ Numpy Array\n", "\n", "เมื่อใช้ตัวดำเนินการทางคณิตศาสต์กับอาร์เรย์แล้ว จะได้ ndarray ชุดใหม่เสมอ" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การบวกลบอาร์เรย์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array u\n" ] }, { "cell_type": "code", "execution_count": 68, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 1])" ] }, "execution_count": 68, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u = np.array([2, 1])\n", "u" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array v\n" ] }, { "cell_type": "code", "execution_count": 69, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2])" ] }, "execution_count": 69, "metadata": {}, "output_type": "execute_result" } ], "source": [ "v = np.array([1, 2])\n", "v" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถบวกอาร์เรย์ทั้งสองนี้แล้วกำหนดให้เป็นอาร์เรย์ z" ] }, { "cell_type": "code", "execution_count": 70, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([3, 3])" ] }, "execution_count": 70, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Numpy Array Addition\n", "# To add two or more arrays use np.add(a,b) or the + sign.\n", "\n", "#z = np.add(u, v)\n", "z = u + v\n", "z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "การดำเนินข้างต้นเทียบเท่ากับการบวกเวกเตอร์" ] }, { "cell_type": "code", "execution_count": 71, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot numpy arrays\n", "\n", "Plotvec1(u, z, v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "การลบก็เช่นเดียวกัน" ] }, { "cell_type": "code", "execution_count": 72, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, -1])" ] }, "execution_count": 72, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# To subtract one array from another use the np.subtract(a,b) or the — sign\n", "#z = np.subtract(u, v)\n", "z = u - v\n", "z" ] }, { "cell_type": "code", "execution_count": 73, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Plotvec1(u, z, v)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การคูณอาร์เรย์ (Multiplication) ด้วยสเกลาร์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array y\n" ] }, { "cell_type": "code", "execution_count": 74, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2])" ] }, "execution_count": 74, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array\n", "\n", "y = np.array([1, 2])\n", "y" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถคูณสมาชิกทุกตัวในอาร์เรย์ด้วย 2 ได้เลยโดยที่ไม่ต้องใช้คำสั่งลูป\n" ] }, { "cell_type": "code", "execution_count": 75, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 4])" ] }, "execution_count": 75, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Numpy Array Multiplication\n", "# To multiply array by scalar use np.multiply(a,b)or the * sign.\n", "\n", "#z = np.multiply(2, y)\n", "z = 2 * y\n", "\n", "z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "การดำเนินข้างต้นเทียบเท่ากับการคูณเวกเตอร์ด้วยสเกลาร์\n" ] }, { "cell_type": "code", "execution_count": 76, "metadata": {}, "outputs": [ { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "Plotvec1(y, z, y)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การคูณสองอาร์เรย์ (Product)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array u\n" ] }, { "cell_type": "code", "execution_count": 77, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([1, 2])" ] }, "execution_count": 77, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array\n", "\n", "u = np.array([1, 2])\n", "u" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array v\n" ] }, { "cell_type": "code", "execution_count": 78, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([3, 2])" ] }, "execution_count": 78, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a numpy array\n", "\n", "v = np.array([3, 2])\n", "v" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "การคูณอาร์เรย์สองอาร์เรย์ u และ v จะได้\n" ] }, { "cell_type": "code", "execution_count": 79, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([3, 4])" ] }, "execution_count": 79, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Calculate the production of two numpy arrays\n", "# To multiply two arrays use np.multiply(a,b)or the * sign.\n", "\n", "#z = np.multiply(u, v)\n", "z = u * v\n", "z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ซึ่งเป็นการคูณแต่ละสมาชิกที่อยู่ในตำแหน่งเดียวกันเป็นคู่ๆ (element-by-element) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากการคูณแล้ว การหาร การยกกำลัง และหารเอาเศษ ก็เป็นการคำนวณเป็นคู่ๆ ทีละตัว ดังตัวอย่างต่อไปนี้" ] }, { "cell_type": "code", "execution_count": 80, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[0.33333333 1. ] \n", "\n", "[1 4] \n", "\n", "[1 0] \n", "\n" ] } ], "source": [ "# To divide two arrays usenp.divide(a,b)or the / sign.\n", "print(u/v, '\\n')\n", "\n", "print(u**v, '\\n')\n", "print(u%v, '\\n')" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การคูณแบบ Dot Product" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ถ้าต้องการคูณสองอาร์เรย์แบบ Dot Product ระหว่าง u และ v ใช้ฟังก์ชั่น dot() หรือใช้โอเปอร์เรเตอร์ @\n" ] }, { "cell_type": "code", "execution_count": 81, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 81, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Calculate the dot product\n", "u = np.array([1, 2])\n", "v = np.array([3, 2])\n", "\n", "np.dot(u, v)" ] }, { "cell_type": "code", "execution_count": 82, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "7" ] }, "execution_count": 82, "metadata": {}, "output_type": "execute_result" } ], "source": [ "u@v" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### การบวกและลบอาร์เรย์ด้วยค่าคงที่\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "พิจารณา Numpy Array ต่อไปนี้" ] }, { "cell_type": "code", "execution_count": 83, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([ 1, 2, 3, -1])" ] }, "execution_count": 83, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create a constant to numpy array\n", "\n", "u = np.array([1, 2, 3, -1]) \n", "u" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "บวกค่าคงที่ 1 ให้กับแต่ละสมาชิกที่อยู่ในอาร์เรย์" ] }, { "cell_type": "code", "execution_count": 84, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([2, 3, 4, 0])" ] }, "execution_count": 84, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Add the constant to array\n", "\n", "u + 1" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "สิ่งที่เกิดขึ้นสรุปเป็นรูปภาพได้ดังรูปต่อไปนี้\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "![](images/NumOneAdd.png)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ฟังก์ชั่นทางคณิตศาสตร์" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าของ $\\pi$ (Pi) ใน Numpy\n" ] }, { "cell_type": "code", "execution_count": 85, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "3.141592653589793" ] }, "execution_count": 85, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# The value of pi\n", "\n", "np.pi" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถสร้างอาร์เรย์ในหน่วยเรเดียน\n" ] }, { "cell_type": "code", "execution_count": 86, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 1.57079633, 3.14159265])" ] }, "execution_count": 86, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Create the numpy array in radians\n", "\n", "x = np.array([0, np.pi/2 , np.pi])\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถใช้ฟังก์ชัน sin กับอาร์เรย์ x และให้ผลลัพท์เป็นอาร์เรย์ y ซึ่งเป็นการหาค่าไซน์ของสมาชิกทุกตัวในอาร์เรย์ x \n" ] }, { "cell_type": "code", "execution_count": 87, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])" ] }, "execution_count": 87, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Calculate the sin of each elements\n", "\n", "y = np.sin(x)\n", "y" ] }, { "cell_type": "code", "execution_count": 88, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0.0000000e+00, 1.0000000e+00, 1.2246468e-16])" ] }, "execution_count": 88, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# ใช้ฟังก์ชั่น np.radians()\n", "x = np.array([0, np.radians(90) , np.radians(180)])\n", "y = np.sin(x)\n", "y\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "จากผลข้างต้น เราจพพบว่า sin(𝜋) ≠ 0 เนื่องจากไม่มีตัวเลขทศนิยมที่จะมาแทนค่า 𝜋 จริงๆ ได้\n", "แก้ด้วยการประมาณค่าโดยใช้ฟังก์ชัน np.around()" ] }, { "cell_type": "code", "execution_count": 89, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0., 1., 0.])" ] }, "execution_count": 89, "metadata": {}, "output_type": "execute_result" } ], "source": [ "np.around(y, decimals=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ค่าคงที่ที่สำคัญอื่นๆ ใน numpy\n", "\n", "```python\n", "np.e\n", "np.pi\n", "np.nan\n", "np.inf\n", "```" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากการคำนวณพื้นฐานแล้ว numpy ยังมีฟังก์ชันสำหรับคำนวณที่ใกล้เคียงกับในไลบรารี `math` เช่น `abs, sqrt, log, log10, exp, sin, cos, tan, arcsin, arccos, arctan, sinh, cosh, tanh, arcsinh, arccosh, arctanh`" ] }, { "cell_type": "code", "execution_count": 90, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 1.25331414, 1.77245385])" ] }, "execution_count": 90, "metadata": {}, "output_type": "execute_result" } ], "source": [ "z = np.sqrt(x)\n", "z" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## ฟังก์ชัน numpy.linspace (start, stop, n) " ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "ฟังก์ชั่นที่ใช้สร้างอาร์เรย์ใน NumPy อีกฟังก์ชั่น คือ ฟังก์ชั่น `numpy.linspace()` ฟังก์ชั่นนี้คล้ายกับฟังก์ชั่น numpy.arange( ) แต่จะแทนที่จะระบุ step (ระยะห่างของข้อมูลแต่ละตัว) ฟังก์ชั่น `numpy.linspace()` จะระบุเป็นจำนวนของข้อมูลที่ต้องการ โดยระยะห่างของข้อมูลแต่ละตัวจะถูกปรับให้มีขนาดเท่าๆ กันโดยอัตโนมัติ มักใช้กำหนดข้อมูลในการพล็อตกราฟ\n", "\n", "\n", "**Syntax**\n", "```\n", "numpy.linspace(start, stop, num)\n", "```\n", "\n", "**ความหมายของแต่ละพารามิเตอร์:**\n", "\n", "start:\tค่าเริ่มต้นของอาร์เรย์\n", "stop:\tค่าสุดท้ายของอาร์เรย์\n", "num:\tจำนวนข้อมูลในอาร์เรย์ (default argument = 50)\n" ] }, { "cell_type": "code", "execution_count": 91, "metadata": {}, "outputs": [], "source": [ "np.linspace?" ] }, { "cell_type": "code", "execution_count": 92, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-2., -1., 0., 1., 2.])" ] }, "execution_count": 92, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Makeup a numpy array within [-2, 2] and 5 elements\n", "\n", "np.linspace(-2, 2, num=5)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "จาก -2 ถึง 2 แต่ต้องการ 9 จำนวน num=9\n" ] }, { "cell_type": "code", "execution_count": 93, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([-2. , -1.5, -1. , -0.5, 0. , 0.5, 1. , 1.5, 2. ])" ] }, "execution_count": 93, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Make a numpy array within [-2, 2] and 9 elements\n", "\n", "np.linspace(-2, 2, num=9)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถใช้ฟังก์ชั่น linspace() สร้างตัวเลข 100 จำนวนที่อยู่ในช่วงตั้งแต่ 0 ถึง $3\\pi$\n" ] }, { "cell_type": "code", "execution_count": 94, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "array([0. , 0.09519978, 0.19039955, 0.28559933, 0.38079911,\n", " 0.47599889, 0.57119866, 0.66639844, 0.76159822, 0.856798 ,\n", " 0.95199777, 1.04719755, 1.14239733, 1.23759711, 1.33279688,\n", " 1.42799666, 1.52319644, 1.61839622, 1.71359599, 1.80879577,\n", " 1.90399555, 1.99919533, 2.0943951 , 2.18959488, 2.28479466,\n", " 2.37999443, 2.47519421, 2.57039399, 2.66559377, 2.76079354,\n", " 2.85599332, 2.9511931 , 3.04639288, 3.14159265, 3.23679243,\n", " 3.33199221, 3.42719199, 3.52239176, 3.61759154, 3.71279132,\n", " 3.8079911 , 3.90319087, 3.99839065, 4.09359043, 4.1887902 ,\n", " 4.28398998, 4.37918976, 4.47438954, 4.56958931, 4.66478909,\n", " 4.75998887, 4.85518865, 4.95038842, 5.0455882 , 5.14078798,\n", " 5.23598776, 5.33118753, 5.42638731, 5.52158709, 5.61678687,\n", " 5.71198664, 5.80718642, 5.9023862 , 5.99758598, 6.09278575,\n", " 6.18798553, 6.28318531, 6.37838508, 6.47358486, 6.56878464,\n", " 6.66398442, 6.75918419, 6.85438397, 6.94958375, 7.04478353,\n", " 7.1399833 , 7.23518308, 7.33038286, 7.42558264, 7.52078241,\n", " 7.61598219, 7.71118197, 7.80638175, 7.90158152, 7.9967813 ,\n", " 8.09198108, 8.18718085, 8.28238063, 8.37758041, 8.47278019,\n", " 8.56797996, 8.66317974, 8.75837952, 8.8535793 , 8.94877907,\n", " 9.04397885, 9.13917863, 9.23437841, 9.32957818, 9.42477796])" ] }, "execution_count": 94, "metadata": {}, "output_type": "execute_result" } ], "source": [ "# Make a numpy array within [0, 3π] and 100 elements \n", "\n", "x = np.linspace(0, 3*np.pi, num=100)\n", "x" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสมารถใช้ฟังก์ชั่น sin() หาค่า sine ของแต่ละสมาชิกในอาร์เรย์ x แล้วกำหนดค่าที่ได้เป็นอาร์เรย์ y\n" ] }, { "cell_type": "code", "execution_count": 95, "metadata": {}, "outputs": [], "source": [ "# Calculate the sine of x list\n", "\n", "y = np.sin(x)" ] }, { "cell_type": "code", "execution_count": 96, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 96, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Plot the result\n", "\n", "plt.plot(x, y) # Plot y versus x as lines and/or markers using default line style and color\n", "#plt.show() # Show graph" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถกำหนดสี ... และอื่นๆ เองได้\n", "\n", "ดูรายละเอียดได้ที่ [matplotlib.pyplot.plot](https://matplotlib.org/stable/api/_as_gen/matplotlib.pyplot.plot.html)" ] }, { "cell_type": "code", "execution_count": 97, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "Text(0, 0.5, 'sin(x)')" ] }, "execution_count": 97, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x, y, 'r+') # Plot with red plusses\n", "plt.xlabel('Angle [rad]')\n", "plt.ylabel('sin(x)')\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "***ตัวอย่างการพล็อตสัญญาณคลื่นสแควร์ (square wave) จากการรวม(ผลบวกของ) สัญญาณฮาร์โมนิกเลขคี่***\n", "\n", "\n", "สัญญาณรูปคลื่นที่ไม่ใช่สัญญาณไซน์ (Non-Sinusoidal Waveform) ที่เกิดขึ้นซ้ำๆ (มีคาบ มีความถี่ที่แน่นอน) สามารถสร้างขึ้นโดยการรวมแรงดันไฟกระแสตรง (DC) กับแรงดันคลื่นไซน์และ/หรือคลื่นโคไซน์ที่มีขนาดของสัญญาณหรือแอมพลิจูด (amplitude) และความถี่ (frequency) ที่แตกต่างกันเข้าด้วยกันได้\n", "\n", "สัญญาณคลื่นสแควร์ (square wave) ประกอบด้วยสัญญาณรูปคลื่นไซน์ที่มีความถี่เดียวกันกับคลื่นสแควร์ (เรียกว่า สัญญาณที่ความถี่มูลฐานหรือสัญญาณฮาร์โมนิกลำดับที่-1 (Fundamental frequency or 1st order harmonic)) กับสัญญาณฮาร์โมนิกลำดับที่ 3,5 และ 7...(3rd, 5th, 7th order harmonic; เฉพาะฮาร์โมนิกเลขคี่) รวมเข้าด้วยกัน โดยที่แอมพลิจูดของฮาร์โมนิกเท่ากับ 1/N โดย N คือเลขฮาร์มอนิก (1, 3, 5, 7…) \n", "\n", "ยกตัวอย่าง เช่น สัญญาณรูปคลื่นสแควร์ $1V_{p-p}$ $50Hz$ $=$ สัญญาณรูปคลื่นไซน์ $1V_{p-p}$ $50Hz$ (ฮาร์มอนิกลำดับที่ 1) $+$ สัญญาณรูปคลื่นไซน์ $\\frac{1}{3}V_{p-p}$ $3*50Hz$ (ฮาร์มอนิกลำดับที่ 3) $+$ สัญญาณรูปคลื่นไซน์ $\\frac{1}{5}V_{p-p}$ $5*50Hz$ (ฮาร์มอนิกลำดับที่ 5) $+$ สัญญาณรูปคลื่นไซน์ $\\frac{1}{7}V_{p-p}$ $7*50Hz$ (ฮาร์มอนิกลำดับที่ 7) $+ ...$ \n", "\n", "ฮาร์มอนิก (Harmonic) คือ สัญญาณที่มีความถี่เป็นจำนวนเท่าของความถี่มูลฐาน (Fundamental Frequency) เช่น ความถี่มูลฐาน $50 Hz$ ความถี่ฮาร์มอนิกลำดับที่ 3 จะเป็น $150 (50*3)Hz$, ลำดับที่ 5 จะเป็น $250 ((50*5))Hz$, ลำดับที่ 7 จะเป็น $350 (50*7)Hz$ $...$ เป็นต้น \n" ] }, { "cell_type": "code", "execution_count": 98, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 98, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# first, third, fifth, seventh, and ninth harmonics.\n", "h1 = np.sin(x)\n", "h3 = np.sin(3*x)/3 \n", "h5 = np.sin(5*x)/5 \n", "h7 = np.sin(7*x)/7 \n", "h9 = np.sin(9*x)/9\n", "\n", "\n", "# Plot this fundamental frequency.\n", "plt.plot(x, h1, linewidth=2) # plot with thick linewidth" ] }, { "cell_type": "code", "execution_count": 99, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 99, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Next add the third harmonic to the fundamental, and plot it.\n", "plt.plot(x, h1+h3, 'b')\n", "plt.plot()" ] }, { "cell_type": "code", "execution_count": 100, "metadata": { "scrolled": true }, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 100, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# Now use the first, third, fifth, seventh, and ninth harmonics.\n", "plt.plot(x, h1+h3+h5+h7+h9)" ] }, { "cell_type": "code", "execution_count": 101, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "# Save graph ('eps', 'jpeg', 'jpg', 'pdf', 'png', 'ps', 'svg', 'svgz')\n", "plt.savefig(\"sin.jpg\")" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "เราสามารถพล็อตหลายกราฟซ้อนกันได้\n", "\n", "คำสั่ง plt.plot รันครั้งหนึ่งจะได้กราฟออกมาหนึ่งเส้น ถ้าหากสั่ง plt.plot ซ้ำก็จะได้เส้นกราฟออกมาอีกเส้น โดยสีของกราฟจะถูกกำหนดขึ้นโดยอัตโนมัติ ปกติแล้วเส้นแรกจะเป็นสีน้ำเงิน เส้นต่อมาเป็นสีส้ม แล้วก็สีเขียว แล้วก็เปลี่ยนเป็นสีอื่นไปอีกเรื่อยๆ" ] }, { "cell_type": "code", "execution_count": 102, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 102, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x, h1)\n", "plt.plot(x, h1+h3)\n", "plt.plot(x, h1+h3+h5)\n", "plt.plot(x, h1+h3+h5+h7)\n", "plt.plot(x, h1+h3+h5+h7+h9)" ] }, { "cell_type": "code", "execution_count": 137, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 137, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYIAAAD7CAYAAABnoJM0AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjUuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8/fFQqAAAACXBIWXMAAAsTAAALEwEAmpwYAAA5fklEQVR4nO3deXxU9bn48c8zk8m+QDYICfu+BdCIWKqAuGGr4K3Xpa1ba1Grte1ta6393ba3t7316q3tta5YbfXW1lqVShXFpSLusghhDZsgWSALkI1sk/n+/shMGMIkmWSSOSec5/165ZWZs803kznznO/2HDHGoJRSyrlcVhdAKaWUtTQQKKWUw2kgUEoph9NAoJRSDqeBQCmlHE4DgVJKOVyfBAIReUJEykVkSyfrRUTuF5HdIlIoIqcFrbtIRIr86+7si/IopZQKX1/VCP4IXNTF+kXAeP/PUuBhABFxAw/6108BrhaRKX1UJqWUUmGI6YuDGGPWiMioLjZZDDxl2mavfSgig0QkBxgF7DbG7AUQkWf8227r6vUyMzPNqFFdvZxSSqmO1q9fX2mMyeq4vE8CQRhygQNBz4v9y0ItP7O7g40aNYp169b1aQGVUupUJyL7Qy2PVmexhFhmulh+8gFElorIOhFZV1FR0aeFU0opJ4tWICgGhgc9zwNKu1h+EmPMMmNMgTGmICvrpJqNUkqpXopWIFgBXOsfPTQHqDbGlAFrgfEiMlpEYoGr/NsqpZSKkj7pIxCRvwDzgUwRKQZ+CngAjDGPACuBi4HdwDHgBv86r4jcBqwC3MATxpitfVEmpZRS4emrUUNXd7PeALd2sm4lbYFCKaWUBXRmsVJKOZwGAqWUcjgNBB0ca/by7NoDNLa0Wl2UAa+8ppHlnxSjd8E7NR2pb+a59cV4W31WF2XAO3D4GCs3l1n2+hoIOnh27QHueL6QK5d9yKGaRquLM2BtOnCUSx54l+/+dRMbDxy1ujiqHzz+7qd8/2+buOGPa6k+1mJ1cQas93ZX8sXfvcs3n97AgcPHLCmDBoIOCourSY6LYdehWi594F026ZdYj724sYQrHv2g/fnmkmoLS6P6y6biowxO9PDh3ioWP/guu8vrrC7SgGKM4cn393HtEx8T72n7KrbqXNFA0EFhSTVzxmTw/C2fI8bl4opHP2B/Vb3VxRowVm09yLef2ciMvEGsvP1sMpPjKCzWQHCqMcawuaSai6YN5S/fmENdk5d/eeg9Dtc3W120AePPH3/GT1dsZcHELF759jnEul2WnSsaCILUNXnZU1FHfl4ak3NS+cs35tDk9bFq60GrizZgrNhYypDUOP5045lkJMeRn5dGYfFRq4ul+tiBww0cPdbC9NxBFIxKZ9m1BdQ0elldVG510QaMFz8pZdLQFB69poD0pFgm5aRYdq5oIAiypaQaY2B6XhoAIzISmTgkhbd2aG6jcHhbfazZVcH8CdnExrR9tKbnprG7vI76Jq/FpVN9qbDkKAD5/nNlZt4gMpNjeatIz5VwVDe0sP6zIyycnI3b1ZZybXpuGptLqvH5oj+4QgNBkM3+all+blr7svmTsli3/zB1+kXWrQ2fHaW20cuCScdzQeXnpeEzsK2sxsKSqb62ubiaWLeLCUNSAHC5hHkTsnlnVwWtFnyRDTTv7qqk1WdYMDG7fVl+Xhq1jV72W9BhrIEgSGFJNbmDEshIjmtfNn9CNi2thvd2V1pYsoHhraJyYlzC3HGZ7csCtSvtJzi1FBZXM3lYanvND2D+xCyOHmvRUWJhWF1UTmp8DDOHD2pflp/X9tiK5iENBEEKi4+2V3UDCkYNJjkuJuK2zy0l1ZYNDQvH5uLIy7e6qILTRw4mJd7Tviw7JZ6ctHjtJziF+HyGLSXVJ9ScAc4en4lLiPhcWb//MOW19h26HWn5fD7D6p0VnD0hixj38a/g8dnJxMVY02GsgcCv+lgL+6uOtV/BBnjcLj4/LpPVRRW9mhjl8xnuf3MXlzzwLosffI+ig7V9VeQ+8+qWgyx56D0W/e87vZ7UcrC6ke1lNSyYlH3Suum5ae3Nbmrg+7Sqntom70nnyqDEWE4bMZjVvewnaGn18fN/bONLD3/AZQ++T/ER+104/eXjz/jSwx9w0W/f4d1dvWsl2FZWQ0Vt0wnNQgAxbhdTh6Vacq5oIPALjN/Nzx100rr5E7Moq26k6FDPvsSP1DfztSfXct/rO7l4Wg4xLuErv/+Q3eW9DwYHDh/jJy9u4YfPFfLD5wq5+5UdEXXEvrHtEN/6ywam56YxLjuZbz69gf98aRstPZwt+vbOtqvA+RNPvldEfl4aeyvrqWnUSUengva+tA6BANr+/5tLqnt8xVxW3cBVyz7kifc+5Uun5VHT2MKXH/uIsuqGXpez6GAtdy3f3H6u3Pf6Tpq9vZ8F/bd1B7hr+WbmjssgIymWa574iPvf3NXjzt1AjWnehFDnyiC2lFZHvZ9FA4FfYBTE9NxQH+62yN2TKx1vq48rHv2A93dX8Ysl03jgy7P48zfmAHD1Yx+xt6Lnk2+ONXv5+pNreWbtAd7eWcHbOyt4dM0e7nxhc69qK28VlfPNpzcwOSeVp74+m2dvOovrPzeKx9/9lB8+V9izY+2oICctnon+zsNggbbPLTqx7JRQWFxNgsfNuKzkk9YFzpU1O8O/Wq5v8rLkwffYUVbD766exa+vmMFTX5vN4fpmru7lDP8j9c3c8IePWb6hhLd3VrB6Zzn3v7mLu1/Z0eNjASz/pJg7ni9k7thMHr/uDP5+61wunTGM+17fyd2v9uyYq4sqmJ6bRlZK3Enr8vPSONbc2qvvh0hoIPArPFDNqIxE0hI9J60bmhbPpKEpPWr7fHlzGbvK67jvyhl8dc5IRIRx2cn8+RtzaPUZbvnThh7laDHG8P/+voVd5XX8/toCPrxrIR/etZDvXzCRf2wq5U8fhrwVaafKaxq59ekNjB+SzP997UxS4z3Exrj42aVTWXrOGJZvLOHTyvAm0rW0+nh3dyXzJ2YhcvLdRwPBVTuMTw2FxUeZOiz1hPbtgKnDUslKievRufLM2gMcqmniievP4JIZwwCYNWIwT37tDCpqm/j2M5/06ELH5zN8568bqaxr5tmbzuLDuxby0V3ncf3nRvHEe5/2uPlzd3ktP/hbIXNGZ/DYtQXEe9wkxcXw2ytnctmsXJ76YB9VdU1hHav6WAsbPjsSsuYMx2tZm6J8rmgg8NtcUs10/5VrKPMnZrNu3xFqw2jeMMbwyNt7GZuVxMXTck5YN2FICr9YMo2iQ7U8t7447PL9de0BXthQwu3njuecoCrlLfPGsmBiFj9/aVuPRmvc9/pOWlp9PPjl004Kft84ewwet4tla/aGdax1+45Q1+Rl3oST+wcABifFMjw9QfsJTgHeVh9bS2tO6h8IEBHmTchizc6KsC50Wlp9PP7OXmaPTufMMRknrDt9ZDo/XDSJD/ce5s3t4QeWB9/azds7K/jJJVNOKOddF09m5vBB3PFcYY+uuO9+ZQcJHjcPfHkWCbHu9uUiwq0LxtLY4uPJ9/eFdaw1uyrwmdBNqACjM5NJinWzOcqDKzQQAJV1TZQcbThpFESwBROz8PpMWM1Da3ZVsr2shpvOGYvLdfIV8qJpQzl95GB+/frOsNr3t5XW8JMVWzl7fCa3Lxx/wjqXS/jNlTPJTonn1qc3hJX8a8fBGp5dd4Br5oxiVGbSSeuzUuK4/PQ8nt9QHFZb7xvbD+FxC3PHZXS6TX7uoPbmNzVw7amop6GlNWT/QMCCidnUNHpZu+9It8dbsbGU0upGbpk3NuT6q2ePYExWEv/1yvaw+q3e313JfW/sZMnMYXzlzBEnrIuNcfHgV07D4xa++fSGsDIMv7+nkje2l/PNBeNOGFYeMC47hfOnDOHJD/aHdS6/sf0QgxI9zBw+OOR6t0uYmptGYZSbUTUQENRR3MWHu2BUOkNT43lxY0m3x3tk9R6GpMaxeNawkOtFhB9/YTIVtU082s1Vd0urj+/9bRNpCR5+e+XM9lmIwQYlxvLgV07jYE0j//nytm7L918rd5AcF8PtC8d1us3Ss8fgbfXxh/f2dXmsVp/hH5tKmT8x+4Rhox3l56Vx4HADRzQXzYAWGAac30XtecGkLBJj3d2eKz6f4dE1e5g4JKXTK2SP28WPFk1mb0U9z3z8WZfHq2vy8oPnChmdmcQvL5sespkyd1AC9105kx0Ha/ntG7u6Ld8vX95O7qAEbpg7qtPtbp43luqGFp5Ze6DL49U3eXlt6yEWTcsJeR4HzMhLY1tpTY8HbESiTwKBiFwkIkUisltE7gyx/gcistH/s0VEWkUk3b9un4hs9q9b1xfl6ald/tFAk3JSO93G7RIunTmM1UUVXSbW2nTgKB/sreLrnx9NXIy70+1OGzGYL+bnsGzNHg5Wd37V/ejbe9heVsMvlkwLeUUSMHP4IG46ZwzPrS9mzc7Oay1v76xgzc4Kbl84nkGJsZ1uNyoziUXTcvjTB/u7HO3zwZ4qymubuGxWbqfbAEz2v7c7ezjyStnLrvI64mJcjM44uSYZkBgbw0VTh/Ly5rIur7rfKipn56E6bpo3JuSXdsB5k7OZMyad37yxq8vP4r2v7qC0uoF7L88nKa7zu/AumJjNFQV5PPbO3i6bK5d/UsLW0hruuGgi8Z7Oz+XTRw5m9qh0Hn9nb5df3q9vO0RDS2tY50qT18dnUZx3FHEgEBE38CCwCJgCXC0iU4K3Mcbca4yZaYyZCfwIeNsYczhokwX+9QWRlqc3Kuuaife4SI3v+hbOS2bm4vUZXu6is+mRt/eQEh/D1bNHdLpNwA8vmoTPB79cuT1kZ9ju8lruf3M3X8jP4cKpQ7s93u0LxzMmK4kfvbA5ZDW1obmV/3p5OyPSE7nmrJHdHu/meWOpbfLy5486vxJb/kkJKXExnBti/kCw7NS2IFZZpzWCgayytomslLiQTZ7BFs/KpbabJHSPvL2H3EEJ7R3EnRERfnzxFA7XN/Ob13eG3GbtvsM89eF+rjtrFKePTO/27/jxF6aQkRTLHc8XhvzyPnqsmf95rYj8vDQuye+6fAA3zx9DaXUjKzaWdrrN8k9KyB2UQMHI0M1CAdkp8QBURfFc6YsawWxgtzFmrzGmGXgGWNzF9lcDf+mD1+0zlXVNZCTFdXlVAjA5J4UJQ5J58ZPQVd5tpTW8uvUg1541sstmkoDh6YncumAc/9hUyv+8VnTCulaf4Y7nCkmMc/OzS6aG9XfEe9zc86X8tquiVScer9nr45an17OzvJafXTqly9pKwPS8ND4/LpPH1uwN2Une0NzKqq0HWTR9aJdXTAAZSW2BoKo+vNEVyp4q65u7rJkGzB2bQWZyHH//JPQX47u7Klm77wg3nj0aT4jRRx1Nz0vjmjkj+cN7+3ji3U9PWNfY0soPny8kd1ACP7hwYlh/R1qCh/9cMo3tZTU8+vaeE9bVN3m5/g9rqapr5meXTu026EFbLWPS0BQeeGt3yMBSUdvEu7srWTxzWLfHy0huq6mHOxKpL/RFIMgFghvHiv3LTiIiicBFwPNBiw3wmoisF5GlfVCeHqusayYzufNmkgARYcmsXNbtPxIyHcPdr+4gNd7D0rNDd3yFcvvCcVw9ezgPvrWn/QO5t6KOf3t2Ixs+O8pPL5kScrxxZwpGpXPdWaN48oN9/Pq1Iqrqmmj1Gb777EZWF1Xwq8umc+6kIWEf7/sXTqSqvpnHQvRlvLH9EHVNXpbM7LqqCzA40YNI2xWlGrgqa5vITOr+XIlxu7hkRg7/3FF+0gAGn8/wq1fa2t7DqTkH/PSSKVw4dQg/f2lb+4i7raXVfPPpDeytqOdX/zK9yyahji6cOpQv5Odw/5u7eWj1bmoaW2jytrL0/9axuaSa+6+exWkjur56DxARfnDhRD6tDN2X8VJhKa0+w5JumoXgeCCojGIgCP9d61yo8NbZoN9LgPc6NAvNNcaUikg28LqI7DDGrDnpRdqCxFKAESPC//CEo6quiaGp8WFtu3hmLve8WsSLG0u47dzjI3je3VXJmp0V/PjiySHnInRGRPjFkunUNnr51Ss7+OeOcj7ed5hYt4ub540N60u2ox9cOJHy2kYeeGs3j72zl8k5qXzy2VHuungSV/XgxIO2vocv5Ofw2Duf8tU5I8kOep9e3FjC0NT4k4b9hRLjdpGeGEuldhYPaFX1TSEnXYZy2axc/vDePl7ZUnbC527FplK2ltbwmytndFuTDBbjdnH/1bP4+h/Xccdzm3h23QE+/vQwyXEx/GjRJM4eH7rDuSs/v3QqtY1e7nm1iIfe2sPozCQ2l1Tz63+dwUXTum+ODXbupGxmj07nt2/s4rLT8kgOCkp/31jKlJzU9mytXUlPjG27aBpgTUPFwPCg53lAZw1lV9GhWcgYU+r/XQ4sp62p6STGmGXGmAJjTEFWVs//4V2pqmtuj8LdyR2UwOzR6Sz/pKS9XT/4CiectveO3C7hvitmsnBSNtvLarh1/jjeu/Nc7lw0qdvmqlCS4mJ46Cun8/p353HpjGFsLanh9nPHsfSc8Gsqwe64cCJen4/fBI2yOFzfzOqiChbPHNblCIhgGcmxUa3uqr5ljOnRuTI9N40xWUksD2pKbfK2cu+qIqbkpLJ4Rs8vcuJi3Dx6zemcNmIweyvq+cGFE3nvznO5qZPhp93JSI7jqa/N5qVvfZ75E7PYXlbDzy6ZwpdOz+vxsUSEuy6eTFV98wlzcPZW1LHpwNFuO4kDYtwuBifGRrUZtS9qBGuB8SIyGiih7cv+yx03EpE0YB7w1aBlSYDLGFPrf3wB8PM+KFPYjDFU1TeF1e4ZcNmsXH70wmYeWr2HL0zPYeOBo2wtreG3V87s0RVOsNgYF49dW4DPmJAzNntjXHYy91w+g19eNj2sdtjOjMxI4itnjuSpD/bxtbmjaGhp5cn39+P1GRb3oMaSkRSnncUDWHVDC16fCftcERGWzMzlvtd38tQH+1g4eQivbC6j5GgD//2l/LDa3kNJiovhrzedBRD2RUh3puWm8cCXT6Ol1RfRudJeg16zl6tnD6fkSAOPvbMXEbrtFA+WkRRLZW30zpWIA4ExxisitwGrADfwhDFmq4jc7F//iH/Ty4DXjDHBeQuGAMv9V70xwJ+NMa9GWqaeqGnw0tJqyOxBIPhCfg7PfPwZ964q4t5VRcS4hKnDUrm0B//oUFwuwRWypS0ykXywA7517jieW1/Mov99B6/PIAKLZw5jck73Vd2AzJS4qM+YVH0nEMTD6U8LuPKM4azYVMpPXtzKT17citslnD0+k8+Pz+x+5y70VQDoqC/OlR9cMJFVWw5y9n+/hddncLuE6z83iqFp4TU/A2Qmxw24GgHGmJXAyg7LHunw/I/AHzss2wvM6Isy9Fal/83uyYc7Nd7Di7d9ns+qjvHPHYf46NPD3DQv9CziU0VGchy/WDKN1UXlnDMhi3kTsnpUi4K2q5xoDolTfSvQedmTi6YhqfG8/t1z2FNRxz93lLNh/1G+H+bInoFqVGYSP7lkCoXF1cyfmMXZ47NISwi/3xDamlG3lkbvrn59EggGssAolsDwxp4YkZHI9XNHc/3c0X1dLFtaMis3rFEPnclMjqW2yUtjS2uvm9CUdQJBPNw+goC2hIspjMsOv/Y40F171qiI9s9MjovqqCHHp5io8o9iyUzp2Ydb9VzgSrJKRw4NSFX1Pa8RqN7JTI6lttFLk7f7fEh9QQNBXe9rBKpnAk1JOnJoYKqsbcIlMLiL1CSqbxw/V6Jz0eT4QFBR14xI24Qn1b8yLZgoo/pOZX0z6Umx/dZRq47L1EAQXVV1TaQnxvbZkE3VucCHW4eQDkxV/lQsqv+1zy6O0sghx3/79WSCjIrM8RwqGggGoko9V6Im0x9wo5WSxfGBoFKvcqImMTaGxFi3Ng0NUFV1TdpRHCWBwSvRGljh+EBQVd9MZg+SuqnIaJqJgUtrBNGTGBtDgsetNYJoaasR6Ic7WjKS4nT46ADU2NJKXZNXawRRlJEcqzWCaGhsaaW20dujWcUqMpnJcVRoKuoBp32+jZ4rURPNSWWODgSH2z/cepUTLZlRvMpRfSeSGfiqdzKTY6M2ws7RgeD4lHn9cEdLRnIsh+ub8fk6u2WFsqPArGLtI4iejKS4qPWnOToQBKpd+uGOnszkOFp9hqMNnd+EXNnP8cyjetEULZkp0bto0kAAZOmHO2o0zcTA1JvMoyoyGUlxeH2G6ihcNDk6EATaqrVGED3H00xoP8FAUlXXTFKsm4RYzRobLYFh7dG4L4GjA0FlbRMJHjeJsY7Pxh01x9NMaI1gIKms69ld/FTkMv3D2iuicKcyRweCtslkWhuIpsCcDW0aGlg0FUv0tTejao2gf2l6iegbnBiLS7RpaKCp1PQSUZcZxdxcfRIIROQiESkSkd0icmeI9fNFpFpENvp/fhLuvv2psq5ZJ8hEmcslpCdF936sKnJ6rkTfoPaLpv4/VyJuHBcRN/AgcD5QDKwVkRXGmG0dNn3HGPPFXu7bL6rqmpiRlxaNl1JBojlRRkXO5zMcrtfac7S5XUJ6UnTOlb6oEcwGdhtj9hpjmoFngMVR2DciPp+hql7bPa0Q7fuxqsgcbWjBZzS9hBUyk6MzqawvAkEucCDoebF/WUdnicgmEXlFRKb2cF9EZKmIrBORdRUVFREXurqhhVaf0ascC7RlINUawUBxfOKlnivRlpEcG5WLpr4IBKHuW9dxKtwGYKQxZgbwO+DvPdi3baExy4wxBcaYgqysrN6WtV37jbg1BXXURXPqvIqczsC3TrSy9fZFICgGhgc9zwNKgzcwxtQYY+r8j1cCHhHJDGff/hIYm5upKaijLjMllvrmVhqaW60uigpDoI1aZ+BHX2ZyXFTuSdAXgWAtMF5ERotILHAVsCJ4AxEZKiLifzzb/7pV4ezbX44n0dIPd7S134ZPawUDQpU2DVkmIzk6F00RjxoyxnhF5DZgFeAGnjDGbBWRm/3rHwEuB24RES/QAFxljDFAyH0jLVM4quo0v7pV2u9dXN/M8PREi0ujulNV14zbJQxK8FhdFMdpn0tQ30RebP+dK32SW8Hf3LOyw7JHgh4/ADwQ7r7RUFXXhEjbWF0VXZp4bmCpqm9qmwjoCtWlp/pTYDBLVV0zeYP7LxA4dmZxdUMLqfEe3PrhjrrAlWVNo6aiHghqGrwMStTagBUC73t/nyuODQQ1jV5SEzTZnBVS/YGg+pgGgoGg7aJJzxUrtJ8r/ZyK2rmBwF8jUNGX4v9SqWn0WlwSFY6axpb2LyQVXYHvqJqG/j1XnBsIGjUQWMXjdpEY66ZG71I2IOhFk3UCrRbaNNRPahq0achKqfEe7SMYILQZ1ToJHjcxLun3iybHBoLqhhbStLprmbQET1RuwaciY4zRc8VCIkJaQv9fNDk2EGjTkLVSE2L6vd1TRe5YcyutPqPnioVSEzxUax9B32tp9XGsuVU7wCykTUMDQ+B/pOeKdVLjY7RpqD/U+ker6JA466RGobqrIheotWmNwDrROFccGQgC0VWvcqzTdpWjTUN2d7xGoBdNVkmN92iNoD8EOim1A8w6gQ4wny9k1nFlE4FJf3quWKetRqB9BH1O2z2tl5rgwRioa9ZagZ21nyvaNGSZ1IQYnVncH7Td03rHZ0xqP4GdaTOq9VLjPTR7fTS29F8qamcGAm33tFz7jEntJ7C1QJNEig6ssExqFJI0OjIQBKpZWiOwTnuNQEcO2VpNQwuJsW48bkd+VdhCYHRjf140OfK/W9PQQoxLSIx1W10Ux4pWVkUVGZ1VbL00rRH0j0A2Rf/dM5UF2j/cGghsTWfgWy8aF03ODAQNXp1MZrHjTUPaR2BnmpzRetEYWNEngUBELhKRIhHZLSJ3hlj/FREp9P+8LyIzgtbtE5HNIrJRRNb1RXm6o/nVrZfc3u6pNQI70xqB9Y6nou6/i6aIQ72IuIEHgfOBYmCtiKwwxmwL2uxTYJ4x5oiILAKWAWcGrV9gjKmMtCzhqtb86pZzu4SUuBjtLLa5msYWJgxJsboYjjZQagSzgd3GmL3GmGbgGWBx8AbGmPeNMUf8Tz8E8vrgdXutRjvAbCFVU1HbXvUxPVesFu9xExfjsn1ncS5wIOh5sX9ZZ74OvBL03ACvich6EVna2U4islRE1onIuoqKiogKrDfasIfUBI/OI7Axn89Q26T9aXbQdq70XyDoi/9wqKE3IRPIiMgC2gLB54MWzzXGlIpINvC6iOwwxqw56YDGLKOtSYmCgoKIEtTorffsITVem4bsrK7ZizE6q9gO+jtJY1/UCIqB4UHP84DSjhuJSD7we2CxMaYqsNwYU+r/XQ4sp62pqd80trTS5PXph9sG+vsqR0WmRide2kZ/p6Lui0CwFhgvIqNFJBa4ClgRvIGIjABeAK4xxuwMWp4kIimBx8AFwJY+KFOnjifR0uqu1VLjPe33hlD2056TS5tRLdffqagj/g8bY7wichuwCnADTxhjtorIzf71jwA/ATKAh/yTuLzGmAJgCLDcvywG+LMx5tVIy9SV4x9uvcqxmt632N6qNeGcbaQlePjs8LF+O36fhHpjzEpgZYdljwQ9vhG4McR+e4EZHZf3J01BbR+pCTHUNXnxtvqI0Vw2tqMpqO2jv1NRO+7s03ZP+wj8D+qatHnIjmr0Bk62EWgaMqZ/buTkuEBw/O5k2u5ptfb0ujqE1JZqGvW+HXaRmuDB6zM09NM9CRwXCPTDbR/t6XV1CKktBWoEyTqwwnLHZxf3z0WT8wKBdoDZRpqmora16oYWUuJjcLs0S6/V+jsVtfMCQWMLsTEu4j16LwKrpWoqalvThHP2ERjC218XTc4LBDqr2DaicQs+1XttKaj1XLGD/k4858BAoHmG7CIat+BTvddWI9BzxQ76+6LJeYFAq7u2kRwXg0u0RmBXmqXXPvr7osl5gUA/3LYhIpqK2sZqGvQGTnbR3/1pzgsEjdruaSf9nUNF9V5No1drzzbhcbtIjHVrZ3Ffabs7mbZ72kVqQozet9iGvK0+6pq0P81OUuP7LwOpowKBMUaruzajNQJ7CqT90BqBfaQm9N89CRwVCBpaWvH6jH64bSStn/Osq94JfOFof5p9aI2gj+iH235S47Wz2I40BbX99OdFk6MCwfEPt7Z72kV/VndV7+kNnOynP0fYOSoQaH51+0mN99DQ0kqz12d1UVQQzcllP/1532JnBQL9cNtO4H9Rq/0EtqI3cLKf1AQPtY0t+Hx9f0+CPgkEInKRiBSJyG4RuTPEehGR+/3rC0XktHD37UuBD7f2EdjH8ayK2jxkJ9qfZj9pCR58Buqb+/5ciTgQiIgbeBBYBEwBrhaRKR02WwSM9/8sBR7uwb59pv1+xdruaRv9nVVR9U51QwsugaRYzdJrF+2J5/rhoqkvagSzgd3GmL3GmGbgGWBxh20WA0+ZNh8Cg0QkJ8x9+0zgyyZF+whso7+zKqreqWlsm28jovcisIv2i6ZjfX+u9EUgyAUOBD0v9i8LZ5tw9u0zNQ0tJHjcxMY4qmvE1jQVtT1punb7OV4jsGcgCHXJ0LE3o7Ntwtm37QAiS0VknYisq6io6GER26QmeJg6LLVX+6r+Efhwa9OQvbTl5NImVDvJSI5jfHZyyC/NSPXFf7oYGB70PA8oDXOb2DD2BcAYswxYBlBQUNCrbvPbF47n9oXje7Or6idp7aOGtLPYTjRLr/1MHJrC6/82r1+O3Rc1grXAeBEZLSKxwFXAig7brACu9Y8emgNUG2PKwtxXncLiPS48btEagc1Ua9OQo0RcIzDGeEXkNmAV4AaeMMZsFZGb/esfAVYCFwO7gWPADV3tG2mZ1MAhIpp4zob0Bk7O0ieNgMaYlbR92QcveyTosQFuDXdf5SypCR6dR2AzektXZ9HhM8pybVPntUZgF81eHw0trVojcBANBMpyqZqK2lYC6T7SEjUQOIUGAmU5vW+xvbRn6dUagWNoIFCWa+ss1j4Cuwj012gfgXNoIFCWa7tvsdYI7KJGawSOo4FAWS413kOz10djS6vVRVFoCmon0kCgLJem+YZsRVNQO48GAmW59sRz2mFsC9pZ7DwaCJTlAveHqNYOY1uoaWzB4xbiPfr14BT6n1aW01TU9hJIQa33InAODQTKcnpzGntpS0GtzUJOooFAWU7vW2wvNQ0tGggcRgOBslyKv49AawT20JaCWieTOYkGAmW5eI+buBiXBgKbCNyvWDmHBgJlC5p4zj5qGrw6dNRhNBAoW2hLRa19BHbQViPQpiEn0UCgbCFNM5DaQmNLK81en84qdhgNBMoWtGnIHjThnDNFFAhEJF1EXheRXf7fg0NsM1xE3hKR7SKyVUS+HbTuZyJSIiIb/T8XR1IeNXDpfYvtQRPOOVOkNYI7gTeNMeOBN/3PO/IC3zPGTAbmALeKyJSg9b8xxsz0/+i9ix2qLRW19hFYLZDmQ4ePOkukgWAx8KT/8ZPAko4bGGPKjDEb/I9rge1AboSvq04xgRqBMcbqojia1gicKdJAMMQYUwZtX/hAdlcbi8goYBbwUdDi20SkUESeCNW0pJwhLcGD12c41qz3JLBSoHlOO4udpdtAICJviMiWED+Le/JCIpIMPA98xxhT41/8MDAWmAmUAb/uYv+lIrJORNZVVFT05KXVAKCJ5+xBO4udqduGQGPMeZ2tE5FDIpJjjCkTkRygvJPtPLQFgaeNMS8EHftQ0DaPAS91UY5lwDKAgoICbT84xRxPPOclJ83iwjhYoJ8mRfsIHCXSpqEVwHX+x9cBL3bcQNpy2T4ObDfG3NdhXU7Q08uALRGWRw1QgQlMWiOwVk1DC3ExLuI9bquLoqIo0kBwN3C+iOwCzvc/R0SGiUhgBNBc4Brg3BDDRO8Rkc0iUggsAL4bYXnUAKWpqO1B8ww5U0T1P2NMFbAwxPJS4GL/43eBkHe4MMZcE8nrq1NHoHNSZxdbq7qhRTuKHUhnFitb0PsW20NbwjntH3AaDQTKFtrvSaCTyiylTUPOpIFA2YLH7SIx1q01AosF7lesnEUDgbKN1HhNPGe1tvsVa9OQ02ggULahqaitZYzRzmKH0kCgbCM1QW9OY6Vjza20+ow2DTmQBgJlG9o0ZC1NOOdcGgiUbejNaaxV056CWgOB02ggULah9y221vEagXYWO40GAmUbaf4agc+nOQWtUH1MU1A7lQYCZRupCR6MgbpmrRVYob1GoE1DjqOBQNmGJp6zVvu9CLRG4DgaCJRttKei1n4CS+i9CJxLA4GyDb1LmbVqGlpIinXjcevXgtPof1zZRqBpSGcXW6O6QRPOOZUGAmUbaZqK2lI1jZpwzqk0ECjb0BqBtdpqBNo/4EQaCJRtpMTHEOMSDtc3W10URzpc30x6UqzVxVAWiCgQiEi6iLwuIrv8vwd3st0+/72JN4rIup7ur5zB5RLSk2KpqtNAYIWqumYykuOsLoayQKQ1gjuBN40x44E3/c87s8AYM9MYU9DL/ZUDZCbHUVnXZHUxHMfb6uPwsWYyNRA4UqSBYDHwpP/xk8CSKO+vTjEZybFUatNQ1B051oIxkJmsTUNOFGkgGGKMKQPw/87uZDsDvCYi60VkaS/2Vw6RlRxHldYIoq6qvu091xqBM3U7REBE3gCGhlj14x68zlxjTKmIZAOvi8gOY8yaHuyPP4AsBRgxYkRPdlUDSEZyLJV1TRhjEBGri+MYlbVttbAM7Sx2pG4DgTHmvM7WicghEckxxpSJSA5Q3skxSv2/y0VkOTAbWAOEtb9/32XAMoCCggJNT3mKykiOo7HFx7HmVpLidChjtARqBNpZ7EyRNg2tAK7zP74OeLHjBiKSJCIpgcfABcCWcPdXzhJomtCRQ9FV6X+/szQQOFKkgeBu4HwR2QWc73+OiAwTkZX+bYYA74rIJuBj4GVjzKtd7a+cK8PfWVmh/QRRVVnXRIxLdEKZQ0X0XzfGVAELQywvBS72P94LzOjJ/sq5MpMCNQINBNFUVddERnKs9ss4lM4sVraSmdJWI6jUpqGoqqzTOQROpoFA2UogxYHWCKKrrUaggcCpNBAoW4mLcZMSH0OVTiqLqsq6ZjJ16KhjaSBQtpOVHKedxVFkjKGyronMFK0ROJUGAmU7Gcmx2jQURfXNrTR5fTqZzME0ECjbyUiK03kEURQIutpH4FwaCJTtZKbEagbSKAq815pwzrk0ECjbyUiK48ixFrytPquL4giBobo6fNS5NBAo2wlcmR4+ps1D0RBohsvQGoFjaSBQthO4Mg1kxFT9K9A0lJGkNQKn0kCgbCfQaRnIiKn6V1VdE6nxMcTG6NeBU+l/XtlOoIlCRw5FR2W9ppdwOg0Eynbam4Z05FBUVNY2aSBwOA0EynZS42PwuEUTz0VJVX2zdhQ7nAYCZTsiQkZSnNYIoqTSn4JaOZcGAmVLmSmaZiIaWlp9HD3Wok1DDqe3I1K2lJEU1+sMpPur6nlrRzlJcTH8a8HwPi6ZvTS2tPLw6j2My07mnAlZpCV4erT/kfrAHAINBE6mgUDZUkZyLLsO1fZon9e2HuTuV3ewt6IeABGYMiyVqcPS+qOItvD7d/byv2/uAsDtEs4YNZh7L5/B8PTEsPYPZHnVFNTOFlHTkIiki8jrIrLL/3twiG0misjGoJ8aEfmOf93PRKQkaN3FkZRHnTqykuOorG/GGBPW9j6f4T/+sQ1j4KeXTOGlb32etAQPd7+yo59Lap3KuiYeeXsv500ewvO3nMUt88byyWdHeeydvWEfIzBEV1NQO1ukfQR3Am8aY8YDb/qfn8AYU2SMmWmMmQmcDhwDlgdt8pvAemPMyo77K2fKSI6l2eujrskb1vZr9x2m5GgD3zlvPDfMHc203DRuWzCOd3ZV8s6uil6XY2tpNRf85m1+tmIrxUeO9fo4AcYYPtxbxdf+uJbrnviY+jD/vlB+9+YuGlpauXPRJE4fmc73L5zI+VOG8FJhGS1h5mkKTNrTFNTOFmkgWAw86X/8JLCkm+0XAnuMMfsjfF11ijs+lyC8foK/bywlMdbN+VOGtC+75qyR5A1O4Fcrd+DzhVezCLa3oo5rH/+Y8tom/vThfubdu5rvPPNJr0czrdt3mMseep+rln3IxgNHeWdXBTf933qavK09Pta+ynqe/ugzrjxjOOOyk9uXXzYrl8P1zWEHv0AaD60ROFukgWCIMaYMwP87u5vtrwL+0mHZbSJSKCJPhGpaUs7UnmYijC/dJm8rLxeWcuHUoSTGHu/2iotx84MLJ7KtrIYXN5X06PVLjjbw1d9/BMALt3yONXcs4IbPjWLlloN8/2+bwm6yCqiobeLGp9ZRXtPIfy6eyvt3nss9l8/g3d2V3P6XT3qcafXeVUXExrj4znnjT1h+zoQsBid6WP5JaVjHqaxvItbtIiVOuwudrNtAICJviMiWED+Le/JCIhILXAr8LWjxw8BYYCZQBvy6i/2Xisg6EVlXUdH7qr4aGAJNFeHUCFYXVVDT6GXJrNyT1l2SP4xpuan8z6qdYTeXVB9r4Zrff0Rtk5envj6bMVnJDBuUwP/74hR+tGgSq4sq+PvGngWWn63YyrGmVp76+plcc9Yo4j1uLj89j59eMoVVWw/x4+Vbwj5WYfFRXt5cxjfOHkN2SvwJ6zxuF1/MH8br2w6G1axWVdc2mUxEevT3qFNLt4HAGHOeMWZaiJ8XgUMikgPg/13exaEWARuMMYeCjn3IGNNqjPEBjwGzuyjHMmNMgTGmICsrK9y/Tw1QWSnhp5n4+yclZCbHMXdsxknrXC7he+dPpORoAys2hneVfP8/d7Gvqp4nrj/jpBFH1541itNGDOI//rEt7CaiV7cc5OXNZXz7vPEnNOMA3DB3NLfMH8tf1x3g/T2VYR3v4dV7SI2P4cazR4dcv2RWLo0tPlZtOdjtsSrrNL2EirxpaAVwnf/xdcCLXWx7NR2ahQJBxO8yIPzLInVKS/fXCCpqu/6yrW5o4c0d5VwyI4cYd+iP8/yJWUwamsKja/Z021ewr7Kepz7YxxUFwzljVPpJ690u4Z7L8znW1MpPV2zt9u+oPtbCv7+4hSk5qSw9Z0zIbb69cDy5gxL45cvbuy3f3oo6Xt16kGvOGklKfOg5A6eNGMSI9MSwai2VdU3t77VyrkgDwd3A+SKyCzjf/xwRGSYi7SOARCTRv/6FDvvfIyKbRaQQWAB8N8LyqFOEx+1ieHoCu8q7nkvw6pYymr0+LgvRLBQgItw0bww7D9XxVlFXlVa4Z9UOPG4X/3b+hE63GZedwu0Lx/FyYRmvbC7r8ng/f2kbh+ubuefyfDydBKp4j5s7LprI1tIaln/S9Zf3Y+/sxeN2cf3nQtcGoO3vXTJzGO/trqS8trHT7bytPnaX1zEmK6nL11SnvogCgTGmyhiz0Bgz3v/7sH95qTHm4qDtjhljMowx1R32v8YYM90Yk2+MuTTQ8awUQH7eIAqLq7vcZsWmUsZkJjE9t+tJY1/MH0buoAQeeXtPp9us23eYlZsPctM5Y8lOje90O4Cb5o1lem4adzxfyGdVoYeV/m3dAZ7fUMw3549lWjfluyR/GPl5ady7qoiG5tCjiMprGnl+fQmXn57X3nTWmcWzcvEZeLmw81Nqd0UdjS0+ZuQN6vJY6tSnuYaUbeXnplF8pIHDnaSaqGvy8vGnh7lg6tBuOzs9bhc3nj2atfuOsH7/4ZPWG2P4xcvbGZIaxzfO6fxqO/h4D33lNAS45en1NLac+OW942AN//7iFuaMSefbC8eHPkgQl0v48cWTOVjTyOPvhp4Q9sR7+/D6fCw9O3QTU7CxWcmMy07mnzs6rwEFguz0vFN35rUKjwYCZVuBL6jC4qMh17+3u5KWVsP8ieENHrjyjOEMTvTw8OqTawUPrd7DxgNH+d4FE08YgtqV4emJ3HfFTLaW1vDzl7a1L69tbOGWP20gJd7D/VfP6rTvoqMzx2RwwZQhPPjWHtbvP3LCuprGFp7+cD+LpuUwKjO8ppz5E7L46NPDHGsOPXqosPgoyXExjM7QpiGn00CgbCvQnLK5k+ah1UXlpMTFcPrI8KafJMbGcMPc0byxvZwfvbC5/Sr+sTV7uXdVEYtnDuPy0/J6VMbzpgzh5nlj+fNHn3HFox/w1d9/xGUPvc/+qnp+d/Wsk4Z3ducXS6YxJDWO65/4mI0HjgLwWdUxrl72IXXNXm6eNzbsY82fmE2z18cHe6pCrt9cXM203FRcLh066nQ6i0TZVmq8hzFZSRSWnBwIjDGsLqrg8+MzO+2EDeWb88fS2NLKQ6v3UFh8lIWTsrn/n7v5Qn4Ov/7XGb36Uvz+BROobWxhx8FaGnytpCV4+O8v5TNnzMnDWbuTnRrPn78xhyuXfcC1j3/E7QvHc78/qdxj1xT0qBnnjNGDSYx1s7qogoWTh5ywrtnrY3tZLTfMHdXjMqpTjwYCZWv5uWl8uPfkNv2iQ7WUVTfynfN6Nqckxu3ijosmcdqIwfzbsxu5/5+7uWjqUH575cywm3BCHfOXl03v1b6hDBuUwJ9vnMNVyz7kFy9vZ1puKg9/5fSwM4oGxMW4+dzYTN4qKscYc0I/ys5DtTS3+rR/QAEaCJTNTc8bxN83llJe03jCSJ7VRW2zy+dN6C6rSWjnTRnCy7efzZvbD/HlM0f2qFYRDcPTE/nrTXN4Y9shrpo9gniPu1fHmT8xize2H2JPRf0Jk9k2+ftd8nMH9UFp1UBnr0+/Uh3kt3cYn9g89NaOcibnpDI0rWdt8MGGpydy/dzRxMbY8zTIG9xWvt4GAaC9I311h/kTm4urGZToYXh6QkRlVKcGe54BSvlNHZaKSzihn6CmsYX1+4+EPVrIyfIGJzI+O7m9BhVQWFzN9Nw0zTGkAA0EyuYSY2MYn53C5qAhpO/tqsTrMyyY2LtmIadZMCmbjz893H7vg8aWVnYeqm2vbSmlgUDZ3vS8NAqLq9tTP68uqiAlPobTRgyytmADxPwJWTS3+nhvd1tSu21lNXh9hunaP6D8NBAo28vPS6OqvpmSow08+f4+nttQzHmTh/R6lI/TFIxKJz0pln9/cQubDhxtn5ehNQIVoKOGlO3l+3Ph3Pr0BjYVV3Pe5Gx+vniqtYUaQGJjXDx945nc+OQ6rnj0A0ZmJJKZHEdOBB3t6tSil1TK9iYNTSHGJWwqruaW+WN59JqCTlMwq9Am56Sy4ra5zBg+iJ2H6sjP045idZzWCJTtxXvc/PTSqWQlx3LRtJzud1AhZSTH8aevn8lj7+xl9uiT77WgnEsDgRoQrpkz0uoinBJiY1zcumCc1cVQNqNNQ0op5XAaCJRSyuE0ECillMNFFAhE5F9FZKuI+ESkoIvtLhKRIhHZLSJ3Bi1PF5HXRWSX/3d4ieWVUkr1mUhrBFuAfwHWdLaBiLiBB4FFwBTgahGZ4l99J/CmMWY88Kb/uVJKqSiK9Ob1240xRd1sNhvYbYzZa4xpBp4BFvvXLQae9D9+ElgSSXmUUkr1XDT6CHKBA0HPi/3LAIYYY8oA/L87zSImIktFZJ2IrKuoqOhsM6WUUj3U7TwCEXkDGBpi1Y+NMS+G8Rqhpi+aMPY7cQdjlgHLAAoKCnq8v1JKqdC6DQTGmPMifI1iYHjQ8zyg1P/4kIjkGGPKRCQHKD9p7xDWr19fKSL7e1meTKCyl/ueKpz+Hjj97wd9D8CZ70HImZnRmFm8FhgvIqOBEuAq4Mv+dSuA64C7/b/DqWFgjOn1HUlEZJ0xptMRTk7g9PfA6X8/6HsA+h4Ei3T46GUiUgycBbwsIqv8y4eJyEoAY4wXuA1YBWwHnjXGbPUf4m7gfBHZBZzvf66UUiqKIqoRGGOWA8tDLC8FLg56vhJYGWK7KmBhJGVQSikVGSfOLF5mdQFswOnvgdP/ftD3APQ9aCeB2/8ppZRyJifWCJRSSgVxVCDoLOeRE4jIcBF5S0S2+/NDfdvqMllFRNwi8omIvGR1WaJNRAaJyHMissP/WTjL6jJFm4h8138ObBGRv4iI4+/Z6ZhA0E3OIyfwAt8zxkwG5gC3OuzvD/Zt2kawOdH/Aq8aYyYBM3DY+yAiucDtQIExZhrgpm1Iu6M5JhDQdc6jU54xpswYs8H/uJa2L4Dcrvc69YhIHvAF4PdWlyXaRCQVOAd4HMAY02yMOWppoawRAySISAyQyPEJro7lpEDQVc4jRxGRUcAs4COLi2KF3wJ3AD6Ly2GFMUAF8Ad/09jvRSTJ6kJFkzGmBPgf4DOgDKg2xrxmbams56RA0Cc5jwY6EUkGnge+Y4ypsbo80SQiXwTKjTHrrS6LRWKA04CHjTGzgHoclvrdf8+TxcBoYBiQJCJftbZU1nNSIOgq55EjiIiHtiDwtDHmBavLY4G5wKUiso+2psFzReRP1hYpqoqBYmNMoCb4HG2BwUnOAz41xlQYY1qAF4DPWVwmyzkpELTnPBKRWNo6iFZYXKaoERGhrW14uzHmPqvLYwVjzI+MMXnGmFG0/f//aYxxzNWgMeYgcEBEJvoXLQS2WVgkK3wGzBGRRP85sRCHdZiHEo2kc7ZgjPGKSCDnkRt4IijnkRPMBa4BNovIRv+yu/zpP5RzfAt42n8xtBe4weLyRJUx5iMReQ7YQNtIuk/QGcY6s1gppZzOSU1DSimlQtBAoJRSDqeBQCmlHE4DgVJKOZwGAqWUcjgNBEop5XAaCJRSyuE0ECillMP9f9q/TZZwwJ+lAAAAAElFTkSuQmCC\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x, h1+h3+h5+h7+h9)" ] }, { "cell_type": "code", "execution_count": 103, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 103, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "# sawtooth wave\n", "\n", "h2 = np.sin(2*x)/2 \n", "h4 = np.sin(4*x)/4 \n", "h6 = np.sin(6*x)/6 \n", "h8 = np.sin(8*x)/8\n", "\n", "\n", "plt.plot(x, h1)\n", "plt.plot(x, h1+h2)\n", "plt.plot(x, h1+h2+h3)\n", "plt.plot(x, h1+h2+h3+h4)\n", "plt.plot(x, h1+h2+h3+h4+h5)\n", "plt.plot(x, h1+h2+h3+h4+h5+h6)\n", "plt.plot(x, h1+h2+h3+h4+h5+h6+h7)\n", "plt.plot(x, h1+h2+h3+h4+h5+h6+h7+h8)\n", "plt.plot(x, h1+h2+h3+h4+h5+h6+h7+h8+h9)" ] }, { "cell_type": "code", "execution_count": 130, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 130, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": { "needs_background": "light" }, "output_type": "display_data" } ], "source": [ "plt.plot(x, h1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "นอกจากนี้ยังมีฟังก์ชันสำหรับเปลี่ยนหน่วยที่ใช้ในตรีโกณมิติ คือ deg2rad() หรือ radians() ใช้สำหรับเปลี่ยนจากองศาเป็นเรเดียน และ rad2deg() หรือ degrees() สำหรับเปลี่ยนจากเรเดียนเป็นองศา" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## [Exercise]" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "1. จากเวกเตอร์ต่อไปนี้ จงหาผลลัพธ์ของการลบเวกเตอร์ **u-v** จากนั้น พล็อตเวกเตอร์โดยใช้ฟังก์ชั่น Plotvec1" ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [], "source": [ "u = np.array([2, 0])\n", "v = np.array([0, 2])\n", "# Write your code below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "z = u - v\n", "print(z)\n", "Plotvec1(u, z, v)\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "2. จงคูณ Numpy array **z** ด้วย $-\\pi$" ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [], "source": [ "z = np.array([2, 4])\n", "# Write your code below and press Shift+Enter to execute\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "k = -np.pi * z\n", "print(k)\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "3. กำหนดให้มีสิสต์ \\[1, 2, 3, 4, 5] และ \\[5, 4, 3, 2, 1] จงก๊อปปี๊ลิสต์ทั้งสองให้เป็นชนิด Numpy array จากนั้นนำไปคูณกัน\n" ] }, { "cell_type": "code", "execution_count": 106, "metadata": {}, "outputs": [], "source": [ "# Write your code below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "\n", "a = np.array([1, 2, 3, 4, 5])\n", "b = np.array([5, 4, 3, 2, 1])\n", "a * b # Output: array([5, 8, 9, 8, 5])\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "4. จงเขียนโค้ดเปลี่ยนลิสต์ \\[-2, 2] และ \\[1, 1] ให้เป็น Numpy arrays a และ b จากนั้น พล็อตอาร์เรย์ให้เป็นเวกเตอร์โดยใช้ฟังก์ชั่น Plotvec2 และหาผลลัพธ์ของการคูณแบบ dot product" ] }, { "cell_type": "code", "execution_count": 107, "metadata": {}, "outputs": [], "source": [ "# Write your code below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "a = np.array([-2, 2])\n", "b = np.array([1, 1])\n", "Plotvec2(a, b)\n", "print(\"The dot product is\", np.dot(a,b))\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "5. จงเขียนโค้ดเปลี่ยนลิสต์ \\[2, 0] และ \\[0, 3] ให้เป็น Numpy arrays a และ b จากนั้น พล็อตอาร์เรย์ให้เป็นเวกเตอร์โดยใช้ฟังก์ชั่น Plotvec2 และหาหาผลลัพธ์ dot product\n" ] }, { "cell_type": "code", "execution_count": 108, "metadata": {}, "outputs": [], "source": [ "# Write your code below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "a = np.array([2, 0])\n", "b = np.array([0, 3])\n", "Plotvec2(a, b)\n", "print(\"The dot product is\", np.dot(a, b))\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "6. จงเขียนโค้ดเปลี่ยนลิสต์ \\[2, 2] และ \\[0, 2] ให้เป็น Numpy arrays a และ b จากนั้น พล็อตอาร์เรย์ให้เป็นเวกเตอร์โดยใช้ฟังก์ชั่น Plotvec2 และหาผลลัพธ์ dot product\n" ] }, { "cell_type": "code", "execution_count": 109, "metadata": {}, "outputs": [], "source": [ "# Write your code below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "a = np.array([2, 2])\n", "b = np.array([0, 2])\n", "Plotvec2(a, b)\n", "print(\"The dot product is\", np.dot(a, b))\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "7. เพราะเหตุใดผลลัพธ์ของการคูณแบบ dot product ของ \\[-2, 2] กับ \\[1, 1] (ข้อ 4) และ dot product ของ \\[2, 0] กับ \\[0, 3] (ข้อ 5) จึงเป็นศูนย์ ในขณะที่ dot product ของ \\[2, 2] กับ \\[0, 2] (ข้อ 6) ได้ผลลัพธ์ไม่เป็นศูนย์? " ] }, { "cell_type": "code", "execution_count": 110, "metadata": {}, "outputs": [], "source": [ "# Write your answer below and press Shift+Enter to execute\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "
Click here for the solution\n", "\n", "```python\n", "\n", "เพราะเวกเตอร์ในคำถามข้อที่ 4 และ 5 ตั้งฉาก จึงได้ผลคูณดอทเป็นศูนย์\n", "\n", "```\n", "\n", "
\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### สรุปข้อแตกต่างระหว่างอาเรย์กับลิสต์\n", "\n", "- อาเรย์จะต้องประกอบด้วยข้อมูลเพียงชนิดเดียวเท่านั้น\n", "- อาเรย์สามารถคำนวณทางคณิตศาสตร์ได้โดยตรง\n", "- อาเรย์คำนวณได้เร็วกว่า\n", "- อาเรย์มีวิธีการเข้าถึงข้อมูลภายในได้ยืดหยุ่นกว่า\n", "- อาเรย์มีคุณสมบัติการถ่ายทอดภายในชิ้นส่วนประกอบ\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "---" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Author\n", "\n", "S.C.\n", "\n", "### Change Log\n", "\n", " \n", "| Date | Version | Change Description |\n", "|---|---|---|\n", "| 08-08-2021 | 0.1 | First edition |\n", "| | | |\n", "| | | |\n" ] } ], "metadata": { "kernelspec": { "display_name": "Python 3 (ipykernel(3.8.13))", "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.8.13" }, "latex_envs": { "LaTeX_envs_menu_present": true, "autoclose": false, "autocomplete": true, "bibliofile": "biblio.bib", "cite_by": "apalike", "current_citInitial": 1, "eqLabelWithNumbers": true, "eqNumInitial": 1, "hotkeys": { "equation": "Ctrl-E", "itemize": "Ctrl-I" }, "labels_anchors": false, "latex_user_defs": false, "report_style_numbering": false, "user_envs_cfg": false }, "toc": { "base_numbering": 1, "nav_menu": {}, "number_sections": true, "sideBar": true, "skip_h1_title": true, "title_cell": "Table of Contents", "title_sidebar": "Contents", "toc_cell": false, "toc_position": {}, "toc_section_display": true, "toc_window_display": false } }, "nbformat": 4, "nbformat_minor": 4 }