owlplanner 2025.4.22__py3-none-any.whl → 2025.4.28__py3-none-any.whl

owlplanner/abcapi.py

@@ -97,6 +97,8 @@ class ConstraintMatrix(object):
         self.ub.append(ub)
         if lb == ub:
             self.key.append("fx")
+        elif lb == -np.inf:
+            self.key.append("up")
         elif ub == np.inf:
             self.key.append("lo")
         else:

owlplanner/plan.py

@@ -230,11 +230,12 @@ 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 levels, 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.
+        # 2 binary variables per year per invididual.
         self.N_z = 2
 
         # Default interpolation parameters for allocation ratios.
@@ -304,8 +305,8 @@ class Plan(object):
         self.myRothX_in = np.zeros((self.N_i, self.N_n))
         self.kappa_ijn = np.zeros((self.N_i, self.N_j, self.N_n))
 
-        # Previous 3 years for Medicare.
-        self.prevMAGI = np.zeros((3))
+        # Previous 2 years and current year for Medicare.
+        self.prevMAGIs = np.zeros((3))
 
         # Default slack on profile.
         self.lambdha = 0
@@ -323,7 +324,7 @@ class Plan(object):
         # If none was given, default is to begin plan on today's date.
         self._setStartingDate(startDate)
 
-        self._buildOffsetMap()
+        # self._buildOffsetMap()
 
         # Initialize guardrails to ensure proper configuration.
         self._adjustedParameters = False
@@ -1021,23 +1022,27 @@ class Plan(object):
 
         return None
 
-    def _buildOffsetMap(self):
+    def _buildOffsetMap(self, options):
         """
         Utility function to map variables to a block vector.
         Refer to companion document for explanations.
         """
-        # Stack all variables in a single block vector.
+        medi = options.get("withMedicare", True)
+
+        # Stack all variables in a single block vector with offsets saved in a dictionary.
         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["m"] = _qC(C["g"], self.N_n)
+        C["s"] = _qC(C["m"], self.N_n) if medi else C["m"]
         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)
+        C["zx"] = _qC(C["x"], self.N_i, self.N_n)
+        C["zm"] = _qC(C["zx"], self.N_i, self.N_n, self.N_z)
+        self.nvars = _qC(C["zm"], self.N_n, self.N_q) if medi else C["zm"]
 
         self.C = C
         self.mylog.vprint(f"Problem has {len(C)} distinct time series forming {self.nvars} decision variables.")
@@ -1057,6 +1062,7 @@ class Plan(object):
         Ni = self.N_i
         Nj = self.N_j
         Nk = self.N_k
+        Nq = self.N_q
         Nn = self.N_n
         Nt = self.N_t
         Nz = self.N_z
@@ -1064,15 +1070,19 @@ class Plan(object):
         i_s = self.i_s
         n_d = self.n_d
 
+        self._buildOffsetMap(options)
+
         Cb = self.C["b"]
         Cd = self.C["d"]
         Ce = self.C["e"]
         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"]
+        Czm = self.C["zm"]
 
         spLo = 1 - self.lambdha
         spHi = 1 + self.lambdha
@@ -1087,32 +1097,54 @@ class Plan(object):
         Tau1_ijn = 1 + tau_ijn
         Tauh_ijn = 1 + tau_ijn / 2
 
-        if "units" in options:
-            units = u.getUnits(options["units"])
-        else:
-            units = 1000
-
-        bigM = 5e6
-        if "bigM" in options:
-            # No units for bigM.
-            bigM = options["bigM"]
+        units = u.getUnits(options.get("units", "k"))
+        # No units for bigM.
+        bigM = options.get("bigM", 5e6)
+        assert isinstance(bigM, (int, float)), f"bigM {bigM} is not a number."
 
         ###################################################################
         # Inequality constraint matrix with upper and lower bound vectors.
         A = abc.ConstraintMatrix(self.nvars)
         B = abc.Bounds(self.nvars)
 
-        # RMDs inequalities, only if there is an initial balance in tax-deferred account.
+        # Start with constraints that depend on objective function.
+        if objective == "maxSpending":
+            # Impose optional constraint on final bequest requested in today's $.
+            # If not specified, defaults to $1 (nominal $).
+            bequest = options.get("bequest", 1)
+            assert isinstance(bequest, (int, float)), "Desired bequest is not a number."
+            bequest *= units * self.gamma_n[-1]
+
+            row = A.newRow()
+            for i in range(Ni):
+                row.addElem(_q3(Cb, i, 0, Nn, Ni, Nj, Nn + 1), 1)
+                row.addElem(_q3(Cb, i, 1, Nn, Ni, Nj, Nn + 1), 1 - self.nu)
+                # Nudge could be added (e.g. 1.02) to artificially favor tax-exempt account
+                # as heirs's benefits of 10y tax-free is not weighted in?
+                row.addElem(_q3(Cb, i, 2, Nn, Ni, Nj, Nn + 1), 1)
+            A.addRow(row, bequest, bequest)
+            # self.mylog.vprint('Adding bequest constraint of:', u.d(bequest))
+        elif objective == "maxBequest":
+            spending = options["netSpending"]
+            assert isinstance(spending, (int, float)), "Desired spending provided is not a number."
+            # Account for time elapsed in the current year.
+            spending *= units * self.yearFracLeft
+            # self.mylog.vprint('Maximizing bequest with desired net spending of:', u.d(spending))
+            # To allow slack in first year, Cg can be made Nn+1 and store basis in g[Nn].
+            A.addNewRow({_q1(Cg, 0, Nn): 1}, spending, spending)
+
+        # RMDs inequalities.
+        # Impose even if there is no initial balance in tax-deferred account
+        # as contributions can happen later...
         for i in range(Ni):
-            if self.beta_ij[i, 1] > 0:
-                for n in range(self.horizons[i]):
-                    rowDic = {
-                        _q3(Cw, i, 1, n, Ni, Nj, Nn): 1,
-                        _q3(Cb, i, 1, n, Ni, Nj, Nn + 1): -self.rho_in[i, n],
-                    }
-                    A.addNewRow(rowDic, zero, inf)
+            for n in range(self.horizons[i]):
+                rowDic = {
+                    _q3(Cw, i, 1, n, Ni, Nj, Nn): 1,
+                    _q3(Cb, i, 1, n, Ni, Nj, Nn + 1): -self.rho_in[i, n],
+                }
+                A.addNewRow(rowDic, zero, inf)
 
