owlplanner 2025.7.1__py3-none-any.whl → 2025.9.15__py3-none-any.whl

owlplanner/abcapi.py

@@ -18,7 +18,7 @@ A for matrix, B for bounds, C for constraints. Thus the name ABCAPI.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 

owlplanner/config.py

@@ -6,7 +6,7 @@ This file contains utility functions to save case parameters.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 
@@ -66,7 +66,7 @@ def saveConfig(myplan, file, mylog):
     diconf["Rates Selection"] = {
         "Heirs rate on tax-deferred estate": float(100 * myplan.nu),
         "Dividend rate": float(100 * myplan.mu),
-        "TCJA expiration year": myplan.yTCJA,
+        "OBBBA expiration year": myplan.yOBBBA,
         "Method": myplan.rateMethod,
     }
     if myplan.rateMethod in ["user", "stochastic"]:
@@ -228,7 +228,7 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     # Rates Selection.
     p.setDividendRate(float(diconf["Rates Selection"].get("Dividend rate", 1.8)))    # Fix for mod.
     p.setHeirsTaxRate(float(diconf["Rates Selection"]["Heirs rate on tax-deferred estate"]))
-    p.yTCJA = int(diconf["Rates Selection"]["TCJA expiration year"])
+    p.yOBBBA = int(diconf["Rates Selection"].get("OBBBA expiration year", 2032))
 
     frm = None
     to = None
@@ -296,6 +296,10 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     # Solver Options.
     p.solverOptions = diconf["Solver Options"]
 
+    # Address legacy case files.
+    if diconf["Solver Options"].get("withMedicare", None) is True:
+        p.solverOptions["withMedicare"] = "loop"
+
     # Check consistency of noRothConversions.
     name = p.solverOptions.get("noRothConversions", "None")
     if name != "None" and name not in p.inames:

owlplanner/mylogging.py

@@ -6,7 +6,7 @@ This file contains routines for handling error messages.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 

owlplanner/plan.py

@@ -10,7 +10,7 @@ mathematical model and a description of all variables and parameters.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 
@@ -226,12 +226,13 @@ class Plan(object):
         self._name = name
         self.setLogstreams(verbose, logstreams)
 
-        # 7 tax brackets, 3 types of accounts, 4 classes of assets.
+        # 7 tax brackets, 6 Medicare brackets, 3 types of accounts, 4 classes of assets.
         self.N_t = 7
+        self.N_q = 6
         self.N_j = 3
         self.N_k = 4
         # 2 binary variables.
-        self.N_z = 2
+        self.N_zx = 2
 
         # Default interpolation parameters for allocation ratios.
         self.interpMethod = "linear"
@@ -258,8 +259,9 @@ class Plan(object):
             raise ValueError("Name for each individual must be provided.")
 
         self.filingStatus = ("single", "married")[self.N_i - 1]
-        # Default year TCJA is speculated to expire.
-        self.yTCJA = 2026
+
+        # Default year OBBBA speculated to be expired and replaced by pre-TCJA rates.
+        self.yOBBBA = 2032
         self.inames = inames
         self.yobs = np.array(yobs, dtype=np.int32)
         self.expectancy = np.array(expectancy, dtype=np.int32)
@@ -297,20 +299,22 @@ class Plan(object):
         self.zeta_in = np.zeros((self.N_i, self.N_n))
         self.pensionAmounts = np.zeros(self.N_i)
         self.pensionAges = 65 * np.ones(self.N_i, dtype=np.int32)
-        self.pensionIsIndexed = [False, False]
+        self.pensionIsIndexed = [False] * self.N_i
         self.ssecAmounts = np.zeros(self.N_i)
         self.ssecAges = 67 * np.ones(self.N_i, dtype=np.int32)
 
         # Parameters from timeLists initialized to zero.
         self.omega_in = np.zeros((self.N_i, self.N_n))
         self.Lambda_in = np.zeros((self.N_i, self.N_n))
+        # Go back 5 years for maturation rules on IRA and Roth.
         self.myRothX_in = np.zeros((self.N_i, self.N_n + 5))
         self.kappa_ijn = np.zeros((self.N_i, self.N_j, self.N_n + 5))
 
-        # Previous 3 years for Medicare.
+        # Previous 2 years of MAGI needed for Medicare.
         self.prevMAGI = np.zeros((2))
+        self.MAGI_n = np.zeros(self.N_n)
 
-        # Init previous balance to none.
+        # Init current balances to none.
         self.beta_ij = None
         self.startDate = None
 
@@ -327,8 +331,6 @@ class Plan(object):
         # Prepare RMD time series.
         self.rho_in = tx.rho_in(self.yobs, self.N_n)
 
-        self._buildOffsetMap()
-
         # Initialize guardrails to ensure proper configuration.
         self._adjustedParameters = False
         self.timeListsFileName = "None"
@@ -340,7 +342,7 @@ class Plan(object):
         self.ARCoord = None
         self.objective = "unknown"
 
-        # Placeholders to check if properly configured.
+        # Placeholders values used to check if properly configured.
         self.xi_n = None
         self.alpha_ijkn = None
 
@@ -368,7 +370,7 @@ class Plan(object):
         """
         Set the date when the plan starts in the current year.
         This is mostly for reproducibility purposes and back projecting known balances to Jan 1st.
-        String format of mydate is 'month/day'.
+        String format of mydate is 'MM/DD', 'MM-DD', 'YYYY-MM-DD', or 'YYYY/MM/DD'. Year is ignored.
         """
         import calendar
 
@@ -397,7 +399,7 @@ class Plan(object):
 
         return None
 
-    def _checkValue(self, value):
+    def _checkValueType(self, value):
         """
         Short utility function to parse and check arguments for plotting.
         """
@@ -450,7 +452,7 @@ class Plan(object):
         Set plots between nominal values or today's $.
         """
 
-        self.defaultPlots = self._checkValue(value)
+        self.defaultPlots = self._checkValueType(value)
         self.mylog.vprint(f"Setting plots default value to {value}.")
 
     def setPlotBackend(self, backend: str):
@@ -463,25 +465,26 @@ class Plan(object):
 
         if backend != self._plotterName:
             self._plotter = PlotFactory.createBackend(backend)
+            self._plotterName = backend
             self.mylog.vprint(f"Setting plotting backend to {backend}.")
 
     def setDividendRate(self, mu):
         """
         Set dividend tax rate. Rate is in percent. Default 1.8%.
         """
-        if not (0 <= mu <= 100):
-            raise ValueError("Rate must be between 0 and 100.")
+        if not (0 <= mu <= 5):
+            raise ValueError("Rate must be between 0 and 5.")
         mu /= 100
         self.mylog.vprint(f"Dividend tax rate set to {u.pc(mu, f=0)}.")
         self.mu = mu
         self.caseStatus = "modified"
 
-    def setExpirationYearTCJA(self, yTCJA):
+    def setExpirationYearOBBBA(self, yOBBBA):
         """
