owlplanner 2025.7.1__py3-none-any.whl → 2025.8.1__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

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("optimizeMedicare", False)
+
         # 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 not options.get("optimizeMedicare", False):
+            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 not options.get("optimizeMedicare", False):
+            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,16 @@ class Plan(object):
             "maxRothConversion",
             "netSpending",
             "noRothConversions",
+            "oppCostX",
+            "optimizeMedicare",
             "previousMAGIs",
             "solver",
             "spendingSlack",
             "startRothConversions",
             "units",
-            "withMedicare",
-            "oppCostX",
+            "xorConstraints",
+            "withSCLoop",
+            "withMedicare",    # Ignore keyword.
         ]
         # We might modify options if required.
         options = {} if options is None else options
@@ -1624,11 +1680,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 +1713,8 @@ class Plan(object):
         """
         Self-consistent loop, regardless of solver.
         """
-        withMedicare = options.get("withMedicare", True)
+        optimizeMedicare = options.get("optimizeMedicare", False)
+        withSCLoop = options.get("withSCLoop", True)
 
         if objective == "maxSpending":
             objFac = -1 / self.xi_n[0]
@@ -1662,32 +1722,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, optimizeMedicare)
         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, optimizeMedicare)
 
             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 +1759,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 +1787,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 +1935,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 +1950,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, optimizeMedicare):
         """
         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 +1969,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 not optimizeMedicare:
+            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 +1988,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 +2014,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 +2044,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 +2055,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 +2238,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 +2381,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 +2406,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 +2426,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 +2470,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 +2492,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 +2514,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 +2591,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 +2607,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 +2794,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.08.01"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.7.1
+Version: 2025.8.1
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl

owlplanner-2025.8.1.dist-info/RECORD

@@ -0,0 +1,22 @@
+owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
+owlplanner/abcapi.py,sha256=rtg7d0UbftinokR9VlB49VUjDjzUq3ONnJbhMXVIrgo,6879
+owlplanner/config.py,sha256=JJOtS6HyqA4qUHUZydSGG_RMWaCfVMRSOAfWbt4evMI,12461
+owlplanner/mylogging.py,sha256=OVGeDFO7LIZG91R6HMpZBzjno-B8PH8Fo00Jw2Pdgqw,2558
+owlplanner/plan.py,sha256=keKC9-XeQxza9--D7TaQfcZCLkGDy5yVV9D5pN25MHg,115211
+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=Or3KaHd8BXidAsAkScGwQRvtWIF5uufpsnfgNdR-Kpw,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.8.1.dist-info/METADATA,sha256=9WRoRbNMdk2kxbT4-Coq912VJixT9rlF1Cv48Po4VJw,54044
+owlplanner-2025.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.8.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.8.1.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,,