-        # Income tax bracket range inequalities.
+        # Income tax bracket range inequalities, from 0 to upper bound.
         for t in range(Nt):
             for n in range(Nn):
                 B.set0_Ub(_q2(CF, t, n, Nt, Nn), self.DeltaBar_tn[t, n])
@@ -1121,8 +1153,31 @@ class Plan(object):
         for n in range(Nn):
             B.set0_Ub(_q1(Ce, n, Nn), self.sigmaBar_n[n])
 
-        # Roth conversions equalities/inequalities.
-        # This condition supercedes everything else.
+        # Impose withdrawal limits on all accounts.
+        for i in range(Ni):
+            for j in range(Nj):
+                for n in range(Nn):
+                    rowDic = {_q3(Cw, i, j, n, Ni, Nj, Nn): -1,
+                              _q2(Cx, i, n, Ni, Nn): -u.krond(j, 1),
+                              _q3(Cb, i, j, n, Ni, Nj, Nn + 1): 1}
+                    A.addNewRow(rowDic, zero, inf)
+
+        # No posthumous account activities.
+        if Ni == 2:
+            # No conversion during last year.
+            # B.set0_Ub(_q2(Cx, i_d, nd-1, Ni, Nn), zero)
+            # B.set0_Ub(_q2(Cx, i_s, Nn-1, Ni, Nn), zero)
+
+            # No withdrawals or deposits for any i_d-owned accounts after year of passing.
+            # Implicit n_d < Nn imposed by for loop.
+            for n in range(n_d, Nn):
+                B.set0_Ub(_q2(Cd, i_d, n, Ni, Nn), zero)
+                B.set0_Ub(_q2(Cx, i_d, n, Ni, Nn), zero)
+                for j in range(Nj):
+                    B.set0_Ub(_q3(Cw, i_d, j, n, Ni, Nj, Nn), zero)
+
+        # Roth conversions bounds, equalities, and inequalities.
+        # Condition "file" supercedes everything else.
         if "maxRothConversion" in options and options["maxRothConversion"] == "file":
             # self.mylog.vprint(f"Fixing Roth conversions to those from file {self.timeListsFileName}.")
             for i in range(Ni):
@@ -1167,59 +1222,13 @@ class Plan(object):
                 for n in range(Nn):
                     B.set0_Ub(_q2(Cx, i_x, n, Ni, Nn), zero)
 
-        # Impose withdrawal limits on taxable and tax-exempt accounts.
-        for i in range(Ni):
-            for j in [0, 2]:
-                for n in range(Nn):
-                    rowDic = {_q3(Cw, i, j, n, Ni, Nj, Nn): -1, _q3(Cb, i, j, n, Ni, Nj, Nn + 1): 1}
-                    A.addNewRow(rowDic, zero, inf)
-
-        # Impose withdrawals and conversion limits on tax-deferred account.
-        for i in range(Ni):
-            for n in range(Nn):
-                rowDic = {
-                    _q2(Cx, i, n, Ni, Nn): -1,
-                    _q3(Cw, i, 1, n, Ni, Nj, Nn): -1,
-                    _q3(Cb, i, 1, n, Ni, Nj, Nn + 1): 1,
-                }
-                A.addNewRow(rowDic, zero, inf)
-
-        # Constraints depending on objective function.
-        if objective == "maxSpending":
-            # Impose optional constraint on final bequest requested in today's $.
-            if "bequest" in options:
-                bequest = options["bequest"]
-                assert isinstance(bequest, (int, float)), "Desired bequest is not a number."
-                bequest *= units * self.gamma_n[-1]
-            else:
-                # If not specified, defaults to $1 (nominal $).
-                bequest = 1
-
-            row = A.newRow()
-            for i in range(Ni):
-                row.addElem(_q3(Cb, i, 0, Nn, Ni, Nj, Nn + 1), 1)
-                row.addElem(_q3(Cb, i, 1, Nn, Ni, Nj, Nn + 1), 1 - self.nu)
-                # Nudge could be added (e.g. 1.02) to artificially favor tax-exempt account
-                # as heirs's benefits of 10y tax-free is not weighted in?
-                row.addElem(_q3(Cb, i, 2, Nn, Ni, Nj, Nn + 1), 1)
-            A.addRow(row, bequest, bequest)
-            # self.mylog.vprint('Adding bequest constraint of:', u.d(bequest))
-        elif objective == "maxBequest":
-            spending = options["netSpending"]
-            assert isinstance(spending, (int, float)), "Desired spending provided is not a number."
-            # Account for time elapsed in the current year.
-            spending *= units * self.yearFracLeft
-            # self.mylog.vprint('Maximizing bequest with desired net spending of:', u.d(spending))
-            # To allow slack in first year, Cg can be made Nn+1 and store basis in g[Nn].
-            A.addNewRow({_q1(Cg, 0, Nn): 1}, spending, spending)
-
         # Set initial balances through constraints.
         for i in range(Ni):
             for j in range(Nj):
                 rhs = self.beta_ij[i, j]
                 A.addNewRow({_q3(Cb, i, j, 0, Ni, Nj, Nn + 1): 1}, rhs, rhs)
 
-        # Link surplus and taxable account deposits regardless of Ni.
+        # Link cash flow surplus and taxable account deposits even for Ni=1.
         for i in range(Ni):
             fac1 = u.krond(i, 0) * (1 - self.eta) + u.krond(i, 1) * self.eta
             for n in range(n_d):
@@ -1233,63 +1242,51 @@ class Plan(object):
         # No surplus allowed during the last year to be used as a tax loophole.
         B.set0_Ub(_q1(Cs, Nn - 1, Nn), zero)
 
-        if Ni == 2:
-            # No conversion during last year.
-            # B.set0_Ub(_q2(Cx, i_d, nd-1, Ni, Nn), zero)
-            # B.set0_Ub(_q2(Cx, i_s, Nn-1, Ni, Nn), zero)
-
-            # No withdrawals or deposits for any i_d-owned accounts after year of passing.
-            # Implicit n_d < Nn imposed by for loop.
-            for n in range(n_d, Nn):
-                B.set0_Ub(_q2(Cd, i_d, n, Ni, Nn), zero)
-                B.set0_Ub(_q2(Cx, i_d, n, Ni, Nn), zero)
-                for j in range(Nj):
-                    B.set0_Ub(_q3(Cw, i_d, j, n, Ni, Nj, Nn), zero)
-
         # Account balances carried from year to year.
         # Considering spousal asset transfer at passing of a spouse.
         # Using hybrid approach with 'if' statement and Kronecker deltas.
         for i in range(Ni):
             for j in range(Nj):
                 for n in range(Nn):