-        Set year at which TCJA is speculated to expire.
+        Set year at which OBBBA is speculated to expire and rates go back to something like pre-TCJA.
         """
-        self.mylog.vprint(f"Setting TCJA expiration year to {yTCJA}.")
-        self.yTCJA = yTCJA
+        self.mylog.vprint(f"Setting OBBBA expiration year to {yOBBBA}.")
+        self.yOBBBA = yOBBBA
         self.caseStatus = "modified"
         self._adjustedParameters = False
 
@@ -516,7 +519,7 @@ class Plan(object):
         self.nu = nu
         self.caseStatus = "modified"
 
-    def setPension(self, amounts, ages, indexed=(False, False), units="k"):
+    def setPension(self, amounts, ages, indexed=None, units="k"):
         """
         Set value of pension for each individual and commencement age.
         Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
@@ -525,8 +528,8 @@ class Plan(object):
             raise ValueError(f"Amounts must have {self.N_i} entries.")
         if len(ages) != self.N_i:
             raise ValueError(f"Ages must have {self.N_i} entries.")
-        if len(indexed) < self.N_i:
-            raise ValueError(f"Indexed list must have at least {self.N_i} entries.")
+        if indexed is None:
+            indexed = [False] * self.N_i
 
         fac = u.getUnits(units)
         amounts = u.rescale(amounts, fac)
@@ -539,7 +542,7 @@ class Plan(object):
         self.pi_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
             if amounts[i] != 0:
-                ns = max(0, self.yobs[i] + ages[i] - thisyear)
+                ns = max(0, ages[i] - thisyear + self.yobs[i])
                 nd = self.horizons[i]
                 self.pi_in[i, ns:nd] = amounts[i]
 
@@ -570,13 +573,13 @@ class Plan(object):
         thisyear = date.today().year
         self.zeta_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
-            ns = max(0, self.yobs[i] + ages[i] - thisyear)
+            ns = max(0, ages[i] - thisyear + self.yobs[i])
             nd = self.horizons[i]
             self.zeta_in[i, ns:nd] = amounts[i]
 
         if self.N_i == 2:
-            # Approximate calculation for spousal benefit (only valid at FRA).
-            self.zeta_in[self.i_s, self.n_d :] = max(amounts[self.i_s], amounts[self.i_d])
+            # Approximate calculation for spousal benefit (only valid at FRA, and if of similar ages).
+            self.zeta_in[self.i_s, self.n_d :] = max(amounts[self.i_s], 0.5*amounts[self.i_d])
 
         self.ssecAmounts = np.array(amounts)
         self.ssecAges = np.array(ages, dtype=np.int32)
@@ -658,36 +661,6 @@ class Plan(object):
             corr=self.rateCorr,
         )
 
-    def value(self, amount, year):
-        """
-        Return value of amount deflated or inflated at the beginning
-        of the year specified.
-        If year is in the past, value is made at the beginning of this year.
-        If year is in the future, amount is adjusted from a reference time
-        aligned with the beginning of the plan to the beginning of the
-        year specified.
-        """
-        thisyear = date.today().year
-        if year <= thisyear:
-            return rates.historicalValue(amount, year)
-        else:
-            return self.forwardValue(amount, year)
-
-    def forwardValue(self, amount, year):
-        """
-        Return the value of amount inflated from beginning of the plan
-        to the beginning of the year provided.
-        """
-        if self.rateMethod is None:
-            raise RuntimeError("A rate method needs to be first selected using setRates(...).")
-
-        thisyear = date.today().year
-        if year <= thisyear:
-            raise RuntimeError("Internal error in forwardValue().")
-        span = year - thisyear
-
-        return amount * self.gamma_n[span]
-
     def setAccountBalances(self, *, taxable, taxDeferred, taxFree, startDate=None, units="k"):
         """
         Three lists containing the balance of all assets in each category for
@@ -977,7 +950,6 @@ class Plan(object):
         for i, iname in enumerate(self.inames):
             h = self.horizons[i]
             df = pd.DataFrame(0, index=np.arange(0, h+5), columns=cols)
-            # df["year"] = self.year_n[:h]
             df["year"] = np.arange(self.year_n[0] - 5, self.year_n[h-1]+1)
             self.timeLists[iname] = df
 
@@ -1015,62 +987,70 @@ class Plan(object):
 
         return dat
 
-    def _adjustParameters(self):
+    def _adjustParameters(self, gamma_n, MAGI_n):
         """
-        Adjust parameters that follow inflation.
+        Adjust parameters that follow inflation or depend on MAGI.
+        Separate variables depending on MAGI (exemptions now depends on MAGI).
         """
         if self.rateMethod is None:
             raise RuntimeError("A rate method needs to be first selected using setRates(...).")
 
+        self.sigmaBar_n, self.theta_tn, self.Delta_tn = tx.taxParams(self.yobs, self.i_d, self.n_d,
+                                                                     self.N_n, gamma_n,
+                                                                     MAGI_n, self.yOBBBA)
+
         if not self._adjustedParameters:
             self.mylog.vprint("Adjusting parameters for inflation.")
-            self.sigma_n, self.theta_tn, self.Delta_tn = tx.taxParams(self.yobs, self.i_d, self.n_d,
-                                                                      self.N_n, self.yTCJA)
-            self.sigmaBar_n = self.sigma_n * self.gamma_n[:-1]
-            self.DeltaBar_tn = self.Delta_tn * self.gamma_n[:-1]
-            self.zetaBar_in = self.zeta_in * self.gamma_n[:-1]
-            self.xiBar_n = self.xi_n * self.gamma_n[:-1]
+            self.DeltaBar_tn = self.Delta_tn * gamma_n[:-1]
+            self.zetaBar_in = self.zeta_in * gamma_n[:-1]
+            self.xiBar_n = self.xi_n * gamma_n[:-1]
             self.piBar_in = np.array(self.pi_in)
             for i in range(self.N_i):
                 if self.pensionIsIndexed[i]:
-                    self.piBar_in[i] *= self.gamma_n[:-1]
+                    self.piBar_in[i] *= gamma_n[:-1]
+
+            self.nm, self.L_nq, self.C_nq = tx.mediVals(self.yobs, self.horizons, gamma_n, self.N_n, self.N_q)
 
             self._adjustedParameters = True
 
-        return None
+        # return None
 
-    def _buildOffsetMap(self):
+    def _buildOffsetMap(self, options):
         """
         Utility function to map variables to a block vector.
         Refer to companion document for explanations.
