From 6c7f40f1b61e7709381ae43ea5bc857a9904dfb5 Mon Sep 17 00:00:00 2001 From: sb Date: Sat, 27 Feb 2021 22:48:38 -0500 Subject: [PATCH] PEP8 updates to examples for v1.0.0 --- .../Finite Cyclical Test.ipynb | 10 ++-- .../example_ConsAggShockModel.ipynb | 22 +++---- .../example_ConsAggShockModel.py | 16 ++--- .../example_ConsGenIncProcessModel.ipynb | 4 +- .../example_ConsGenIncProcessModel.py | 4 +- .../example_ConsIndShock.ipynb | 20 +++---- .../ConsumptionSaving/example_ConsIndShock.py | 20 +++---- .../example_ConsMarkovModel.ipynb | 58 +++++++++---------- .../example_ConsMarkovModel.py | 14 ++--- .../example_ConsPrefShockModel.ipynb | 2 +- .../example_ConsPrefShockModel.py | 6 +- .../example_ConsRepAgentModel.py | 6 +- .../example_TractableBufferStockModel.ipynb | 4 +- .../example_TractableBufferStockModel.py | 4 +- .../GenIncProcessModel.ipynb | 2 +- .../GenIncProcessModel/GenIncProcessModel.py | 2 +- .../Gentle-Intro/Gentle-Intro-To-HARK.ipynb | 6 +- examples/Gentle-Intro/Gentle-Intro-To-HARK.py | 6 +- .../HowWeSolveIndShockConsumerType.ipynb | 38 ++++++------ .../HowWeSolveIndShockConsumerType.py | 38 ++++++------ examples/Journeys/Journey_1_PhD.ipynb | 4 +- .../Quick_start_with_solution.ipynb | 48 +++++++-------- 22 files changed, 167 insertions(+), 167 deletions(-) diff --git a/examples/ConsIndShockModel/Finite Cyclical Test.ipynb b/examples/ConsIndShockModel/Finite Cyclical Test.ipynb index 19ad2b210..f730cb319 100644 --- a/examples/ConsIndShockModel/Finite Cyclical Test.ipynb +++ b/examples/ConsIndShockModel/Finite Cyclical Test.ipynb @@ -8,7 +8,7 @@ "source": [ "# Initial imports and notebook setup, click arrow to show\n", "from HARK.ConsumptionSaving.ConsIndShockModel import IndShockConsumerType\n", - "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from HARK.utilities import plot_funcs_der, plot_funcs\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", "mystr = lambda number : \"{:.4f}\".format(number)" @@ -74,7 +74,7 @@ "name": "stderr", "output_type": "stream", "text": [ - "unpackcFunc is deprecated and it will soon be removed, please use unpack('cFunc') instead.\n" + "unpack_cFunc is deprecated and it will soon be removed, please use unpack('cFunc') instead.\n" ] }, { @@ -102,10 +102,10 @@ "CyclicalExample.cycles = 0 # Make this consumer type have an infinite horizon\n", "CyclicalExample.solve()\n", "\n", - "CyclicalExample.unpackcFunc()\n", + "CyclicalExample.unpack_cFunc()\n", "print('Quarterly consumption functions:')\n", "mMin = min([X.mNrmMin for X in CyclicalExample.solution])\n", - "plotFuncs(CyclicalExample.cFunc,mMin,5)" + "plot_funcs(CyclicalExample.cFunc,mMin,5)" ] }, { @@ -144,7 +144,7 @@ "FiniteCyclicalExample.unpack('cFunc')\n", "print('Quarterly consumption functions:')\n", "mMin = min([X.mNrmMin for X in FiniteCyclicalExample.solution])\n", - "plotFuncs(FiniteCyclicalExample.cFunc,mMin,5)" + "plot_funcs(FiniteCyclicalExample.cFunc,mMin,5)" ] }, { diff --git a/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb b/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb index 8d219c169..f1c11ed62 100644 --- a/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb +++ b/examples/ConsumptionSaving/example_ConsAggShockModel.ipynb @@ -73,10 +73,10 @@ "\n", " # Make a Cobb-Douglas economy for the agents\n", " EconomyExample = CobbDouglasEconomy(agents=[AggShockExample])\n", - " EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", + " EconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", "\n", " # Have the consumers inherit relevant objects from the economy\n", - " AggShockExample.getEconomyData(EconomyExample)" + " AggShockExample.get_economy_data(EconomyExample)" ] }, { @@ -136,13 +136,13 @@ }, { "ename": "NameError", - "evalue": "name 'plotFuncs' is not defined", + "evalue": "name 'plot_funcs' 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 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Aggregate savings as a function of aggregate market resources:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mplotFuncs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mEconomyExample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAFunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mEconomyExample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkSS\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 17\u001b[0m print(\n\u001b[1;32m 18\u001b[0m \u001b[0;34m\"Consumption function at each aggregate market resources gridpoint (in general equilibrium):\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", - "\u001b[0;31mNameError\u001b[0m: name 'plotFuncs' is not defined" + "\u001b[0;32m\u001b[0m in \u001b[0;36m\u001b[0;34m\u001b[0m\n\u001b[1;32m 14\u001b[0m \u001b[0;34m\u001b[0m\u001b[0m\n\u001b[1;32m 15\u001b[0m \u001b[0mprint\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0;34m\"Aggregate savings as a function of aggregate market resources:\"\u001b[0m\u001b[0;34m)\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n\u001b[0;32m---> 16\u001b[0;31m \u001b[0mplot_funcs\u001b[0m\u001b[0;34m(\u001b[0m\u001b[0mEconomyExample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mAFunc\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m0\u001b[0m\u001b[0;34m,\u001b[0m \u001b[0;36m2\u001b[0m \u001b[0;34m*\u001b[0m \u001b[0mEconomyExample\u001b[0m\u001b[0;34m.\u001b[0m\u001b[0mkSS\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 17\u001b[0m print(\n\u001b[1;32m 18\u001b[0m \u001b[0;34m\"Consumption function at each aggregate market resources gridpoint (in general equilibrium):\"\u001b[0m\u001b[0;34m\u001b[0m\u001b[0;34m\u001b[0m\u001b[0m\n", + "\u001b[0;31mNameError\u001b[0m: name 'plot_funcs' is not defined" ] } ], @@ -199,8 +199,8 @@ " # Make a Cobb-Douglas economy for the agents\n", " MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample])\n", " MrkvEconomyExample.DampingFac = 0.2 # Turn down damping\n", - " MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", - " AggShockMrkvExample.getEconomyData(\n", + " MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", + " AggShockMrkvExample.get_economy_data(\n", " MrkvEconomyExample\n", " ) # Have the consumers inherit relevant objects from the economy" ] @@ -309,8 +309,8 @@ " )\n", " ]\n", " KSeconomy.PermGroFacAgg = [1.0, 1.0]\n", - " KSexampleType.getEconomyData(KSeconomy)\n", - " KSeconomy.makeAggShkHist()\n", + " KSexampleType.get_economy_data(KSeconomy)\n", + " KSeconomy.make_AggShkHist()\n", "\n", " # Solve the K-S model\n", " t_start = process_time()\n", @@ -366,8 +366,8 @@ " PolyStateEconomy.intercept_prev = StateCount * [0.0]\n", " PolyStateEconomy.update()\n", " PolyStateEconomy.makeAggShkDstn()\n", - " PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks\n", - " PolyStateExample.getEconomyData(\n", + " PolyStateEconomy.make_AggShkHist() # Simulate a history of aggregate shocks\n", + " PolyStateExample.get_economy_data(\n", " PolyStateEconomy\n", " ) # Have the consumers inherit relevant objects from the economy\n", "\n", diff --git a/examples/ConsumptionSaving/example_ConsAggShockModel.py b/examples/ConsumptionSaving/example_ConsAggShockModel.py index 20bc3f0f0..f5a353193 100644 --- a/examples/ConsumptionSaving/example_ConsAggShockModel.py +++ b/examples/ConsumptionSaving/example_ConsAggShockModel.py @@ -36,10 +36,10 @@ def mystr(number): # Make a Cobb-Douglas economy for the agents EconomyExample = CobbDouglasEconomy(agents=[AggShockExample]) - EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks + EconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks # Have the consumers inherit relevant objects from the economy - AggShockExample.getEconomyData(EconomyExample) + AggShockExample.get_economy_data(EconomyExample) if solve_agg_shocks_micro: # Solve the microeconomic model for the aggregate shocks example type (and display results) @@ -103,8 +103,8 @@ def mystr(number): # Make a Cobb-Douglas economy for the agents MrkvEconomyExample = CobbDouglasMarkovEconomy(agents=[AggShockMrkvExample]) MrkvEconomyExample.DampingFac = 0.2 # Turn down damping - MrkvEconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks - AggShockMrkvExample.getEconomyData( + MrkvEconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks + AggShockMrkvExample.get_economy_data( MrkvEconomyExample ) # Have the consumers inherit relevant objects from the economy @@ -192,8 +192,8 @@ def mystr(number): ) ] KSeconomy.PermGroFacAgg = [1.0, 1.0] - KSexampleType.getEconomyData(KSeconomy) - KSeconomy.makeAggShkHist() + KSexampleType.get_economy_data(KSeconomy) + KSeconomy.make_AggShkHist() # Solve the K-S model t_start = process_time() @@ -242,8 +242,8 @@ def mystr(number): PolyStateEconomy.intercept_prev = StateCount * [0.0] PolyStateEconomy.update() PolyStateEconomy.makeAggShkDstn() - PolyStateEconomy.makeAggShkHist() # Simulate a history of aggregate shocks - PolyStateExample.getEconomyData( + PolyStateEconomy.make_AggShkHist() # Simulate a history of aggregate shocks + PolyStateExample.get_economy_data( PolyStateEconomy ) # Have the consumers inherit relevant objects from the economy diff --git a/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb index a94c4f430..2b0d261c8 100644 --- a/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb +++ b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "outputs": [], "source": [ - "from HARK.utilities import plotFuncs\n", + "from HARK.utilities import plot_funcs\n", "from time import process_time\n", "import matplotlib.pyplot as plt\n", "import numpy as np\n", @@ -224,7 +224,7 @@ " \"Consumption function for normalized problem (without explicit permanent income):\"\n", ")\n", "mNrmMin = NormalizedExample.solution[0].mNrmMin\n", - "plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20)" + "plot_funcs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20)" ] }, { diff --git a/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py index ff18bcbc0..bc1b66eda 100644 --- a/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py +++ b/examples/ConsumptionSaving/example_ConsGenIncProcessModel.py @@ -1,5 +1,5 @@ # %% -from HARK.utilities import plotFuncs +from HARK.utilities import plot_funcs from time import process_time import matplotlib.pyplot as plt import numpy as np @@ -95,7 +95,7 @@ def mystr(number): "Consumption function for normalized problem (without explicit permanent income):" ) mNrmMin = NormalizedExample.solution[0].mNrmMin -plotFuncs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20) +plot_funcs(NormalizedExample.solution[0].cFunc, mNrmMin, mNrmMin + 20) # %% [markdown] # The "explicit permanent income" solution deviates from the solution to the normalized problem because diff --git a/examples/ConsumptionSaving/example_ConsIndShock.ipynb b/examples/ConsumptionSaving/example_ConsIndShock.ipynb index 8d6f4428e..5a26863c8 100644 --- a/examples/ConsumptionSaving/example_ConsIndShock.ipynb +++ b/examples/ConsumptionSaving/example_ConsIndShock.ipynb @@ -13,7 +13,7 @@ " init_lifecycle,\n", " init_cyclical\n", ")\n", - "from HARK.utilities import plotFuncsDer, plotFuncs\n", + "from HARK.utilities import plot_funcs_der, plot_funcs\n", "from time import time" ] }, @@ -103,7 +103,7 @@ "# Plot the perfect foresight consumption function\n", "print(\"Perfect foresight consumption function:\")\n", "mMin = PFexample.solution[0].mNrmMin\n", - "plotFuncs(PFexample.cFunc[0], mMin, mMin + 10)" + "plot_funcs(PFexample.cFunc[0], mMin, mMin + 10)" ] }, { @@ -218,9 +218,9 @@ "source": [ "# Plot the consumption function and MPC for the infinite horizon consumer\n", "print(\"Concave consumption function:\")\n", - "plotFuncs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)\n", + "plot_funcs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)\n", "print(\"Marginal consumption function:\")\n", - "plotFuncsDer(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)" + "plot_funcs_der(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5)" ] }, { @@ -252,7 +252,7 @@ "# Compare the consumption functions for the perfect foresight and idiosyncratic\n", "# shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc.\n", "print(\"Consumption functions for perfect foresight vs idiosyncratic shocks:\")\n", - "plotFuncs(\n", + "plot_funcs(\n", " [PFexample.cFunc[0], IndShockExample.cFunc[0]],\n", " IndShockExample.solution[0].mNrmMin,\n", " 100,\n", @@ -268,7 +268,7 @@ "# Compare the value functions for the two types\n", "if IndShockExample.vFuncBool:\n", " print(\"Value functions for perfect foresight vs idiosyncratic shocks:\")\n", - " plotFuncs(\n", + " plot_funcs(\n", " [PFexample.solution[0].vFunc, IndShockExample.solution[0].vFunc],\n", " IndShockExample.solution[0].mNrmMin + 0.5,\n", " 10,\n", @@ -355,7 +355,7 @@ "mMin = min(\n", " [LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)]\n", ")\n", - "plotFuncs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5)" + "plot_funcs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5)" ] }, { @@ -386,7 +386,7 @@ "source": [ "# Plot the consumption functions during retirement\n", "print(\"Consumption functions while retired:\")\n", - "plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5)" + "plot_funcs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5)" ] }, { @@ -474,7 +474,7 @@ "# Plot the consumption functions for the cyclical consumer type\n", "print(\"Quarterly consumption functions:\")\n", "mMin = min([X.mNrmMin for X in CyclicalExample.solution])\n", - "plotFuncs(CyclicalExample.cFunc, mMin, 5)" + "plot_funcs(CyclicalExample.cFunc, mMin, 5)" ] }, { @@ -514,7 +514,7 @@ "print(\"Solving a kinky consumer took \" + mystr(end_time - start_time) + \" seconds.\")\n", "KinkyExample.unpack('cFunc')\n", "print(\"Kinky consumption function:\")\n", - "plotFuncs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5)" + "plot_funcs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5)" ] }, { diff --git a/examples/ConsumptionSaving/example_ConsIndShock.py b/examples/ConsumptionSaving/example_ConsIndShock.py index 0f2a18f46..32a499f11 100644 --- a/examples/ConsumptionSaving/example_ConsIndShock.py +++ b/examples/ConsumptionSaving/example_ConsIndShock.py @@ -5,7 +5,7 @@ init_lifecycle, init_cyclical ) -from HARK.utilities import plotFuncsDer, plotFuncs +from HARK.utilities import plot_funcs_der, plot_funcs from time import time mystr = lambda number: "{:.4f}".format(number) @@ -31,7 +31,7 @@ # Plot the perfect foresight consumption function print("Perfect foresight consumption function:") mMin = PFexample.solution[0].mNrmMin -plotFuncs(PFexample.cFunc[0], mMin, mMin + 10) +plot_funcs(PFexample.cFunc[0], mMin, mMin + 10) if do_simulation: PFexample.T_sim = 120 # Set number of simulation periods @@ -55,14 +55,14 @@ # Plot the consumption function and MPC for the infinite horizon consumer print("Concave consumption function:") -plotFuncs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) +plot_funcs(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) print("Marginal consumption function:") -plotFuncsDer(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) +plot_funcs_der(IndShockExample.cFunc[0], IndShockExample.solution[0].mNrmMin, 5) # Compare the consumption functions for the perfect foresight and idiosyncratic # shock types. Risky income cFunc asymptotically approaches perfect foresight cFunc. print("Consumption functions for perfect foresight vs idiosyncratic shocks:") -plotFuncs( +plot_funcs( [PFexample.cFunc[0], IndShockExample.cFunc[0]], IndShockExample.solution[0].mNrmMin, 100, @@ -71,7 +71,7 @@ # Compare the value functions for the two types if IndShockExample.vFuncBool: print("Value functions for perfect foresight vs idiosyncratic shocks:") - plotFuncs( + plot_funcs( [PFexample.solution[0].vFunc, IndShockExample.solution[0].vFunc], IndShockExample.solution[0].mNrmMin + 0.5, 10, @@ -102,11 +102,11 @@ mMin = min( [LifecycleExample.solution[t].mNrmMin for t in range(LifecycleExample.T_cycle)] ) -plotFuncs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5) +plot_funcs(LifecycleExample.cFunc[: LifecycleExample.T_retire], mMin, 5) # Plot the consumption functions during retirement print("Consumption functions while retired:") -plotFuncs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5) +plot_funcs(LifecycleExample.cFunc[LifecycleExample.T_retire :], 0, 5) # Simulate some data; results stored in mNrmNow_hist, cNrmNow_hist, pLvlNow_hist, and t_age_hist if do_simulation: @@ -129,7 +129,7 @@ # Plot the consumption functions for the cyclical consumer type print("Quarterly consumption functions:") mMin = min([X.mNrmMin for X in CyclicalExample.solution]) -plotFuncs(CyclicalExample.cFunc, mMin, 5) +plot_funcs(CyclicalExample.cFunc, mMin, 5) # Simulate some data; results stored in cHist, mHist, bHist, aHist, MPChist, and pHist if do_simulation: @@ -148,7 +148,7 @@ print("Solving a kinky consumer took " + mystr(end_time - start_time) + " seconds.") KinkyExample.unpack('cFunc') print("Kinky consumption function:") -plotFuncs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5) +plot_funcs(KinkyExample.cFunc[0], KinkyExample.solution[0].mNrmMin, 5) if do_simulation: KinkyExample.T_sim = 120 diff --git a/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb index e5cd8b30e..31b751799 100644 --- a/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb +++ b/examples/ConsumptionSaving/example_ConsMarkovModel.ipynb @@ -6,7 +6,7 @@ "metadata": {}, "outputs": [], "source": [ - "from HARK.utilities import plotFuncs\n", + "from HARK.utilities import plot_funcs\n", "from time import process_time\n", "from copy import deepcopy, copy\n", "import numpy as np\n", @@ -184,7 +184,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Note that $\\texttt{MarkovConsumerType}$ currently has no method to automatically construct a valid IncomeDstn - $\\texttt{IncomeDstn}$ is manually constructed in each case. Writing a method to supersede $\\texttt{IndShockConsumerType.updateIncomeProcess}$ for the “Markov model” would be a welcome contribution!" + "Note that $\\texttt{MarkovConsumerType}$ currently has no method to automatically construct a valid IncomeDstn - $\\texttt{IncomeDstn}$ is manually constructed in each case. Writing a method to supersede $\\texttt{IndShockConsumerType.update_income_process}$ for the “Markov model” would be a welcome contribution!" ] }, { @@ -194,7 +194,7 @@ "outputs": [], "source": [ "# Interest factor, permanent growth rates, and survival probabilities are constant arrays\n", - "SerialUnemploymentExample(Rfree = np.array(4 * [SerialUnemploymentExample.Rfree]))\n", + "SerialUnemploymentExample.assign_parameters(Rfree = np.array(4 * [SerialUnemploymentExample.Rfree]))\n", "SerialUnemploymentExample.PermGroFac = [\n", " np.array(4 * SerialUnemploymentExample.PermGroFac)\n", "]\n", @@ -210,13 +210,13 @@ "name": "stdout", "output_type": "stream", "text": [ - "Solving a Markov consumer with serially correlated unemployment took 0.4966 seconds.\n", + "Solving a Markov consumer with serially correlated unemployment took 0.3053 seconds.\n", "Consumption functions for each discrete state:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -238,15 +238,15 @@ " + \" seconds.\"\n", ")\n", "print(\"Consumption functions for each discrete state:\")\n", - "plotFuncs(SerialUnemploymentExample.solution[0].cFunc, 0, 50)\n", + "plot_funcs(SerialUnemploymentExample.solution[0].cFunc, 0, 50)\n", "if SerialUnemploymentExample.vFuncBool:\n", " print(\"Value functions for each discrete state:\")\n", - " plotFuncs(SerialUnemploymentExample.solution[0].vFunc, 5, 50)" + " plot_funcs(SerialUnemploymentExample.solution[0].vFunc, 5, 50)" ] }, { "cell_type": "code", - "execution_count": 9, + "execution_count": 7, "metadata": {}, "outputs": [], "source": [ @@ -271,7 +271,7 @@ }, { "cell_type": "code", - "execution_count": 10, + "execution_count": 8, "metadata": {}, "outputs": [], "source": [ @@ -283,7 +283,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 9, "metadata": {}, "outputs": [], "source": [ @@ -305,7 +305,7 @@ }, { "cell_type": "code", - "execution_count": 12, + "execution_count": 10, "metadata": {}, "outputs": [], "source": [ @@ -330,7 +330,7 @@ }, { "cell_type": "code", - "execution_count": 13, + "execution_count": 11, "metadata": {}, "outputs": [], "source": [ @@ -351,14 +351,14 @@ }, { "cell_type": "code", - "execution_count": 14, + "execution_count": 12, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Solving an \"unemployment immunity\" consumer took 0.4554 seconds.\n", + "Solving an \"unemployment immunity\" consumer took 0.3282 seconds.\n", "Consumption functions for each discrete state:\n" ] }, @@ -382,7 +382,7 @@ }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -405,7 +405,7 @@ ")\n", "print(\"Consumption functions for each discrete state:\")\n", "mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)])\n", - "plotFuncs(ImmunityExample.solution[0].cFunc, mNrmMin, 10)" + "plot_funcs(ImmunityExample.solution[0].cFunc, mNrmMin, 10)" ] }, { @@ -419,7 +419,7 @@ }, { "cell_type": "code", - "execution_count": 15, + "execution_count": 13, "metadata": {}, "outputs": [], "source": [ @@ -433,7 +433,7 @@ }, { "cell_type": "code", - "execution_count": 16, + "execution_count": 14, "metadata": {}, "outputs": [], "source": [ @@ -449,7 +449,7 @@ }, { "cell_type": "code", - "execution_count": 17, + "execution_count": 15, "metadata": {}, "outputs": [], "source": [ @@ -461,7 +461,7 @@ }, { "cell_type": "code", - "execution_count": 18, + "execution_count": 16, "metadata": { "lines_to_next_cell": 2 }, @@ -494,20 +494,20 @@ }, { "cell_type": "code", - "execution_count": 19, + "execution_count": 17, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Solving a serially correlated growth consumer took 0.4086 seconds.\n", + "Solving a serially correlated growth consumer took 0.3307 seconds.\n", "Consumption functions for each discrete state:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "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\n", "text/plain": [ "
" ] @@ -529,12 +529,12 @@ " + \" seconds.\"\n", ")\n", "print(\"Consumption functions for each discrete state:\")\n", - "plotFuncs(SerialGroExample.solution[0].cFunc, 0, 10)" + "plot_funcs(SerialGroExample.solution[0].cFunc, 0, 10)" ] }, { "cell_type": "code", - "execution_count": 20, + "execution_count": 18, "metadata": {}, "outputs": [], "source": [ @@ -550,20 +550,20 @@ }, { "cell_type": "code", - "execution_count": 21, + "execution_count": 19, "metadata": {}, "outputs": [ { "name": "stdout", "output_type": "stream", "text": [ - "Solving a serially correlated interest consumer took 0.4242 seconds.\n", + "Solving a serially correlated interest consumer took 0.2512 seconds.\n", "Consumption functions for each discrete state:\n" ] }, { "data": { - "image/png": "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\n", + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAYAAAAD4CAYAAADlwTGnAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjMuNCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy8QVMy6AAAACXBIWXMAAAsTAAALEwEAmpwYAAAo0klEQVR4nO3deXycZbn/8c+VmUlmsq/dsjdNd+hCuiAVyl5kKbJoWRQVThVBBfeDHj3i8Rz9iccNVHqg4gpyUDwVK7RSoEApNN1om+570iVp9n0yM9fvjwwQSkuTdtpnMnO9X6+8OnM/y1yZV/N857mfe55bVBVjjDHxJ8HpAowxxjjDAsAYY+KUBYAxxsQpCwBjjIlTFgDGGBOn3E4XcCy5ublaUlLidBnGGDNorF69+oiq5g1km6gMgJKSEiorK50uwxhjBg0R2TvQbawLyBhj4pQFgDHGxCkLAGOMiVMWAMYYE6csAIwxJk5ZABhjTJyyADDGmDh1wu8BiMhC4CqgVlUnHmP5V4Bb+uxvHJCnqg0isgdoBYJAQFUrIlW4McYYONjcyfqdNSe1bX++CPYY8CDw22MtVNUfAj8EEJGrgXtVtaHPKheq6pGTqs4YY8zbugNBNtU0s33LBhp2vURL4wp8TTW4G3NOan8nDABVXS4iJf3c303A4ydViTHGmHc53NLFup0HOLRlBQ2HXiTQvIHkxk5cjWWkdI4kPeEqWtNKCbp9wMUD3n/EbgUhIsnAHODuPs0KLBERBR5W1QWRej1jjIklPcEQVTXNbNu2ifodL9Hc9Brepr24GzJJah3FsJ5Sur0X0J4ynGByAq0+JdnTSkmBh8KpBfDwwF8zkvcCuhp49ajun1mqWiMiQ4ClIrJFVZcfa2MRmQ/MBygqKopgWcYYE32aO3pYu6eWfZteo6F6GT2ta0luaCehsYSUjpGky6W0pZXS40mlOwMC2k1Whp/RY1IomF7GsFHZJPpO7RAeyQCYx1HdP6paE/63VkSeBqYDxwyA8NnBAoCKigqbqNgYEzNUlX0NHazftoe6rctpqHsBd/N2Eus9eJrLGdJdRo/307Sn5hPyuWj1gc/VSv6IRIomDyd/ShFZw5KRBIloXREJABHJAC4Abu3TlgIkqGpr+PFlwP2ReD1jjIlm/kCITTVNbNu6kfody2hteg1fUw2u+jx8beUUBM+hI/VGurw59KRDs/aQkdrJxHIfhdPLGD4mF2+K57TX2Z9hoI8Ds4FcEakGvg14AFT1V+HVPgwsUdX2PpsOBZ4Wkbde54+q+mzkSjfGmOjQ3NHDmj2H2bdpJY3Vy/C3riOloZWExlJSO8rIlKtpSS8l6PHRmQUBOsjNheKzsymYXkpuYRou15n/WpaoRl9vS0VFhdp8AMaYaKSq7K3vYP32PRzZ+hINtS/hbt1GYr0LT9NoUrtHEkgqoy2tABUXaIhkTxvDC1MoqiilYFI+aTlewh+OI0ZEVg/0u1ZROSGMMcZEi7e7c7ZsoGHni7Q2r8DbWIOrIQdv62gKA5NpT72OLl8ePenQpD1kpIS7c2acue6ck2EBYIwxfTR1+MOjc1bSFO7OSW5sIaGhhJSOUWTIlbSmjSTgSaYrCwJ0kpcTouisLAqmlZJXnI7LPTjusmMBYIyJW8fqznG1biOpIQF3Uzl5XSMJJt1Oa2ohIZ/77dE5RQWJFJ1TQP7kAjLyfBHvzjlTLACMMXEjGFK2HGphU9Um6rf/k9amV/E2Vfd257SUUxg4m46UD9OZPIRAGjSlBshI7mBCeTKFM0YyYkwe3tTo7M45GRYAxpiY5Q+E2FDdxLaqtdTvXEp7y0qSG2txHSkitb2cTK6gNX0kPZ7Ut7tzcrOVsyZmkj+tlKElGbg8g6M752RYABhjYkanP8jaPUfYtekNGvb+k662VaTUN5NQP5LMjnKyXB+hJb2UkDeJVi/4XG0U5HspmppP/uQCMocmD9runJNhAWCMGbSaO3tYs+sQeze+RmPNUoKt6/HVd5HQWE5Oxyg08ZO0pBUTSnbT7FNSE9soH+mleMYo8icOJTk90elfwVEWAMaYQaOutZvVO2o4sGk5DQf/ibRX4a1T3I2jGdo9ioD3zt4LtikJNCcHSfN1MKHcR9G5oxgxNpek5Njpv48ECwBjTNSqbuxgzba91Fa9QFPdMtyt2/DUeUlsHk2+v5zu5Dm0p4wgkA5NGiAztZPJ41IoOncUw0Zl40lyOf0rRDULAGNMVFBVdta1s37Ldo5seZ7mhpdIatmNuz4db9MYCgJTaE+9kS5fHv4MaFI/OZk9jJuYTuHMspi/YHs6WAAYYxwRCinbalt5c1MV9VuX0NL8yts3TEtuGU1R6IO0pn0Sf1JmeIROF3m5IYon5VA4vZTcglQSHLh/TiyxADDGnBGqyo7aNtZVbebIludoaVqOr7EG15F8UltHk8kcWtNH0eNJpSMbeqSDYcNcFE8dRuE5xafldsjxzgLAGHNavNWls27zVo5sXkJz44v4Gvfjqh9OassYMrmSloxRBBKTacsBb0IbBQVeiqcVUjC5gPTcyN8wzbybBYAxJiJUlT31Hayp2s6RLUtobngBb+M+XEeGkNIyhgwupyV9FAFP6tsH/OIiLyXnllJw9ghSs5Kc/hXijgWAMeakqCr7GzpZvWUHtVVLaa5fhrd5D666XJJbxlAYupjW9HJ6EtNoz4FAQjuFBUmUziymYHI+adlep3+FuGcBYIzpt/0NHazesovDm/9JU93zeJt3467PJLlpHEWhC2hNuwN/UgYd2RCQdkbkJ1I6o5DCKQWk5/qcLt8cxQLAGHNcB5o6WbVlD4ereg/4iS07cdelkdw0luLgebSlf4LupKy3L9oOH+6mZHo+RecUkp47eO+SGS8sAIwxb2vu6OH17dXsX/88DYeexdOyFU9dCt6mcRQFptOWdivd3mw6s3tvnDZ0WAIlFcMpnlZMxhA74A82FgDGxLGuniCrdx9h+/pXaNy3mFDrWpLqhMSGcRT6J9Ge+hG6fLlvj8MfOgRKKoZSNK2kd1imHfAHtf5MCr8QuAqoVdWJx1g+G/g/YHe46S+qen942Rzgp4ALeERVvx+Zso0xJyMYUqpqmtmwYS3125+hq+U1fPUtuI6MYVjHGPzJ99CWWkBPBjRpN0PyQpScM4Ti6SVkD0+xcfgxpj9nAI8BDwK/fZ91XlbVq/o2iIgLeAi4FKgGVonIIlWtOslajTED9NaMV5WbtlJXtZiWxhdJbjxAQl0xWW1jwf1xWtJHEkp105gSICuti4pJ6RTPKmdIcToJdsCPaScMAFVdLiIlJ7Hv6cAOVd0FICJPAHMBCwBjTqMjbd28vnkvBzcupeHwEpKad+CuyyW1eRyZXEVzRjlBr4/mJCUtqY0JY5MpnVXO8LG5eBLt5mnxJFLXAM4VkfXAAeDLqroJyAf291mnGpgRodczxoR1+AO8sfMwu9e+REPNYqR1A4m1Sfgax1EUmEFr+m34kzLf/vJVaYmX0vNGUTRpeExNb2gGLhIBsAYoVtU2EfkQ8FegfKA7EZH5wHyAoqKiCJRlTGxSVbYcamXd+jXUbV1Ed/Or+I504jkylhFdY+lKuYKOlOFvX7gdNkwYOSOf4mlFNhbfvMspB4CqtvR5vFhEfiEiuUANUNhn1YJw2/H2swBYAFBRUaGnWpcxsaSx3c+KzXupWb+Yprrn8DbswVVbSHbreDTxDlrTSwiku2hK6yEn08/EKdmUfGAkuQVpduHWHNcpB4CIDAMOq6qKyHQgAagHmoByESml98A/D7j5VF/PmHgQCIZYt6+BqjWvUr9nEdq6hsTDbnwNEykKzqY5YywBb2pvP763jbPGp1B6wRiGl2XZPfFNv/VnGOjjwGwgV0SqgW8DHgBV/RVwA3CniASATmCeqioQEJG7gefoHQa6MHxtwBhzDDVNnby+YQuHNz5Da8Pz+OrrcNeVM6xjPN2+L9Kemk9XFgTppKDQQ9msUoqn5uNLi+95bc3Jk95jdXSpqKjQyspKp8sw5rTq6gny+o5D7FyzjIaav+Fu3oynNpOUpokkyjiaM8oJuZIQDZCd3sXIqYWUzhpFbkGqfQHLvIeIrFbVioFsY98ENuYM2t/QwevrN3B445/pbFqOt64Dz5HxFHRPpD3tRrq8ObTnQMjVRvkoLyPPH0vBhDwSvfanaiLP/lcZcxr1BENU7jrCttXPU7fvaTyNVbhrh5DefDYZ7k/RklFKIN1Fo/oZmhekbOZwSmeW2Ggdc0ZYABgTYUfaunl1w3YOrvsrrQ1L8dU14Knt/ZTflvZRur1ZtORCWmIrZ01IYeQFYxhWnoXL5rc1Z5gFgDGnKBRSNtU0s371q9Tt+gs0VpJ4OIXUxkmky400ZZYTSPfQqH6GDQlSPquA0pnFpGTYDFjGWRYAxpyEtu4AKzbvY++aZ2g8vBhf/X7ch8sZ1jGBrpSv05E8lLYc8LnaGDvWR/mF4xgxNgeX2z7lm+hhAWBMPx1u6eKVNRs48OaT+BtfxHtI8TWcTWHwUpozxxJM8dGYHCA3s5tJM/Mom1VGRl6y02Ubc1wWAMYch6qy7VArlateoXbbk0jjajyH8shqmkzI+1la04rpzIKgtFNSkkT5RWMoOnsYniS7oZoZHCwAjOkjEAxRubuOzW88x5H9f8F7ZDvuQ6MY1jGJjrQr6fLm0JwbIiO5nXOmplM2e4yNyzeDlgWAiXsd/gCvVu1lV+VfaTn8DL7aehJrz6Kg51xaMu8gkJJMY3IPQ3L8TP/gCMrOG0lyun371gx+FgAmLjW2+1m+tor9656gq34ZvoNCSv1kRiRcT3PGaHoy3LTQSWGRhzEXl1M0eYR17ZiYYwFg4kZdazcvr3mT6vV/IFD7EkkHM8lsnkIo6bO0phXRHh61M368l9GXTGBYebbNiGVimgWAiWmHmrt4edVqat78HVr/GkkHhpDTMpXulK/SmTyU5pze/vxpFRmMumgs2cNTnC7ZmDPGAsDEnP0NHbz6+koOVP2ehCOVJB4sYEjrFDrTvkmXN4em3BA56R2cc/4wyi8YZf35Jm5ZAJiYsL+hg5dXvMzBLb/HU7cOz8FShrdPoS39KvzeTJqSAuRldzNzdgFls0rxpthUiMZYAJhB63BLFy+9tpLqjY/hPryaxIOjGdExmdaMG+hJTqPJ18PQvB7GX1zMyJnFJPrsv7sxfdlfhBlUGtv9vLRqHXvWPgqHV5B0oJTh7RW0ZF5HICWVpuRuRgxXxl9WRklFAZ5EG7ljzPFYAJio19rVw/K1VexatZDAoZfwHhjBkNYK2jO+iz85nSafnxEjQkycM5qSqSNsSkRj+skCwEQlfyDEyxt3suW1X9Nd8xzeA9nkNE+jI+2bdHuzaUrqYVheDxMvH0npjEL7pG/MSbAAMFFDVVm3t47VLz1J097H8e13k9E4HX/KV+n05dGUGyQvq5OJlxZRdl6JzZJlzCnqz6TwC4GrgFpVnXiM5bcAXwMEaAXuVNX14WV7wm1BIDDQ+SpNfNhf387Ly5dQs+VRkmsOk1I7jTzPv9CWVkRzTpCc9HamXTSC8vPLbPSOMRHUn49QjwEPAr89zvLdwAWq2igiVwALgBl9ll+oqkdOqUoTc1q6enjh9TXsXP0wnpo1+A6czYjQHJoyx9KenUCqp5mZH8xi3JwJNk7fmNPkhAGgqstFpOR9lq/o83QlUBCBukwMUlXe2HaAtS89QueeRXhrChnWPoOWrBvpzkhCaWPi2Ymcde0UskekOV2uMTEv0p2otwP/6PNcgSUiosDDqrrgeBuKyHxgPkBRUVGEyzJOOtzSxfMvPMuBjb8keV876fXn4Ur7Bn5fJi3eLgqLYNK1E8kfl4fYvXeMOWMiFgAiciG9ATCrT/MsVa0RkSHAUhHZoqrLj7V9OBwWAFRUVGik6jLO6AmGePnN7Wx89SHY/TIpByYzlOtpyRhFc06IvIw2Jl1VQtm5xbg9NoLHGCdEJABE5GzgEeAKVa1/q11Va8L/1orI08B04JgBYGLD/vp2li39E3VbFpK6N5Xc1vNoyfweXRlekBamzkzm7LlTSMm0CdGNcdopB4CIFAF/AT6mqtv6tKcACaraGn58GXD/qb6eiT7BkPLqxh2se/HHJOxaRcrBGeQk3klHynCaE/3k5wc554aJjBiXZzNnGRNF+jMM9HFgNpArItXAtwEPgKr+CvgWkAP8IvzH/dZwz6HA0+E2N/BHVX32NPwOxiH1bd0sWbaYmrU/J3WPl5y282nOmktHloe0xEZmXTqUcZeOsfH6xkQpUY2+7vaKigqtrKx0ugxzHOt2HWTFkp8R2L6U1JpzSHDPoj01n4RQFyVlCUy/+VxyCjOcLtOYuCIiqwf6XSv7aGb6JRAM8cKqdWx46Xv4djSR3nQBbZnfpTMziRRXI7Muy2X8nAk2baIxg4gFgHlfzZ09PLt0ETWVPyF1dz55gctpyRhFS5afgnw/02+exrDyXKfLNMacBAsAc0y7a5v5599/QefGv5JWPZ103xfoTslGtIVzzvMx+boP2m0ZjBnkLADMu2zcc4gX/3Y/CZuqSK+fTSDz3+nISiI9sZ7zryti1PllNlG6MTHCAsCgqrxetZOVi/8N75ZmMtsuoznrBlqyAowY3skHbpvBkJHZTpdpjIkwC4A4FgopL1auZd2Sb5G6zUd24DJa08toy+hg/ERl+scuICXDvrBlTKyyAIhDoZDywhtvsOEf3yBlZwFZchMdKcMh1ELFLB9Tbjjfxu4bEwfsrzyOqCrL3qjkzb/fR/qOUlITP0N3ajYuaeD8q/IYP2c2LpdNp2hMvLAAiAOqyourKln/t2+QtrOUtMTP0JWeRYqrjtk3F1P2gQvtFg3GxCELgBj3xsbNrHjqi6RvKyEl6TN0pWeS6qrloo+VUDrDDvzGxDMLgBi1dW8NS/54D75NaaS676AzPYtU12EuuW0kJdPswG+MsQCIOQfqm3n6d1/Ds7aJFP0wnanDSJZaPvSJUkpnXOR0ecaYKGIBECM6uwP86ckf0fXia6R0z6U9tZiE0BEuun4IYy+xT/zGmPeyABjkVJVnX1rCrj8/QFrdlQQzP48/oYmZFycz5fob7Vu7xpjjsgAYxDbv3sPSRz9Lxo7JSPpXaE8LMG5iN+d/eq5Ns2iMOSELgEGoo7uHP/z6m8grDXgTP01bRgpDs+u44itzSclOdro8Y8wgYQEwyLy4cjlVv/sBvubr6UgtIUUOcPXnpjF8/AinSzPGDDIWAIPEkeZW/vSzfyF10yg041783jZmXpzE1BtusQu8xpiTYgEwCPzj+afZ//s/kchHaMtIZ1jOIa6870a8qXajNmPMyevXjV9EZKGI1IrIxuMsFxH5mYjsEJE3RWRqn2W3icj28M9tkSo8HjS1tvPQd26m9pFt9CTNR9xdXP3pMq7/z1vt4G+MOWX9PQN4DHgQ+O1xll8BlId/ZgC/BGaISDbwbaACUGC1iCxS1cZTKToeLHt1CdsXLsSj82hPS6G0uI7LvzrPbtZmjImYfgWAqi4XkZL3WWUu8FtVVWCliGSKyHBgNrBUVRsARGQpMAd4/JSqjmH+niC/+fk9eFYNI5Axn6TAIeZ+bjL5Z5U4XZoxJsZE6hpAPrC/z/PqcNvx2t9DROYD8wGKiooiVNbgsrummmf/63N4Wj9Ke3ouhSMOcOV9N+Ny26d+Y0zkRc1FYFVdACwAqKioUIfLOeOeXfK/HPjtcjT5swTdLVx6Ux6jZ1/idFnGmBgWqQCoAQr7PC8It9XQ2w3Ut/3FCL1mTAiFlMd++kUSKkvoTPswaa5d3PjDm/Fl2Be6jDGnV6T6FhYBHw+PBpoJNKvqQeA54DIRyRKRLOCycJsBmlrbePhLHyW0/lw6UsZRPqaOjz14ux38jTFnRL/OAETkcXo/yeeKSDW9I3s8AKr6K2Ax8CFgB9ABfDK8rEFEvgusCu/q/rcuCMe7nXt2sOw7/wnuTxF0dXDJrXmMPv8yp8syxsSR/o4CuukEyxW46zjLFgILB15a7Hr55WfZ8avl+NNuxRfYzY3/dQNpQzKcLssYE2ei5iJwvHjqdz+m9dkEOtIuIdO7hXkPfBqX2+7caYw58ywAzqDHfvglghsm05U6jJLSfVz5tc86XZIxJo5ZAJwBqsoj//ZpqLmcQJKXaZcGmX7DJ5wuyxgT5ywATrNAIMijX70dmq+HhAAXf2IYo887x+myjDHGAuB0CgSCLLz3DkJd83BpE1d9ZRojxpU5XZYxxgAWAKdNIBDk0S/cQbBnHp7AYW783hVkjshzuixjjHmbBcBpEAgEWfj5+QQDN5HYc5CP/OBq0odkO12WMca8iwVAhGkoxK/v+TSBwDwSe6qZ98B1pObYGH9jTPSxAIggVeXRL99Jj/9GEnuquelH15GSbQd/Y0x0sgCIoF9/43P0tF6LJ1DHDd+7yg7+xpioZgEQIb//wX34a+fgCrZwzTdn2QVfY0zUs5lGIuCZPzxE55apiPq57AvjGVpW4nRJxhhzQnYGcIreePkfHF6SSiAxmenXJlAy+SynSzLGmH6xM4BTULN/NxsX7KDLO4LSKQc558o5TpdkjDH9ZgFwkgKBAM9+8xE6UyaQk7uWOZ+93emSjDFmQCwATtJv7vkiXb6LSQ6uYt73vup0OcYYM2B2DeAk/OmB7+Dv/hBJPTu55ZdfcLocY4w5KRYAA7T+tWW0bBqLS9qZ87VZJPq8TpdkjDEnxbqABqCzq5PVv1iDPzGbkbPaKBg3zumSjDHmpPUrAERkjohsFZEdIvL1Yyz/sYisC/9sE5GmPsuCfZYtimDtZ9wf7/0mnSlTSU1cySWfus3pcowx5pScsAtIRFzAQ8ClQDWwSkQWqWrVW+uo6r191v8cMKXPLjpVdXLEKnbIX3/xI7qDl+Ht3sytD97ndDnGGHPK+nMGMB3Yoaq7VNUPPAHMfZ/1bwIej0Rx0eJg9R6OvJ6HK9jJJV893yZxN8bEhP4EQD6wv8/z6nDbe4hIMVAKLOvT7BWRShFZKSLXHu9FRGR+eL3Kurq6fpR15iz+1v/Q7Ssgt2w7xRPsm77GmNgQ6YvA84CnVDXYp61YVSuAm4GfiMgx50RU1QWqWqGqFXl50XMjtSf/33/Q5bkQX/cqrr/vK06XY4wxEdOfAKgBCvs8Lwi3Hcs8jur+UdWa8L+7gBd59/WBqFazdzvNVWV4epq46t8/6nQ5xhgTUf0JgFVAuYiUikgivQf594zmEZGxQBbwWp+2LBFJCj/OBc4Dqo7eNlo9+53f4PcOZcj4fQwpLnG6HGOMiagTjgJS1YCI3A08B7iAhaq6SUTuBypV9a0wmAc8oaraZ/NxwMMiEqI3bL7fd/RQNPv7//ycbvcFeLtWce2Xv+Z0OcYYE3H9+iawqi4GFh/V9q2jnv/7MbZbAQy6q6ZtbS0ceiUZl7uDi75id/g0xsQm+ybwMfzv179Hl6+UlLw1lE6Y5HQ5xhhzWti9gI6yadWrdHeehzewjXk//6bT5RhjzGljZwBHef2hZQTdPkovT8bt8ThdjjHGnDYWAH38/X9+QWfSufh6VnLRzR93uhxjjDmtLADCAj09HHrZjTvQzoVfvtbpcowx5rSzAAh74tv305U8Cm/qG5SOH3QDl4wxZsDsIjDQ0lBP58EJJOlBPvKA3enTGBMf7AwA+PO3HsCfNITU0p34UlOcLscYY86IuD8D2LetCn/nTLyBbdxw3786XY4xxpwxcX8G8M8fPk7Ak8bQcwM27NMYE1fiOgB2rF2FX2fi7VjHVZ+52+lyjDHmjIrrAFj+4DMEXUkUXZrhdCnGGHPGxW0AVL2+gu6EmXi71nDpx253uhxjjDnj4jYAVj78T0IJbkZeeczZLY0xJubFZQBsXLGcLvcMfF2VXPiRW5wuxxhjHBGXAfDGo8tQcVF2TbHTpRhjjGPiLgB2V22gO2E6vs51XHD9zU6XY4wxjom7AHjhJ08ScnkZdr5949cYE9/iKgDqqvfRE5yGt2MjH7rjTqfLMcYYR/UrAERkjohsFZEdIvL1Yyz/hIjUici68M8dfZbdJiLbwz+3RbL4gfr7fz1MwJNK1qROJ8swxpiocMJ7AYmIC3gIuBSoBlaJyCJVrTpq1T+p6t1HbZsNfBuoABRYHd62MSLVD0BrYwP+zql4A9v58L1fOdMvb4wxUac/ZwDTgR2quktV/cATwNx+7v9yYKmqNoQP+kuBOSdX6ql5+rv/TU9iFsllB5CEuOr5MsaYY+rPkTAf2N/neXW47WjXi8ibIvKUiBQOcFtEZL6IVIpIZV1dXT/K6r/uzk66GyaQ1LmPG/71GxHdtzHGDFaR+ij8N6BEVc+m91P+bwa6A1VdoKoVqlqRl5cXobJ6/fk/foDfO5TEYdvwJCZGdN/GGDNY9ScAaoDCPs8Lwm1vU9V6Ve0OP30EOKe/255uqkpHdTGJXYe57t/ec/3aGGPiVn8CYBVQLiKlIpIIzAMW9V1BRIb3eXoNsDn8+DngMhHJEpEs4LJw2xnzzEM/p9tXjDt1Hamp6WfypY0xJqqdcBSQqgZE5G56D9wuYKGqbhKR+4FKVV0EfF5ErgECQAPwifC2DSLyXXpDBOB+VW04Db/HcdWu8uPydHDxlz95Jl/WGGOinqiq0zW8R0VFhVZWVp7yfta+9Dwr/hjC1/MKn1r4nQhUZowx0UlEVqtqxUC2ienxkGt/txwQRl0z3ulSjDEm6sRsADQePkSPnoO3cwPnX/tRp8sxxpioE7MB8LcfPETAk0rquDanSzHGmKh0wovAg1EwEMDfUE6SVnPdl2zopzHGHEtMngH87Wc/o9tbgDujCk+ix+lyjDEmKsVkANSvF9w9bVz+5flOl2KMMVEr5gKgculiurxn4WEVw4tGOl2OMcZErZgLgDefWAUo42+c5nQpxhgT1WIqAOoO7Mcv5+DtXM/MOdc4XY4xxkS1mAqAZx9YQNCdTPpEv9OlGGNM1IupYaDd9aUkyQGuvcdm/DLGmBOJmTOA5379CN2+EhKSN9rQT2OM6YeYCYCa5bUkBP3Mmn+906UYY8ygEBMBcGDXDrrdk0n0r2X0ZBv9Y4wx/RETAbD0p48RcnnJnmJdP8YY01+D/iJwKBSip3k0Sbqfq+/6gtPlGGPMoDHozwD+8fAv6fYW4ErbjNtjZwDGGNNfgz4ADr3eSkKwm9l33eJ0KcYYM6gM6gDYs2Ujfs9kkvxrKB13ltPlGGPMoNKvABCROSKyVUR2iMh7brAvIl8UkSoReVNEnheR4j7LgiKyLvyzKJLFv/jg44RcieSemxbJ3RpjTFw44UVgEXEBDwGXAtXAKhFZpKpVfVZbC1SoaoeI3An8P+CteRg7VXVyZMuGQE8PgbbxJOkervqXuyK9e2OMiXn9OQOYDuxQ1V2q6geeAOb2XUFVX1DVjvDTlUBBZMt8r8W/fIhu73DcmdtJcLlO98sZY0zM6U8A5AP7+zyvDrcdz+3AP/o894pIpYisFJFrj7eRiMwPr1dZV1d3wqLqVvtxBTq5+HOfOOG6xhhj3iuiF4FF5FagAvhhn+ZiVa0AbgZ+IiJlx9pWVReoaoWqVuTl5b3v6+x4cy3dSZPwBNZQOGpMpMo3xpi40p8AqAEK+zwvCLe9i4hcAnwDuEZVu99qV9Wa8L+7gBeBKadQLwCvPPwUmuBh+KycU92VMcbErf4EwCqgXERKRSQRmAe8azSPiEwBHqb34F/bpz1LRJLCj3OB84C+F48HLBQKEWgfS1LnXq64/c5T2ZUxxsS1E44CUtWAiNwNPAe4gIWquklE7gcqVXURvV0+qcD/igjAPlW9BhgHPCwiIXrD5vtHjR4asOceeZhu7xhS3EsJv5YxxpiT0K97AanqYmDxUW3f6vP4kuNstwKI6De0Dr7WQILbzwfvujGSuzXGmLgzqL4JXFdTjd81mUT/esrOmup0OcYYM6gNqgB49icPE3T7SB8XdLoUY4wZ9AbV7aD9tfkkJtQx954vOl2KMcYMeoPmDGDFor/Q5RuNy/MmiV6v0+UYY8ygN2gCYMuidaAhzrrxA06XYowxMWFQBEBnezuB0CS8nZuZdumVTpdjjDExYVAEwP/96L/pScwiKb/2xCsbY4zpl0FxEbh9ZwpudytXfulup0sxxpiYEfVnAJtXvUZ30kTcuo6s3KFOl2OMMTEj6gNg5a//hia4KZp92qcYMMaYuBLVXUCBnh6CHRPw6m4u/fjtTpdjjDExJarPAP6x4Jd0e4fjytjhdCnGGBNzojoA6la1kRDsZvZdtzhdijHGxJyoDYDD+3bjd08i0b+ekjETnS7HGGNiTtQGwHM/eYSg20fW2TbhuzHGnA5RexG4p76YxITDXPP5e5wuxRhjYlJUngG0NTbQ5RuFK2kjbo/H6XKMMSYmRWUAdDV3gQaZestFTpdijDExKyoDQEnG21nF5A9e7HQpxhgTs/oVACIyR0S2isgOEfn6MZYnicifwstfF5GSPsv+Ndy+VUQu78/rqbjwFTf0+5cwxhgzcCcMABFxAQ8BVwDjgZtEZPxRq90ONKrqKODHwA/C244H5gETgDnAL8L7e//X1CBXf+negfwexhhjBqg/ZwDTgR2quktV/cATwNyj1pkL/Cb8+CngYhGRcPsTqtqtqruBHeH9vS+hg7TMzH7+CsYYY05GfwIgH9jf53l1uO2Y66hqAGgGcvq5LQAiMl9EKkWkMpSo/aveGGPMSYuai8CqukBVK1S1YsiIY2aEMcaYCOpPANQAhX2eF4TbjrmOiLiBDKC+n9saY4xxQH8CYBVQLiKlIpJI70XdRUetswi4Lfz4BmCZqmq4fV54lFApUA68EZnSjTHGnIoT3gpCVQMicjfwHOACFqrqJhG5H6hU1UXAo8DvRGQH0EBvSBBe70mgCggAd6lq8DT9LsYYYwZAej+oR5eKigqtrKx0ugxjjBk0RGS1qlYMZJuouQhsjDHmzLIAMMaYOGUBYIwxccoCwBhj4lRUXgQWkVZgq9N1RIlc4IjTRUQBex/eYe/FO+y9eMcYVU0byAbROiPY1oFezY5VIlJp74W9D33Ze/EOey/eISIDHjppXUDGGBOnLACMMSZORWsALHC6gChi70Uvex/eYe/FO+y9eMeA34uovAhsjDHm9IvWMwBjjDGnmQWAMcbEqagKgBNNPh8vRKRQRF4QkSoR2SQiX3C6JqeJiEtE1orIM07X4iQRyRSRp0Rki4hsFpFzna7JKSJyb/jvY6OIPC4iXqdrOlNEZKGI1IrIxj5t2SKyVES2h//NOtF+oiYA+jn5fLwIAF9S1fHATOCuOH4v3vIFYLPTRUSBnwLPqupYYBJx+p6ISD7weaBCVSfSe6v6ec5WdUY9Bsw5qu3rwPOqWg48H37+vqImAOjf5PNxQVUPquqa8ONWev/I43aeTBEpAK4EHnG6FieJSAZwPr3zb6CqflVtcrQoZ7kBX3gWwmTggMP1nDGqupzeuVf6mgv8Jvz4N8C1J9pPNAVAvyeQjyciUgJMAV53uBQn/QT4KhByuA6nlQJ1wK/D3WGPiEiK00U5QVVrgAeAfcBBoFlVlzhbleOGqurB8ONDwNATbRBNAWCOIiKpwJ+Be1S1xel6nCAiVwG1qrra6VqigBuYCvxSVacA7fTjND8Whfu359IbiiOAFBG51dmqokd4St4TjvGPpgCwCeT7EBEPvQf/P6jqX5yux0HnAdeIyB56uwUvEpHfO1uSY6qBalV962zwKXoDIR5dAuxW1TpV7QH+AnzA4ZqcdlhEhgOE/6090QbRFAD9mXw+LoiI0NvPu1lV/9vpepykqv+qqgWqWkLv/4llqhqXn/RU9RCwX0TGhJsupne+7Xi0D5gpIsnhv5eLidML4n0sAm4LP74N+L8TbRA1dwM93uTzDpfllPOAjwEbRGRduO0+VV3sXEkmSnwO+EP4Q9Iu4JMO1+MIVX1dRJ4C1tA7am4tcXRbCBF5HJgN5IpINfBt4PvAkyJyO7AX+MgJ92O3gjDGmPgUTV1AxhhjziALAGOMiVMWAMYYE6csAIwxJk5ZABhjTJyyADDGmDhlAWCMMXHq/wNNJr3SEAbiHAAAAABJRU5ErkJggg==\n", "text/plain": [ "
" ] @@ -585,7 +585,7 @@ " + \" seconds.\"\n", ")\n", "print(\"Consumption functions for each discrete state:\")\n", - "plotFuncs(SerialRExample.solution[0].cFunc, 0, 10)" + "plot_funcs(SerialRExample.solution[0].cFunc, 0, 10)" ] }, { diff --git a/examples/ConsumptionSaving/example_ConsMarkovModel.py b/examples/ConsumptionSaving/example_ConsMarkovModel.py index 229ffdfb2..c8bfba087 100644 --- a/examples/ConsumptionSaving/example_ConsMarkovModel.py +++ b/examples/ConsumptionSaving/example_ConsMarkovModel.py @@ -1,6 +1,6 @@ # -*- coding: utf-8 -*- # %% -from HARK.utilities import plotFuncs +from HARK.utilities import plot_funcs from time import process_time from copy import deepcopy, copy import numpy as np @@ -132,7 +132,7 @@ ] # %% [markdown] -# Note that $\texttt{MarkovConsumerType}$ currently has no method to automatically construct a valid IncomeDstn - $\texttt{IncomeDstn}$ is manually constructed in each case. Writing a method to supersede $\texttt{IndShockConsumerType.updateIncomeProcess}$ for the “Markov model” would be a welcome contribution! +# Note that $\texttt{MarkovConsumerType}$ currently has no method to automatically construct a valid IncomeDstn - $\texttt{IncomeDstn}$ is manually constructed in each case. Writing a method to supersede $\texttt{IndShockConsumerType.update_income_process}$ for the “Markov model” would be a welcome contribution! # %% # Interest factor, permanent growth rates, and survival probabilities are constant arrays @@ -153,10 +153,10 @@ + " seconds." ) print("Consumption functions for each discrete state:") -plotFuncs(SerialUnemploymentExample.solution[0].cFunc, 0, 50) +plot_funcs(SerialUnemploymentExample.solution[0].cFunc, 0, 50) if SerialUnemploymentExample.vFuncBool: print("Value functions for each discrete state:") - plotFuncs(SerialUnemploymentExample.solution[0].vFunc, 5, 50) + plot_funcs(SerialUnemploymentExample.solution[0].vFunc, 5, 50) # %% # Simulate some data; results stored in cHist, mNrmNow_hist, cNrmNow_hist, and MrkvNow_hist @@ -241,7 +241,7 @@ ) print("Consumption functions for each discrete state:") mNrmMin = np.min([ImmunityExample.solution[0].mNrmMin[j] for j in range(StateCount)]) -plotFuncs(ImmunityExample.solution[0].cFunc, mNrmMin, 10) +plot_funcs(ImmunityExample.solution[0].cFunc, mNrmMin, 10) # %% [markdown] # ### 3. Serial permanent income growth @@ -305,7 +305,7 @@ + " seconds." ) print("Consumption functions for each discrete state:") -plotFuncs(SerialGroExample.solution[0].cFunc, 0, 10) +plot_funcs(SerialGroExample.solution[0].cFunc, 0, 10) # %% # Make a consumer with serially correlated interest factors @@ -328,4 +328,4 @@ + " seconds." ) print("Consumption functions for each discrete state:") -plotFuncs(SerialRExample.solution[0].cFunc, 0, 10) +plot_funcs(SerialRExample.solution[0].cFunc, 0, 10) diff --git a/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb b/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb index 13bd84c76..21cad351e 100644 --- a/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb +++ b/examples/ConsumptionSaving/example_ConsPrefShockModel.ipynb @@ -383,7 +383,7 @@ "source": [ "if KinkyPrefExample.vFuncBool:\n", " print(\"Value function (unconditional on shock):\")\n", - " plotFuncs(\n", + " plot_funcs(\n", " KinkyPrefExample.solution[0].vFunc,\n", " KinkyPrefExample.solution[0].mNrmMin + 0.5,\n", " 5,\n", diff --git a/examples/ConsumptionSaving/example_ConsPrefShockModel.py b/examples/ConsumptionSaving/example_ConsPrefShockModel.py index a2aaf2352..30e613f24 100644 --- a/examples/ConsumptionSaving/example_ConsPrefShockModel.py +++ b/examples/ConsumptionSaving/example_ConsPrefShockModel.py @@ -1,6 +1,6 @@ # %% import matplotlib.pyplot as plt -from HARK.utilities import plotFuncs +from HARK.utilities import plot_funcs from time import process_time import numpy as np from HARK.ConsumptionSaving.ConsPrefShockModel import ( @@ -102,7 +102,7 @@ # %% if PrefShockExample.vFuncBool: print("Value function (unconditional on shock):") - plotFuncs( + plot_funcs( PrefShockExample.solution[0].vFunc, PrefShockExample.solution[0].mNrmMin + 0.5, 5, @@ -170,7 +170,7 @@ # %% if KinkyPrefExample.vFuncBool: print("Value function (unconditional on shock):") - plotFuncs( + plot_funcs( KinkyPrefExample.solution[0].vFunc, KinkyPrefExample.solution[0].mNrmMin + 0.5, 5, diff --git a/examples/ConsumptionSaving/example_ConsRepAgentModel.py b/examples/ConsumptionSaving/example_ConsRepAgentModel.py index 8730285bb..5757ff539 100644 --- a/examples/ConsumptionSaving/example_ConsRepAgentModel.py +++ b/examples/ConsumptionSaving/example_ConsRepAgentModel.py @@ -2,7 +2,7 @@ from copy import deepcopy from time import time import numpy as np -from HARK.utilities import plotFuncs +from HARK.utilities import plot_funcs from HARK.ConsumptionSaving.ConsIndShockModel import ( init_idiosyncratic_shocks ) @@ -50,7 +50,7 @@ print( "Solving a representative agent problem took " + str(t_end - t_start) + " seconds." ) -plotFuncs(RAexample.solution[0].cFunc, 0, 20) +plot_funcs(RAexample.solution[0].cFunc, 0, 20) # %% # Simulate the representative agent model @@ -84,7 +84,7 @@ + str(t_end - t_start) + " seconds." ) -plotFuncs(RAmarkovExample.solution[0].cFunc, 0, 10) +plot_funcs(RAmarkovExample.solution[0].cFunc, 0, 10) # %% # Simulate the two state representative agent model diff --git a/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb index 26eb51a60..570b8fb3b 100644 --- a/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb +++ b/examples/ConsumptionSaving/example_TractableBufferStockModel.ipynb @@ -110,7 +110,7 @@ "# Plot the consumption function and whatnot\n", "m_upper = 1.5 * ExampleType.mTarg\n", "conFunc_PF = lambda m: ExampleType.h * ExampleType.PFMPC + ExampleType.PFMPC * m\n", - "# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper)\n", + "# plot_funcs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper)\n", "plot_funcs([ExampleType.solution[0].cFunc, ExampleType.solution[0].cFunc_U], 0, m_upper)" ] }, @@ -265,7 +265,7 @@ "print(\n", " 'Solving the same model \"the long way\" took ' + str(t_end - t_start) + \" seconds.\"\n", ")\n", - "# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper)\n", + "# plot_funcs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper)\n", "plot_funcs(MarkovType.cFunc[0], 0, m_upper)\n", "diffFunc = lambda m: ExampleType.solution[0].cFunc(m) - MarkovType.cFunc[0][0](m)\n", "print(\"Difference between the (employed) consumption functions:\")\n", diff --git a/examples/ConsumptionSaving/example_TractableBufferStockModel.py b/examples/ConsumptionSaving/example_TractableBufferStockModel.py index 044758e81..28571dc99 100644 --- a/examples/ConsumptionSaving/example_TractableBufferStockModel.py +++ b/examples/ConsumptionSaving/example_TractableBufferStockModel.py @@ -42,7 +42,7 @@ # Plot the consumption function and whatnot m_upper = 1.5 * ExampleType.mTarg conFunc_PF = lambda m: ExampleType.h * ExampleType.PFMPC + ExampleType.PFMPC * m -# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) +# plot_funcs([ExampleType.solution[0].cFunc,ExampleType.mSSfunc,ExampleType.cSSfunc],0,m_upper) plot_funcs([ExampleType.solution[0].cFunc, ExampleType.solution[0].cFunc_U], 0, m_upper) if do_simulation: @@ -115,7 +115,7 @@ print( 'Solving the same model "the long way" took ' + str(t_end - t_start) + " seconds." ) -# plotFuncs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) +# plot_funcs([ExampleType.solution[0].cFunc,ExampleType.solution[0].cFunc_U],0,m_upper) plot_funcs(MarkovType.cFunc[0], 0, m_upper) diffFunc = lambda m: ExampleType.solution[0].cFunc(m) - MarkovType.cFunc[0][0](m) print("Difference between the (employed) consumption functions:") diff --git a/examples/GenIncProcessModel/GenIncProcessModel.ipynb b/examples/GenIncProcessModel/GenIncProcessModel.ipynb index f5bede365..6fdbc2492 100644 --- a/examples/GenIncProcessModel/GenIncProcessModel.ipynb +++ b/examples/GenIncProcessModel/GenIncProcessModel.ipynb @@ -121,7 +121,7 @@ "The \"constructed\" inputs above are using expected attributes and are drawn on various methods as explained below.\n", "\n", "\n", - "* The input $\\texttt{IncomeDstn}$ is created by the method `updateIncomeProcess` which inherits from `IndShockConsumerType`.\n", + "* The input $\\texttt{IncomeDstn}$ is created by the method `update_income_process` which inherits from `IndShockConsumerType`.\n", "\n", "* The input $\\texttt{pLvlNextFunc}$ is created by the method `updatepLvlNextFunc` which uses the initial sequence of $\\texttt{pLvlNextFunc}$, the mean and standard deviation of the (log) initial permanent income, $\\texttt{pLvlInitMean}$ and $\\texttt{pLvlInitStd}$. \n", "In this model, the method creates a trivial $\\texttt{pLvlNextFunc}$ attribute with no persistent income dynamics. But we can overwrite it by subclasses in order to make an AR1 income process for example. \n", diff --git a/examples/GenIncProcessModel/GenIncProcessModel.py b/examples/GenIncProcessModel/GenIncProcessModel.py index d3ad19f35..31e6e7416 100644 --- a/examples/GenIncProcessModel/GenIncProcessModel.py +++ b/examples/GenIncProcessModel/GenIncProcessModel.py @@ -132,7 +132,7 @@ # The "constructed" inputs above are using expected attributes and are drawn on various methods as explained below. # # -# * The input $\texttt{IncomeDstn}$ is created by the method `updateIncomeProcess` which inherits from `IndShockConsumerType`. +# * The input $\texttt{IncomeDstn}$ is created by the method `update_income_process` which inherits from `IndShockConsumerType`. # # * The input $\texttt{pLvlNextFunc}$ is created by the method `updatepLvlNextFunc` which uses the initial sequence of $\texttt{pLvlNextFunc}$, the mean and standard deviation of the (log) initial permanent income, $\texttt{pLvlInitMean}$ and $\texttt{pLvlInitStd}$. # In this model, the method creates a trivial $\texttt{pLvlNextFunc}$ attribute with no persistent income dynamics. But we can overwrite it by subclasses in order to make an AR1 income process for example. diff --git a/examples/Gentle-Intro/Gentle-Intro-To-HARK.ipynb b/examples/Gentle-Intro/Gentle-Intro-To-HARK.ipynb index 905c9a2a0..a060713f5 100644 --- a/examples/Gentle-Intro/Gentle-Intro-To-HARK.ipynb +++ b/examples/Gentle-Intro/Gentle-Intro-To-HARK.ipynb @@ -263,7 +263,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Yikes! Let's take a look at the bottom of the consumption function. In the cell below, the bounds of the $\\texttt{plotFuncs}$ function are set to display down to the lowest defined value of the consumption function." + "Yikes! Let's take a look at the bottom of the consumption function. In the cell below, the bounds of the $\\texttt{plot_funcs}$ function are set to display down to the lowest defined value of the consumption function." ] }, { @@ -546,7 +546,7 @@ "\n", "Suppose you were interested in changing (say) the amount of permanent income risk. From the section above, you might think that you could simply change the attribute $\\texttt{TranShkStd}$, solve the model again, and it would work.\n", "\n", - "That's _almost_ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you _actually_ want to change. Changing $\\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\\texttt{solve}$ method again). In the cell below, we invoke the method $\\texttt{updateIncomeProcess}$ so HARK knows to reconstruct the attribute $\\texttt{IncomeDstn}$." + "That's _almost_ true-- there's one extra step. $\\texttt{TranShkStd}$ is a primitive input, but it's not the thing you _actually_ want to change. Changing $\\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\\texttt{solve}$ method again). In the cell below, we invoke the method $\\texttt{update_income_process}$ so HARK knows to reconstruct the attribute $\\texttt{IncomeDstn}$." ] }, { @@ -574,7 +574,7 @@ "source": [ "OtherExample = deepcopy(IndShockExample) # Make a copy so we can compare consumption functions\n", "OtherExample.assign_parameters(PermShkStd = [0.2]) # Double permanent income risk (note that it's a one element list)\n", - "OtherExample.updateIncomeProcess() # Call the method to reconstruct the representation of F_t\n", + "OtherExample.update_income_process() # Call the method to reconstruct the representation of F_t\n", "OtherExample.solve()" ] }, diff --git a/examples/Gentle-Intro/Gentle-Intro-To-HARK.py b/examples/Gentle-Intro/Gentle-Intro-To-HARK.py index 8f2219e12..c90fdbca9 100644 --- a/examples/Gentle-Intro/Gentle-Intro-To-HARK.py +++ b/examples/Gentle-Intro/Gentle-Intro-To-HARK.py @@ -146,7 +146,7 @@ print("This agent's consumption function is defined (consumption is positive) down to m_t = " + str(mMinimum)) # %% [markdown] -# Yikes! Let's take a look at the bottom of the consumption function. In the cell below, the bounds of the $\texttt{plotFuncs}$ function are set to display down to the lowest defined value of the consumption function. +# Yikes! Let's take a look at the bottom of the consumption function. In the cell below, the bounds of the $\texttt{plot_funcs}$ function are set to display down to the lowest defined value of the consumption function. # %% plot_funcs(PFexample.solution[0].cFunc, @@ -289,12 +289,12 @@ # # Suppose you were interested in changing (say) the amount of permanent income risk. From the section above, you might think that you could simply change the attribute $\texttt{TranShkStd}$, solve the model again, and it would work. # -# That's _almost_ true-- there's one extra step. $\texttt{TranShkStd}$ is a primitive input, but it's not the thing you _actually_ want to change. Changing $\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\texttt{solve}$ method again). In the cell below, we invoke the method $\texttt{updateIncomeProcess}$ so HARK knows to reconstruct the attribute $\texttt{IncomeDstn}$. +# That's _almost_ true-- there's one extra step. $\texttt{TranShkStd}$ is a primitive input, but it's not the thing you _actually_ want to change. Changing $\texttt{TranShkStd}$ doesn't actually update the income distribution... unless you tell it to (just like changing an agent's preferences does not change the consumption function that was stored for the old set of parameters -- until you invoke the $\texttt{solve}$ method again). In the cell below, we invoke the method $\texttt{update_income_process}$ so HARK knows to reconstruct the attribute $\texttt{IncomeDstn}$. # %% OtherExample = deepcopy(IndShockExample) # Make a copy so we can compare consumption functions OtherExample.assign_parameters(PermShkStd = [0.2]) # Double permanent income risk (note that it's a one element list) -OtherExample.updateIncomeProcess() # Call the method to reconstruct the representation of F_t +OtherExample.update_income_process() # Call the method to reconstruct the representation of F_t OtherExample.solve() # %% [markdown] diff --git a/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb b/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb index 1ebf67416..2fbcb6e2d 100644 --- a/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb +++ b/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.ipynb @@ -7,10 +7,10 @@ "# How we solve a model defined by the `IndShockConsumerType` class\n", "The IndShockConsumerType reprents the work-horse consumption savings model with temporary and permanent shocks to income, finite or infinite horizons, CRRA utility and more. In this DemARK we take you through the steps involved in solving one period of such a model. The inheritance chains can be a little long, so figuring out where all the parameters and methods come from can be a bit confusing. Hence this map! The intention is to make it easier to know how to inheret from IndShockConsumerType in the sense that you know where to look for specific solver logic, but also so you know can figure out which methods to overwrite or supplement in your own `AgentType` and solver!\n", "## The `solveConsIndShock` function\n", - "In HARK, a period's problem is always solved by the callable (function or callable object instance) stored in the field `solve_one_period`. In the case of `IndShockConsumerType`, this function is called `solveConsIndShock`. The function accepts a number of arguments, that it uses to construct an instance of either a `ConsIndShockSolverBasic` or a `ConsIndShockSolver`. These solvers both have the methods `prepareToSolve` and `solve`, that we will have a closer look at in this notebook. This means, that the logic of `solveConsIndShock` is basically:\n", + "In HARK, a period's problem is always solved by the callable (function or callable object instance) stored in the field `solve_one_period`. In the case of `IndShockConsumerType`, this function is called `solveConsIndShock`. The function accepts a number of arguments, that it uses to construct an instance of either a `ConsIndShockSolverBasic` or a `ConsIndShockSolver`. These solvers both have the methods `prepare_to_solve` and `solve`, that we will have a closer look at in this notebook. This means, that the logic of `solveConsIndShock` is basically:\n", "\n", " 1. Check if cubic interpolation (`CubicBool`) or construction of the value function interpolant (`vFuncBool`) are requested. Construct an instance of `ConsIndShockSolverBasic` if neither are requested, else construct a `ConsIndShockSolver`. Call this `solver`.\n", - " 1. Call `solver.prepareToSolve()`\n", + " 1. Call `solver.prepare_to_solve()`\n", " 1. Call `solver.solve()` and return the output as the current solution." ] }, @@ -50,23 +50,23 @@ "\n", "To sum up, the `__init__` method lives in `ConsIndShockSetup`, calls `assign_parameters` and `defUtilityFuncs` from `ConsPerfForesightSolver` and defines its own methods with the same names that adds some methods used to solve the `IndShockConsumerType` using EGM. The main things controlled by the end-user are whether cubic interpolation should be used, `CubicBool`, and if the value function should be explicitly formed, `vFuncBool`.\n", "### Prepare to solve\n", - "We are now in bullet 2) from the list above. The `prepareToSolve` method is all about grabbing relevant information from next period's solution, calculating some limiting solutions. It comes from `ConsIndShockSetup` and calls two methods:\n", + "We are now in bullet 2) from the list above. The `prepare_to_solve` method is all about grabbing relevant information from next period's solution, calculating some limiting solutions. It comes from `ConsIndShockSetup` and calls two methods:\n", "\n", "1. `ConsIndShockSetup.setAndUpdateValues(self.solution_next,self.IncomeDstn,self.LivPrb,self.DiscFac)`\n", "2. `ConsIndShockSetup.defBoroCnst(self.BoroCnstArt)`\n", "\n", "First, we have `setAndUpdateValues`. The main purpose is to grab the relevant vectors that represent the shock distributions, the effective discount factor, and value function (marginal, level, marginal marginal depending on the options). It also calculates some limiting marginal propensities to consume and human wealth levels. Second, we have `defBoroCnst`. As the name indicates, it calculates the natural borrowing constraint, handles artificial borrowing constraints, and defines the consumption function where the constraint binds (`cFuncNowCnst`).\n", "\n", - "To sum, `prepareToSolve` sets up the stochastic environment an borrowing constraints the consumer might face. It also grabs interpolants from \"next period\"'s solution.\n", + "To sum, `prepare_to_solve` sets up the stochastic environment an borrowing constraints the consumer might face. It also grabs interpolants from \"next period\"'s solution.\n", "\n", "### Solve it!\n", "The last method `solveConsIndShock` will call from the `solver` is `solve`. This method essentially has four steps:\n", - " 1. Pre-processing for EGM: solver.prepareToCalcEndOfPrdvP\n", - " 1. First step of EGM: solver.calcEndOfPrdvP\n", - " 1. Second step of EGM: solver.makeBasicSolution\n", - " 1. Add MPC and human wealth: solver.addMPCandHumanWealth\n", + " 1. Pre-processing for EGM: solver.prepare_to_calc_EndOfPrdvP\n", + " 1. First step of EGM: solver.calc_EndOfPrdvP\n", + " 1. Second step of EGM: solver.make_basic_solution\n", + " 1. Add MPC and human wealth: solver.add_MPC_and_human_wealth\n", "\n", - "#### Pre-processing for EGM `prepareToCalcEndOfPrdvP`\n", + "#### Pre-processing for EGM `prepare_to_calc_EndOfPrdvP`\n", "Find relevant values of end-of-period asset values (according to `aXtraGrid` and natural borrowing constraint) and next period values implied by current period end-of-period assets and stochastic elements. The method stores the following in `self`:\n", "\n", " 1. values of permanent shocks in `PermShkVals_temp`\n", @@ -76,13 +76,13 @@ "\n", "The method also returns `aNrmNow`. The definition is in `ConsIndShockSolverBasic` and is not overwritten in `ConsIndShockSolver`.\n", "\n", - "#### First step of EGM `calcEndOfPrdvP`\n", + "#### First step of EGM `calc_EndOfPrdvP`\n", "Find the marginal value of having some level of end-of-period assets today. End-of-period assets as well as stochastics imply next-period resources at the beginning of the period, calculated above. Return the result as `EndOfPrdvP`.\n", "\n", - "#### Second step of EGM `makeBasicSolution`\n", + "#### Second step of EGM `make_basic_solution`\n", "Apply inverse marginal utility function to nodes from about to find (m, c) pairs for the new consumption function in `getPointsForInterpolation` and create the interpolants in `usePointsForInterpolation`. The latter constructs the `ConsumerSolution` that contains the current consumption function `cFunc`, the current marginal value function `vPfunc`, and the smallest possible resource level `mNrmMinNow`.\n", "\n", - "#### Add MPC and human wealth `addMPCandHumanWealth`\n", + "#### Add MPC and human wealth `add_MPC_and_human_wealth`\n", "Add values calculated in `defBoroCnst` now that we have a solution object to put them in.\n", "\n", "#### Special to the non-Basic solver\n", @@ -185,7 +185,7 @@ "metadata": {}, "outputs": [], "source": [ - "solver.prepareToSolve()" + "solver.prepare_to_solve()" ] }, { @@ -268,7 +268,7 @@ "cell_type": "markdown", "metadata": {}, "source": [ - "Then, we set up all the grids, grabs the discrete shock distributions, and state grids in `prepareToCalcEndOfPrdvP`." + "Then, we set up all the grids, grabs the discrete shock distributions, and state grids in `prepare_to_calc_EndOfPrdvP`." ] }, { @@ -299,7 +299,7 @@ } ], "source": [ - "solver.prepareToCalcEndOfPrdvP()" + "solver.prepare_to_calc_EndOfPrdvP()" ] }, { @@ -315,14 +315,14 @@ "metadata": {}, "outputs": [], "source": [ - "EndOfPrdvP = solver.calcEndOfPrdvP()" + "EndOfPrdvP = solver.calc_EndOfPrdvP()" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Then, we essentially just have to construct the (resource, consumption) pairs by completing the EGM step, and constructing the interpolants by using the knowledge that the limiting solutions are those of the perfect foresight model. This is done with `makeBasicSolution` as discussed above." + "Then, we essentially just have to construct the (resource, consumption) pairs by completing the EGM step, and constructing the interpolants by using the knowledge that the limiting solutions are those of the perfect foresight model. This is done with `make_basic_solution` as discussed above." ] }, { @@ -331,7 +331,7 @@ "metadata": {}, "outputs": [], "source": [ - "solution = solver.makeBasicSolution(EndOfPrdvP,solver.aNrmNow,solver.makeLinearcFunc)" + "solution = solver.make_basic_solution(EndOfPrdvP,solver.aNrmNow,solver.make_linear_cFunc)" ] }, { @@ -358,7 +358,7 @@ } ], "source": [ - "solver.addMPCandHumanWealth(solution)" + "solver.add_MPC_and_human_wealth(solution)" ] }, { diff --git a/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.py b/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.py index 3ff456eb1..33aae7603 100644 --- a/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.py +++ b/examples/HowWeSolveIndShockConsumerType/HowWeSolveIndShockConsumerType.py @@ -17,10 +17,10 @@ # # How we solve a model defined by the `IndShockConsumerType` class # The IndShockConsumerType reprents the work-horse consumption savings model with temporary and permanent shocks to income, finite or infinite horizons, CRRA utility and more. In this DemARK we take you through the steps involved in solving one period of such a model. The inheritance chains can be a little long, so figuring out where all the parameters and methods come from can be a bit confusing. Hence this map! The intention is to make it easier to know how to inheret from IndShockConsumerType in the sense that you know where to look for specific solver logic, but also so you know can figure out which methods to overwrite or supplement in your own `AgentType` and solver! # ## The `solveConsIndShock` function -# In HARK, a period's problem is always solved by the callable (function or callable object instance) stored in the field `solve_one_period`. In the case of `IndShockConsumerType`, this function is called `solveConsIndShock`. The function accepts a number of arguments, that it uses to construct an instance of either a `ConsIndShockSolverBasic` or a `ConsIndShockSolver`. These solvers both have the methods `prepareToSolve` and `solve`, that we will have a closer look at in this notebook. This means, that the logic of `solveConsIndShock` is basically: +# In HARK, a period's problem is always solved by the callable (function or callable object instance) stored in the field `solve_one_period`. In the case of `IndShockConsumerType`, this function is called `solveConsIndShock`. The function accepts a number of arguments, that it uses to construct an instance of either a `ConsIndShockSolverBasic` or a `ConsIndShockSolver`. These solvers both have the methods `prepare_to_solve` and `solve`, that we will have a closer look at in this notebook. This means, that the logic of `solveConsIndShock` is basically: # # 1. Check if cubic interpolation (`CubicBool`) or construction of the value function interpolant (`vFuncBool`) are requested. Construct an instance of `ConsIndShockSolverBasic` if neither are requested, else construct a `ConsIndShockSolver`. Call this `solver`. -# 1. Call `solver.prepareToSolve()` +# 1. Call `solver.prepare_to_solve()` # 1. Call `solver.solve()` and return the output as the current solution. # %% [markdown] @@ -56,23 +56,23 @@ # # To sum up, the `__init__` method lives in `ConsIndShockSetup`, calls `assign_parameters` and `defUtilityFuncs` from `ConsPerfForesightSolver` and defines its own methods with the same names that adds some methods used to solve the `IndShockConsumerType` using EGM. The main things controlled by the end-user are whether cubic interpolation should be used, `CubicBool`, and if the value function should be explicitly formed, `vFuncBool`. # ### Prepare to solve -# We are now in bullet 2) from the list above. The `prepareToSolve` method is all about grabbing relevant information from next period's solution, calculating some limiting solutions. It comes from `ConsIndShockSetup` and calls two methods: +# We are now in bullet 2) from the list above. The `prepare_to_solve` method is all about grabbing relevant information from next period's solution, calculating some limiting solutions. It comes from `ConsIndShockSetup` and calls two methods: # # 1. `ConsIndShockSetup.setAndUpdateValues(self.solution_next,self.IncomeDstn,self.LivPrb,self.DiscFac)` # 2. `ConsIndShockSetup.defBoroCnst(self.BoroCnstArt)` # # First, we have `setAndUpdateValues`. The main purpose is to grab the relevant vectors that represent the shock distributions, the effective discount factor, and value function (marginal, level, marginal marginal depending on the options). It also calculates some limiting marginal propensities to consume and human wealth levels. Second, we have `defBoroCnst`. As the name indicates, it calculates the natural borrowing constraint, handles artificial borrowing constraints, and defines the consumption function where the constraint binds (`cFuncNowCnst`). # -# To sum, `prepareToSolve` sets up the stochastic environment an borrowing constraints the consumer might face. It also grabs interpolants from "next period"'s solution. +# To sum, `prepare_to_solve` sets up the stochastic environment an borrowing constraints the consumer might face. It also grabs interpolants from "next period"'s solution. # # ### Solve it! # The last method `solveConsIndShock` will call from the `solver` is `solve`. This method essentially has four steps: -# 1. Pre-processing for EGM: solver.prepareToCalcEndOfPrdvP -# 1. First step of EGM: solver.calcEndOfPrdvP -# 1. Second step of EGM: solver.makeBasicSolution -# 1. Add MPC and human wealth: solver.addMPCandHumanWealth +# 1. Pre-processing for EGM: solver.prepare_to_calc_EndOfPrdvP +# 1. First step of EGM: solver.calc_EndOfPrdvP +# 1. Second step of EGM: solver.make_basic_solution +# 1. Add MPC and human wealth: solver.add_MPC_and_human_wealth # -# #### Pre-processing for EGM `prepareToCalcEndOfPrdvP` +# #### Pre-processing for EGM `prepare_to_calc_EndOfPrdvP` # Find relevant values of end-of-period asset values (according to `aXtraGrid` and natural borrowing constraint) and next period values implied by current period end-of-period assets and stochastic elements. The method stores the following in `self`: # # 1. values of permanent shocks in `PermShkVals_temp` @@ -82,13 +82,13 @@ # # The method also returns `aNrmNow`. The definition is in `ConsIndShockSolverBasic` and is not overwritten in `ConsIndShockSolver`. # -# #### First step of EGM `calcEndOfPrdvP` +# #### First step of EGM `calc_EndOfPrdvP` # Find the marginal value of having some level of end-of-period assets today. End-of-period assets as well as stochastics imply next-period resources at the beginning of the period, calculated above. Return the result as `EndOfPrdvP`. # -# #### Second step of EGM `makeBasicSolution` +# #### Second step of EGM `make_basic_solution` # Apply inverse marginal utility function to nodes from about to find (m, c) pairs for the new consumption function in `get_points_for_interpolation` and create the interpolants in `usePointsForInterpolation`. The latter constructs the `ConsumerSolution` that contains the current consumption function `cFunc`, the current marginal value function `vPfunc`, and the smallest possible resource level `mNrmMinNow`. # -# #### Add MPC and human wealth `addMPCandHumanWealth` +# #### Add MPC and human wealth `add_MPC_and_human_wealth` # Add values calculated in `defBoroCnst` now that we have a solution object to put them in. # # #### Special to the non-Basic solver @@ -131,7 +131,7 @@ LifecycleExample.CubicBool) # %% -solver.prepareToSolve() +solver.prepare_to_solve() # %% [markdown] # Many important values are now calculated and stored in solver, such as the effective discount factor, the smallest permanent income shock, and more. @@ -149,28 +149,28 @@ plot_funcs([solver.cFuncNowCnst],solver.mNrmMinNow,10) # %% [markdown] -# Then, we set up all the grids, grabs the discrete shock distributions, and state grids in `prepareToCalcEndOfPrdvP`. +# Then, we set up all the grids, grabs the discrete shock distributions, and state grids in `prepare_to_calc_EndOfPrdvP`. # %% -solver.prepareToCalcEndOfPrdvP() +solver.prepare_to_calc_EndOfPrdvP() # %% [markdown] # Then we calculate the marginal utility of next period's resources given the stochastic environment and current grids. # %% -EndOfPrdvP = solver.calcEndOfPrdvP() +EndOfPrdvP = solver.calc_EndOfPrdvP() # %% [markdown] -# Then, we essentially just have to construct the (resource, consumption) pairs by completing the EGM step, and constructing the interpolants by using the knowledge that the limiting solutions are those of the perfect foresight model. This is done with `makeBasicSolution` as discussed above. +# Then, we essentially just have to construct the (resource, consumption) pairs by completing the EGM step, and constructing the interpolants by using the knowledge that the limiting solutions are those of the perfect foresight model. This is done with `make_basic_solution` as discussed above. # %% -solution = solver.makeBasicSolution(EndOfPrdvP,solver.aNrmNow,solver.makeLinearcFunc) +solution = solver.make_basic_solution(EndOfPrdvP,solver.aNrmNow,solver.make_linear_cFunc) # %% [markdown] # Lastly, we add the MPC and human wealth quantities we calculated in the method that prepared the solution of this period. # %% -solver.addMPCandHumanWealth(solution) +solver.add_MPC_and_human_wealth(solution) # %% [markdown] # All that is left is to verify that the solution in `solution` is identical to `LifecycleExample.solution[0]`. We can plot the against each other: diff --git a/examples/Journeys/Journey_1_PhD.ipynb b/examples/Journeys/Journey_1_PhD.ipynb index 7c57c409f..9677f5319 100644 --- a/examples/Journeys/Journey_1_PhD.ipynb +++ b/examples/Journeys/Journey_1_PhD.ipynb @@ -333,10 +333,10 @@ } ], "source": [ - "EconomyExample.makeAggShkHist() # Simulate a history of aggregate shocks\n", + "EconomyExample.make_AggShkHist() # Simulate a history of aggregate shocks\n", "\n", "# Have the consumers inherit relevant objects from the economy\n", - "AggShockExample.getEconomyData(EconomyExample)\n", + "AggShockExample.get_economy_data(EconomyExample)\n", "\n", "AggShockExample.solve() #solve the model\n", "\n", diff --git a/examples/Journeys/Quickstart_tutorial/Quick_start_with_solution.ipynb b/examples/Journeys/Quickstart_tutorial/Quick_start_with_solution.ipynb index 252223448..024f3956d 100644 --- a/examples/Journeys/Quickstart_tutorial/Quick_start_with_solution.ipynb +++ b/examples/Journeys/Quickstart_tutorial/Quick_start_with_solution.ipynb @@ -103,7 +103,7 @@ "\n", "from copy import deepcopy\n", "from HARK.ConsumptionSaving.ConsIndShockModel import *\n", - "from HARK.utilities import plotFuncsDer, plotFuncs \n" + "from HARK.utilities import plot_funcs_der, plot_funcs \n" ] }, { @@ -336,7 +336,7 @@ "source": [ "### Plotting the solution\n", "\n", - "After $\\texttt{solve}$ method is used, the value and consumption functions can be plotted. HARK dedicated function for doing so is $\\texttt{plotFuncs}$. As arguments, you need to give a function from the solution (possible a few functions) and the limits of interval for which you want to make a plot. \n", + "After $\\texttt{solve}$ method is used, the value and consumption functions can be plotted. HARK dedicated function for doing so is $\\texttt{plot_funcs}$. As arguments, you need to give a function from the solution (possible a few functions) and the limits of interval for which you want to make a plot. \n", "\n", "For example, we can plot consumption and value functions on the interval from mNrmMin to -mNrmMin.\n" ] @@ -397,9 +397,9 @@ "min_v = Example_agent_2.solution[0].mNrmMin\n", "max_v = -Example_agent_2.solution[0].mNrmMin\n", "print(\"Consumption function\")\n", - "plotFuncs([Example_agent_2.solution[0].cFunc],min_v,max_v)\n", + "plot_funcs([Example_agent_2.solution[0].cFunc],min_v,max_v)\n", "print(\"Value function\")\n", - "plotFuncs([Example_agent_2.solution[0].vFunc],min_v,max_v)" + "plot_funcs([Example_agent_2.solution[0].vFunc],min_v,max_v)" ] }, { @@ -479,7 +479,7 @@ "metadata": {}, "outputs": [], "source": [ - "Example_agent_2.track_vars = ['aNrmNow','cNrm']\n", + "Example_agent_2.track_vars = ['aNrm','cNrm']\n", "Example_agent_2.initialize_sim()\n", "Example_agent_2.simulate()" ] @@ -517,7 +517,7 @@ ], "source": [ "periods= np.linspace(0,1000,1000)\n", - "asset_level = np.mean(Example_agent_2.history['aNrmNow'][0:1000], axis = 1)\n", + "asset_level = np.mean(Example_agent_2.history['aNrm'][0:1000], axis = 1)\n", "cons_level = np.mean(Example_agent_2.history['cNrm'][0:1000], axis = 1)\n", "\n", "plt.figure(figsize=(5,5))\n", @@ -710,7 +710,7 @@ "min_v = Exercise_agent.solution[0].mNrmMin\n", "max_v = -Exercise_agent.solution[0].mNrmMin\n", "print(\"Value function\")\n", - "plotFuncs([Exercise_agent.solution[0].vFunc],min_v,max_v)" + "plot_funcs([Exercise_agent.solution[0].vFunc],min_v,max_v)" ] }, { @@ -818,7 +818,7 @@ "outputs": [], "source": [ "#Solution\n", - "Exercise_agent.track_vars = ['aNrmNow','cNrm']\n", + "Exercise_agent.track_vars = ['aNrm','cNrm']\n", "Exercise_agent.initialize_sim()\n", "Exercise_agent.simulate()" ] @@ -1054,7 +1054,7 @@ "source": [ "### Methods of plotting the solution\n", "\n", - "$\\texttt{plotFuncs()}$ enables to plot many functions at the same graph. You need to declare them as vector of functions. \n", + "$\\texttt{plot_funcs()}$ enables to plot many functions at the same graph. You need to declare them as vector of functions. \n", "\n", "To see this, just follow an example. We plot the consumption functions for each age $t$ of the consumer. \n", "\n", @@ -1108,7 +1108,7 @@ "min_v = min(LC_agent.solution[t].mNrmMin for t in range(11) )\n", "max_v = -min_v\n", "print(\"Consumption functions\")\n", - "plotFuncs(LC_agent.cFunc[:],min_v,max_v)\n", + "plot_funcs(LC_agent.cFunc[:],min_v,max_v)\n", "\n" ] }, @@ -1154,7 +1154,7 @@ ], "source": [ "print(\"Value functions\")\n", - "plotFuncs([LC_agent.solution[0].vFunc, LC_agent.solution[5].vFunc, LC_agent.solution[9].vFunc],min_v,max_v)\n" + "plot_funcs([LC_agent.solution[0].vFunc, LC_agent.solution[5].vFunc, LC_agent.solution[9].vFunc],min_v,max_v)\n" ] }, { @@ -1219,13 +1219,13 @@ } ], "source": [ - "LC_agent.track_vars = ['aNrmNow','cNrm', 'aLvlNow']\n", + "LC_agent.track_vars = ['aNrm','cNrm', 'aLvl']\n", "LC_agent.initialize_sim()\n", "LC_agent.simulate()\n", "\n", " \n", "periods= np.linspace(0,200,200)\n", - "assets_level = np.mean(LC_agent.history['aLvlNow'][0:200], axis = 1)\n", + "assets_level = np.mean(LC_agent.history['aLvl'][0:200], axis = 1)\n", "\n", "plt.figure(figsize=(5,5))\n", "plt.plot(periods,assets_level,label='assets level')\n", @@ -1261,7 +1261,7 @@ } ], "source": [ - "after_burnout = np.mean(LC_agent.history['aLvlNow'][10:200], axis = 1)\n", + "after_burnout = np.mean(LC_agent.history['aLvl'][10:200], axis = 1)\n", "\n", "plt.figure(figsize=(5,5))\n", "plt.plot(periods[10:200],after_burnout,label='assets level')\n", @@ -1288,7 +1288,7 @@ "metadata": {}, "outputs": [], "source": [ - "sim_wealth = np.reshape(LC_agent.history['aLvlNow'],-1)" + "sim_wealth = np.reshape(LC_agent.history['aLvl'],-1)" ] }, { @@ -1342,14 +1342,14 @@ "outputs": [], "source": [ "\n", - "from HARK.utilities import getLorenzShares, getPercentiles\n" + "from HARK.utilities import get_lorenz_shares, get_percentiles\n" ] }, { "cell_type": "markdown", "metadata": {}, "source": [ - "Then, use $\\texttt{getLorenzShares}$ to plot the Lornez curve. " + "Then, use $\\texttt{get_lorenz_shares}$ to plot the Lornez curve. " ] }, { @@ -1372,8 +1372,8 @@ ], "source": [ "pctiles = np.linspace(0.001,0.999,15)\n", - "#SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", - "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "#SCF_Lorenz_points = get_lorenz_shares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = get_lorenz_shares(sim_wealth,percentiles=pctiles)\n", "\n", "plt.figure(figsize=(5,5))\n", "plt.title('Lorenz curve')\n", @@ -1532,7 +1532,7 @@ "min_v = min(Ex_agent.solution[t].mNrmMin for t in range(11) )\n", "max_v = -min_v\n", "print(\"Consumption functions\")\n", - "plotFuncs(Ex_agent.cFunc[:],min_v,max_v)\n", + "plot_funcs(Ex_agent.cFunc[:],min_v,max_v)\n", "\n", "\n", "Simulation_dictionary = { 'AgentCount': 1000,\n", @@ -1550,18 +1550,18 @@ "for key,value in Simulation_dictionary.items():\n", " setattr(Ex_agent,key,value)\n", "\n", - "Ex_agent.track_vars = ['aNrmNow','cNrm', 'aLvlNow']\n", + "Ex_agent.track_vars = ['aNrm','cNrm', 'aLvl']\n", "Ex_agent.initialize_sim()\n", "Ex_agent.simulate()\n", "\n", "\n", - "sim_wealth = np.reshape(Ex_agent.history['aLvlNow'],-1)\n", + "sim_wealth = np.reshape(Ex_agent.history['aLvl'],-1)\n", "print(\"Wealth distribution histogram\")\n", "n, bins, patches = plt.hist(sim_wealth,50,density=True, range=[-1.0,2.0])\n", "\n", "pctiles = np.linspace(0.001,0.999,15)\n", - "#SCF_Lorenz_points = getLorenzShares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", - "sim_Lorenz_points = getLorenzShares(sim_wealth,percentiles=pctiles)\n", + "#SCF_Lorenz_points = get_lorenz_shares(SCF_wealth,weights=SCF_weights,percentiles=pctiles)\n", + "sim_Lorenz_points = get_lorenz_shares(sim_wealth,percentiles=pctiles)\n", "\n", "plt.figure(figsize=(5,5))\n", "plt.title('Lorenz curve')\n",