-                    if Ni == 2 and n_d < Nn and i == i_d and n == n_d - 1:
-                        # fac1 = 1 - (u.krond(n, n_d - 1) * u.krond(i, i_d))
-                        fac1 = 0
-                    else:
-                        fac1 = 1
-
+                    # fac1 = 1 - (u.krond(n, n_d - 1) * u.krond(i, i_d))
+                    fac1 = 0 if (Ni == 2 and n_d < Nn and i == i_d and n == n_d - 1) else 1
+                    fac1_ijn = fac1 * Tau1_ijn[i, j, n]
                     rhs = fac1 * self.kappa_ijn[i, j, n] * Tauh_ijn[i, j, n]
 
                     row = A.newRow()
                     row.addElem(_q3(Cb, i, j, n + 1, Ni, Nj, Nn + 1), 1)
-                    row.addElem(_q3(Cb, i, j, n, Ni, Nj, Nn + 1), -fac1 * Tau1_ijn[i, j, n])
-                    row.addElem(_q3(Cw, i, j, n, Ni, Nj, Nn), fac1 * Tau1_ijn[i, j, n])
-                    row.addElem(_q2(Cd, i, n, Ni, Nn), -fac1 * u.krond(j, 0) * Tau1_ijn[i, 0, n])
+                    row.addElem(_q3(Cb, i, j, n, Ni, Nj, Nn + 1), -fac1_ijn)
+                    row.addElem(_q2(Cd, i, n, Ni, Nn), -u.krond(j, 0) * fac1_ijn)
+                    row.addElem(_q3(Cw, i, j, n, Ni, Nj, Nn), fac1_ijn)
                     row.addElem(
                         _q2(Cx, i, n, Ni, Nn),
-                        -fac1 * (u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i, j, n],
+                        -(u.krond(j, 2) - u.krond(j, 1)) * fac1_ijn,
                     )
 
                     if Ni == 2 and n_d < Nn and i == i_s and n == n_d - 1:
                         fac2 = self.phi_j[j]
+                        fac2_idjn = fac2 * Tau1_ijn[i_d, j, n]
                         rhs += fac2 * self.kappa_ijn[i_d, j, n] * Tauh_ijn[i_d, j, n]
-                        row.addElem(_q3(Cb, i_d, j, n, Ni, Nj, Nn + 1), -fac2 * Tau1_ijn[i_d, j, n])
-                        row.addElem(_q3(Cw, i_d, j, n, Ni, Nj, Nn), fac2 * Tau1_ijn[i_d, j, n])
-                        row.addElem(_q2(Cd, i_d, n, Ni, Nn), -fac2 * u.krond(j, 0) * Tau1_ijn[i_d, 0, n])
+
+                        row.addElem(_q3(Cb, i_d, j, n, Ni, Nj, Nn + 1), -fac2_idjn)
+                        row.addElem(_q2(Cd, i_d, n, Ni, Nn), -u.krond(j, 0) * fac2_idjn)
+                        row.addElem(_q3(Cw, i_d, j, n, Ni, Nj, Nn), fac2_idjn)
                         row.addElem(
                             _q2(Cx, i_d, n, Ni, Nn),
-                            -fac2 * (u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i_d, j, n],
+                            -(u.krond(j, 2) - u.krond(j, 1)) * fac2_idjn,
                         )
                     A.addRow(row, rhs, rhs)
 
         tau_0prev = np.roll(self.tau_kn[0, :], 1)
+        # No tax on losses, nor tax-loss harvesting.
         tau_0prev[tau_0prev < 0] = 0
 
-        # Net cash flow.
+        # Cash flow for net spending.
         for n in range(Nn):
-            rhs = -self.M_n[n]
-            row = A.newRow({_q1(Cg, n, Nn): 1})
-            row.addElem(_q1(Cs, n, Nn), 1)
+            rhs = 0
+            row = A.newRow()
+            row.addElem(_q1(Cg, n, Nn), 1)
+            row.addElem(_q1(Cm, n, Nn), 1)
             for i in range(Ni):
                 fac = self.psi * self.alpha_ijkn[i, 0, 0, n]
                 rhs += (
@@ -1301,13 +1298,13 @@ class Plan(object):
                 )
 
                 row.addElem(_q3(Cb, i, 0, n, Ni, Nj, Nn + 1), fac * self.mu)
+                row.addElem(_q2(Cd, i, n, Ni, Nn), 1 + fac * self.mu)
                 # Minus capital gains on taxable withdrawals using last year's rate if >=0.
                 # Plus taxable account withdrawals, and all other withdrawals.
-                row.addElem(_q3(Cw, i, 0, n, Ni, Nj, Nn), fac * (tau_0prev[n] - self.mu) - 1)
+                row.addElem(_q3(Cw, i, 0, n, Ni, Nj, Nn), -1 + fac * (tau_0prev[n] - self.mu))
                 penalty = 0.1 if n < self.n59[i] else 0
                 row.addElem(_q3(Cw, i, 1, n, Ni, Nj, Nn), -1 + penalty)
                 row.addElem(_q3(Cw, i, 2, n, Ni, Nj, Nn), -1 + penalty)
-                row.addElem(_q2(Cd, i, n, Ni, Nn), fac * self.mu)
 
             # Minus tax on ordinary income, T_n.
             for t in range(Nt):
@@ -1315,7 +1312,7 @@ class Plan(object):
 
             A.addRow(row, rhs, rhs)
 
-        # Impose income profile.
+        # Enforce income profile.
         for n in range(1, Nn):
             rowDic = {_q1(Cg, 0, Nn): -spLo * self.xiBar_n[n], _q1(Cg, n, Nn): self.xiBar_n[0]}
             A.addNewRow(rowDic, zero, inf)
@@ -1334,33 +1331,102 @@ class Plan(object):
                 row.addElem(_q2(Cx, i, n, Ni, Nn), -1)
 
                 # Taxable returns on securities in taxable account.
