{ "cells": [ { "cell_type": "markdown", "metadata": {}, "source": [ "# Day 3\n", "## Library `math`\n", "- It has the fixed value $\\pi$ and functions `sin`, `cos`, `tan`, `exp`, `log` etc.\n", "- Please see the following example." ] }, { "cell_type": "code", "execution_count": 8, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "3.141592653589793\n", "1.0\n", "7.38905609893065\n", "2.0\n" ] } ], "source": [ "import math\n", "\n", "print(math.pi)\n", "print(math.sin(math.pi * 0.5))\n", "et = math.exp(2.0)\n", "print(et)\n", "print(math.log(et))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Try to use such functions." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Bisection method\n", "\n", "### Assumption\n", "- Assume that $f(x)$ is monotone increasing function.\n", "- We solve $f(x) = 0$.\n", "- For initial values $a$ and $b$, we have $f(a) < 0$ and $f(b) > 0$.\n", "- The precision of answer is $\\varepsilon$.\n", "### Algorithm\n", "0. $x = (a + b) / 2$\n", "0. If $b - a < \\varepsilon$, stop the algorithrm and $x$ is answer.\n", "0. If $f(x) > 0$, let $b = x$.\n", "0. If $f(x) < 0$, let $a = x$.\n", "0. If $f(x) = 0$, stop the algorithrm and $x$ is answer.\n", "0. Go to 1. \n", "\n", "\n", "### Practice\n", "- Solve the following by bisection method.\n", "$$\n", "\\sin(x) + x - 1 = 0\n", "$$\n", "- The lower initila value is 0 and the upper initial value $\\pi / 2$.\n", "- $\\varepsilon = 10^{-6}$" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "# Vector and matrix calculation\n", "\n", "## Library `numpy`\n", "- ndarray (array of numpy) is similar to list.\n", "- Calulation of np.array is faster than them.\n", "- `dtype` should be set if it is not `int`. Mix of type is not allowed." ] }, { "cell_type": "code", "execution_count": 9, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "[1. 2. 3. 4. 5.]\n", "[[ 5. 3. -1. 4. 5.]\n", " [ 1. 4. 5. 3. 2.]\n", " [-1. 0. 5. 2. 2.]]\n", "v1.size = 5\n", "m1.size = 15\n", "len(v1) = 5\n", "len(m1) = 3\n", "v1.shape = (5,)\n", "m1.shape = (3, 5)\n", "Number of rows of m1 = 3\n", "Number of columns of m1 = 5\n", "v1[2] = 3.0\n", "m1[1,2] = 5.0\n", "m1[0:2,1:3] = [[ 3. -1.]\n", " [ 4. 5.]]\n", "np.zeros(2) = [0. 0.]\n", "np.zeros((2, 3)) = [[0. 0. 0.]\n", " [0. 0. 0.]]\n", "np.ones(2) = [1. 1.]\n", "np.ones((2, 3)) = [[1. 1. 1.]\n", " [1. 1. 1.]]\n" ] }, { "ename": "NameError", "evalue": "name 'ar2' 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\u001b[0m in \u001b[0;36m\u001b[0;34m()\u001b[0m\n\u001b[1;32m 40\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"np.ones((2, 3)) = {0}\"\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mformat\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mones\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;36m2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m3\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 41\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 42\u001b[0;31m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mnp\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mdot\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mar2\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0mar1\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 43\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mar2\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m1\u001b[0m\u001b[0;34m]\u001b[0m\u001b[0;34m[\u001b[0m\u001b[0;36m2\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 'ar2' is not defined" ] } ], "source": [ "import numpy as np\n", "\n", "v1 = np.array([1, 2, 3, 4, 5], dtype='float')\n", "v2 = np.array([2, -1, 3, 3, -2], dtype = 'float')\n", "m1 = np.array([[5, 3, -1, 4, 5],[1, 4, 5, 3, 2],[-1, 0, 5, 2, 2]], dtype='float')\n", "m2 = np.array([[1, 3, -2],[1, -2, 5]], dtype='float')\n", "print(v1)\n", "print(m1)\n", "\n", "# Size\n", "print(\"v1.size = {0}\".format(v1.size))\n", "print(\"m1.size = {0}\".format(m1.size))\n", "\n", "# Len\n", "print(\"len(v1) = {0}\".format(len(v1)))\n", "print(\"len(m1) = {0}\".format(len(m1)))\n", "\n", "# Shape\n", "print(\"v1.shape = {0}\".format(v1.shape))\n", "print(\"m1.shape = {0}\".format(m1.shape))\n", "\n", "(rowM1, colM1) = m1.shape\n", "\n", "print(\"Number of rows of m1 = {0}\".format(rowM1))\n", "print(\"Number of columns of m1 = {0}\".format(colM1))\n", "\n", "# An element\n", "print(\"v1[2] = {0}\".format(v1[2]))\n", "print(\"m1[1,2] = {0}\".format(m1[1,2]))\n", "\n", "# Extract elements\n", "print(\"m1[0:2,1:3] = {0}\".format(m1[0:2,1:3]))\n", "\n", "# Make zero matrix\n", "print(\"np.zeros(2) = {0}\".format(np.zeros(2)))\n", "print(\"np.zeros((2, 3)) = {0}\".format(np.zeros((2, 3))))\n", "\n", "# Make a matrix with all elements 1\n", "print(\"np.ones(2) = {0}\".format(np.ones(2)))\n", "print(\"np.ones((2, 3)) = {0}\".format(np.ones((2, 3))))\n", "\n", "print(np.dot(ar2, ar1))\n", "print(ar2[1][2])" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Calculate the innerproduct of `v1` and `v2` by using `for` sentence.\n", "- Calculate the product of `m1` and `v1` by using `for` sentence.\n", "- Calculate the product of `m1` and `m2` by using `for` sentence." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Inner product\n", "\n", "\n", "# Multiplicastion of a matrix and a vector\n", "\n", "\n", "# Multiplicastion of a matrix and a vector\n", "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### dot product\n", "- Inner product and matrix multiplication can be done easily." ] }, { "cell_type": "code", "execution_count": 3, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "11.0\n", "11.0\n", "[1. 2. 3. 4. 5.]\n" ] } ], "source": [ "print(np.dot(v1, v2))\n", "print(v1.dot(v2))\n", "print(v1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Try dot product for matrix and vector multiplication.\n", "- Try dot product for matrix and matrix multiplication." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Make functions to do selection sort in both ascending and descending orders for given data in ndarray." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "\n", "def sortSelectAscend(ar):\n", " # Make its content\n", "\n", "def sortSelectDescend(ar):\n", " # Make its content\n", "\n", " \n", "ar1 = np.array([10, -2, 13, 42, 35, 23, -23, 12, 12])\n", "print(ar1)\n", "sortSelectAscend(ar1)\n", "print(ar1)\n", "sortSelectDescend(ar1)\n", "print(ar1)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## Statistics\n", "### Practice\n", "- Calulate mean, variance, standard deviation, and median for given data in `ndarray` by using `for` sentence.\n", "- Median : If the number of data $N$ is odd, the $(N+1)/2$-th largest data. If it is even, the average of $N$-th and $(N+1)$-th largest data." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "data = np.array([10, 21, 34, 4, 15, 16, 7], dtype='float') # The given data\n", "\n", "N = len(data)\n", "# Mean\n", "\n", "# Variace\n", "\n", "# Standard deviation\n", "\n", "print(\"Mean: {0:.2f}, Variance: {1:.2f}, Standard deviation: {2:.2f}\".format(mean, variance, stdev))\n", "\n", "# Median\n", "# Selection sort\n", "\n", "print('Median: {0:.2f}'.format(median))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- They can be calculated by using library of `statistics`" ] }, { "cell_type": "code", "execution_count": 4, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ "Mean: 15.29, Variance: 101.24, Standard deviation: 10.06\n", "Median: 15.00\n" ] } ], "source": [ "import statistics as st\n", "import numpy as np\n", "\n", "data = np.array([10, 21, 34, 4, 15, 16, 7], dtype='float')\n", "mean = st.mean(data)\n", "variance = st.variance(data)\n", "stdev = st.stdev(data)\n", "median = st.median(data)\n", "print(\"Mean: {0:.2f}, Variance: {1:.2f}, Standard deviation: {2:.2f}\".format(mean, variance, stdev))\n", "print('Median: {0:.2f}'.format(median))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Program to describe a histgram of random values of a uniform distribution and print mean and standard deviation\n", "- Its true values are 0.5 and $1 / \\sqrt{12}$, respectively." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "import numpy as np\n", "import statistics as st\n", "import matplotlib.pyplot as plt\n", " \n", "N = 10000\n", "# Generate N random values of unifrom distibution between 0 and 1\n", "data = np.random.rand(N)\n", " \n", "# Output graph\n", "plt.hist(data)\n", "\n", "mean = st.mean(data)\n", "stdev = st.stdev(data)\n", "print(\"Mean: {0:.2f}, Standard deviation: {1:.2f}, 1 / sqrt(12) = {2}\".format(mean, stdev, 1.0 / np.sqrt(12.0)))\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Make random values of au niform distribution of which mean is 0 and standard deviation is 1." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Draw graph of a normal distribution." ] }, { "cell_type": "code", "execution_count": 6, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 6, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "mean = 50.0\n", "stdv = 10.0\n", "x = np.arange(0, 100, 0.1)\n", "pdfn = np.exp(-(x - mean) * (x - mean) / (2.0 * stdv * stdv)) / (np.sqrt(2.0 * np.pi) * stdv)\n", "plt.plot(x, pdfn)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "- Draw graph of a normal distribution and a histgram of random values of normal distribution." ] }, { "cell_type": "code", "execution_count": 7, "metadata": {}, "outputs": [ { "data": { "text/plain": [ "[]" ] }, "execution_count": 7, "metadata": {}, "output_type": "execute_result" }, { "data": { "image/png": "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\n", "text/plain": [ "
" ] }, "metadata": {}, "output_type": "display_data" } ], "source": [ "import numpy as np\n", "import matplotlib.pyplot as plt\n", "\n", "mean = 50.0\n", "stdv = 10.0\n", "N = 10000\n", "\n", "# Generate N random values of normal distibution of average mean and stardard deviation stdv\n", "data = np.random.normal(mean, stdv, N)\n", "\n", "# Probability density function of normal distribution\n", "x = np.arange(0, 100, 0.1)\n", "pdfn = np.exp(-(x - mean) * (x - mean) / (2.0 * stdv * stdv)) / (np.sqrt(2.0 * np.pi) * stdv)\n", "\n", "# Output graph\n", "NBin = 50 # Number of bins\n", "RangeBin = [20, 80] # Range of bins\n", "plt.hist(data, NBin, RangeBin)\n", "plt.plot(x, N * (RangeBin[1] - RangeBin[0]) / float(NBin) * pdfn)\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Central limit theorem\n", "- Assume that $X_1,\\,X_2,\\,\\ldots,¥, X_N$ are independent random variable of identical distribution.\n", "- Then, \n", "$$\n", "\\frac{X_1+ X_2 + \\cdots + X_N}{\\sqrt{N}}\n", "$$\n", "converges to a random variable of a normal distribution of which mean and standard deviation are respectively the same as those of original distribution when $N \\rightarrow \\infty$.\n", "\n", "\n", "### Practice\n", "By drawing the histgram of sum of random values of the uniform distribution of which mean is 0 divided by $\\sqrt{N}$ and standard deviation is 1 and the graph of probability density function of the starndard normal distribution." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# Central limit theorem\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "## File input/output\n", "\n", "- `open(filePath, mode)` : to open file.\n", "- `(object of io.TextIOWrapper).write()` : write data to the file.\n", "- `(object of io.TextIOWrapper).readline()` : read a line" ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [ "# File \n", "import numpy as np\n", "N = 100\n", "with open('data1.txt', mode='w') as fw:\n", " fw.write(str(N)+\"\\n\") # \\ = Option ¥\n", " for loop in range(0, N):\n", " n = int(1000 * np.random.rand())\n", " fw.write(str(n)+\"\\n\") # \\ = Option ¥\n", " \n", "with open('data1.txt', mode='r') as fr:\n", " sVal = fr.readline()\n", " Nr = int(sVal)\n", " data = np.zeros(Nr, dtype='int')\n", " pos = 0\n", " sVal = fr.readline()\n", " while sVal:\n", " data[pos] = int(sVal)\n", " sVal = fr.readline()\n", " pos += 1\n", "\n", "print(data)" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ "### Practice\n", "- Make a program to read file `data1.txt` in `ndarray` and sort it in both order. (Copy data to another ndarrary before sort.)\n", "- Make a program to read file `data1.txt` in `ndarray` and mean, variance, standard deviation, and median." ] }, { "cell_type": "code", "execution_count": null, "metadata": {}, "outputs": [], "source": [] } ], "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.6.4" } }, "nbformat": 4, "nbformat_minor": 2 }