7_SciPy_optimize.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# `SciPy.optimize`：解の求め方と最適化問題"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "<div name=\"html-admonition\" style=\"font-size: 0.8em\">\n",
    "<input type=\"button\" onclick=\"location.href='https://translate.google.com/translate?hl=&sl=ja&tl=en&u='+window.location;\" value=\"Google translation\" style=\"color:#ffffff;background-color:#008080; height:25px\" onmouseover=\"this.style.background='#99ccff'\" onmouseout=\"this.style.background='#008080'\"/> in English or the language of your choice.\n",
    "</div><br>"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "import numpy as np\n",
    "import scipy.optimize as op\n",
    "import pandas as pd\n",
    "\n",
    "# 警告メッセージを非表示\n",
    "import warnings\n",
    "warnings.filterwarnings(\"ignore\")"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## はじめに"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "線形の方程式の解を求めることは比較的簡単である。１変数の場合，式を変形すれば解を簡単に求めることができる。変数が複数ある場合でも，[「連立一次方程式の解」の節](sec:2-simultaneousEq)で説明したように，`numpy.linalg`を使えば簡単に解を求めることができる。例えば，[差分方程式と経済分析](https://py4macro.github.io/7_DifferenceEq.html)で扱う45度線モデルと蜘蛛の巣モデルは線形であるため、長期的な均衡の値を簡単に計算することができる。またソロー・モデルも線形ではないが、定常状態の資本ストック（$k_*$）について解くことができるので、長期的な値を計算することが可能である。しかし非線形モデルによっては、長期的均衡の値を簡単に求めることができない場合もあり、その場合に使う手法をここで説明する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "コードを書いて非線形の方程式の解を求めるには色々な方法があるり，ここではその代表的な方法の考え方についてまず説明する。その後`SciPy`（「サイパイ」と読み，Scientific Pythonの略）というパッケージにある`optimize`というモジュールを紹介する。`SciPy`は`NumPy`の大幅な拡張版と理解して良いだろう。`SciPy`を読み込むと`NumPy`の関数などを利用できるようになる。しかし`SciPy`は大きなパッケージであり，全てを読み込む必要もない。従って，`NumPy`を読み込んで`SciPy`のサブパッケージや関数を読み込むということで十分であろう。そして`SciPy`のモジュール`optimize`に非線形の方程式の解を簡単に求めることができる関数が含まれている。もちろんこれらの関数は線形の方程式の解を求める為にも使える。また`scipy.optimize`には最適化問題のための関数も用意されており，`Python`で経済学を学ぶ為には必須となるツールと言えるだろう。消費者の効用最大化問題やソロー・モデルの資本の黄金律水準などに応用して使い方を説明する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 解の求め方と考え方"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Bisection法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Bisection法の考え方について説明するために，次の関数を考えよう。\n",
    "\n",
    "$$f(x)=x^3+4x^2-3$$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f(x):\n",
    "    return x**3 + 4*x**2 -3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に３つの変数`a`，`b`，`c`に下の値を割り当てる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = -3.0\n",
    "b = -0.5\n",
    "c = 0.5*(a+b)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$x$が`a`，`b`，`c`の値を取る場合の$f(x)$の値を計算してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(6.0, -2.125, 3.890625)"
      ]
     },
     "execution_count": 4,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "f(a), f(b), f(c)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これらの情報を図示すると次のようになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {
    "hidden": true
   },
   "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": [
    "x = np.linspace(-3.1, 0, 100)          # 1\n",
    "\n",
    "df1 = pd.DataFrame({'X':x, 'Y':f(x)})  # 2\n",
    "\n",
    "ax = df1.plot('X','Y')     # 3\n",
    "\n",
    "ax.axhline(0, c='orange')  # 4\n",
    "ax.text(a,-1,\"a\")          # 5\n",
    "ax.text(b,-1,\"b\")\n",
    "ax.text(c,-1,\"c\")\n",
    "ax.scatter([a,b,c], [f(a), f(b),f(c)], s=50, c='k')  # 6\n",
    "ax.scatter([a,b,c], [0,0,0], s=50, c='red')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. `-3.1`から`0`から等間隔で`100`の値を生成し横軸に設定する。\n",
    "2. `x`と`f(x)`の値からなる`DataFrame`の作成。\n",
    "3. `X`を横軸、`Y`を縦軸に指定し`f(x)`の曲線をプロットする。また図の軸を`ax`とする。\n",
    "4. `ax`のメソッド`axhline(<横軸の値>)`を使い`ax`に平行線を表示する。`c='orange'`は色を指定する引数。\n",
    "5. `ax`のメソッド`text(<横軸の値>,<縦軸の値>,<表示する文字>)`を使い`ax`に文字を表示する。\n",
    "6. `ax`のメソッド`scatter()`を使い`ax`に点を表示する。\n",
    "    * 第１引数：横軸の値のリスト\n",
    "    * 第２引数：縦軸の値のリスト\n",
    "    * 第３引数：点のサイズ\n",
    "    * 第４引数：点の色\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜`bisection`法の考え方＞\n",
    "* [中間値の定理](https://ja.wikipedia.org/wiki/中間値の定理)に基づく。\n",
    "* `f(a)`と`f(b)`の符号が異なり`f(x)`が連続関数である場合、`a`と`b`の間には`f(x)`がゼロになる`x`の値が必ず存在する。（一般的には，`f(x)`がゼロになる`x`の値は奇数個存在することになる。）\n",
    "* 上の図の`c=(a+b)/2`は`a`と`b`の平均値であり、次の３つの可能性がある。\n",
    "    1. `f(c)=0`\n",
    "        * この場合は解が求められたことになる。\n",
    "    1. `f(c)>0`\n",
    "        * （上の図のように）`f(c)`と`f(a)`が同じ符号であるため、次は`c`と`b`の間で同様の計算をおこなう。例えば，`d=(c+b)/2`を計算する。\n",
    "    1. `f(c)<0`\n",
    "        * （上の図とは異なるが）`f(c)`と`f(a)`は異なる符号であるため、次は`a`と`c`の間で同様の計算をおこなう。例えば，`d=(a+c)/2`を計算する。\n",
    "* このように`f(x)=0`となる`x`を「挟み撃ち」するように計算プロセスを続けると`f(x)=0`を満たす`x`の値に十分に近い値を求めることができる。\n",
    "\n",
    "＜注意点＞\n",
    "* 計算には`a`と`b`のように１つの根を挟む２点が必要となる。\n",
    "* 挟んだ根だけを求めることになる。\n",
    "* 求めた値は近似となる。\n",
    "* 求めた値は収束値なので収束する速度が一つの「壁」になり得る。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 手計算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "実際にコードを書き，Bisection法の考え理解しよう。次の関数を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def my_bisect(f,a,b,N):\n",
    "    \"\"\" [a,b]におけるf(x)=0の近似解（bisection法）   # 1\n",
    "    \n",
    "    引数\n",
    "    ----------\n",
    "    f : f(x)=0の連続関数\n",
    "    a,b : 根を挟む初期の値\n",
    "    N : 中間値を計算するプロセスの回数\n",
    "\n",
    "    返り値\n",
    "    -------\n",
    "    N回ループ後の解の近似値\n",
    "    * f(a)*f(b) >= 0 の場合、メッセージが返される。\n",
    "    * c=(a+b)/2とし、f(a)、f(b)、f(c)が同じ符号の場合、メッセージが返される。\n",
    "    \"\"\"\n",
    "    \n",
    "    if f(a)*f(b) >= 0:       # 2\n",
    "        print(\"f(a)とf(b)は同じ符号です。a、bの値を変えてください。\")\n",
    "        return None\n",
    "    \n",
    "    a_ = a                   # 3\n",
    "    b_ = b                   # 4\n",
    "    \n",
    "    for n in range(N):       # 5\n",
    "        \n",
    "        c_ = (a_ + b_)/2     # 6\n",
    "        fc = f(c_)           # 7\n",
    "        \n",
    "        if f(a_)*fc < 0:     # 8\n",
    "            b_ = c_\n",
    "            \n",
    "        elif f(b_)*fc < 0:   # 9\n",
    "            a_ = c_\n",
    "            \n",
    "        elif fc == 0:        # 10\n",
    "            print(\"正確な根が求められました。\")\n",
    "            return c_\n",
    "        \n",
    "        else:                # 11\n",
    "            print(\"計算に失敗しました。\")\n",
    "            return None\n",
    "        \n",
    "    print(f'{N}回ループ後の値です。')\n",
    "        \n",
    "    return (a_ + b_)/2       # 12"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. `\"\"\"`と`\"\"\"`で挟んだ領域は`docstring`と呼ばれ、関数の説明をする。書かなくても良いが、自分が忘れた頃に関数のコードを読むことになるかもしれないので、書く方がオススメ。\n",
    "2. `f(a)`と`f(b)`の符号が同じ場合は計算を中止する。\n",
    "3. `bisection`法では根を挟む２つの変数が必要だが、計算を繰り返す毎に両変数がアップデートされる。そのアップデート用の変数として`a_`と`b_`の初期値を`a`と`b`に設定している。\n",
    "4. (3)を参照。\n",
    "5. `N`回の`for`ループとして中間値を計算する。\n",
    "6. 中間値を計算して変数`c_`に割り当てる。\n",
    "7. 中間値での関数の値を変数`fc`に割り当てる。\n",
    "8. 中間値と`a_`での関数の符号が異なる場合、`c_`を`b_`に割り当てる（アップデートする）。（`a_`は以前と同じ値。）\n",
    "9. 中間値と`b_`での関数の符号が異なる場合、`c_`を`a_`に割り当てる（アップデートする）。（`b_`は以前と同じ値。）\n",
    "10. 中間値である`c_`での関数の値が`0`の場合、近似ではなく正確な根が求められることになる。その旨を立てるメッセージを表示し，`c_`の値を返す。\n",
    "11. その他の場合は計算の失敗となる。その旨のメッセージを表示し，`None`を返す。\n",
    "12. `N`回のループ終了後に`a_`と`b_`の中間値として根の近似値が返される。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の例を使って実際に計算してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_ex1(x):\n",
    "    return x**2 - 2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`f_ex1`には次の正と負の２つの解が存在する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(1.4142135623730951, -1.4142135623730951)"
      ]
     },
     "execution_count": 8,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "np.sqrt(2), -np.sqrt(2)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず$x>0$の解を計算してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10回ループ後の値です。\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.4150390625"
      ]
     },
     "execution_count": 9,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_bisect(f_ex1, 0, 2, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に$x<0$の解をしてみる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10回ループ後の値です。\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1.4150390625"
      ]
     },
     "execution_count": 10,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_bisect(f_ex1, -2, 0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`N`の値が変わると根の近似値がどう変化するか試してみよう。\n",
    "\n",
    "次の場合は計算に失敗する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "f(a)とf(b)は同じ符号です。a、bの値を変えてください。\n"
     ]
    }
   ],
   "source": [
    "my_bisect(f_ex1, -2, 2, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### `Scipy`の関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "上で考えた`my_bisect()`関数は，解法の考えを理解するために使ったが，実際にBisection法を使う場合は，`SciPy`パッケージの`optimize`モジュールに用意されている`bisect()`関数を使おう。基本的な考えは同じであり，`my_bisect()`より格段に洗練された関数と考えれば良いだろう。またBisection法だけではなく他にも様々な方法があり，その一つであるBrent法に基づく関数もここで紹介することにする。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "##### `bisect`関数 "
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "使い方は、上で定義した`my_bisect`関数と基本的に同じであり、近似値が十分に近い数値になるように`for`ループ回数の引数`N`は自動で決定される。\n",
    "\n",
    "```\n",
    "bisect(f, a, b)\n",
    "```\n",
    "* `f`：評価の対象となる関数名\n",
    "* `a`：解探査区間の最小値\n",
    "* `b`：解探査区間の最大値"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623715149"
      ]
     },
     "execution_count": 12,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.bisect(f_ex1, 0, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.4142135623715149"
      ]
     },
     "execution_count": 13,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.bisect(f_ex1, -2, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "##### `brentq`関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`brentq`関数はBrent法に基づいており、`bisect`関数を拡張した手法（ここでは説明を割愛）である。より安定的により速く解への収束が可能となっている。基本的に使い方は`bisect`と同じである。\n",
    "\n",
    "\n",
    "```\n",
    "brentq(f, a, b)\n",
    "```\n",
    "* `f`：評価の対象となる関数名\n",
    "* `a`：解探査区間の最小値\n",
    "* `b`：解探査区間の最大値"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.4142135623731364"
      ]
     },
     "execution_count": 14,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.brentq(f_ex1, 0, 2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.4142135623730951"
      ]
     },
     "execution_count": 15,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.brentq(f_ex1, -2, 0)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`bisect`と`brentq`のどちらを使っても良いが、`brentq`を使うことを推奨する。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### Newton法"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここではもう一つの解法であるNewton法について説明する。図にある関数`f(x)`を考えよう。$x_1$での傾きは$f^{\\prime}(x_1)$であり、次の式が成り立つことが確認できる。\n",
    "\n",
    "$$\n",
    "f^{\\prime}(x_0)=\\dfrac{f(x_0)}{x_0-x_1}\n",
    "\\quad\\Rightarrow\\quad\n",
    "x_1 = x_0 - \\dfrac{f(x_0)}{f^{\\prime}(x_0)}\n",
    "$$\n",
    "\n",
    "```{figure} /images/newton.jpeg\n",
    "---\n",
    "scale: 30%\n",
    "name: fig:scipy-newton\n",
    "---\n",
    "Newton法\n",
    "```\n",
    "\n",
    "即ち、$x_0$が与えられ$f^{\\prime}(x_0)$が分かれば、$x_1$を求めることができる。更に、$x_1$が与えられ、$f^{\\prime}(x_1)$が分かれば、$x_2$を求めることができる。一般的には次の差分方程式が成り立つことになる。\n",
    "\n",
    "$$\n",
    "x_{t+1} = x_t - \\dfrac{f(x_t)}{f^{\\prime}(x_t)}\n",
    "$$ (eq:scipy-newton)\n",
    "\n",
    "この式に従って$x_{t+1}$の計算を続けると、$x_{t+1}$は$f(x)=0$を満たす$x$に漸近的に近づいていき、根に十分に近い値を計算することが可能となる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜コメント＞\n",
    "* 求めた値は近似となる。\n",
    "* `bisec`関数と`brentq`関数よりも早い率で解に収束する特徴がある。\n",
    "* `bisec`関数と`brentq`関数と違って、必ず解を求めることができるとは限らない。解探索の`x`の初期値の設定が重要となる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 手計算"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Newton法の基本的な考えを説明するために式[](fig:scipy-newton)を捉える関数を定義しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 16,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def my_newton(f,Df,x0,N):\n",
    "    \"\"\" Newton法でf(x)=0の根を近似する。\n",
    "\n",
    "    引数\n",
    "    ----------\n",
    "    f : f(x)=0の関数名f\n",
    "    Df : f(x)の導関数\n",
    "    x0 : 解探索の初期のxの値\n",
    "    N : ループの回数\n",
    "\n",
    "    返り値\n",
    "    -------\n",
    "    根の近似値\n",
    "    Df(x) == 0の場合は None がメッセージが表示される。\n",
    "    \"\"\"\n",
    "    \n",
    "    x_ = x0              # 1\n",
    "    \n",
    "    for n in range(N):   # 2\n",
    "        \n",
    "        fx = f(x_)       # 3\n",
    "        Dfx = Df(x_)     # 4\n",
    "        \n",
    "        if Dfx == 0:     # 5\n",
    "            print('導関数はゼロです。解は見つかりませんでした')\n",
    "            return None\n",
    "        \n",
    "        else:            # 6\n",
    "            x_ = x_ - fx/Dfx\n",
    "\n",
    "    print(f'{N}回ループ後の値です。')\n",
    "    return x_            # 7"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. $x$の初期値の設定。また、式[](fig:scipy-newton)の左辺の値$x_{1+t}$は計算を繰り返す毎にアップデートされるが、そのアップデート用の変数として`x_`を使う事になる。\n",
    "2. `for`ループを`N`回行う。\n",
    "3. `x_`での関数`f(x)`の値を`fx`に割り当てる。 \n",
    "4. `x_`での導関数`Df(x)`の値を`Dfx`に割り当てる。 \n",
    "5. 導関数`Dfx`がゼロになる場合は計算不可能なので，その旨のメッセージを表示し、`None`を返す。\n",
    "6. 導関数`Dfx`がゼロでなければ、式[](fig:scipy-newton)に従って計算し、`x_`をアップデートする。\n",
    "7. 近似解`x_`を返す。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "例として`f_ex(x)`を使うが、まず導関数を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def Df_ex1(x):\n",
    "    return 2*x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず$x>0$の解を求めよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 18,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10回ループ後の値です。\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "1.414213562373095"
      ]
     },
     "execution_count": 18,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_newton(f_ex1, Df_ex1, 1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に$x<0$の解を求める。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 19,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "10回ループ後の値です。\n"
     ]
    },
    {
     "data": {
      "text/plain": [
       "-1.414213562373095"
      ]
     },
     "execution_count": 19,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "my_newton(f_ex1, Df_ex1, -1, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次は計算に失敗するケースとなる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 20,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "導関数はゼロです。解は見つかりませんでした\n"
     ]
    }
   ],
   "source": [
    "my_newton(f_ex1, Df_ex1, 0, 10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### `Scipy`の関数"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`Scipy`パッケージの`optimize`モジュールには`newton`法の関数が用意されており、説明で使った手計算の`my_newton()`関数と比べると格段に洗練れている。使い方は簡単で、引数に関数と`x`の初期値を指定するだけであり、近似の誤差とループの回数は自動的に設定される。\n",
    "\n",
    "```\n",
    "newton(f, x0)\n",
    "```\n",
    "* `f`：評価の対象となる関数名\n",
    "* `x0`：解探査の初期値"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "1.414213562373095"
      ]
     },
     "execution_count": 21,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(f_ex1, 1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 22,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-1.414213562373095"
      ]
     },
     "execution_count": 22,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(f_ex1, -1)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "またリストとして`x`の初期値を複数設定することも可能である。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([1.41421356, 1.41421356])"
      ]
     },
     "execution_count": 23,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(f_ex1, [1,10])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これを利用して、複数の根を同時に計算することも可能となる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.41421356,  1.41421356])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(f_ex1, [-1,1])"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "### マクロ経済学への応用"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 45度線モデル"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ケインズの45度線モデルでは，所得$Y$以外の変数は外生変数として所得が決定されるマクロ経済学の基本的なモデルである。次の記号・仮定を使う。\n",
    "\n",
    "* 所得：$Y$\n",
    "* 計画支出：$E=C(Y)+I+G$\n",
    "* 消費関数：$C(Y)=d+cY^{a}$\n",
    "    * 自発的消費：$d=10$\n",
    "    * 限界消費性向：$c=0.7$\n",
    "    * $\\alpha=0.7$\n",
    "* 投資：$I=15$\n",
    "* 政府支出：$G=10$\n",
    "* 均衡：$E=Y$\n",
    "\n",
    "１つの式でまとめると次式となる。\n",
    "\n",
    "$$\n",
    "0= Y -\\left(I+G+C(Y)\\right)\\equiv h_0(Y)\n",
    "$$\n",
    "\n",
    "この式をプロットするために，次のパラメータの下での`h0()`関数を定義する。\n",
    "```\n",
    "a = 0.5\n",
    "c = 0.7\n",
    "d = 10\n",
    "i = 15\n",
    "g = 10\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 25,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def h0(y):\n",
    "    \n",
    "    a = 0.8\n",
    "    c = 0.7\n",
    "    d = 10\n",
    "    i = 15\n",
    "    g = 10\n",
    "\n",
    "    return y - (i + g + d + c*y**a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "プロットしてみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {
    "hidden": true
   },
   "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": [
    "yy = np.linspace(20,100,100)\n",
    "\n",
    "df1 = pd.DataFrame({'Y':yy, 'h0(Y)':h0(yy)})\n",
    "\n",
    "ax_ = df1.plot('Y','h0(Y)')\n",
    "ax_.axhline(0,c='red')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`h0(y)`関数は右上りとなっている。傾きを直感的に説明すると次のようになる。`Y`が増加すると，当たり前だが所得`Y`は線形的に増加する。一方で，計画支出の一部である消費も増加するが，`a`は0.5に設定されているため，増加分は逓減している。したがって，所得と計画支出の差は上昇することになる。\n",
    "\n",
    "均衡の$Y$を計算してみよう。\n",
    "\n",
    "＜Bisection法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51.35063858666513"
      ]
     },
     "execution_count": 27,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.bisect(h0, 40, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜Brent法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51.35063858666476"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.brentq(h0, 40, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜Newton法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "51.35063858666476"
      ]
     },
     "execution_count": 29,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(h0, 40)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### IS曲線の導出"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでも45度線モデルを使い財市場の均衡で決定される所得$Y$を考えるが，投資は利子率$r$の非線形の減少関数と仮定する。この仮定により，利子率$r$を所与とした所得の均衡を考えることが可能となり，非線形の$IS$曲線をプロットすることができる。\n",
    "\n",
    "45度線モデルの投資$I$を次のように変更する。\n",
    "\n",
    "$$\n",
    "I = \\dfrac{j}{r^{b}}\n",
    "$$\n",
    "\n",
    "* $r=$ 実質利子率\n",
    "* $j=15$\n",
    "* $b=0.5$\n",
    "\n",
    "均衡式は次式で与えられる。\n",
    "\n",
    "$$\n",
    "0=Y-\\left( \\dfrac{j}{r^{b}}+G+C(Y) \\right)\\equiv h_1(Y)\n",
    "$$\n",
    "\n",
    "まず関数を再定義するが，$y$と$r$を引数とする。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def h1(y,r):\n",
    "    \n",
    "    a = 0.8\n",
    "    b = 0.5\n",
    "    c = 0.7\n",
    "    d = 10\n",
    "    i = 15\n",
    "    j = 15\n",
    "    g = 10\n",
    "\n",
    "    return y - ( j/r**b + i + g + d + c*y**a )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$r$の複数の値を設定する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "r_arr = np.linspace(0.01, 0.1, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に`for`ループを使い、財市場での均衡が成立する`r`と`Y`の組み合わせを計算する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "y_list = []\n",
    "\n",
    "for r in r_arr:\n",
    "    y = op.newton(h1, 30, args=(r,))    # 1\n",
    "    y_list.append(y)\n",
    "\n",
    "df2 = pd.DataFrame({'Y':y_list, 'r':r_arr})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. 関数`h1(y,r)`には`y`と`r`の２つの引数がある。一方、関数`newton()`では`h1()`の第一引数の値を計算することを想定しており，「その他の引数」は`args`で指定する必要がある。この機能を利用することにより、`r`を所与として`h1(y,r)=0`となる`y`の値を計算することが可能となる。`args`を指定する際、タプル`()`で「その他の引数」を指定し、それが１つの場合は`(r,)`のように`,`を付け加える必要がある（基本的にタプルは`,`で定義されるため）。\n",
    "```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {
    "hidden": true
   },
   "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": [
    "df2.plot('Y','r')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### ソロー・モデル"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "モデルの簡単な説明は[「ソロー・モデル」の章](https://py4macro.github.io/8_Solow.html)を参照してほしい。\n",
    "\n",
    "* 産出量：$y_t$\n",
    "* 資本ストック：$k_t$\n",
    "* 労働：$l_t=1$（労働人口増加率は`0`）\n",
    "* 貯蓄率：$0<s<1$\n",
    "* 資本減耗率：$0<d<1$\n",
    "* 生産性：$A>0$\n",
    "* 生産関数：$y_t=Ak_t^a$\n",
    "* 資本の蓄積方程式：\n",
    "    \n",
    "    $$\n",
    "    k_{t+1} = sAk_t^a + (1-d)k_t\n",
    "    $$\n",
    "    \n",
    "* 定常状態での$k_t$：$k_*$\n",
    "    \n",
    "    $$\n",
    "    0 = sAk_*^a + (1-d)k_* - k_* \\equiv m(k_*)\n",
    "    $$\n",
    "    \n",
    "パラメターを次の値とする"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "s = 0.2\n",
    "a = 0.3\n",
    "d = 0.1\n",
    "A = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "$k$の定常状態$k_*$は次式で定義される。\n",
    "\n",
    "$$\n",
    "0 = sAk_*^a + (1-d)k_* - k_{*}\n",
    "$$ (eq:scipy-kss)\n",
    "\n",
    "この方程式の解を求めるが，関数`kss()`を定義しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 35,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def kss(k):\n",
    "    return s*A*k**a + (1-d)*k - k"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず式[](eq:scipy-kss)をプロットするが，そのために$k$の値を設定しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 36,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "k_arr = np.linspace(0,100, 1000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`for`ループで`kss(k_*)`を計算し、結果を`DataFrame`に格納する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "k_list = []\n",
    "\n",
    "for k in k_arr:\n",
    "    k_list.append(kss(k))\n",
    "\n",
    "df3 = pd.DataFrame({'k':k_arr, 'kss(k)':k_list})"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 38,
   "metadata": {
    "hidden": true
   },
   "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": [
    "ax_ = df3.plot('k', 'kss(k)')\n",
    "ax_.axhline(0, c='red')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`scipy.optimize`を使い定常状態$k_*$を計算してみよう。\n",
    "\n",
    "＜Bisection法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 39,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72.21281575281978"
      ]
     },
     "execution_count": 39,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.bisect(kss, 60, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜Brent法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 40,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72.21281575282009"
      ]
     },
     "execution_count": 40,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.brentq(kss, 60, 100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "＜Newton法＞"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 41,
   "metadata": {
    "hidden": true,
    "scrolled": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "72.21281575281984"
      ]
     },
     "execution_count": 41,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(kss, 60)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "#### 投資"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "企業の投資問題を考える。初期投資`fc`を投入すると$T$期間$\\pi$の利潤を得るとする。実質利子率は$r$とすると$T$期間の利潤の現在価値の合計は次のようになる。\n",
    "\n",
    "$$\n",
    "\\int_0^{T}e^{-rt}\\pi dt=\\frac{\\pi}{r}\\left(1-e^{-Tr}\\right)\n",
    "$$\n",
    "\n",
    "パラメータは次の値としよう"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 42,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "r = 0.07\n",
    "pi = 10\n",
    "fc = 100"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "問題：\n",
    ">「投資の正味現在価値（net present value）がゼロになるにはどれだけ長く事業が続く必要があるか？」"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "利潤の正味現在価値は\n",
    "\n",
    "$$\n",
    "\\frac{\\pi}{r}\\left(1-e^{-Tr}\\right)-fc\n",
    "$$\n",
    "\n",
    "で与えられる。この式を捉える関数を作成しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 43,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def npv(x):\n",
    "    return (1-np.exp(-x*r))*pi/r - fc"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Newton法を使い`npv()`がゼロになる$T$を計算する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 44,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "17.19961149037052"
      ]
     },
     "execution_count": 44,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.newton(npv,10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 最適化問題：１変数の場合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "最適化問題は経済学の根幹をなすが、ここでは`scipy.optimize`の`minimize_scalar`関数の使い方を簡単に説明する。様々な引数が用意されているが、基本的には次のようなコードの書き方となる。\n",
    "\n",
    "1. デフォルトではBrent法が使われる。\n",
    "    ```\n",
    "    minimize_scalar(f, bracket=(a,b))\n",
    "    ```\n",
    "    * `f`は最小化したい関数名\n",
    "    * `bracket`は計算の初期値を指定する引数であり、省略可能。初期値を設定する場合は２つ必要である。関数を最小化すると思われる`x`に対して必ずしも`a<x<b`が満たされるように`a`と`b`の値を設定する必要はなく、下で定義する`f_ex2`の例が示すように、必ずしも区間内に解があるとは限らない。\n",
    "1. Bounded法を使う場合\n",
    "    ```\n",
    "    minimize_scalar(f, method='bounded', bounds=(a,b))\n",
    "    ```\n",
    "    * `f`：最小化したい関数名\n",
    "    * `method`：計算手法を指定する引数であり、`bounded`を指定する（デフォルトは`brent`）。\n",
    "    * `bounds`は関数を最大化する`x`の値を探す区間を指定する引数であり、`a`は区間の最小値、`b`は区間の最大値（裏でBrent法が使われており、関数を最小化する`x`の探索は`bounds`で指定した区間に限られる）\n",
    "\n",
    "＜２つの注意点＞\n",
    "1. 返り値は、関数を最小化する変数の値だけではなく、様々な情報が整理されたオブジェクトとして返される。\n",
    "1. 最大化のための関数は用意されていない。従って、最大化したい関数にマイナスの符号をつけて`minimize_scalar()`関数を評価する必要がある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例１"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`f_ex1`関数を例として考えよう。最小化される`x`を計算する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 45,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -2.0\n",
       "    nfev: 40\n",
       "     nit: 36\n",
       " success: True\n",
       "       x: 9.803862664247969e-09"
      ]
     },
     "execution_count": 45,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1 = op.minimize_scalar(f_ex1)\n",
    "res1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この返り値の中で重要なのは次の３つである。\n",
    "* `fun`（１行目）：最小化された場合の関数の値\n",
    "* `success`（最後から２行目）：計算が成功したかどうかを示す。\n",
    "    * `True`：成功\n",
    "    * `False`：失敗\n",
    "* `x`（最後）：関数を最小化する変数の値\n",
    "\n",
    "それぞれは次のように属性としてアクセスできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 46,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "-2.0"
      ]
     },
     "execution_count": 46,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1.fun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 47,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 47,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1.success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "9.803862664247969e-09"
      ]
     },
     "execution_count": 48,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res1.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例２"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に最小値が複数ある場合を考えよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_ex2(x):\n",
    "    return x**4 - x**2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まずこの関数を図示しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "metadata": {
    "hidden": true
   },
   "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": [
    "xx = np.linspace(-1.1, 1.1, 100)\n",
    "df_ex2 = pd.DataFrame({'X':xx, 'f_ex2':f_ex2(xx)})\n",
    "ax_ = df_ex2.plot('X','f_ex2')\n",
    "ax_.axhline(0,c='red')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "まず`method`のデフォルトである`brent`法を使ってみよう。解が２つあるため、次のコードでは`Python`が選んだ解しか求めることができない。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.24999999999999994\n",
       "    nfev: 15\n",
       "     nit: 11\n",
       " success: True\n",
       "       x: 0.7071067853059209"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res2 = op.minimize_scalar(f_ex2)\n",
    "res2"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に引数`bracket`を使ってみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.24999999999999994\n",
       "    nfev: 16\n",
       "     nit: 12\n",
       " success: True\n",
       "       x: -0.7071067842613271"
      ]
     },
     "execution_count": 52,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3 = op.minimize_scalar(f_ex2, bracket=(-1,-0.5))\n",
    "res3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "しかし次の２つ例は`bracket`内に必ず解が存在するとは限らないことを示している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.25\n",
       "    nfev: 14\n",
       "     nit: 10\n",
       " success: True\n",
       "       x: -0.7071067804088556"
      ]
     },
     "execution_count": 53,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3 = op.minimize_scalar(f_ex2, bracket=(-1,-0.8))\n",
    "res3"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.25\n",
       "    nfev: 16\n",
       "     nit: 12\n",
       " success: True\n",
       "       x: 0.7071067805303989"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3 = op.minimize_scalar(f_ex2, bracket=(-1,-0.1))\n",
    "res3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "「ん？」と思うかもしれないが、`brent`のアルゴリズムがそのようになっているので、その性質を覚えるしかない。\n",
    "\n",
    "一方、`method='bounded'`を使うと、`bounds`で指定された区間の解が探索される。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 55,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.24999999999998732\n",
       " message: 'Solution found.'\n",
       "    nfev: 10\n",
       "  status: 0\n",
       " success: True\n",
       "       x: -0.707106701474177"
      ]
     },
     "execution_count": 55,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res4 = op.minimize_scalar(f_ex2, method='bounded', bounds=(-1,0))\n",
    "res4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### ソロー・モデル：黄金律"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "資本の黄金律水準とは、長期均衡において一人当たり消費を最大化する資本ストックであり、貯蓄率$s$に依存している。それを示すために、まず定常状態の資本ストック$k_*$をパラメータで示すが，次式は式[](eq:scipy-kss)から導出できる。\n",
    "\n",
    "$$\n",
    "k_*=\\left(\n",
    "        \\frac{As}{d}\n",
    "    \\right)^{\\frac{1}{1-a}}\n",
    "$$\n",
    "\n",
    "更に、定常状態での一人当たりGDPと消費は次式で与えられる。\n",
    "\n",
    "$$\n",
    "y_*=Ak_*^{a}\n",
    "\\quad\n",
    "c_*=(1-s)y_*\n",
    "$$\n",
    "\n",
    "これらを使うと、一人当たり消費を貯蓄率の関数として表すことができる。\n",
    "\n",
    "$$\n",
    "c=(1-s)A\\left(\\frac{As}{d}\\right)^{\\frac{a}{1-a}}\n",
    "$$\n",
    "\n",
    "関数として定義し図示してみよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 56,
   "metadata": {
    "hidden": true
   },
   "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": [
    "# sの値\n",
    "s_arr = np.linspace(0,1,100)\n",
    "\n",
    "# 消費関数\n",
    "def c(s):\n",
    "    return (1-s)*A*(A*s/d)**(a/(1-a))\n",
    "\n",
    "# 消費の値を入れるリスト\n",
    "c_list = []\n",
    "\n",
    "# 消費の計算\n",
    "for s in s_arr:\n",
    "    c_list.append(c(s))\n",
    "\n",
    "# DataFrameの作成\n",
    "df4 = pd.DataFrame({'s':s_arr, 'c(s)':c_list})\n",
    "\n",
    "# プロット\n",
    "df4.plot('s','c(s)')\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に一人当たり消費を最大化する貯蓄率を求めるために関数を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def c_minus(s):\n",
    "    return -(1-s)*A*(A*s/d)**(a/(1-a))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "最大化するためにマイナスの符号が追加されていることに留意しよう。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "デフォルトのBrent法を使い消費を最大化する貯蓄率$s$を求める。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 58,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -30.071147877019232\n",
       "    nfev: 17\n",
       "     nit: 13\n",
       " success: True\n",
       "       x: 0.30000000024161544"
      ]
     },
     "execution_count": 58,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.minimize_scalar(c_minus)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "Bounded法でも同じ解が求められる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 59,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -30.071147877017722\n",
       " message: 'Solution found.'\n",
       "    nfev: 9\n",
       "  status: 0\n",
       " success: True\n",
       "       x: 0.2999998786598638"
      ]
     },
     "execution_count": 59,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.minimize_scalar(c_minus, method='bounded', bounds=(0, 1))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 労働供給問題"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ミクロ経済学で学ぶ消費者の労働供給問題を考えよう。消費者は消費財と余暇の２財を消費し，効用を最大化する消費財と余暇を選択すると考える。\n",
    "\n",
    "変数の定義：\n",
    "* $u$：効用\n",
    "* $c$：消費\n",
    "* $l$：労働供給（24時間のパーセント）\n",
    "* $p$：消費財の価格\n",
    "* $w$：賃金\n",
    "* $1$：24時間を100%として。\n",
    "* $1-l$：余暇\n",
    "\n",
    "* 効用関数：\n",
    "    \n",
    "    $$u=a\\ln(c)+(1-a)\\ln(1-l)$$\n",
    "    \n",
    "* 制約式：\n",
    "\n",
    "    $$pc=wl$$ (eq:scipy-pcwl)\n",
    "\n",
    "制約式のもとで消費者は$c$と$l$を選択し効用を最大化する。\n",
    "\n",
    "＜解法＞\n",
    "* 制約式を効用関数に代入する\n",
    "\n",
    "    $$\\max_{l}\\;a\\ln\\left(\\frac{wl}{p}\\right)+(1-a)\\ln(1-l)$$\n",
    "\n",
    "  これにより効用は$l$の関数になり，`.minimize_scalar()`が使える形になっている。\n",
    "\n",
    "次の値を仮定する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 60,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "a = 0.6\n",
    "p = 1\n",
    "w = 10"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "目的関数（最大化する対象となる関数）を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 61,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def u_minus(l):\n",
    "    return -( a*np.log(w*l/p)+(1-a)*np.log(1-l) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "効用を最大化する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 62,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.7085393887825051\n",
       " message: 'Solution found.'\n",
       "    nfev: 9\n",
       "  status: 0\n",
       " success: True\n",
       "       x: 0.5999985035112788"
      ]
     },
     "execution_count": 62,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res_u = op.minimize_scalar(u_minus, method='bounded', bounds=(0,1))\n",
    "res_u"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 63,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最適な労働供給は0.60である。\n"
     ]
    }
   ],
   "source": [
    "print(f'最適な労働供給は{res_u.x:.2f}である。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "予算制約式から消費量は\n",
    "\n",
    "$$\n",
    "c=\\frac{wl}{p}\n",
    "$$ (eq:scipy-c)\n",
    "\n",
    "となるので，"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 64,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最適な消費量は6.00である。\n"
     ]
    }
   ],
   "source": [
    "print(f'最適な消費量は{res_u.x*w/p:.2f}である。')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 65,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "最大化された効用水準は0.71である。\n"
     ]
    }
   ],
   "source": [
    "print(f'最大化された効用水準は{-res_u.fun:.2f}である。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "結果を図示するために、効用関数を$c$で解くと次式となる。\n",
    "\n",
    "$$\n",
    "c=\n",
    "\\left(\n",
    "    \\frac{e^u}{(1-l)^{1-a}}\n",
    "\\right)^{\\frac{1}{a}}\n",
    "$$ (eq:scipy-cc)\n",
    "\n",
    "この関数を捉える関数を作成しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 66,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def c_utility(l):\n",
    "    return ( np.exp(-res_u.fun)/(1-l)**(1-a) )**(1/a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "プロットするために図の横軸になる労働供給$l$の値を生成する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 67,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "l_arr = np.linspace(0,0.999,100)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "（注意）次のコードで$l=1$になると警告が出てしまう。理由は式[](eq:scipy-cc)の右辺の分母がゼロになるためである。それを避けるために，`0`から`0.999`の間の値を100個生成している。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "これらを使い、無差別曲線の値を計算する。この際、`res_u.fun`を利用する（マイナスになることに注意しよう）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 68,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "c_utility_list = []\n",
    "\n",
    "for l in l_arr:\n",
    "    c_utility_list.append(c_utility(l))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に制約線の値を生成する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 69,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "c_constraint_list = []\n",
    "\n",
    "for l in l_arr:\n",
    "    c_constraint_list.append(w*l/p)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここで式[](eq:scipy-c)を使っている。\n",
    "\n",
    "値を`DataFrame`にまとめる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 70,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "df_5 = pd.DataFrame({'l':l_arr,\n",
    "                     'c_utility':c_utility_list,\n",
    "                     'c_constraint':c_constraint_list})"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`df_5`を使いプロットする。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 71,
   "metadata": {
    "hidden": true
   },
   "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": [
    "ax_ = df_5.plot('l','c_utility')       # 1\n",
    "df_5.plot('l','c_constraint', ax=ax_)  # 2\n",
    "ax_.set_ylim([0,20])                   # 3\n",
    "pass"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. プロットの軸を`ax_`に割り当てている。\n",
    "2. 制約式のずを同じ軸に表示するために引数`ax=ax_`を使い、軸を`ax_`に指定している。\n",
    "3. `set_ylim()`は軸`ax_`のメソッドであり、縦軸の表示範囲を指定する。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true
   },
   "source": [
    "## 最適化問題：２変数の場合"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 説明"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "２変数の場合は`minimize`関数を使う。様々な引数が用意されているが、基本的には次のようなコードの書き方となる。\n",
    "\n",
    "```\n",
    "minimize(f, x0, bounds=(a,b), constraints)\n",
    "```\n",
    "* `f`は最小化したい関数名\n",
    "    * `f(x)`のように引数は`x`１つで書く必要があり、`x`を`array`と理解すれば良いだろう（例を参照）。\n",
    "* `bounds`（指定しなくても良い）は関数を最大化する`x`の値を探す区間を指定する引数である。\n",
    "    * `a`は区間の最小値、`b`は区間の最大値を指し、次のように設定する。\n",
    "        ```\n",
    "        [(変数１の最小値, 変数１の最大値), (変数２の最小値, 変数２の最大値)]\n",
    "        ```\n",
    "    * 指定しない箇所は`None`とする。例えば、非負の値に限定したい場合は`[(0,None),(0,None)]`とする。\n",
    "    * 裏でBrent法が使われており、関数を最小化する`x`の探索は`bounds`で指定した区間に限られる。\n",
    "* `constraints`（指定しなくても良い）は制約式。\n",
    "    * １つの制約式を１つの辞書として設定する。また制約式が複数ある場合は、それぞれに辞書を作成し、複数の辞書からなるリストもしくはタプルとして設定する。\n",
    "    * 詳細は例３と例４を参照\n",
    "\n",
    "＜２つの注意点＞\n",
    "1. 返り値は、関数を最小化るる変数の値だけではなく、様々な情報が整理されたオブジェクトとして返される。\n",
    "1. 最大化のための関数は用意されていない。従って、最大化した関数にマイナスの符号をつけて`minimize()`関数を評価する必要がある。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例１"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の最小化問題を考えよう。\n",
    "\n",
    "$$\n",
    "\\min_{y,z}\\; y^2+2zy+z^2+10\n",
    "$$\n",
    "\n",
    "まず関数を定義するが、次の点に留意すること。\n",
    "* `f_ex3`の引数`x`を`array`として考える。\n",
    "* `x`の第0要素を`y`とし、第1要素を`z`とする。\n",
    "* 次のようなイメージ\n",
    "    ```\n",
    "    x = np.array(y,z)\n",
    "    ```"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 72,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_ex3(x):   # 1\n",
    "    y = x[0]    # 2\n",
    "    z = x[1]    # 3\n",
    "    return y**2 + y*z + z**2 + 10  # 4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "```{admonition} コードの説明\n",
    ":class: dropdown\n",
    "\n",
    "1. 関数`f_ex3`の引数`x`を`array`と想定する。\n",
    "2. `x`の第0要素を`y`に割り当てる。\n",
    "3. `x`の第1要素を`z`に割り当てる。\n",
    "4. 最大化する関数を返す。\n",
    "```"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に解探索の初期値を設定しよう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 73,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x0 = [0.3, 0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`x0`の第0要素は`y`の初期値、第1要素は`z`の初期値となる。これは関数`f_ex3`の引数である`x`の要素の順番に対応している。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 74,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "      fun: 10.000000000001792\n",
       " hess_inv: array([[ 0.66873401, -0.33559015],\n",
       "       [-0.33559015,  0.66913043]])\n",
       "      jac: array([-1.07288361e-06,  1.54972076e-06])\n",
       "  message: 'Optimization terminated successfully.'\n",
       "     nfev: 12\n",
       "      nit: 3\n",
       "     njev: 4\n",
       "   status: 0\n",
       "  success: True\n",
       "        x: array([-1.26041337e-06,  1.40562889e-06])"
      ]
     },
     "execution_count": 74,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3 = op.minimize(f_ex3, x0=x0)\n",
    "res3"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "この返り値の中で重要なのは次の４つである。\n",
    "* `fun`（１行目）：最小化された場合の関数の値\n",
    "* `message`（５行目）:「最適化は成功した」というメッセージ\n",
    "* `success`（最後から２行目）：計算が成功したかどうかを示すブール値。\n",
    "    * `True`：計算成功\n",
    "    * `False`：計算失敗\n",
    "* `x`（最後）：関数を最小化する変数の値\n",
    "    * 第0要素は`y`の値、第1要素は`z`の値\n",
    "\n",
    "それぞれは次のように属性としてアクセスできる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 75,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "10.000000000001792"
      ]
     },
     "execution_count": 75,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3.fun"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 76,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "'Optimization terminated successfully.'"
      ]
     },
     "execution_count": 76,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3.message"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 77,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "True"
      ]
     },
     "execution_count": 77,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3.success"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 78,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "array([-1.26041337e-06,  1.40562889e-06])"
      ]
     },
     "execution_count": 78,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res3.x"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例２"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次の最大化問題を考えよう。\n",
    "\n",
    "$$\n",
    "\\max_{y,z}\\; -z^2-y^2+zy+z+y\n",
    "$$\n",
    "\n",
    "まず関数を定義するが，例１と同様に次の点に要注意。\n",
    "* `f_ex4`の引数`x`は`array`として考える。\n",
    "* `x`の第0要素を`y`とし、第1要素を`z`とする。\n",
    "* 次のようなイメージ\n",
    "    ```\n",
    "    x = np.array(y,z)\n",
    "    ```\n",
    "* 返り値にマイナスの符号が追加されている。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 79,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_ex4(x):\n",
    "    y = x[0]\n",
    "    z = x[1]\n",
    "    return -( -z**2-y**2+z*y+z+y )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に解探索の初期値を設定する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 80,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "x0 = [0.5, 0.5]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "解探索の初期値として`[0.5, 0.5]`を設定し計算する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 81,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "      fun: -0.9999999999999998\n",
       " hess_inv: array([[1, 0],\n",
       "       [0, 1]])\n",
       "      jac: array([0., 0.])\n",
       "  message: 'Optimization terminated successfully.'\n",
       "     nfev: 6\n",
       "      nit: 1\n",
       "     njev: 2\n",
       "   status: 0\n",
       "  success: True\n",
       "        x: array([0.99999999, 0.99999999])"
      ]
     },
     "execution_count": 81,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res4 = op.minimize(f_ex4, x0=[0.5, 0.5])\n",
    "res4"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例３"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでは制約付き最大化問題を考える。次の制約のもとで例２の`f_ex4`を最大化するとしよう。\n",
    "\n",
    "$$\n",
    "y+z=1\n",
    "$$\n",
    "\n",
    "制約式の導入を４つのステップに分けて説明する。\n",
    "\n",
    "**＜ステップ１＞**<br>\n",
    "制約式を捉えるコード書くために、左辺が非負となるように書き換える。\n",
    "\n",
    "$$\n",
    "y+z-1=0\n",
    "$$\n",
    "\n",
    "**＜ステップ２＞**<br>\n",
    "この式の左辺が返り値となる関数を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 82,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_const(x):\n",
    "    y = x[0]\n",
    "    z = x[1]\n",
    "    return x[0]+x[1]-1"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "ここでも引数`x`は`array`と想定しており，第0要素を`y`に，第1要素を`z`に割り当てている。\n",
    "\n",
    "**＜ステップ３＞**<br>\n",
    "この関数を使い次のように引数`constraints`に設定する変数を作成する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 83,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "const = {'type':'eq', 'fun': f_const}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "右辺は辞書となっており、キーと値の２つのペアがある。\n",
    "* `type`：制約式のタイプを指定するキー。\n",
    "    * `eq`：制約式が等号の場合。\n",
    "    * `ineq`：制約式が不等号の場合。    \n",
    "* `fun`：制約式を指定するキー。\n",
    "    * `f_const`：制約式の関数名\n",
    "    \n",
    "**＜ステップ４＞**<br>\n",
    "引数`constraints`に変数`const`を指定し計算する（初期値を`[5.0, 0.6]`とする）。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 84,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.7499999999999016\n",
       "     jac: array([-0.50000054, -0.49999945])\n",
       " message: 'Optimization terminated successfully'\n",
       "    nfev: 13\n",
       "     nit: 4\n",
       "    njev: 4\n",
       "  status: 0\n",
       " success: True\n",
       "       x: array([0.49999982, 0.50000018])"
      ]
     },
     "execution_count": 84,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "res5 = op.minimize(f_ex4, x0=[5.0, 0.6], constraints=const)\n",
    "res5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 85,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "yは0.5であり、zは0.5です。\n"
     ]
    }
   ],
   "source": [
    "print(f'yは{res5.x[0]:.1f}であり、zは{res5.x[1]:.1f}です。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`y`の値と`z`の値は制約式を満たすことがわかる。また制約式がない場合と比べて、`y`の値と`z`の値は異なり、最大化された関数の値も異なる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 86,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "制約式がない場合の関数の最大値は1.00であり、制約がある場合は0.75となる。\n"
     ]
    }
   ],
   "source": [
    "print(f'制約式がない場合の関数の最大値は{-res4.fun:.2f}であり、制約がある場合は{-res5.fun:.2f}となる。')"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 例４"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "制約が不等式の場合を簡単に説明する。例３の制約式を\n",
    "\n",
    "$$\n",
    "y+z\\leq 1\n",
    "$$\n",
    "\n",
    "としよう。\n",
    "\n",
    "**＜ステップ１＞**<br>\n",
    "左辺が非負になるように書き換えると\n",
    "\n",
    "$$\n",
    "1-y-z\\geq 0\n",
    "$$\n",
    "\n",
    "となる。\n",
    "\n",
    "**＜ステップ２＞**<br>\n",
    "この不等式の左辺を制約式としてコードを書くが、上の`f_const`と異なることがわかる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 87,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def f_const_ineq(x):\n",
    "    y = x[0]\n",
    "    z = x[1]\n",
    "    return 1-x[0]-x[1]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "**＜ステップ３＞**<br>\n",
    "この場合の引数`constraint`に使う辞書は次のようになる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 88,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "const_ineq = {'type':'ineq', 'fun': f_const_ineq}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`const`との違いは、キー`type`に対応する値が`ineq`になっており、`fun`には`f_const_ineq`が指定されている。\n",
    "\n",
    "**＜ステップ４＞**<br>\n",
    "計算すると同じ結果になることが確認できる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 89,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.7499999999999043\n",
       "     jac: array([-0.50000052, -0.49999944])\n",
       " message: 'Optimization terminated successfully'\n",
       "    nfev: 13\n",
       "     nit: 4\n",
       "    njev: 4\n",
       "  status: 0\n",
       " success: True\n",
       "       x: array([0.49999982, 0.50000018])"
      ]
     },
     "execution_count": 89,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "op.minimize(f_ex4, x0=[5.0, 0.6], constraints=const_ineq)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "当たり前だが例３の解と同じになっている。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 労働供給問題"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "労働供給問題を再考する。まず効用関数を設定し直そう。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 90,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def u(x):\n",
    "    c = x[0]\n",
    "    l = x[1]\n",
    "    return -( a*np.log(c)+(1-a)*np.log(1-l) )"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "次に制約式[](eq:scipy-pcwl)だが、下のように書き換えることができる。\n",
    "\n",
    "$$\n",
    "pc=wl\n",
    "\\quad\n",
    "\\Rightarrow\n",
    "\\quad\n",
    "wl-pc=0\n",
    "$$\n",
    "\n",
    "これを使い制約式を定義する。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 91,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "def budget(x):\n",
    "    c = x[0]\n",
    "    l = x[1]\n",
    "    return w*x[1]-p*x[0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "引数`constraint`に使う辞書は次のように書くことができる。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 92,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "const = {'type':'eq', 'fun': budget}"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "また経済理論から次のことが明らかである。\n",
    "* `c`は非負\n",
    "* `l`は0と1の間にある\n",
    "\n",
    "この情報を引数`bounds`に設定するが、次のような書き方となる。\n",
    "```\n",
    "[(cの最小値、cの最大値), (lの最小値、lの最大値)]\n",
    "```\n",
    "ここで`c`と`l`の順番は関数`budget`の引数`x`に対応しており，それぞれの要素の値は\n",
    "* `c`の最小値：0\n",
    "* `c`の最大値：$w/p$\n",
    "* `l`の最小値：0\n",
    "* `l`の最大値：1\n",
    "\n",
    "となる。これらの値を使い引数`bounds`に設定する値を次のようにする。"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 93,
   "metadata": {
    "hidden": true
   },
   "outputs": [],
   "source": [
    "bnds = [(0,w/p),(0,1)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 94,
   "metadata": {
    "hidden": true
   },
   "outputs": [
    {
     "data": {
      "text/plain": [
       "     fun: -0.7085392478935648\n",
       "     jac: array([-0.09995668,  1.00065053])\n",
       " message: 'Optimization terminated successfully'\n",
       "    nfev: 18\n",
       "     nit: 6\n",
       "    njev: 6\n",
       "  status: 0\n",
       " success: True\n",
       "       x: array([6.00260037, 0.60026004])"
      ]
     },
     "execution_count": 94,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# 初期値\n",
    "x0 = [4.0, 0.3]\n",
    "\n",
    "# 計算\n",
    "op.minimize(u, x0, bounds=bnds, constraints=const)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "`minimize_scalar()`で解いた値と同じであることが確認できる。"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "heading_collapsed": true,
    "hidden": true
   },
   "source": [
    "### 練習問題"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {
    "hidden": true
   },
   "source": [
    "予算制約式が不等号の場合の労働供給問題を解きなさい。"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "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.11.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}