-                fak = np.sum(self.tau_kn[1:Nk, n] * self.alpha_ijkn[i, 0, 1:Nk, n], axis=0)
-                rhs += 0.5 * fak * self.kappa_ijn[i, 0, n]
-                row.addElem(_q3(Cb, i, 0, n, Ni, Nj, Nn + 1), -fak)
-                row.addElem(_q3(Cw, i, 0, n, Ni, Nj, Nn), fak)
-                row.addElem(_q2(Cd, i, n, Ni, Nn), -fak)
+                fak_i = np.sum(self.tau_kn[1:Nk, n] * self.alpha_ijkn[i, 0, 1:Nk, n], axis=0)
+                rhs += 0.5 * fak_i * self.kappa_ijn[i, 0, n]
+                row.addElem(_q3(Cb, i, 0, n, Ni, Nj, Nn + 1), -fak_i)
+                row.addElem(_q3(Cw, i, 0, n, Ni, Nj, Nn), fak_i)
+                row.addElem(_q2(Cd, i, n, Ni, Nn), -fak_i)
 
             for t in range(Nt):
                 row.addElem(_q2(CF, t, n, Nt, Nn), 1)
 
             A.addRow(row, rhs, rhs)
 
-        # Configure binary variables.
+        # Medicare calculations.
+        if options.get("withMedicare", True):
+            nm, L_nq, C_nq = tx.mediVals(self.yobs, self.horizons, self.gamma_n, Nn, Nq)
+            for n in range(Nn):
+                # SOS1 constraint: 1 for n < nm otherwise all zero.
+                row = A.newRow()
+                for q in range(Nq):
+                    B.setBinary(_q2(Czm, n, q, Nn, Nq))
+                    row.addElem(_q2(Czm, n, q, Nn, Nq), 1)
+                val = 0 if n < nm else 1
+                A.addRow(row, val, val)
+
+                # Medicare costs calculations.
+                row = A.newRow()
+                row.addElem(_q1(Cm, n, Nn), 1)
+                for q in range(Nq):
+                    row.addElem(_q2(Czm, n, q, Nn, Nq), -C_nq[n, q])
+                A.addRow(row, zero, zero)
+
+                largeM = 2*L_nq[n, Nq]
+                # Medicare brackets calculations.
+                if n >= nm:
+                    # Lower bound.
+                    row = A.newRow()
+                    rhs = 0
+                    for q in range(0, Nq):
+                        row.addElem(_q2(Czm, n, q, Nn, Nq), L_nq[n, q])
+                    if n > 2 or (n == 2 and self.yearFracLeft == 1):
+                        for i in range(Ni):
+                            fac = (self.mu * self.alpha_ijkn[i, 0, 0, n-2]
+                                   + np.sum(self.alpha_ijkn[i, 0, 1:, n-2] * self.tau_kn[1:, n-2], axis=0))
+
+                            row.addElem(_q3(Cb, i, 0, n-2, Ni, Nj, Nn + 1), -fac)
+                            row.addElem(_q2(Cd, i, n-2, Ni, Nn), -fac)
+                            row.addElem(_q3(Cw, i, 0, n-2, Ni, Nj, Nn),
+                                        fac - self.alpha_ijkn[i, 0, 0, n-2]*max(0, self.tau_kn[0, min(0, n-3)]))
+                            row.addElem(_q3(Cw, i, 1, n-2, Ni, Nj, Nn), -1)
+                            row.addElem(_q2(Cx, i, n-2, Ni, Nn), -1)
+                            rhs += self.omega_in[i, n-2] + 0.85*self.zetaBar_in[i, n-2] + self.piBar_in[i, n-2]
+                            rhs += 0.5*self.kappa_ijn[i, 0, n-2] * fac
+                    else:
+                        rhs = self.prevMAGIs[n]
+
+                    A.addRow(row, -largeM, rhs)
+
+                    # Upper bound. Lots of duplication. Can be merged with lower bound at one point.
+                    row = A.newRow()
+                    rhs = largeM
+                    for q in range(0, Nq):
+                        row.addElem(_q2(Czm, n, q, Nn, Nq), largeM - L_nq[n, q+1])
+                    if n > 2 or (n == 2 and self.yearFracLeft == 1):
+                        for i in range(Ni):
+                            fac = (self.mu * self.alpha_ijkn[i, 0, 0, n-2]
+                                   + np.sum(self.alpha_ijkn[i, 0, 1:, n-2] * self.tau_kn[1:, n-2], axis=0))
+
+                            row.addElem(_q3(Cb, i, 0, n-2, Ni, Nj, Nn + 1), +fac)
+                            row.addElem(_q2(Cd, i, n-2, Ni, Nn), +fac)
+                            row.addElem(_q3(Cw, i, 0, n-2, Ni, Nj, Nn),
+                                        -fac + self.alpha_ijkn[i, 0, 0, n-2]*max(0, self.tau_kn[0, min(0, n-3)]))
+                            row.addElem(_q3(Cw, i, 1, n-2, Ni, Nj, Nn), +1)
+                            row.addElem(_q2(Cx, i, n-2, Ni, Nn), +1)
+                            rhs -= self.omega_in[i, n-2] + 0.85*self.zetaBar_in[i, n-2] + self.piBar_in[i, n-2]
+                            rhs -= 0.5*self.kappa_ijn[i, 0, n-2] * fac
+                    else:
+                        rhs = largeM - self.prevMAGIs[n]
+
+                    A.addRow(row, zero, rhs)
+
+        # Set mutual exclusions of withdrawals, conversions, and deposits.
         for i in range(Ni):
             for n in range(self.horizons[i]):
+                # Configure binary variables.
                 for z in range(Nz):