+        All binary variables must be lumped at the end of the vector.
         """
+        medi = options.get("withMedicare", "loop") == "optimize"
+
         # Stack all variables in a single block vector with all binary variables at the end.
         C = {}
         C["b"] = 0
         C["d"] = _qC(C["b"], self.N_i, self.N_j, self.N_n + 1)
         C["e"] = _qC(C["d"], self.N_i, self.N_n)
-        C["F"] = _qC(C["e"], self.N_n)
-        C["g"] = _qC(C["F"], self.N_t, self.N_n)
-        C["s"] = _qC(C["g"], self.N_n)
+        C["f"] = _qC(C["e"], self.N_n)
+        C["g"] = _qC(C["f"], self.N_t, self.N_n)
+        C["m"] = _qC(C["g"], self.N_n)
+        C["s"] = _qC(C["m"], self.N_n)
         C["w"] = _qC(C["s"], self.N_n)
         C["x"] = _qC(C["w"], self.N_i, self.N_j, self.N_n)
-        C["z"] = _qC(C["x"], self.N_i, self.N_n)
-        self.nvars = _qC(C["z"], self.N_i, self.N_n, self.N_z)
-        self.nbins = self.nvars - C["z"]
-        # # self.nvars = _qC(C["x"], self.N_i, self.N_n)
-        # # self.nbins = 0
+        C["zx"] = _qC(C["x"], self.N_i, self.N_n)
+        C["zm"] = _qC(C["zx"], self.N_i, self.N_n, self.N_zx)
+        self.nvars = _qC(C["zm"], self.N_n - self.nm, self.N_q - 1) if medi else C["zm"]
+        self.nbins = self.nvars - C["zx"]
 
         self.C = C
         self.mylog.vprint(
             f"Problem has {len(C)} distinct series, {self.nvars} decision variables (including {self.nbins} binary).")
 
-        return None
-
     def _buildConstraints(self, objective, options):
         """
         Utility function that builds constraint matrix and vectors.
         Refactored for clarity and maintainability.
         """
+        # Ensure parameters are adjusted for inflation and MAGI.
+        self._adjustParameters(self.gamma_n, self.MAGI_n)
+
         self.A = abc.ConstraintMatrix(self.nvars)
         self.B = abc.Bounds(self.nvars, self.nbins)
 
@@ -1089,11 +1069,11 @@ class Plan(object):
         self._add_net_cash_flow()
         self._add_income_profile()
         self._add_taxable_income()
-        self._configure_binary_variables(options)
+        self._configure_Medicare_binary_variables(options)
+        self._add_Medicare_costs(options)
+        self._configure_exclusion_binary_variables(options)
         self._build_objective_vector(objective)
 
-        return None
-
     def _add_rmd_inequalities(self):
         for i in range(self.N_i):
             if self.beta_ij[i, 1] > 0:
@@ -1107,7 +1087,7 @@ class Plan(object):
     def _add_tax_bracket_bounds(self):
         for t in range(self.N_t):
             for n in range(self.N_n):
-                self.B.setRange(_q2(self.C["F"], t, n, self.N_t, self.N_n), 0, self.DeltaBar_tn[t, n])
+                self.B.setRange(_q2(self.C["f"], t, n, self.N_t, self.N_n), 0, self.DeltaBar_tn[t, n])
 
     def _add_standard_exemption_bounds(self):
         for n in range(self.N_n):
@@ -1313,6 +1293,7 @@ class Plan(object):
             rhs = -self.M_n[n] - self.J_n[n]
             row = self.A.newRow({_q1(self.C["g"], n, self.N_n): 1})
             row.addElem(_q1(self.C["s"], n, self.N_n), 1)
+            row.addElem(_q1(self.C["m"], n, self.N_n), 1)
             for i in range(self.N_i):
                 fac = self.psi_n[n] * self.alpha_ijkn[i, 0, 0, n]
                 rhs += (
@@ -1330,7 +1311,7 @@ class Plan(object):
                 row.addElem(_q2(self.C["d"], i, n, self.N_i, self.N_n), fac * self.mu)
 
             for t in range(self.N_t):
-                row.addElem(_q2(self.C["F"], t, n, self.N_t, self.N_n), self.theta_tn[t, n])
+                row.addElem(_q2(self.C["f"], t, n, self.N_t, self.N_n), self.theta_tn[t, n])
 
             self.A.addRow(row, rhs, rhs)
 
@@ -1360,10 +1341,13 @@ class Plan(object):
                 row.addElem(_q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n), fak)
                 row.addElem(_q2(self.C["d"], i, n, self.N_i, self.N_n), -fak)
             for t in range(self.N_t):
-                row.addElem(_q2(self.C["F"], t, n, self.N_t, self.N_n), 1)
+                row.addElem(_q2(self.C["f"], t, n, self.N_t, self.N_n), 1)
             self.A.addRow(row, rhs, rhs)
 
-    def _configure_binary_variables(self, options):
+    def _configure_exclusion_binary_variables(self, options):
+        if not options.get("xorConstraints", True):
+            return
+
         bigM = options.get("bigM", 5e6)
         if not isinstance(bigM, (int, float)):
             raise ValueError(f"bigM {bigM} is not a number.")
@@ -1371,14 +1355,14 @@ class Plan(object):
         for i in range(self.N_i):
             for n in range(self.horizons[i]):
                 self.A.addNewRow(
-                    {_q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z): bigM,
+                    {_q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx): bigM,
                      _q1(self.C["s"], n, self.N_n): -1},
                     0,
                     bigM,
                 )
                 self.A.addNewRow(
                     {
-                        _q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z): bigM,
+                        _q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx): bigM,
                         _q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n): 1,
                         _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1,
                     },
@@ -1386,20 +1370,94 @@ class Plan(object):
                     bigM,
                 )
                 self.A.addNewRow(
-                    {_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z): bigM,
+                    {_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx): bigM,
                      _q2(self.C["x"], i, n, self.N_i, self.N_n): -1},
                     0,
                     bigM,
                 )
                 self.A.addNewRow(
-                    {_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z): bigM,
+                    {_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx): bigM,
                      _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1},
                     0,
                     bigM,
                 )
             for n in range(self.horizons[i], self.N_n):
-                self.B.setRange(_q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z), 0, 0)
-                self.B.setRange(_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z), 0, 0)
+                self.B.setRange(_q3(self.C["zx"], i, n, 0, self.N_i, self.N_n, self.N_zx), 0, 0)
+                self.B.setRange(_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx), 0, 0)
+
+    def _configure_Medicare_binary_variables(self, options):
+        if options.get("withMedicare", "loop") != "optimize":
+            return
+
+        bigM = options.get("bigM", 5e6)
+        if not isinstance(bigM, (int, float)):
+            raise ValueError(f"bigM {bigM} is not a number.")
+
+        Nmed = self.N_n - self.nm
+        offset = 0
+        if self.nm < 2:
+            offset = 2 - self.nm
+            for nn in range(offset):
+                n = self.nm + nn
+                for q in range(self.N_q - 1):
+                    self.A.addNewRow({_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1): bigM},
+                                     -np.inf, bigM - self.L_nq[nn, q] + self.prevMAGI[n])
+                    self.A.addNewRow({_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1): -bigM},
+                                     -np.inf, self.L_nq[nn, q] - self.prevMAGI[n])
+
+        for nn in range(offset, Nmed):
+            n2 = self.nm + nn - 2  # n - 2
+            for q in range(self.N_q - 1):
+                rhs1 = bigM - self.L_nq[nn, q]
+                rhs2 = self.L_nq[nn, q]
+                row1 = self.A.newRow()
+                row2 = self.A.newRow()
+
+                row1.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), +bigM)
+                row2.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), -bigM)
+                for i in range(self.N_i):
+                    row1.addElem(_q3(self.C["w"], i, 1, n2, self.N_i, self.N_j, self.N_n), -1)
+                    row2.addElem(_q3(self.C["w"], i, 1, n2, self.N_i, self.N_j, self.N_n), +1)
+
+                    row1.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), -1)
+                    row2.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), +1)
+
+                    afac = (self.mu*self.alpha_ijkn[i, 0, 0, n2]
+                            + np.sum(self.alpha_ijkn[i, 0, 1:, n2]*self.tau_kn[1:, n2]))
+                    afac = 0
+                    row1.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), -afac)
+                    row2.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), +afac)
+
+                    row1.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), -afac)
+                    row2.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), +afac)
+
+                    bfac = self.alpha_ijkn[i, 0, 0, n2] * max(0, self.tau_kn[0, max(0, n2-1)])
+                    row1.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), +afac - bfac)
+                    row2.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), -afac + bfac)
+
+                    sumoni = (self.omega_in[i, n2] + self.psi_n[n2] * self.zetaBar_in[i, n2] + self.piBar_in[i, n2]
+                              + 0.5 * self.kappa_ijn[i, 0, n2] * afac)
+                    rhs1 += sumoni
+                    rhs2 -= sumoni
+
+                self.A.addRow(row1, -np.inf, rhs1)
+                self.A.addRow(row2, -np.inf, rhs2)
+
+    def _add_Medicare_costs(self, options):
+        if options.get("withMedicare", "loop") != "optimize":
+            return
+
+        for n in range(self.nm):
+            self.B.setRange(_q1(self.C["m"], n, self.N_n), 0, 0)
+
+        Nmed = self.N_n - self.nm
+        for nn in range(Nmed):
+            n = self.nm + nn
+            row = self.A.newRow()
+            row.addElem(_q1(self.C["m"], n, self.N_n), 1)
+            for q in range(self.N_q - 1):
+                row.addElem(_q2(self.C["zm"], nn, q, Nmed, self.N_q - 1), -self.C_nq[nn, q+1])
+            self.A.addRow(row, self.C_nq[nn, 0], self.C_nq[nn, 0])
 
     def _build_objective_vector(self, objective):
         c = abc.Objective(self.nvars)
@@ -1484,12 +1542,7 @@ class Plan(object):
         self.mylog.vprint(f"Running {N} Monte Carlo simulations.")
         self.mylog.setVerbose(verbose)
 
-        # Turn off Medicare by default, unless specified in options.
-        if "withMedicare" not in options:
-            myoptions = dict(options)
-            myoptions["withMedicare"] = False
-        else:
-            myoptions = options
+        myoptions = options
 
         if objective == "maxSpending":
             columns = ["partial", objective]
@@ -1573,13 +1626,15 @@ class Plan(object):
             "maxRothConversion",
             "netSpending",
             "noRothConversions",
+            "oppCostX",
+            "withMedicare",
             "previousMAGIs",
             "solver",
             "spendingSlack",
             "startRothConversions",
             "units",
-            "withMedicare",
-            "oppCostX",
+            "xorConstraints",
+            "withSCLoop",
         ]
         # We might modify options if required.
         options = {} if options is None else options
@@ -1624,11 +1679,14 @@ class Plan(object):
             raise ValueError(f"Slack value out of range {lambdha}.")
         self.lambdha = lambdha / 100
 
-        # Ensure parameters are adjusted for inflation.
-        self._adjustParameters()
+        # Reset long-term capital gain tax rate and MAGI to zero.
+        self.psi_n = np.zeros(self.N_n)
+        self.MAGI_n = np.zeros(self.N_n)
+        self.J_n = np.zeros(self.N_n)
+        self.M_n = np.zeros(self.N_n)
 
-        # Reset long-term capital gain tax rate to zero.
-        self.psi_n[:] = 0
+        self._adjustParameters(self.gamma_n, self.MAGI_n)
+        self._buildOffsetMap(options)
 
         solver = myoptions.get("solver", self.defaultSolver)
         if solver not in knownSolvers:
@@ -1654,7 +1712,8 @@ class Plan(object):
         """
         Self-consistent loop, regardless of solver.
         """
-        withMedicare = options.get("withMedicare", True)
+        includeMedicare = options.get("withMedicare", "loop") == "loop"
+        withSCLoop = options.get("withSCLoop", True)
 
         if objective == "maxSpending":
             objFac = -1 / self.xi_n[0]
@@ -1662,32 +1721,34 @@ class Plan(object):
             objFac = -1 / self.gamma_n[-1]
 
         it = 0
-        absdiff = np.inf
         old_x = np.zeros(self.nvars)
-        old_solutions = [np.inf]
-        self._estimateMedicare(None, withMedicare)
+        old_objfns = [np.inf]
+        self._computeNLstuff(None, includeMedicare)
         while True:
-            solution, xx, solverSuccess, solverMsg = solverMethod(objective, options)
+            objfn, xx, solverSuccess, solverMsg = solverMethod(objective, options)
 
-            if not solverSuccess or solution is None:
+            if not solverSuccess or objfn is None:
                 self.mylog.vprint("Solver failed:", solverMsg, solverSuccess)
                 break
 
-            if not withMedicare:
+            if not withSCLoop:
                 break
 
-            self._estimateMedicare(xx)
-
-            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution * objFac, f=2)}")
+            self._computeNLstuff(xx, includeMedicare)
 
             delta = xx - old_x
-            absdiff = np.sum(np.abs(delta), axis=0)
-            if absdiff < 1:
+            absSolDiff = np.sum(np.abs(delta), axis=0)/100
+            absObjDiff = abs(objFac*(objfn + old_objfns[-1]))/100
+            self.mylog.vprint(f"Iteration: {it} objective: {u.d(objfn * objFac, f=2)},"
+                              f" |dX|: {absSolDiff:.2f}, |df|: {u.d(absObjDiff, f=2)}")
+
+            # 50 cents accuracy.
+            if absSolDiff < .5 and absObjDiff < .5:
                 self.mylog.vprint("Converged on full solution.")
                 break
 
             # Avoid oscillatory solutions. Look only at most recent solutions. Within $10.
-            isclosenough = abs(-solution - min(old_solutions[int(it / 2) :])) < 10 * self.xi_n[0]
+            isclosenough = abs(-objfn - min(old_objfns[int(it / 2) :])) < 10 * self.xi_n[0]
             if isclosenough:
                 self.mylog.vprint("Converged through selecting minimum oscillating objective.")
                 break
@@ -1697,13 +1758,13 @@ class Plan(object):
                 break
 
             it += 1
-            old_solutions.append(-solution)
+            old_objfns.append(-objfn)
             old_x = xx
 
         if solverSuccess:
-            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it+1} iterations.")
+            self.mylog.vprint(f"Self-consistent loop returned after {it+1} iterations.")
             self.mylog.vprint(solverMsg)
-            self.mylog.vprint(f"Objective: {u.d(solution * objFac)}")
+            self.mylog.vprint(f"Objective: {u.d(objfn * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
             self._aggregateResults(xx)
             self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
@@ -1725,7 +1786,7 @@ class Plan(object):
             "disp": False,
             "mip_rel_gap": 1e-7,
             "presolve": True,
-            "node_limit": 10000  # Limit search nodes for faster solutions
+            # "node_limit": 10000  # Limit search nodes for faster solutions
         }
 
         self._buildConstraints(objective, options)
@@ -1873,10 +1934,11 @@ class Plan(object):
 
         return solution, xx, solverSuccess, solverMsg
 
-    def _computeNIIT(self):
+    def _computeNIIT(self, MAGI_n, I_n, Q_n):
         """
