owlplanner 2025.12.5__py3-none-any.whl → 2026.1.26__py3-none-any.whl

{owlplanner-2025.12.5.dist-info → owlplanner-2026.1.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.12.5
+Version: 2026.1.26
 Summary: Owl - Optimal Wealth Lab: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -683,6 +683,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.  But first, please read
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
+License-File: AUTHORS
 License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: End Users/Desktop
@@ -691,7 +692,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.10
+Requires-Dist: click>=8.3.1
 Requires-Dist: highspy
+Requires-Dist: jupyter>=1.1.1
+Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: odfpy
@@ -699,6 +703,7 @@ Requires-Dist: openpyxl
 Requires-Dist: pandas
 Requires-Dist: plotly>=6.3
 Requires-Dist: pulp
+Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: scipy
 Requires-Dist: seaborn
 Requires-Dist: streamlit
@@ -710,7 +715,7 @@ Description-Content-Type: text/markdown
 
 ## A retirement exploration tool based on linear programming
 
-<img align=right src="https://github.com/mdlacasse/Owl/blob/main/docs/images/owl.png?raw=true" width="250">
+<img align="right" src="papers/images/owl.png" width="250">
 
 -------------------------------------------------------------------------------------
 
@@ -722,6 +727,10 @@ Users can select varying return rates to perform historical back testing,
 stochastic rates for performing Monte Carlo analyses,
 or fixed rates either derived from historical averages, or set by the user.
 
+Owl is designed for US retirees as it considers US federal tax laws,
+Medicare premiums, rules for 401k including required minimum distributions,
+maturation rules for Roth accounts and conversions, social security rules, etc.
+
 There are three ways to run Owl:
 
 - **Streamlit Hub:** Run Owl remotely as hosted on the Streamlit Community Server at
@@ -733,154 +742,6 @@ Follow these [instructions](docker/README.md) for using this option.
 - **Self-hosting:** Run Owl locally on your computer using Python code and libraries.
 Follow these [instructions](INSTALL.md) to install from the source code and self-host on your own computer.
 
--------------------------------------------------------------------------------------
-## Overview
-This package is a modeling framework for exploring the sensitivity of retirement financial decisions.
-Strictly speaking, it is not a planning tool, but more an environment for exploring *what if* scenarios.
-It provides different realizations of a financial strategy through the rigorous
-mathematical optimization of relevant decision variables. Two major objective goals can be set: either
-maximize net spending, or after-tax bequest under various constraints.
-Look at the *Capabilities* section below for more detail.
-
-One can certainly have a savings plan, but due to the volatility of financial investments,
-it is impossible to have a certain asset earnings plan. This does not mean one cannot make decisions.
-These decisions need to be guided with an understanding of the sensitivity of the parameters.
-This is exactly where this tool fits in. Given your savings capabilities and spending desires,
-it can generate different future realizations of
-your strategy under different market assumptions, helping to better understand your financial situation.
-
--------------------------------------------------------------------------------------
-## Purpose and vision
-One goal of Owl is to provide a free and open-source ecosystem that has cutting-edge optimization capabilities,
-allowing for the next generation of Python-literate retirees to experiment with their own financial future
-while providing a codebase where they can learn and contribute. At the same time, an intuitive and easy-to-use
-user interface based on Streamlit allows a broad set of users to benefit from the application as it only requires basic financial knowledge.
-
-There are and were
-good retirement optimizers in the recent past, but the vast majority of them are either proprietary platforms
-collecting your data, or academic papers that share the results without really sharing the details of
-the underlying mathematical models.
-The algorithms in Owl rely on the open-source HiGHS linear programming solver but they have also been ported and tested on
-other platforms such as Mosek and COIN-OR. The complete formulation and
-detailed description of the underlying
-mathematical model can be found [here](https://github.com/mdlacasse/Owl/blob/main/docs/owl.pdf).
-
-It is anticipated that most end users will use Owl through the graphical interface
-either at [owlplanner.streamlit.app](https://owlplanner.streamlit.app)
-or [installed](INSTALL.md) on their own computer.
-The underlying Python package can also be used directly through Python scripts or Jupyter Notebooks
-as described [here](USER_GUIDE.md).
-
-Not every retirement decision strategy can be framed as an easy-to-solve optimization problem.
-In particular, if one is interested in comparing different withdrawal strategies,
-[FI Calc](https://ficalc.app) is an elegant application that addresses this need.
-If, however, you also want to optimize spending, bequest, and Roth conversions, with
-an approach also considering Medicare and federal income tax over the next few years,
-then Owl is definitely a tool that can help guide your decisions.
-
---------------------------------------------------------------------------------------
-## Capabilities
-Owl can optimize for either maximum net spending under the constraint of a given bequest (which can be zero),
-or maximize the after-tax value of a bequest under the constraint of a desired net spending profile,
-and under the assumption of a heirs marginal tax rate.
-Roth conversions are also considered, subject to an optional maximum conversion amount,
-and optimized to suit the goals of the selected objective function.
-All calculations are indexed for inflation, which is either provided as a fixed rate,
-or through historical values, as are all other rates used for the calculations.
-These rates can be used for backtesting different scenarios by choosing
-*historical* rates, or by choosing *historical average* rates over a historical year range,
-or what I coined "*histochastic*" rates which are
-generated using the statistical distribution of observed historical rates.
-
-Portfolios available for experimenting include assets from the S&P 500, Corporate Bonds Baa, Treasury 10-y Notes,
-and cash assets assumed to just follow inflation which is represented by the Consumer Price Index.
-Other asset classes can easily be added, but would add complexity while only providing diminishing insights.
-Historical data used are from
-[Aswath Damodaran](https://pages.stern.nyu.edu/~adamodar/) at the Stern School of Business.
-Asset allocations are selected for the duration of the plan, and these can glide linearly
-or along a configurable s-curve over the lifespan of the individual.
-
-Spending profiles are adjusted for inflation, and so are all other indexable quantities. Proflies can be
-flat or follow a *smile* curve which is also adjustable through three simple parameters.
-
-Available rates are from 1928 to last year and can be used to test historical performance.
-Fixed rates can also be provided, as well as *histochastic* rates, which are generated using
-the statistical characteristics (means and covariance matrix) of
-a selected historical year range. Pure *stochastic* rates can also be generated
-if the user provides means, volatility (expressed as standard deviation), and optionally
-the correlations between the different assets return rates provided as a matrix, or a list of
-the off-diagonal elements (see documentation for details).
-Average rates calculated over a historical data period can also be chosen.
-
-Monte Carlo simulations capabilities are included and provide a probability of success and a histogram of
-outcomes. These simulations can be used for either determining the probability distribution of the
-maximum net spending amount under
-the constraint of a desired bequest, or the probability distribution of the maximum
-bequest under the constraint of a desired net spending amount. Unlike discrete-event
-simulators, Owl uses an optimization algorithm for every new scenario, which results in more
-calculations being performed. As a result, the number of cases to be considered should be kept
-to a reasonable number. For a few hundred cases, a few minutes of calculations can provide very good estimates
-and reliable probability distributions.
-
-Optimizing each solution is more representative than event-base simulators
-in the sense that optimal solutions
-will naturally adjust to the return scenarios being considered.
-This is more realistic as retirees would certainly re-evaluate
-their expectations under severe market drops or gains.
-This optimal approach provides a net benefit over event-based simulators,
-which maintain a distribution strategy either fixed, or within guardrails for capturing the
-retirees' reactions to the market.
-
-Basic input parameters can be entered through the user interface
-while optional additional time series can be read from
-an Excel spreadsheet that contains future wages, contributions
-to savings accounts, and planned *big-ticket items* such as the purchase of a lake house,
-the sale of a boat, large gifts, or inheritance.
-
-Three types of savings accounts are considered: taxable, tax-deferred, and tax-free,
-which are all tracked separately for married individuals. Asset transition to the surviving spouse
-is done according to beneficiary fractions for each type of savings account.
-Tax status covers married filing jointly and single, depending on the number of individuals reported.
-
-Maturation rules for Roth contributions and conversions are implemented as constraints
-limiting withdrawal amounts to cover Roth account balances for 5 years after the events.
-Medicare and IRMAA calculations are performed through a self-consistent loop on cash flow constraints.
-They can also be optimized explicitly as an option, but this choice can lead to longer calculations
-due to the use of the many additional binary variables required by the formulation.
-Future Medicare and IRMAA values are simple projections of current values with the assumed inflation rates.
-
-Owl has a basic social security calculator that determines the actual benefits based on the individual's
-primary insurance amount (PIA), full retirement age (FRA), and claiming age. Both
-spousal's benefits and survivor's benefits are calculated for non-complex cases.
-
-### Limitations
-Owl is work in progress. At the current time:
-- Only the US federal income tax is considered (and minimized through the optimization algorithm).
-Head of household filing status has not been added but can easily be.
-- Required minimum distributions are calculated, but tables for spouses more than 10 years apart are not included.
-These cases are detected and will generate an error message.
-- Current version has no optimization of asset allocations between individuals and/or types of savings accounts.
-If there is interest, that could be added in the future.
-- In the current implementation, social securiy is always taxed at 85%, assuming that your taxable income will be larger than 34 k$ (single) or 44 k$ (married filing jointly).
-- When Medicare calculations are done through a self-consistent loop,
-the Medicare premiums are calculated after an initial solution is generated,
-and then a new solution is re-generated with these premiums as a constraint.
-In some situations, when the income (MAGI) is near an IRMAA bracket, oscillatory solutions can arise.
-While the solutions generated are very close to one another, Owl will pick the smallest solution
-for being conservative. While sometimes computationally costly,
-a comparison with a full Medicare optimization should always be performed.
-- Part D is not included in the IRMAA calculations. Only Part B is taken into account, 
-which is considerably more significant.
-- Future tax brackets are pure speculations derived from the little we know now and projected to the next 30 years.
-Your guesses are as good as mine.
-
-The solution from an optimization algorithm has only two states: feasible and infeasible.
-Therefore, unlike event-driven simulators that can tell you that your distribution strategy runs
-out of money in year 20, an optimization-based solver can only tell you that a solution does or does not
-exist for the plan being considered. Examples of infeasible solutions include requesting a bequeathed
-estate value too large for the savings assets to support, even with zero net spending basis,
-or maximizing the bequest subject to a net spending basis that is already too large for the savings
-assets to support, even with no estate being left.
 
 ---------------------------------------------------------------
 ## Documentation
@@ -892,16 +753,47 @@ assets to support, even with no estate being left.
 ---------------------------------------------------------------------
 
 ## Credits
-- Historical rates from [Aswath Damodaran](https://pages.stern.nyu.edu/~adamodar/)
-- Image from [freepik](https://freepik.com)
-- Optimization solver from [HiGHS](https://highs.dev)
-- Streamlit Community Cloud [Streamlit](https://streamlit.io)
-- Contributors: Josh (noimjosh@gmail.com) for Docker image code,
- kg333 for fixing an error in Docker's instructions,
- Dale Seng (sengsational) for great insights and suggestions,
+- Contributors:
  Robert E. Anderson (NH-RedAnt) for bug fixes and suggestions,
  Clark Jefcoat (hubcity) for fruitful interactions,
- Benjamin Quinn (blquinn) and Gene Wood (gene1wood) for improvements and bug fixes.
+ kg333 for fixing an error in Docker's instructions,
+ John Leonard (jleonard99) for great suggestions, website, and more to come,
+ Benjamin Quinn (blquinn) for improvements and bug fixes,
+ Dale Seng (sengsational) for great insights, testing, and suggestions,
+ Josh Williams (noimjosh) for Docker image code,
+ Gene Wood (gene1wood) for improvements and bug fixes.
+- Greg Grothaus for developing [ssa.tools](https://ssa.tools) and providing an integration with Owl.
+- Owl image is from [freepik](https://freepik.com).
+- Historical rates are from [Aswath Damodaran](https://pages.stern.nyu.edu/~adamodar/).
+- Linear programming optimization solvers are from
+[HiGHS](https://highs.dev) and [PuLP](https://coin-or.github.io/pulp/).
+It can also run on [MOSEK](https://mosek.com) if available on your computer.
+- Owl planner relies on the following [Python](https://python.org) packages:
+    - [highspy](https://highs.dev),
+    [loguru](https://github.com/Delgan/loguru),
+    [Matplotlib](https://matplotlib.org),
+    [Numpy](https://numpy.org),
+    [odfpy](https://https://pypi.org/project/odfpy),
+    [openpyxl](https://openpyxl.readthedocs.io),
+    [Pandas](https://pandas.pydata.org),
+    [Plotly](https://plotly.com),
+    [PuLP](https://coin-or.github.io/pulp),
+    [Scipy](https://scipy.org),
+    [Seaborn](https://seaborn.pydata.org),
+    [toml](https://toml.io),
+ and [Streamlit](https://streamlit.io) for the front-end.
+
+## Bugs and Feature Requests
+Please submit bugs and feature requests through
+[GitHub](https://github.com/mdlacasse/owl/issues) if you have a GitHub account
+or directly by [email](mailto:martin.d.lacasse@gmail.com).
+Or just drop me a line to report your experience with the tool.
+
+## Privacy
+This app does not store or forward any information. All data entered is lost
+after a session is closed. However, you can choose to download selected parts of your
+own data to your computer before closing the session. These data will be stored strictly on
+your computer and can be used to reproduce a case at a later time.
 
 ---------------------------------------------------------------------
 

owlplanner-2026.1.26.dist-info/RECORD

@@ -0,0 +1,36 @@
+"owlplanner/In Discussion #58, the case of Kim and Sam.md",sha256=ah5BgkP4Bo04SZ2-Ory8PBeoFRVd7YNUBktYtjp42v0,25193
+owlplanner/__init__.py,sha256=X9u8PrfeTyfjuksYhx0eNrIACgX5Tg3Le7pz8qKkJXk,1341
+owlplanner/abcapi.py,sha256=5yWuiu5eBVO46V5vklO_zfCCrFZX9guRZ9XEemeJ878,7229
+owlplanner/config.py,sha256=-q6TYMagUJGv1ige6VvWPFtZ5ZWkT9Yh-HQrnnWDHfU,19834
+owlplanner/debts.py,sha256=c-eLynjOFryYisae51Po6Iuh46_d_AGOUbOz3z96ZJY,9850
+owlplanner/fixedassets.py,sha256=ItFeXjIdhMVNyXY0xBW6P9ODRajVg1kDRaid9-Eu_Ww,11510
+owlplanner/mylogging.py,sha256=amQA0qWPsXMoJkYYF3nMaVtCDZMWxXJ1hbJS0TkMvf8,8269
+owlplanner/plan.py,sha256=VWrKDGl3UgNB6GQzfw7hQzVNJW_BcupH0I2zP9yKtsw,152509
+owlplanner/progress.py,sha256=ayqoRUMn6dtIxHDYaeX1mu7W2rAhkBYAi4Y2Y_NtdYA,2521
+owlplanner/rates.py,sha256=W-cXEbJl7L9cPEhQbtz4bf_JAkChoCfDSFoZHDUZeys,14393
+owlplanner/socialsecurity.py,sha256=4vn76dUZ2P2fMKyy4eu2ramGNvPQymKzsNFZvwbFWOc,7595
+owlplanner/tax2026.py,sha256=-aHOVv5pErXY82PK5dQBjqoAqYc74w4C5zqGODboUBw,15659
+owlplanner/timelists.py,sha256=4dBZVCgNIx0RwUfimp_k-m9KhRFj6BHX8Hon1vb8oo8,15032
+owlplanner/utils.py,sha256=l2-3HmZutFlEfJUp7gFblY3PBNYm7HiPPCGl0wFkVmA,9461
+owlplanner/version.py,sha256=ah-vzrsjzBTIMnscgEdl8z7Y1yu4uXQ5B3og10cS2y4,747
+owlplanner/cli/README.md,sha256=R-jwwiX5ZW6gCKaRPWVCgwKVoN2MKozrLAkKvfUT4vA,2292
+owlplanner/cli/_main.py,sha256=qAy_2oCLaa_EhvfGFnuh_sVXkCcgp70WMSL7_QKH5XI,1497
+owlplanner/cli/cli_logging.py,sha256=CTBaAMpJIG7ge9Gz44YykBiea3hMxdAXHyiLj1UyvDU,1690
+owlplanner/cli/cmd_list.py,sha256=lOpS_5LGR1IpJLOaHQOrwm1EtbGwv0tfIcZZ8QObmMM,2584
+owlplanner/cli/cmd_run.py,sha256=aLy-X6x_3MSO_yBQ1R4MWKzczfQgWuRQUsNTrVUaWj8,3009
+owlplanner/data/__init__.py,sha256=jpbWHd9n4F06pyfQj1kI3HQ3uiWXfZCjb5BYINOr9_M,850
+owlplanner/data/awi.csv,sha256=w9YwPEqhxqo1Czumh3ihLXLPtk8kJQgqWKClMysOq-c,1625
+owlplanner/data/bendpoints.csv,sha256=h0a7_XqTuyHWe5ZlS3mjIcAWqOMG_93GoiETS-1xxUY,746
+owlplanner/data/newawi.csv,sha256=w9YwPEqhxqo1Czumh3ihLXLPtk8kJQgqWKClMysOq-c,1625
+owlplanner/data/rates.csv,sha256=6Pr5cXFunZKRzB32--kWzhuRnTQMNFfZaww0QF1SIag,3898
+owlplanner/plotting/__init__.py,sha256=UrKO_zHTxZ-Wb2sQbyk2vNHe20Owzt6M1KJ2M6Z5GGw,944
+owlplanner/plotting/base.py,sha256=70-J5AWnHtWqrehVhCNojnTdfNT6PnEpxBKzDh3R57o,3298
+owlplanner/plotting/factory.py,sha256=sVZ0uAuGKBVVh1qkF2IS7xNZGUPIQRIfqgUt2s2Ncjk,1694
+owlplanner/plotting/matplotlib_backend.py,sha256=AILNOhXi_gsR__i1hKoHaEHvMUqQMyLeRAGCoCBfQBY,19222
+owlplanner/plotting/plotly_backend.py,sha256=OqMJRxAhpwIbKSV-Od1-q-tzOs66McZPbKD32be2qx0,34523
+owlplanner-2026.1.26.dist-info/METADATA,sha256=ZHGDl0MzxLspxcYtBCoxp8q1oQKnEZ1qH_gjzInxw1Q,46494
+owlplanner-2026.1.26.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+owlplanner-2026.1.26.dist-info/entry_points.txt,sha256=m2Ql-6VQbotl65wiqx35d3TIh-Tm6Wdjrz3hNdqZKKg,52
+owlplanner-2026.1.26.dist-info/licenses/AUTHORS,sha256=KD6uW6iEOHf51J8DEJ6az-gowFv3NWIpW4zRgqxwuAA,464
+owlplanner-2026.1.26.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2026.1.26.dist-info/RECORD,,

owlplanner-2026.1.26.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+owlcli = owlplanner.cli._main:cli

owlplanner-2026.1.26.dist-info/licenses/AUTHORS

@@ -0,0 +1,15 @@
+# This is the list of Owlplanner's significant contributors.
+#
+# This does not necessarily list everyone who has contributed code.
+# To see the full list of contributors, see the revision history in
+# source control.
+Martin-D. Lacasse (mdlacasse, original author)
+Robert E. Anderson (NH-RedAnt)
+Clark Jefcoat (hubcity)
+kg333
+John Leonard (jleonard99)
+Benjamin Quinn (blquinn)
+Dale Seng (sengsational)
+Josh Williams (noimjosh)
+Gene Wood (gene1wood)
+

owlplanner/tax2025.py

@@ -1,339 +0,0 @@
-"""
-
-Owl/tax2025
----
-
-A retirement planner using linear programming optimization.
-
-See companion document for a complete explanation and description
-of all variables and parameters.
-
-Module to handle all tax calculations.
-
-Copyright © 2024 - Martin-D. Lacasse
-
-Disclaimers: This code is for educational purposes only and does not constitute financial advice.
-
-"""
-
-import numpy as np
-from datetime import date
-
-
-##############################################################################
-# Prepare the data.
-
-taxBracketNames = ["10%", "12/15%", "22/25%", "24/28%", "32/33%", "35%", "37/40%"]
-
-rates_OBBBA = np.array([0.10, 0.12, 0.22, 0.24, 0.32, 0.35, 0.370])
-rates_preTCJA = np.array([0.10, 0.15, 0.25, 0.28, 0.33, 0.35, 0.396])
-
-###############################################################################
-# Start of section where rates need to be actualized every year.
-###############################################################################
-# Single [0] and married filing jointly [1].
-
-# These are 2025 current.
-taxBrackets_OBBBA = np.array(
-    [
-        [11925, 48475, 103350, 197300, 250525, 626350, 9999999],
-        [23850, 96950, 206700, 394600, 501050, 751600, 9999999],
-    ]
-)
-
-irmaaBrackets = np.array(
-    [
-        [0, 106000, 133000, 167000, 200000, 500000],
-        [0, 212000, 266000, 334000, 400000, 750000],
-    ]
-)
-
-# Index [0] stores the standard Medicare part B premium.
-# Following values are incremental IRMAA part B monthly fees.
-irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
-
-# Make projection for pre-TCJA using 2017 to current year.
-# taxBrackets_2017 = np.array(
-#    [ [9325, 37950, 91900, 191650, 416700, 418400, 9999999],
-#      [18650, 75900, 153100, 233350, 416700, 470700, 9999999],
-#    ])
-#
-# stdDeduction_2017 = [6350, 12700]
-#
-# For 2025, I used a 30.5% adjustment from 2017, rounded to closest 50.
-#
-# These are speculated.
-taxBrackets_preTCJA = np.array(
-    [
-        [12150, 49550, 119950, 250200, 544000, 546200, 9999999],  # Single
-        [24350, 99100, 199850, 304600, 543950, 614450, 9999999],  # MFJ
-    ]
-)
-
-# These are 2025 current.
-stdDeduction_OBBBA = np.array([15750, 31500])    # Single, MFJ
-# These are speculated (adjusted for inflation).
-stdDeduction_preTCJA = np.array([8300, 16600])  # Single, MFJ
-
-# These are current (adjusted for inflation) per individual.
-extra65Deduction = np.array([2000, 1600])       # Single, MFJ
-
-# Thresholds setting capital gains brackets 0%, 15%, 20% (adjusted for inflation).
-capGainRates = np.array(
-    [
-        [48350, 533400],
-        [96700, 600050],
-    ]
-)
-
-# Thresholds for net investment income tax (not adjusted for inflation).
-niitThreshold = np.array([200000, 250000])
-niitRate = 0.038
-
-# Thresholds for 65+ bonus for circumventing tax on social security.
-bonusThreshold = np.array([75000, 150000])
-
-###############################################################################
-# End of section where rates need to be actualized every year.
-###############################################################################
-
-
-def mediVals(yobs, horizons, gamma_n, Nn, Nq):
-    """
-    Return tuple (nm, L, C) of year index when Medicare starts and vectors L, and C
-    defining end points of constant piecewise linear functions representing IRMAA fees.
-    """
-    thisyear = date.today().year
-    assert Nq == len(irmaaFees), f"Inconsistent value of Nq: {Nq}."
-    assert Nq == len(irmaaBrackets[0]), "Inconsistent IRMAA brackets array."
-    Ni = len(yobs)
-    # What index year will Medicare start? 65 - age.
-    nm = 65 - (thisyear - yobs)
-    nm = np.min(nm)
-    # Has it already started?
-    nm = max(0, nm)
-    Nmed = Nn - nm
-
-    L = np.zeros((Nmed, Nq-1))
-    C = np.zeros((Nmed, Nq))
-
-    # Year starts at offset nm in the plan.
-    for nn in range(Nmed):
-        imed = 0
-        n = nm + nn
-        if thisyear + n - yobs[0] >= 65 and n < horizons[0]:
-            imed += 1
-        if Ni == 2 and thisyear + n - yobs[1] >= 65 and n < horizons[1]:
-            imed += 1
-        if imed:
-            status = 0 if Ni == 1 else 1 if n < horizons[0] and n < horizons[1] else 0
-            L[nn] = gamma_n[n] * irmaaBrackets[status][1:]
-            C[nn] = imed * gamma_n[n] * irmaaFees
-        else:
-            raise RuntimeError("mediVals: This should never happen.")
-
-    return nm, L, C
-
-
-def capitalGainTaxRate(Ni, magi_n, gamma_n, nd, Nn):
-    """
-    Return an array of decimal rates for capital gains.
-    Parameter nd is the index year of first passing of a spouse, if applicable,
-    nd == Nn for single individuals.
-    """
-    status = Ni - 1
-    cgRate_n = np.zeros(Nn)
-
-    for n in range(Nn):
-        if status and n == nd:
-            status -= 1
-
-        if magi_n[n] > gamma_n[n] * capGainRates[status][1]:
-            cgRate_n[n] = 0.20
-        elif magi_n[n] > gamma_n[n] * capGainRates[status][0]:
-            cgRate_n[n] = 0.15
-
-    return cgRate_n
-
-
-def mediCosts(yobs, horizons, magi, prevmagi, gamma_n, Nn):
-    """
-    Compute Medicare costs directly.
-    """
-    thisyear = date.today().year
-    Ni = len(yobs)
-    costs = np.zeros(Nn)
-    for n in range(Nn):
-        status = 0 if Ni == 1 else 1 if n < horizons[0] and n < horizons[1] else 0
-        for i in range(Ni):
-            if thisyear + n - yobs[i] >= 65 and n < horizons[i]:
-                # Start with the (inflation-adjusted) basic Medicare part B premium.
-                costs[n] += gamma_n[n] * irmaaFees[0]
-                if n < 2:
-                    mymagi = prevmagi[n]
-                else:
-                    mymagi = magi[n - 2]
-                for q in range(1, 6):
-                    if mymagi > gamma_n[n] * irmaaBrackets[status][q]:
-                        costs[n] += gamma_n[n] * irmaaFees[q]
-
-    return costs
-
-
-def taxParams(yobs, i_d, n_d, N_n, gamma_n, MAGI_n, yOBBBA=2099):
-    """
-    Input is year of birth, index of shortest-lived individual,
-    lifespan of shortest-lived individual, total number of years
-    in the plan, and the year that preTCJA rates might come back.
-
-    It returns 3 time series:
-    1) Standard deductions at year n (sigma_n).
-    2) Tax rate in year n (theta_tn)
-    3) Delta from top to bottom of tax brackets (Delta_tn)
-    This is pure speculation on future values.
-    Returned values are not indexed for inflation.
-    """
-    # Compute the deltas in-place between brackets, starting from the end.
-    deltaBrackets_OBBBA = np.array(taxBrackets_OBBBA)
-    deltaBrackets_preTCJA = np.array(taxBrackets_preTCJA)
-    for t in range(6, 0, -1):
-        for i in range(2):
-            deltaBrackets_OBBBA[i, t] -= deltaBrackets_OBBBA[i, t - 1]
-            deltaBrackets_preTCJA[i, t] -= deltaBrackets_preTCJA[i, t - 1]
-
-    # Prepare the 3 arrays to return - use transpose for easy slicing.
-    sigmaBar = np.zeros((N_n))
-    Delta = np.zeros((N_n, 7))
-    theta = np.zeros((N_n, 7))
-
-    filingStatus = len(yobs) - 1
-    souls = list(range(len(yobs)))
-    thisyear = date.today().year
-
-    for n in range(N_n):
-        # First check if shortest-lived individual is still with us.
-        if n == n_d:
-            souls.remove(i_d)
-            filingStatus -= 1
-
-        if thisyear + n < yOBBBA:
-            sigmaBar[n] = stdDeduction_OBBBA[filingStatus] * gamma_n[n]
-            Delta[n, :] = deltaBrackets_OBBBA[filingStatus, :]
-        else:
-            sigmaBar[n] = stdDeduction_preTCJA[filingStatus] * gamma_n[n]
-            Delta[n, :] = deltaBrackets_preTCJA[filingStatus, :]
-
-        # Add 65+ additional exemption(s) and "bonus" phasing out.
-        for i in souls:
-            if thisyear + n - yobs[i] >= 65:
-                sigmaBar[n] += extra65Deduction[filingStatus] * gamma_n[n]
-                if thisyear + n <= 2028:
-                    sigmaBar[n] += 6000 * max(0, 1 - 0.06*max(0, MAGI_n[n] - bonusThreshold[filingStatus]))
-
-        # Fill in future tax rates for year n.
-        if thisyear + n < yOBBBA:
-            theta[n, :] = rates_OBBBA[:]
-        else:
-            theta[n, :] = rates_preTCJA[:]
-
-    Delta = Delta.transpose()
-    theta = theta.transpose()
-
-    # Return series unadjusted for inflation, except for sigmaBar, in STD order.
-    return sigmaBar, theta, Delta
-
-
-def taxBrackets(N_i, n_d, N_n, yOBBBA=2099):
-    """
-    Return dictionary containing future tax brackets
-    unadjusted for inflation for plotting.
-    """
-    if not (0 < N_i <= 2):
-        raise ValueError(f"Cannot process {N_i} individuals.")
-
-    n_d = min(n_d, N_n)
-    status = N_i - 1
-
-    # Number of years left in OBBBA from this year.
-    thisyear = date.today().year
-    if yOBBBA < thisyear:
-        raise ValueError(f"Expiration year {yOBBBA} cannot be in the past.")
-
-    ytc = yOBBBA - thisyear
-
-    data = {}
-    for t in range(len(taxBracketNames) - 1):
-        array = np.zeros(N_n)
-        for n in range(N_n):
-            stat = status if n < n_d else 0
-            array[n] = taxBrackets_OBBBA[stat][t] if n < ytc else taxBrackets_preTCJA[stat][t]
-
-        data[taxBracketNames[t]] = array
-
-    return data
-
-
-def rho_in(yobs, N_n):
-    """
-    Return Required Minimum Distribution fractions for each individual.
-    This implementation does not support spouses with more than
-    10-year difference.
-    It starts at age 73 until it goes to 75 in 2033.
-    """
-    # Notice that table starts at age 72.
-    rmdTable = [
-        27.4,
-        26.5,
-        25.5,
-        24.6,
-        23.7,
-        22.9,
-        22.0,
-        21.1,
-        20.2,
-        19.4,
-        18.5,
-        17.7,
-        16.8,
-        16.0,
-        15.2,
-        14.4,
-        13.7,
-        12.9,
-        12.2,
-        11.5,
-        10.8,
-        10.1,
-        9.5,
-        8.9,
-        8.4,
-        7.8,
-        7.3,
-        6.8,
-        6.4,
-        6.0,
-        5.6,
-        5.2,
-        4.9,
-        4.6,
-    ]
-
-    N_i = len(yobs)
-    if N_i == 2 and abs(yobs[0] - yobs[1]) > 10:
-        raise RuntimeError("RMD: Unsupported age difference of more than 10 years.")
-
-    rho = np.zeros((N_i, N_n))
-    thisyear = date.today().year
-    for i in range(N_i):
-        agenow = thisyear - yobs[i]
-        # Account for increase of RMD age between 2023 and 2032.
-        yrmd = 70 if yobs[i] < 1949 else 72 if 1949 <= yobs[i] <= 1950 else 73 if 1951 <= yobs[i] <= 1959 else 75
-        for n in range(N_n):
-            yage = agenow + n
-
-            if yage < yrmd:
-                pass  # rho[i][n] = 0
-            else:
-                rho[i][n] = 1.0 / rmdTable[yage - 72]
-
-    return rho