-                    B.setBinary(_q3(Cz, i, n, z, Ni, Nn, Nz))
+                    B.setBinary(_q3(Czx, i, n, z, Ni, Nn, Nz))
 
                 # Exclude simultaneous deposits and withdrawals from taxable or tax-free accounts.
                 A.addNewRow(
-                    {_q3(Cz, i, n, 0, Ni, Nn, Nz): bigM, _q1(Cs, n, Nn): -1},
+                    {_q3(Czx, i, n, 0, Ni, Nn, Nz): bigM, _q1(Cs, n, Nn): -1},
                     zero,
                     bigM,
                 )
 
                 A.addNewRow(
                     {
-                        _q3(Cz, i, n, 0, Ni, Nn, Nz): bigM,
+                        _q3(Czx, i, n, 0, Ni, Nn, Nz): bigM,
                         _q3(Cw, i, 0, n, Ni, Nj, Nn): 1,
                         _q3(Cw, i, 2, n, Ni, Nj, Nn): 1,
                     },
@@ -1370,13 +1436,13 @@ class Plan(object):
 
                 # Exclude simultaneous Roth conversions and tax-exempt withdrawals.
                 A.addNewRow(
-                    {_q3(Cz, i, n, 1, Ni, Nn, Nz): bigM, _q2(Cx, i, n, Ni, Nn): -1},
+                    {_q3(Czx, i, n, 1, Ni, Nn, Nz): bigM, _q2(Cx, i, n, Ni, Nn): -1},
                     zero,
                     bigM,
                 )
 
                 A.addNewRow(
-                    {_q3(Cz, i, n, 1, Ni, Nn, Nz): bigM, _q3(Cw, i, 2, n, Ni, Nj, Nn): 1},
+                    {_q3(Czx, i, n, 1, Ni, Nn, Nz): bigM, _q3(Cw, i, 2, n, Ni, Nj, Nn): 1},
                     zero,
                     bigM,
                 )
@@ -1668,17 +1734,14 @@ class Plan(object):
         if objective == "maxSpending" and "bequest" not in myoptions:
             self.mylog.vprint("Using bequest of $1.")
 
-        self.prevMAGI = np.zeros(3)
+        self.prevMAGIs = np.zeros(3)
         if "previousMAGIs" in myoptions:
             magi = myoptions["previousMAGIs"]
             if len(magi) != 3:
                 raise ValueError("previousMAGIs must have 3 values.")
 
-            if "units" in options:
-                units = u.getUnits(options["units"])
-            else:
-                units = 1000
-            self.prevMAGI = units * np.array(magi)
+            units = u.getUnits(options.get("units", "k"))
+            self.prevMAGIs = units * np.array(magi)
 
         self.lambdha = 0
         if "spendingSlack" in myoptions:
@@ -1712,76 +1775,31 @@ class Plan(object):
         """
         from scipy import optimize
 
-        withMedicare = True
-        if "withMedicare" in options and options["withMedicare"] is False:
-            withMedicare = False
-
-        if objective == "maxSpending":
-            objFac = -1 / self.xi_n[0]
-        else:
-            objFac = -1 / self.gamma_n[-1]
-
         # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
-        milpOptions = {"disp": False, "mip_rel_gap": 1e-6}
-
-        it = 0
-        absdiff = np.inf
-        old_x = np.zeros(self.nvars)
-        old_solutions = [np.inf]
-        self._estimateMedicare(None, withMedicare)
-        while True:
-            self._buildConstraints(objective, options)
-            Alu, lbvec, ubvec = self.A.arrays()
-            Lb, Ub = self.B.arrays()
-            integrality = self.B.integralityArray()
-            c = self.c.arrays()
-
-            bounds = optimize.Bounds(Lb, Ub)
-            constraint = optimize.LinearConstraint(Alu, lbvec, ubvec)
-            solution = optimize.milp(
-                c,
-                integrality=integrality,
-                constraints=constraint,
-                bounds=bounds,
-                options=milpOptions,
-            )
-            it += 1
-
-            if not solution.success:
-                break
-
-            if not withMedicare:
-                break
-
-            self._estimateMedicare(solution.x)
+        milpOptions = {"disp": False, "mip_rel_gap": 1e-7}
 
-            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution.fun * objFac, f=2)}")
+        self._buildConstraints(objective, options)
+        Alu, lbvec, ubvec = self.A.arrays()
+        Lb, Ub = self.B.arrays()
+        integrality = self.B.integralityArray()
+        c = self.c.arrays()
 
-            delta = solution.x - old_x
-            absdiff = np.sum(np.abs(delta), axis=0)
-            if absdiff < 1:
-                self.mylog.vprint("Converged on full solution.")
-                break
-
-            # Avoid oscillatory solutions. Look only at most recent solutions. Within $10.
-            isclosenough = abs(-solution.fun - min(old_solutions[int(it / 2) :])) < 10 * self.xi_n[0]
-            if isclosenough:
-                self.mylog.vprint("Converged through selecting minimum oscillating objective.")
-                break
-
-            if it > 59:
-                self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
-                break
-
-            old_solutions.append(-solution.fun)
-            old_x = solution.x
+        bounds = optimize.Bounds(Lb, Ub)
+        constraint = optimize.LinearConstraint(Alu, lbvec, ubvec)
+        solution = optimize.milp(c, integrality=integrality,
+                                 constraints=constraint, bounds=bounds, options=milpOptions)
 
         if solution.success:
-            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
+            self.mylog.vprint("Solution successful.")
             self.mylog.vprint(solution.message)
+            if objective == "maxSpending":
+                objFac = -1 / self.xi_n[0]
+            else:
+                objFac = -1 / self.gamma_n[-1]
+
             self.mylog.vprint(f"Objective: {u.d(solution.fun * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
-            self._aggregateResults(solution.x)
+            self._aggregateResults(options, solution.x)
             self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
             self.caseStatus = "solved"
         else:
@@ -1796,17 +1814,6 @@ class Plan(object):
         """
         import mosek
 
-        withMedicare = True
-        if "withMedicare" in options and options["withMedicare"] is False:
-            withMedicare = False
-
-        if objective == "maxSpending":
-            objFac = -1 / self.xi_n[0]
-        else:
-            objFac = -1 / self.gamma_n[-1]
-
-        # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
-
         bdic = {
             "fx": mosek.boundkey.fx,
             "fr": mosek.boundkey.fr,
@@ -1815,88 +1822,57 @@ class Plan(object):
             "up": mosek.boundkey.up,
         }
 
-        it = 0
-        absdiff = np.inf
-        old_x = np.zeros(self.nvars)
-        old_solutions = [np.inf]
-        self._estimateMedicare(None, withMedicare)
-        while True:
-            self._buildConstraints(objective, options)
-            Aind, Aval, clb, cub = self.A.lists()
-            ckeys = self.A.keys()
-            vlb, vub = self.B.arrays()
-            integrality = self.B.integralityList()
-            vkeys = self.B.keys()
-            cind, cval = self.c.lists()
-
-            task = mosek.Task()
-            # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-5)
-            # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
-            # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
-            task.appendcons(self.A.ncons)
-            task.appendvars(self.A.nvars)
-
-            for ii in range(len(cind)):
-                task.putcj(cind[ii], cval[ii])
-
-            for ii in range(self.nvars):
-                task.putvarbound(ii, bdic[vkeys[ii]], vlb[ii], vub[ii])
-
-            for ii in range(len(integrality)):
-                task.putvartype(integrality[ii], mosek.variabletype.type_int)
-
-            for ii in range(self.A.ncons):
-                task.putarow(ii, Aind[ii], Aval[ii])
-                task.putconbound(ii, bdic[ckeys[ii]], clb[ii], cub[ii])
-
-            task.putobjsense(mosek.objsense.minimize)
-            task.optimize()
-
-            solsta = task.getsolsta(mosek.soltype.itg)
-            # prosta = task.getprosta(mosek.soltype.itg)
-            it += 1
-
-            if solsta != mosek.solsta.integer_optimal:
-                break
+        self._buildConstraints(objective, options)
+        Aind, Aval, clb, cub = self.A.lists()
+        ckeys = self.A.keys()
+        vlb, vub = self.B.arrays()
+        integrality = self.B.integralityList()
+        vkeys = self.B.keys()
+        cind, cval = self.c.lists()
 
-            xx = np.array(task.getxx(mosek.soltype.itg))
-            solution = task.getprimalobj(mosek.soltype.itg)
+        task = mosek.Task()
+        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-5)
+        # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
+        # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
+        task.appendcons(self.A.ncons)
+        task.appendvars(self.A.nvars)
 