-        Compute Wages (W), Dividends (Q), Interests (I), and exemption(e).
-        For accounting for rent and trust income, one can easily add a column
+        Compute ACA tax on Dividends (Q) and Interests (I).
+        Pass arguments to better understand dependencies.
+        For accounting for rent and/or trust income, one can easily add a column
         to the Wages and Contributions file and add yearly amount to Q_n + I_n below.
         """
         J_n = np.zeros(self.N_n)
@@ -1887,17 +1949,17 @@ class Plan(object):
                 status -= 1
 
             Gmax = tx.niitThreshold[status]
-            if self.MAGI_n[n] > Gmax:
-                J_n[n] = tx.niitRate * min(self.MAGI_n[n] - Gmax, self.I_n[n] + self.Q_n[n])
+            if MAGI_n[n] > Gmax:
+                J_n[n] = tx.niitRate * min(MAGI_n[n] - Gmax, I_n[n] + Q_n[n])
 
         return J_n
 
-    def _estimateMedicare(self, x=None, withMedicare=True):
+    def _computeNLstuff(self, x, includeMedicare):
         """
         Compute MAGI, Medicare costs, long-term capital gain tax rate, and
         net investment income tax (NIIT).
         """
-        if x is None or withMedicare is False:
+        if x is None:
             self.MAGI_n = np.zeros(self.N_n)
             self.J_n = np.zeros(self.N_n)
             self.M_n = np.zeros(self.N_n)
@@ -1906,9 +1968,11 @@ class Plan(object):
 
         self._aggregateResults(x, short=True)
 
-        self.J_n = self._computeNIIT()
-        self.M_n = tx.mediCosts(self.yobs, self.horizons, self.MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
+        self.J_n = self._computeNIIT(self.MAGI_n, self.I_n, self.Q_n)
         self.psi_n = tx.capitalGainTaxRate(self.N_i, self.MAGI_n, self.gamma_n[:-1], self.n_d, self.N_n)
+        # Compute Medicare through self-consistent loop.
+        if includeMedicare:
+            self.M_n = tx.mediCosts(self.yobs, self.horizons, self.MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
 
         return None
 
@@ -1923,18 +1987,19 @@ class Plan(object):
         Nk = self.N_k
         Nn = self.N_n
         Nt = self.N_t
-        # Nz = self.N_z
+        # Nzx = self.N_zx
         n_d = self.n_d
 
         Cb = self.C["b"]
         Cd = self.C["d"]
         Ce = self.C["e"]
-        CF = self.C["F"]
+        Cf = self.C["f"]
         Cg = self.C["g"]
+        Cm = self.C["m"]
         Cs = self.C["s"]
         Cw = self.C["w"]
         Cx = self.C["x"]
-        Cz = self.C["z"]
+        Czx = self.C["zx"]
 
         x = u.roundCents(x)
 
@@ -1948,26 +2013,28 @@ class Plan(object):
         self.d_in = np.array(x[Cd:Ce])
         self.d_in = self.d_in.reshape((Ni, Nn))
 
-        self.e_n = np.array(x[Ce:CF])
+        self.e_n = np.array(x[Ce:Cf])
+
+        self.f_tn = np.array(x[Cf:Cg])
+        self.f_tn = self.f_tn.reshape((Nt, Nn))
 
-        self.F_tn = np.array(x[CF:Cg])
-        self.F_tn = self.F_tn.reshape((Nt, Nn))
+        self.g_n = np.array(x[Cg:Cm])
 
-        self.g_n = np.array(x[Cg:Cs])
+        self.m_n = np.array(x[Cm:Cs])
 
         self.s_n = np.array(x[Cs:Cw])
 
         self.w_ijn = np.array(x[Cw:Cx])
         self.w_ijn = self.w_ijn.reshape((Ni, Nj, Nn))
 
-        self.x_in = np.array(x[Cx:Cz])
+        self.x_in = np.array(x[Cx:Czx])
         self.x_in = self.x_in.reshape((Ni, Nn))
 
-        # self.z_inz = np.array(x[Cz:])
-        # self.z_inz = self.z_inz.reshape((Ni, Nn, Nz))
+        # self.z_inz = np.array(x[Czx:])
+        # self.z_inz = self.z_inz.reshape((Ni, Nn, Nzx))
         # print(self.z_inz)
 
-        self.G_n = np.sum(self.F_tn, axis=0)
+        self.G_n = np.sum(self.f_tn, axis=0)
 
         tau_0 = np.array(self.tau_kn[0, :])
         tau_0[tau_0 < 0] = 0
@@ -1976,10 +2043,10 @@ class Plan(object):
         self.Q_n = np.sum(
             (
                 self.mu
-                * (self.b_ijn[:, 0, :-1] - self.w_ijn[:, 0, :] + self.d_in[:, :] + 0.5 * self.kappa_ijn[:, 0, :Nn])
+                * (self.b_ijn[:, 0, :Nn] - self.w_ijn[:, 0, :] + self.d_in[:, :] + 0.5 * self.kappa_ijn[:, 0, :Nn])
                 + tau_0prev * self.w_ijn[:, 0, :]
             )
-            * self.alpha_ijkn[:, 0, 0, :-1],
+            * self.alpha_ijkn[:, 0, 0, :Nn],
             axis=0,
         )
         self.U_n = self.psi_n * self.Q_n
@@ -1987,14 +2054,14 @@ class Plan(object):
         self.MAGI_n = self.G_n + self.e_n + self.Q_n
 
         I_in = ((self.b_ijn[:, 0, :-1] + self.d_in - self.w_ijn[:, 0, :])
-                * np.sum(self.alpha_ijkn[:, 0, 1:, :-1] * self.tau_kn[1:, :], axis=1))
+                * np.sum(self.alpha_ijkn[:, 0, 1:, :Nn] * self.tau_kn[1:, :], axis=1))
         self.I_n = np.sum(I_in, axis=0)
 
         # Stop after building minimu required for self-consistent loop.
         if short:
             return
 
-        self.T_tn = self.F_tn * self.theta_tn
+        self.T_tn = self.f_tn * self.theta_tn
         self.T_n = np.sum(self.T_tn, axis=0)
         self.P_n = np.zeros(Nn)
         # Add early withdrawal penalty if any.
@@ -2170,8 +2237,8 @@ class Plan(object):
         dic[" Total net investment income tax paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total net investment income tax paid]"] = f"{u.d(taxPaid)}"
 
-        taxPaid = np.sum(self.M_n, axis=0)
-        taxPaidNow = np.sum(self.M_n / self.gamma_n[:-1], axis=0)
+        taxPaid = np.sum(self.m_n + self.M_n, axis=0)
+        taxPaidNow = np.sum((self.m_n + self.M_n) / self.gamma_n[:-1], axis=0)
         dic[" Total Medicare premiums paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total Medicare premiums paid]"] = f"{u.d(taxPaid)}"
 
@@ -2313,7 +2380,7 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
+        value = self._checkValueType(value)
         title = self._name + "\nNet Available Spending"
         if tag:
             title += " - " + tag
@@ -2338,7 +2405,7 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
+        value = self._checkValueType(value)
         figures = self._plotter.plot_asset_composition(self.year_n, self.inames, self.b_ijkn,
                                                        self.gamma_n, value, self._name, tag)
         if figure:
@@ -2358,8 +2425,8 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
-        tax_brackets = tx.taxBrackets(self.N_i, self.n_d, self.N_n, self.yTCJA)
+        value = self._checkValueType(value)
+        tax_brackets = tx.taxBrackets(self.N_i, self.n_d, self.N_n, self.yOBBBA)
         title = self._name + "\nTaxable Ordinary Income vs. Tax Brackets"
         if tag:
             title += " - " + tag
@@ -2402,7 +2469,7 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
+        value = self._checkValueType(value)
         title = self._name + "\nSavings Balance"
         if tag:
             title += " - " + tag
@@ -2424,7 +2491,7 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
+        value = self._checkValueType(value)
         title = self._name + "\nRaw Income Sources"
         if tag:
             title += " - " + tag
@@ -2446,13 +2513,13 @@ class Plan(object):
         The value parameter can be set to *nominal* or *today*, overriding
         the default behavior of setDefaultPlots().
         """
