{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# Numpyの使用\n",
    "\n",
    "### Numpyとは\n",
    "\n",
    "数値計算のためのPythonのライブラリです。特に、多次元配列の生成や、配列の一括計算、行列とベクトルの演算ができます。\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 1. Numpyのインポートと配列の生成\n",
    "\n",
    "以下のコードではNumpyをインポートして、エイリアス（別名）をnpとします。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "\n",
    "#エイリアスは自由に作れます。例えば、\n",
    "import numpy as mynp"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpyによる1次元配列を作成します。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5 6 7 8]\n",
      "[1 2 3 4 5 6 7 8]\n"
     ]
    }
   ],
   "source": [
    "n_list = [1,2,3,4,5,6,7,8]\n",
    "n_array = np.array(n_list)\n",
    "print(n_array)\n",
    "\n",
    "#または、\n",
    "n_array = np.array([1,2,3,4,5,6,7,8])\n",
    "print(n_array)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpyによる2次元配列を作成します。[ ]の使用方法に注意してください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "array([[1, 2, 3, 4],\n",
       "       [5, 6, 7, 8]])"
      ]
     },
     "execution_count": 3,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "n_array2 = np.array([[1,2,3,4],[5,6,7,8]])\n",
    "print(n_array2)\n",
    "n_array2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpyは、いくつかの便利な配列の作成関数を提供しています。\n",
    "\n",
    "- linspace(a, b, num) : 区間[a,b]の(num-1)等分割を作成します。作成した数列の成分の数はnumになります。\n",
    "- arange(a, b, step) : aからbまで間隔がstepである数列を作成します。特に、bは配列に入らないことに注意してください。\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9 1. ]\n",
      "[0.  0.1 0.2 0.3 0.4 0.5 0.6 0.7 0.8 0.9]\n"
     ]
    }
   ],
   "source": [
    "a = 0\n",
    "b = 1\n",
    "x1 = np.linspace(a, b, 11)\n",
    "x2 = np.arange(a, b, 0.1)\n",
    "print(x1)\n",
    "print(x2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### 配列のサイズと次元を調べる\n",
    "\n",
    "Numpyの配列はshapeとndimという属性を持っています。これらを使って、配列のサイズと次元を調べることができます。\n",
    "\n",
    "- shape : 配列の行の数、列の数\n",
    "- ndim : 配列の次元\n",
    "\n",
    "**注意** \n",
    "- shapeとndimの後に()は必要ありません。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "xのサイズ： (2, 4)\n",
      "xの次元： 2\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3,4],[5,6,7,8]])\n",
    "print(x)\n",
    "print(\"xのサイズ：\", x.shape)\n",
    "print(\"xの次元：\", x.ndim)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# 配列の成分へのアクセス\n",
    "\n",
    "配列の成分にアクセスするために、以下の方法が使用されます。\n",
    "\n",
    "- x[m,n] : xのm行目、n列目の成分\n",
    "- x[m] : xのm行目\n",
    "- x[:,n] : xのn列目（ここで「:」は「すべて」を意味しています。）\n",
    "\n",
    "行と列の番号は0から数えることに注意してください。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2 3 4]\n",
      " [5 6 7 8]]\n",
      "xの1行目、3列目の成分： 8\n",
      "xの1行目のすべての成分： [5 6 7 8]\n",
      "xの1列目のすべての成分： [2 6]\n",
      "xの1列目のすべての成分を0にします。\n",
      "[[1 0 3 4]\n",
      " [5 0 7 8]]\n"
     ]
    }
   ],
   "source": [
    "x = np.array([[1,2,3,4],[5,6,7,8]])\n",
    "print(x)\n",
    "\n",
    "print(\"xの1行目、3列目の成分：\", x[1,3])\n",
    "print(\"xの1行目のすべての成分：\", x[1])\n",
    "print(\"xの1列目のすべての成分：\", x[:,1])\n",
    "\n",
    "print(\"xの1列目のすべての成分を0にします。\")\n",
    "x[:,1] = 0\n",
    "print(x)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 2. Numpyの配列の一括計算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpyは多くの数学の関数を提供しています。mathライブラリとは異なり、配列の各成分に関して一括計算ができます。\n",
    "\n",
    "以下の例では、[0, 2*pi]の分割に関してsin関数の値を計算します。計算した数列を利用して、sin関数のグラフの描画ができます。\n",
    "\n",
    "**比較**\n",
    "-  mathライブラリでは、math.sin(x1)はエラーとなります。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[0.         0.31415927 0.62831853 0.9424778  1.25663706 1.57079633\n",
      " 1.88495559 2.19911486 2.51327412 2.82743339 3.14159265 3.45575192\n",
      " 3.76991118 4.08407045 4.39822972 4.71238898 5.02654825 5.34070751\n",
      " 5.65486678 5.96902604 6.28318531]\n",
      "[ 0.00000000e+00  3.09016994e-01  5.87785252e-01  8.09016994e-01\n",
      "  9.51056516e-01  1.00000000e+00  9.51056516e-01  8.09016994e-01\n",
      "  5.87785252e-01  3.09016994e-01  1.22464680e-16 -3.09016994e-01\n",
      " -5.87785252e-01 -8.09016994e-01 -9.51056516e-01 -1.00000000e+00\n",
      " -9.51056516e-01 -8.09016994e-01 -5.87785252e-01 -3.09016994e-01\n",
      " -2.44929360e-16]\n"
     ]
    }
   ],
   "source": [
    "x1 = np.linspace(0, 2*np.pi, 21)\n",
    "y1 = np.sin(x1)\n",
    "print(x1)\n",
    "print(y1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x1,y1,'r-o')\n",
    "plt.grid()"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Numpyで作成した配列の四則演算やべき乗も一括計算ができます。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[1 2 3 4 5]\n",
      "[ 2  4  6  8 10]\n",
      "[ 2  4  6  8 10]\n",
      "[ 1  4  9 16 25]\n"
     ]
    }
   ],
   "source": [
    "a = np.array([1,2,3,4,5])\n",
    "b = a+a\n",
    "c = 2*a\n",
    "d = a**2\n",
    "print(a)\n",
    "print(b)\n",
    "print(c)\n",
    "print(d)\n",
    "\n",
    "#注意：以下のコードでは、a2はNumpyを使わない通常のリストであるので、一括計算ができません。\n",
    "#特に、リストに対して「+」と「*」の演算子は別の意味を持ちます。\n",
    "# a2 = [1,2,3,4,5]\n",
    "# b2 = a2+a2\n",
    "# print(b2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 演習1\n",
    "\n",
    "Numpyを利用して、以下の関数のグラフを描いてください。\n",
    "$$\n",
    "f(x)=\\sin(x^3)\\cos(x)+1, \\quad x \\in [1,2]\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 3. Numpyの便利な関数\n",
    "\n",
    "Numpyでは、abs、min、maxなどの数学関数が提供されています。以下のコードで使用している関数を確認してください。\n",
    "\n",
    "Numpyのすべての関数\n",
    "- LINK: https://numpy.org/doc/stable/reference/index.html\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最大値： 1.0\n",
      "最小値： -1.0\n",
      "平均値： 0.1435080831458535\n",
      "総和： 3.0136697460629236\n",
      "絶対値： [0.00000000e+00 3.82683432e-01 7.07106781e-01 9.23879533e-01\n",
      " 1.00000000e+00 9.23879533e-01 7.07106781e-01 3.82683432e-01\n",
      " 1.22464680e-16 3.82683432e-01 7.07106781e-01 9.23879533e-01\n",
      " 1.00000000e+00 9.23879533e-01 7.07106781e-01 3.82683432e-01\n",
      " 2.44929360e-16 3.82683432e-01 7.07106781e-01 9.23879533e-01\n",
      " 1.00000000e+00]\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "x = np.linspace(0,2.5*np.pi,21)\n",
    "y = np.sin(x)\n",
    "\n",
    "import matplotlib.pyplot as plt\n",
    "plt.plot(x,y,'ro')\n",
    "plt.grid()\n",
    "\n",
    "print(\"最大値：\", np.max(y))\n",
    "print(\"最小値：\", np.min(y))\n",
    "print(\"平均値：\", np.average(y))\n",
    "print(\"総和：\", np.sum(y))\n",
    "\n",
    "print(\"絶対値：\", np.abs(y))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 4. 行列の積\n",
    "\n",
    "Numpyでは2次元配列は行列に対応しており、行列自身に関する演算や、行列（ベクトル）の積などの演算ができます。\n",
    "\n",
    "- 行列の転置：transpose()\n",
    "- 行列のトレース：trace()\n",
    "- 行列の逆行列：linalg.inv(A)（ここでは、Numpyの子ライブラリの関数を使用します。）\n",
    "- 行列（ベクトル）の積：「@」演算子、またはdot()\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "[[1 2]\n",
      " [3 4]]\n",
      "Aの転置：\n",
      " [[1 3]\n",
      " [2 4]]\n",
      "Aのトレース：\n",
      " 5\n",
      "Aの逆行列：\n",
      " [[-2.   1. ]\n",
      " [ 1.5 -0.5]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[1,2],[3,4]])\n",
    "print(A)\n",
    "\n",
    "print(\"Aの転置：\\n\", A.transpose())\n",
    "print(\"Aのトレース：\\n\", A.trace())\n",
    "print(\"Aの逆行列：\\n\", np.linalg.inv(A))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "行列:\n",
      " [[2 0]\n",
      " [0 4]]\n",
      "ベクトル:\n",
      " [[1]\n",
      " [2]]\n",
      "行列Aとベクトルxの積 (@演算子を使用)：\n",
      " [[2]\n",
      " [8]]\n",
      "行列Aとベクトルxの積 (dot()関数を使用)：\n",
      " [[2]\n",
      " [8]]\n"
     ]
    }
   ],
   "source": [
    "A = np.array([[2,0],[0,4]])\n",
    "x = np.array([[1],[2]])\n",
    "print(\"行列:\\n\",A)\n",
    "print(\"ベクトル:\\n\",x)\n",
    "\n",
    "y=A@x\n",
    "print(\"行列Aとベクトルxの積 (@演算子を使用)：\\n\",y)\n",
    "y=A.dot(x)\n",
    "print(\"行列Aとベクトルxの積 (dot()関数を使用)：\\n\",y)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 演習2（option） \n",
    "\n",
    "$[0,1]$の100分割を用いて、以下の関数の積分の近似値を求めてください。ただし、forループは使用せず、Numpyの関数sin、sumなどを使用してください。\n",
    "\n",
    "$$\n",
    "\\int_{0}^1 \\sin(x^3) \\,dx\n",
    "$$"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## 演習3（option）\n",
    "\n",
    "以下の行列 $A$ とベクトル $b$ に関する連立一次方程式 $Ax=b$ の解を計算してください。\n",
    "\n",
    "$$\n",
    "A = \\left(\n",
    "\\begin{array}{ccc}\n",
    "2 & 1 & 0 \\\\\n",
    "1 & 2 & 1 \\\\\n",
    "0 & 1 & 2 \\\\\n",
    "\\end{array}\n",
    "\\right)\n",
    ",\\quad \n",
    "b = \\left(\n",
    "\\begin{array}{c}\n",
    "1\\\\\n",
    "2\\\\\n",
    "3\\\\\n",
    "\\end{array}\n",
    "\\right)\n",
    "$$\n",
    "\n",
    "ヒント：\n",
    "- numpy.linalg.inv()を利用して行列の逆行列を求めれば、連立一次方程式の解を計算できます。\n",
    "- numpy.linalg.solve()について調べて利用することも可能です。\n"
   ]
  },
  {
   "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}