-            if withMedicare is False:
-                break
+        for ii in range(len(cind)):
+            task.putcj(cind[ii], cval[ii])
 
-            self._estimateMedicare(xx)
+        for ii in range(self.nvars):
+            task.putvarbound(ii, bdic[vkeys[ii]], vlb[ii], vub[ii])
 
-            self.mylog.vprint("Iteration:", it, "objective:", u.d(solution * objFac, f=2))
+        for ii in range(len(integrality)):
+            task.putvartype(integrality[ii], mosek.variabletype.type_int)
 
-            delta = xx - old_x
-            absdiff = np.sum(np.abs(delta), axis=0)
-            if absdiff < 1:
-                self.mylog.vprint("Converged on full solution.")
-                break
+        for ii in range(self.A.ncons):
+            task.putarow(ii, Aind[ii], Aval[ii])
+            task.putconbound(ii, bdic[ckeys[ii]], clb[ii], cub[ii])
 
-            # 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]
-            if isclosenough:
-                self.mylog.vprint("Converged through selecting minimum oscillating objective.")
-                break
+        task.putobjsense(mosek.objsense.minimize)
+        task.optimize()
 
-            if it > 59:
-                self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
-                break
-
-            old_solutions.append(-solution)
-            old_x = xx
+        solsta = task.getsolsta(mosek.soltype.itg)
+        # prosta = task.getprosta(mosek.soltype.itg)
 
         task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
         # task.writedata(self._name+'.ptf')
         if solsta == mosek.solsta.integer_optimal:
-            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
+            xx = np.array(task.getxx(mosek.soltype.itg))
+            solution = task.getprimalobj(mosek.soltype.itg)
+
+            self.mylog.vprint("Solution successful.")
             task.solutionsummary(mosek.streamtype.msg)
+            if objective == "maxSpending":
+                objFac = -1 / self.xi_n[0]
+            else:
+                objFac = -1 / self.gamma_n[-1]
+
             self.mylog.vprint("Objective:", u.d(solution * objFac))
             self.caseStatus = "solved"
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
-            self._aggregateResults(xx)
+            self._aggregateResults(options, xx)
             self._timestamp = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
         else:
             self.mylog.vprint("WARNING: Optimization failed:", "Infeasible or unbounded.")
@@ -1920,11 +1896,11 @@ class Plan(object):
             self.F_tn = self.F_tn.reshape((self.N_t, self.N_n))
             MAGI_n = np.sum(self.F_tn, axis=0) + np.array(x[self.C["e"] : self.C["F"]])
 