-        value = self._checkValue(value)
+        value = self._checkValueType(value)
         title = self._name + "\nFederal Income Tax"
         if tag:
             title += " - " + tag
         # All taxes: ordinary income, dividends, and NIIT.
         allTaxes = self.T_n + self.U_n + self.J_n
-        fig = self._plotter.plot_taxes(self.year_n, allTaxes, self.M_n, self.gamma_n,
+        fig = self._plotter.plot_taxes(self.year_n, allTaxes, self.m_n + self.M_n, self.gamma_n,
                                        value, title, self.inames)
         if figure:
             return fig
@@ -2523,7 +2590,7 @@ class Plan(object):
             "net spending": self.g_n,
             "taxable ord. income": self.G_n,
             "taxable gains/divs": self.Q_n,
-            "Tax bills + Med.": self.T_n + self.U_n + self.M_n + self.J_n,
+            "Tax bills + Med.": self.T_n + self.U_n + self.m_n + self.M_n + self.J_n,
         }
 
         fillsheet(ws, incomeDic, "currency")
@@ -2539,7 +2606,7 @@ class Plan(object):
             "all deposits": -np.sum(self.d_in, axis=0),
             "ord taxes": -self.T_n - self.J_n,
             "div taxes": -self.U_n,
-            "Medicare": -self.M_n,
+            "Medicare": -self.m_n - self.M_n,
         }
         sname = "Cash Flow"
         ws = wb.create_sheet(sname)