-        self.M_n = tx.mediCosts(self.yobs, self.horizons, MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
+        self.M_n = tx.mediCosts(self.yobs, self.horizons, MAGI_n, self.prevMAGIs, self.gamma_n[:-1], self.N_n)
 
         return None
 
-    def _aggregateResults(self, x):
+    def _aggregateResults(self, options, x):
         """
         Utility function to aggregate results from solver.
         Process all results from solution vector.
@@ -1934,6 +1910,7 @@ class Plan(object):
         Nj = self.N_j
         Nk = self.N_k
         Nn = self.N_n
+        Nq = self.N_q
         Nt = self.N_t
         # Nz = self.N_z
         n_d = self.n_d
@@ -1943,10 +1920,12 @@ class Plan(object):
         Ce = self.C["e"]
         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"]
+        Czm = self.C["zm"]
 
         x = u.roundCents(x)
 
@@ -1965,19 +1944,28 @@ class Plan(object):
         self.F_tn = np.array(x[CF:Cg])
         self.F_tn = self.F_tn.reshape((Nt, Nn))
 
-        self.g_n = np.array(x[Cg:Cs])
+        self.g_n = np.array(x[Cg:Cm])
+
+        if options.get("withMedicare", True):
+            self.m_n = np.array(x[Cm:Cs])
+        else:
+            self.m_n = np.zeros(Nn)
 
         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))
-        # print(self.z_inz)
+        # self.zx_inz = np.array(x[Czx:Czm])
+        # self.zx_inz = self.zx_inz.reshape((Ni, Nn, Nz))
+        # print(self.zx_inz)
+
+        if options.get("withMedicare", True):
+            self.zm_nq = np.array(x[Czm:])
+            self.zm_nq = self.zm_nq.reshape((Nn, Nq))
 
         # Partial distribution at the passing of first spouse.
         if Ni == 2 and n_d < Nn:
@@ -2166,10 +2154,10 @@ class Plan(object):
         dic["Total tax paid on gains and dividends"] = f"{u.d(taxPaidNow)}"
         dic["[Total tax paid on gains and dividends]"] = f"{u.d(taxPaid)}"
 
-        taxPaid = np.sum(self.M_n, axis=0)
-        taxPaidNow = np.sum(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)}"
+        medtaxPaid = np.sum(self.m_n, axis=0)
+        medtaxPaidNow = np.sum(self.m_n / self.gamma_n[:-1], axis=0)
+        dic["Total Medicare premiums paid"] = f"{u.d(medtaxPaidNow)}"
+        dic["[Total Medicare premiums paid]"] = f"{u.d(medtaxPaid)}"
 
         if self.N_i == 2 and self.n_d < self.N_n:
             p_j = self.partialEstate_j * (1 - self.phi_j)
@@ -2622,12 +2610,12 @@ class Plan(object):
         style = {"income taxes": "-", "Medicare": "-."}
 
         if value == "nominal":
-            series = {"income taxes": self.T_n, "Medicare": self.M_n}
+            series = {"income taxes": self.T_n, "Medicare": self.m_n}
             yformat = "\\$k (nominal)"
         else:
             series = {
                 "income taxes": self.T_n / self.gamma_n[:-1],
-                "Medicare": self.M_n / self.gamma_n[:-1],
+                "Medicare": self.m_n / self.gamma_n[:-1],
             }
             yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
 
@@ -2762,7 +2750,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,
+            "Tax bills + Med.": self.T_n + self.U_n + self.m_n,
         }
 
         fillsheet(ws, incomeDic, "currency")
@@ -2778,7 +2766,7 @@ class Plan(object):
             "all deposits": -np.sum(self.d_in, axis=0),
             "ord taxes": -self.T_n,
             "div taxes": -self.U_n,
-            "Medicare": -self.M_n,
+            "Medicare": -self.m_n,
         }
         sname = "Cash Flow"
         ws = wb.create_sheet(sname)

owlplanner/tax2025.py

@@ -42,14 +42,15 @@ taxBrackets_TCJA = np.array(
 
 irmaaBrackets = np.array(
     [
-        [0, 106000, 133000, 167000, 200000, 500000],
-        [0, 212000, 266000, 334000, 400000, 750000],
+        [0, 106000, 133000, 167000, 200000, 500000, 9999999],
+        [0, 212000, 266000, 334000, 400000, 750000, 9999999],
     ]
 )
 
 # Index [0] stores the standard Medicare part B premium.
 # Following values are incremental IRMAA part B monthly fees.
 irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
+irmaaCosts = np.cumsum(irmaaFees)
 
 # Make projection for non-TCJA using 2017 to current year.
 # taxBrackets_2017 = np.array(
@@ -82,6 +83,34 @@ extra65Deduction = np.array([2000, 1600])
 ###############################################################################
 
 
+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(irmaaCosts), f"Inconsistent value of Nq: {Nq}."
+    assert Nq+1 == len(irmaaBrackets[0]), "Inconsistent IRMAA brackets array."
+    Ni = len(yobs)
+    L = np.zeros((Nn, Nq+1))
+    C = np.zeros((Nn, Nq))
+    nm = 0
+    for n in range(Nn):
+        icount = 0
+        if thisyear + n - yobs[0] >= 65 and n < horizons[0]:
+            icount += 1
+        if Ni == 2 and thisyear + n - yobs[1] >= 65 and n < horizons[1]:
+            icount += 1
+        if icount > 0:
+            status = 0 if Ni == 1 else 1 if n < horizons[0] and n < horizons[1] else 0
+            L[n] = gamma_n[n] * irmaaBrackets[status]
+            C[n] = icount * gamma_n[n] * irmaaCosts
+        else:
+            nm = n + 1
+
+    return nm, L, C
+
+
 def mediCosts(yobs, horizons, magi, prevmagi, gamma_n, Nn):
     """
     Compute Medicare costs directly.

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.04.22"
+__version__ = "2025.04.28"

{owlplanner-2025.4.22.dist-info → owlplanner-2025.4.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.4.22
+Version: 2025.4.28
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -719,7 +719,8 @@ or fixed rates either derived from historical averages, or set by the user.
 
 There are a few ways to run Owl:
 
-- Run Owl directly on the Streamlit Community Server at [owlplanner.streamlit.app](https://owlplanner.streamlit.app).
+- Run Owl directly on the Streamlit Community Server at
+[owlplanner.streamlit.app](https://owlplanner.streamlit.app).
 
 - Run locally on your computer using a Docker image.
 Follow these [instructions](docker/README.md) for this option.
@@ -758,8 +759,8 @@ while providing a codebase where they can learn and contribute. There are and we
 good retirement optimizers in the recent past, but the vast majority of them are either proprietary platforms
 collecting your data, or academic papers that share the results without really sharing the details of
 the underlying mathematical models.
-The algorithms in Owl rely on the open-source HiGHS linear programming solver. The complete formulation and
-detailed description of the underlying
+The algorithms in Owl rely on the open-source HiGHS linear programming solver.
+The complete formulation and detailed description of the underlying
 mathematical model can be found [here](https://raw.github.com/mdlacasse/Owl/main/docs/owl.pdf).
 
 It is anticipated that most end users will use Owl through the graphical interface
@@ -772,16 +773,18 @@ Not every retirement decision strategy can be framed as an easy-to-solve optimiz
 In particular, if one is interested in comparing different withdrawal strategies,
 [FI Calc](ficalc.app) is an elegant application that addresses this need.
 If, however, you also want to optimize spending, bequest, and Roth conversions, with
-an approach also considering Medicare and federal income tax over the next few years,
+an approach also considering Medicare costs and federal income tax over the next few years,
 then Owl is definitely a tool that can help guide your decisions.
 
 --------------------------------------------------------------------------------------
 ## Capabilities
-Owl can optimize for either maximum net spending under the constraint of a given bequest (which can be zero),
+Owl can optimize for either the maximum net spending amount under the constraint
+of a given bequest (which can be zero),
 or maximize the after-tax value of a bequest under the constraint of a desired net spending profile,
-and under the assumption of a heirs marginal tax rate.
-Roth conversions are also considered, subject to an optional maximum conversion amount,
-and optimized to suit the goals of the selected objective function.
+under the assumption of a heirs marginal tax rate.
+Roth conversions are also considered, subject to an optional maximum Roth conversion amount,
+and optimized to suit the goals of the selected objective function, while considering
+Medicare costs, and federal income tax under different rates of return assumptions.
 All calculations are indexed for inflation, which is either provided as a fixed rate,
 or through historical values, as are all other rates used for the calculations.
 These rates can be used for backtesting different scenarios by choosing
@@ -839,29 +842,29 @@ which are all tracked separately for married individuals. Asset transition to th
 is done according to beneficiary fractions for each type of savings account.
 Tax status covers married filing jointly and single, depending on the number of individuals reported.
 
-Medicare and IRMAA calculations are performed through a self-consistent loop on cash flow constraints.
+Federal income tax, Medicare part B premiums, and IRMAA calculations are part of the optimization.
 Future values are simple projections of current values with the assumed inflation rates.
 
 ### Limitations
 Owl is work in progress. At the current time:
 - Only the US federal income tax is considered (and minimized through the optimization algorithm).
 Head of household filing status has not been added but can easily be.
-- Required minimum distributions are calculated, but tables for spouses more than 10 years apart are not included.
+- Required minimum distributions are always performed and calculated,
+but tables for spouses more than 10 years apart are not included.
 These cases are detected and will generate an error message.
 - Social security rule for surviving spouse assumes that benefits were taken at full retirement age.
-- Current version has no optimization of asset allocations between individuals and/or types of savings accounts.
-If there is interest, that could be added in the future.
 - In the current implementation, social securiy is always taxed at 85%.
-- Medicare calculations are done through a self-consistent loop.
-This means that the Medicare premiums are calculated after an initial solution is generated,
-and then a new solution is re-generated with these premiums as a constraint.
-In some situations, when the income (MAGI) is near an IRMAA bracket, oscillatory solutions can arise.
-While the solutions generated are very close to one another, Owl will pick the smallest solution
-for being conservative.
+- Medicare calculations require the use of binary variables which add to the computational costs.
+I've observed run requiring up to 10 seconds.
+These calculations can be turned off when shorter time to solutions are required.
+The use of a commercial solver (e.g. MOSEK) can substantially reduce computing time
+but require a license.
 - Part D is not included in the IRMAA calculations. Being considerably more significant,
 only Part B is taken into account. 
-- Future tax brackets are pure speculations derived from the little we know now and projected to the next 30 years.
-Your guesses are as good as mine.
+- Future tax brackets are pure speculations derived from the little we know now and projected
+to the next 30 years. Your guesses are as good as mine.
+- Current version has no optimization of asset allocations between individuals and/or types of savings accounts.
+If there is interest, that could be added in the future.
 
 The solution from an optimization algorithm has only two states: feasible and infeasible.
 Therefore, unlike event-driven simulators that can tell you that your distribution strategy runs
@@ -874,7 +877,8 @@ assets to support, even with no estate being left.
 ---------------------------------------------------------------
 ## Documentation
 
-- Documentation for the app user interface is available from the interface [itself](https://owlplanner.streamlit.app/Documentation).
+- Documentation for the app user interface is available from the interface
+[itself](https://owlplanner.streamlit.app/Documentation).
 - Installation guide and software requirements can be found [here](INSTALL.md).
 - User guide for the underlying Python package as used in a Jupyter notebook can be found [here](USER_GUIDE.md).
 
@@ -891,7 +895,7 @@ assets to support, even with no estate being left.
 
 ---------------------------------------------------------------------
 
-Copyright © 2024 - Martin-D. Lacasse
+Copyright © 2025 - Martin-D. Lacasse
 
 Disclaimers: I am not a financial planner. You make your own decisions.
 This program comes with no guarantee. Use at your own risk.

{owlplanner-2025.4.22.dist-info → owlplanner-2025.4.28.dist-info}/RECORD

@@ -1,18 +1,17 @@
-owlplanner/.plan.py.swo,sha256=6DmRbuBtsIhjhN44-D5GbxY2mfnsoIJpT-fQsFMDGNo,4096
 owlplanner/__init__.py,sha256=QqrdT0Qks20osBTg7h0vJHAxpP9lL7DA99xb0nYbtw4,254
-owlplanner/abcapi.py,sha256=LbzW_KcNy0IeHp42MUHwGu_H67B2h_e1_vu-c2ACTkQ,6646
+owlplanner/abcapi.py,sha256=xf5233Ph952y7O-m1vc0WmbTz3RlQtDemfqD40edlZ4,6710
 owlplanner/config.py,sha256=F6GS3n02VeFX0GCVeM4J7Ra0in4N632W6TZIXk7Yj2w,12519
 owlplanner/logging.py,sha256=tYMw04O-XYSzjTj36fmKJGLcE1VkK6k6oJNeqtKXzuc,2530
-owlplanner/plan.py,sha256=c8_nOMiNXFiVDKqSxBbzYTZhgYvQJecJnZwAZqBmryE,117670
+owlplanner/plan.py,sha256=_9MQWUEcElLbdZ-J0DqmcMim3Q9KrVmUpFPHtSiatZA,118775
 owlplanner/progress.py,sha256=8jlCvvtgDI89zXVNMBg1-lnEyhpPvKQS2X5oAIpoOVQ,384
 owlplanner/rates.py,sha256=gJaoe-gJqWCQV5qVLlHp-Yn9TSJs-PJzeTbOwMCbqWs,15682
-owlplanner/tax2025.py,sha256=JDBtFFAf2bWtKUMuE3W5F0nBhYaKBjmdJj0iayM2iGA,7829
+owlplanner/tax2025.py,sha256=yxpFhETe2fmo1qosKSrIX81z4fMMu4VcKSBd-ePSrTw,8913
 owlplanner/timelists.py,sha256=tYieZU67FT6TCcQQis36JaXGI7dT6NqD7RvdEjgJL4M,4026
 owlplanner/utils.py,sha256=WpJgn79YZfH8UCkcmhd-AZlxlGuz1i1-UDBRXImsY6I,2485
-owlplanner/version.py,sha256=hMtSc1ylUesUgt89a7O-P3iBLxQCOd1RsXXs1SsFL8g,28
+owlplanner/version.py,sha256=vGljB4UJ5r4pxBlvSDiQ77nNw16bav9YeZM-RB6mrPo,28
 owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
-owlplanner-2025.4.22.dist-info/METADATA,sha256=hVV4m0iYvXfqCm0dMDRxuvQR-EUCv1mGvwp9e6jfElw,53927
-owlplanner-2025.4.22.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.4.22.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.4.22.dist-info/RECORD,,
+owlplanner-2025.4.28.dist-info/METADATA,sha256=raP9OUYGLRQ_TL2udRcCM0j4rwtyLaHTFPYRv6lQ_VY,53939
+owlplanner-2025.4.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.4.28.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.4.28.dist-info/RECORD,,