@@ -2726,7 +2793,7 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
     else:
         fname = basename
 
-    if overwrite is False and isfile(fname):
+    if not overwrite and isfile(fname):
         mylog.print(f'File "{fname}" already exists.')
         key = input("Overwrite? [Ny] ")
         if key != "y":

owlplanner/progress.py

@@ -3,7 +3,7 @@ A simple object to display progress.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 

owlplanner/rates.py

@@ -23,7 +23,7 @@ to the last current data year.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 
@@ -32,7 +32,6 @@ import numpy as np
 import pandas as pd
 import os
 import sys
-from datetime import date
 
 from owlplanner import mylogging as log
 from owlplanner import utils as u
@@ -120,27 +119,6 @@ def getRatesDistributions(frm, to, mylog=None):
     return means, stdev, corr, covar
 
 
-def historicalValue(amount, year):
-    """
-    Return the deflated value of amount given in this year's dollars as
-    valued at the beginning of the year specified.
-    """
-    thisyear = date.today().year
-    if TO != thisyear - 1:
-        raise RuntimeError(f"Rates file needs to be updated to be current to {thisyear}.")
-    if year < FROM:
-        raise ValueError(f"Only data from {FROM} is available.")
-    if year > thisyear:
-        raise ValueError(f"Year must be < {thisyear} for historical data.")
-
-    span = thisyear - year
-    ub = len(Inflation)
-    for n in range(ub - span, ub):
-        amount /= 1 + Inflation[n] / 100
-
-    return amount
-
-
 class Rates(object):
     """
     Rates are stored in a 4-array in the following order:

owlplanner/tax2025.py

@@ -12,7 +12,7 @@ Module to handle all tax calculations.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 
@@ -25,8 +25,8 @@ from datetime import date
 
 taxBracketNames = ["10%", "12/15%", "22/25%", "24/28%", "32/33%", "35%", "37/40%"]
 
-rates_TCJA = np.array([0.10, 0.12, 0.22, 0.24, 0.32, 0.35, 0.370])
-rates_nonTCJA = np.array([0.10, 0.15, 0.25, 0.28, 0.33, 0.35, 0.396])
+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.
@@ -34,7 +34,7 @@ rates_nonTCJA = np.array([0.10, 0.15, 0.25, 0.28, 0.33, 0.35, 0.396])
 # Single [0] and married filing jointly [1].
 
 # These are 2025 current.
-taxBrackets_TCJA = np.array(
+taxBrackets_OBBBA = np.array(
     [
         [11925, 48475, 103350, 197300, 250525, 626350, 9999999],
         [23850, 96950, 206700, 394600, 501050, 751600, 9999999],
@@ -52,7 +52,7 @@ irmaaBrackets = np.array(
 # 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 non-TCJA using 2017 to current year.
+# 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],
@@ -63,7 +63,7 @@ irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
 # For 2025, I used a 30.5% adjustment from 2017, rounded to closest 50.
 #
 # These are speculated.
-taxBrackets_nonTCJA = np.array(
+taxBrackets_preTCJA = np.array(
     [
         [12150, 49550, 119950, 250200, 544000, 546200, 9999999],  # Single
         [24350, 99100, 199850, 304600, 543950, 614450, 9999999],  # MFJ
@@ -71,11 +71,11 @@ taxBrackets_nonTCJA = np.array(
 )
 
 # These are 2025 current (adjusted for inflation).
-stdDeduction_TCJA = np.array([15000, 30000])    # Single, MFJ
+stdDeduction_OBBBA = np.array([15750, 31500])    # Single, MFJ
 # These are speculated (adjusted for inflation).
-stdDeduction_nonTCJA = np.array([8300, 16600])  # Single, MFJ
+stdDeduction_preTCJA = np.array([8300, 16600])  # Single, MFJ
 
-# These are current (adjusted for inflation).
+# These are current (adjusted for inflation) per individual.
 extra65Deduction = np.array([2000, 1600])       # Single, MFJ
 
 # Thresholds for capital gains (adjusted for inflation).
@@ -90,11 +90,51 @@ capGainRates = np.array(
 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.
@@ -105,7 +145,7 @@ def capitalGainTaxRate(Ni, magi_n, gamma_n, nd, Nn):
     cgRate_n = np.zeros(Nn)
 
     for n in range(Nn):
-        if n == nd:
+        if status and n == nd:
             status -= 1
 
         if magi_n[n] > gamma_n[n] * capGainRates[status][1]:
@@ -140,11 +180,11 @@ def mediCosts(yobs, horizons, magi, prevmagi, gamma_n, Nn):
     return costs
 
 
-def taxParams(yobs, i_d, n_d, N_n, y_TCJA=2026):
+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 TCJA might expire.
+    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).
@@ -154,15 +194,15 @@ def taxParams(yobs, i_d, n_d, N_n, y_TCJA=2026):
     Returned values are not indexed for inflation.
     """
     # Compute the deltas in-place between brackets, starting from the end.
-    deltaBrackets_TCJA = np.array(taxBrackets_TCJA)
-    deltaBrackets_nonTCJA = np.array(taxBrackets_nonTCJA)
+    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_TCJA[i, t] -= deltaBrackets_TCJA[i, t - 1]
-            deltaBrackets_nonTCJA[i, t] -= deltaBrackets_nonTCJA[i, t - 1]
+            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.
-    sigma = np.zeros((N_n))
+    sigmaBar = np.zeros((N_n))
     Delta = np.zeros((N_n, 7))
     theta = np.zeros((N_n, 7))
 
@@ -176,51 +216,57 @@ def taxParams(yobs, i_d, n_d, N_n, y_TCJA=2026):
             souls.remove(i_d)
             filingStatus -= 1
 
-        if thisyear + n < y_TCJA:
-            sigma[n] = stdDeduction_TCJA[filingStatus]
-            Delta[n, :] = deltaBrackets_TCJA[filingStatus, :]
+        if thisyear + n < yOBBBA:
+            sigmaBar[n] = stdDeduction_OBBBA[filingStatus] * gamma_n[n]
+            Delta[n, :] = deltaBrackets_OBBBA[filingStatus, :]
         else:
-            sigma[n] = stdDeduction_nonTCJA[filingStatus]
-            Delta[n, :] = deltaBrackets_nonTCJA[filingStatus, :]
+            sigmaBar[n] = stdDeduction_preTCJA[filingStatus] * gamma_n[n]
+            Delta[n, :] = deltaBrackets_preTCJA[filingStatus, :]
 
-        # Add 65+ additional exemption(s).
+        # Add 65+ additional exemption(s) and "bonus" phasing out.
         for i in souls:
             if thisyear + n - yobs[i] >= 65:
-                sigma[n] += extra65Deduction[filingStatus]
+                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 < y_TCJA:
-            theta[n, :] = rates_TCJA[:]
+        if thisyear + n < yOBBBA:
+            theta[n, :] = rates_OBBBA[:]
         else:
-            theta[n, :] = rates_nonTCJA[:]
+            theta[n, :] = rates_preTCJA[:]
 
     Delta = Delta.transpose()
     theta = theta.transpose()
 
-    # Return series unadjusted for inflation, in STD order.
-    return sigma, theta, Delta
+    # Return series unadjusted for inflation, except for sigmaBar, in STD order.
+    return sigmaBar, theta, Delta
 
 
-def taxBrackets(N_i, n_d, N_n, y_TCJA):
+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 TCJA from this year.
+    # Number of years left in OBBBA from this year.
     thisyear = date.today().year
-    ytc = y_TCJA - thisyear
+    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_TCJA[stat][t] if n < ytc else taxBrackets_nonTCJA[stat][t]
+            array[n] = taxBrackets_OBBBA[stat][t] if n < ytc else taxBrackets_preTCJA[stat][t]
 
         data[taxBracketNames[t]] = array
 
@@ -280,12 +326,12 @@ def rho_in(yobs, 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):
-            year = thisyear + n
             yage = agenow + n
 
-            # Account for increase of RMD age between 2023 and 2032.
-            if (yage < 73) or (year > 2032 and yage < 75):
+            if yage < yrmd:
                 pass  # rho[i][n] = 0
             else:
                 rho[i][n] = 1.0 / rmdTable[yage - 72]

owlplanner/timelists.py

@@ -12,7 +12,7 @@ Utility functions to read and check timelists.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 

owlplanner/utils.py

@@ -6,7 +6,7 @@ This file contains functions for handling data.
 
 Copyright © 2024 - Martin-D. Lacasse
 
-Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
 
 """
 

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.07.01"
+__version__ = "2025.09.15"

{owlplanner-2025.7.1.dist-info → owlplanner-2025.9.15.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.7.1
+Version: 2025.9.15
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -744,7 +744,7 @@ Look at *Basic capabilities* 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 it. Given your savings capabilities and spending desires,
+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.
 

owlplanner-2025.9.15.dist-info/RECORD

@@ -0,0 +1,22 @@
+owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
+owlplanner/abcapi.py,sha256=rtg7d0UbftinokR9VlB49VUjDjzUq3ONnJbhMXVIrgo,6879
+owlplanner/config.py,sha256=UF2Dy6E9PiX6Ua8B1R0aYCNUoIYmY46up8awf_36B_Q,12615
+owlplanner/mylogging.py,sha256=OVGeDFO7LIZG91R6HMpZBzjno-B8PH8Fo00Jw2Pdgqw,2558
+owlplanner/plan.py,sha256=pIKULy5GFo_8xOZByZ9_CXrHx9TcXQpaob8cblK46N8,115180
+owlplanner/progress.py,sha256=dUUlFmSAKUei36rUj2BINRY10f_YEUo_e23d0es6nrc,530
+owlplanner/rates.py,sha256=9Nmo8AKsyi5PoCUrzhr06phkSlNTv-TXzj5iYFU76AY,14113
+owlplanner/tax2025.py,sha256=2Jb_UbPT6ye-znRjA0nSaF8T8M17QW4MoRPDoW9XJ8s,10833
+owlplanner/timelists.py,sha256=Q4kBt9kKAa5qxsvOe9wfyUtCQVgiwPmJXTwXUPRBBv8,4066
+owlplanner/utils.py,sha256=afAjeO6Msf6Rn4jwz_7Ody9rHGWlBR7iQFqe1xzLNQc,2513
+owlplanner/version.py,sha256=zy-IhWuHFT4sXG7yuvz7mQvMfgQ6BwWFA7KrAtVvwYg,28
+owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
+owlplanner/plotting/__init__.py,sha256=uhxqtUi0OI-QWNOO2LkXgQViW_9yM3rYb-204Wit974,250
+owlplanner/plotting/base.py,sha256=UimGKpMTV-dVm3BX5Apr_Ltorc7dlDLCRPRQ3RF_v7c,2578
+owlplanner/plotting/factory.py,sha256=EDopIAPQr9zHRgemObko18FlCeRNhNCoLNNFAOq-X6s,1030
+owlplanner/plotting/matplotlib_backend.py,sha256=AOEkapD94U5hGNoS0EdbRoe8mgdMHH4oOvkXADZS914,17957
+owlplanner/plotting/plotly_backend.py,sha256=AO33GxBHGYG5osir_H1iRRtGxdhs4AjfLV2d_xm35nY,33138
+owlplanner-2025.9.15.dist-info/METADATA,sha256=yacvHpuuPAtZ4fvLHH2UcbIdtkWwgVc0zwIvtOBNw64,54045
+owlplanner-2025.9.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.9.15.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.9.15.dist-info/RECORD,,

owlplanner-2025.7.1.dist-info/RECORD

@@ -1,22 +0,0 @@
-owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
-owlplanner/abcapi.py,sha256=8VCXS7nH_QZYxCUU3lwO0_UPR9Q5fuYQ6DHDLvHVLPg,6878
-owlplanner/config.py,sha256=-sSz37hwlnmI9_oXZn-R1rpmY0Vyk5L4X--NxGpgEMA,12446
-owlplanner/mylogging.py,sha256=RKUr-y-1XvKZzLMcfdtm4IM30LuRpJwb2qUeXmAWqME,2557
-owlplanner/plan.py,sha256=rivQ9lSFJx6Eahx83VyTOm6n4uxjbr6LiwiyChRhAnc,111133
-owlplanner/progress.py,sha256=2DOjOLo6Mo7m21wY-9iZhoUksAyi4VCbb6UL2RegNCw,529
-owlplanner/rates.py,sha256=7jXcuHbkJ3AVIeBYZdwme18rdYslIzCuT-c0cLzvKUU,14819
-owlplanner/tax2025.py,sha256=3uDJfKiSRFUp5WDcouAnTEQqEY7LnDKxqxDSKiTsOSQ,8927
-owlplanner/timelists.py,sha256=4pRumdoFlEmmh07wpGhDqauHl2doLG5JcRkvi41fvR4,4065
-owlplanner/utils.py,sha256=6Ky8ZKfNE9x--3znsZ8VZaT2PptDinszRxWsOCPanu8,2512
-owlplanner/version.py,sha256=J00-UKwWWUboYr10jyhzSLOwp2iWtGoC1DRPgnuINV0,28
-owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
-owlplanner/plotting/__init__.py,sha256=uhxqtUi0OI-QWNOO2LkXgQViW_9yM3rYb-204Wit974,250
-owlplanner/plotting/base.py,sha256=UimGKpMTV-dVm3BX5Apr_Ltorc7dlDLCRPRQ3RF_v7c,2578
-owlplanner/plotting/factory.py,sha256=EDopIAPQr9zHRgemObko18FlCeRNhNCoLNNFAOq-X6s,1030
-owlplanner/plotting/matplotlib_backend.py,sha256=AOEkapD94U5hGNoS0EdbRoe8mgdMHH4oOvkXADZS914,17957
-owlplanner/plotting/plotly_backend.py,sha256=AO33GxBHGYG5osir_H1iRRtGxdhs4AjfLV2d_xm35nY,33138
-owlplanner-2025.7.1.dist-info/METADATA,sha256=_T6vNe7aESAIt668fK9IVb0VDEv5P3Z16bYPyTvr9QY,54044
-owlplanner-2025.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.7.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.7.1.dist-info/RECORD,,