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

owlplanner/abcapi.py

@@ -47,12 +47,10 @@ class Row(object):
         self.ind.append(ind)
         self.val.append(val)
 
-    def addElemDic(self, rowDic=None):
+    def addElemDic(self, rowDic={}):
         """
         Add elements at indices provided by a dictionary.
         """
-        if rowDic is None:
-            rowDic = {}
         for key in rowDic:
             self.addElem(key, rowDic[key])
         return self
@@ -75,13 +73,11 @@ class ConstraintMatrix(object):
         self.ub = []
         self.key = []
 
-    def newRow(self, rowDic=None):
+    def newRow(self, rowDic={}):
         """
         Create a new row and populate its elements using the dictionary provided.
         Return the row created.
         """
-        if rowDic is None:
-            rowDic = {}
         row = Row(self.nvars)
         row.addElemDic(rowDic)
         return row
@@ -97,10 +93,12 @@ 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 and lb == -np.inf:
+            self.key.append("fr")
         elif ub == np.inf:
             self.key.append("lo")
+        elif lb == -np.inf:
+            self.key.append("up")
         else:
             self.key.append("ra")
         self.ncons += 1
@@ -147,13 +145,16 @@ class Bounds(object):
     Solver-neutral API for bounds on variables.
     """
 
-    def __init__(self, nvars):
+    def __init__(self, nvars, nbins):
         self.nvars = nvars
+        self.nbins = nbins
         self.ind = []
         self.lb = []
         self.ub = []
         self.key = []
         self.integrality = []
+        for ii in range(nvars-nbins, nvars):
+            self.setBinary(ii)
 
     def setBinary(self, ii):
         assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
@@ -163,27 +164,20 @@ class Bounds(object):
         self.key.append("ra")
         self.integrality.append(ii)
 
-    def set0_Ub(self, ii, ub):
-        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
-        self.ind.append(ii)
-        self.lb.append(0)
-        self.ub.append(ub)
-        self.key.append("ra")
-
-    def setLb_Inf(self, ii, lb):
-        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
-        self.ind.append(ii)
-        self.lb.append(lb)
-        self.ub.append(np.inf)
-        self.key.append("lo")
-
     def setRange(self, ii, lb, ub):
         assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
+        assert lb <= ub, f"Lower bound {lb} > upper bound {ub}."
         self.ind.append(ii)
         self.lb.append(lb)
         self.ub.append(ub)
         if lb == ub:
             self.key.append("fx")
+        elif ub == np.inf and lb == -np.inf:
+            self.key.append("fr")
+        elif ub == np.inf:
+            self.key.append("lo")
+        elif lb == -np.inf:
+            self.key.append("up")
         else:
             self.key.append("ra")
 

owlplanner/plan.py

@@ -230,12 +230,11 @@ class Plan(object):
         self._name = name
         self.setLogstreams(verbose, logstreams)
 
-        # 7 tax brackets, 6 Medicare levels, 3 types of accounts, 4 classes of assets.
+        # 7 tax 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 per year per invididual.
+        # 2 binary variables.
         self.N_z = 2
 
         # Default interpolation parameters for allocation ratios.
@@ -305,8 +304,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 2 years and current year for Medicare.
-        self.prevMAGIs = np.zeros((3))
+        # Previous 3 years for Medicare.
+        self.prevMAGI = np.zeros((3))
 
         # Default slack on profile.
         self.lambdha = 0
@@ -324,7 +323,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
@@ -1022,30 +1021,30 @@ class Plan(object):
 
         return None
 
-    def _buildOffsetMap(self, options):
+    def _buildOffsetMap(self):
         """
         Utility function to map variables to a block vector.
         Refer to companion document for explanations.
         """
-        medi = options.get("withMedicare", True)
-
-        # Stack all variables in a single block vector with offsets saved in a dictionary.
+        # 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["m"] = _qC(C["g"], self.N_n)
-        C["s"] = _qC(C["m"], self.N_n) if medi else C["m"]
+        C["s"] = _qC(C["g"], 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["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"]
+        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
 
         self.C = C
-        self.mylog.vprint(f"Problem has {len(C)} distinct time series forming {self.nvars} decision variables.")
+        self.mylog.vprint(
+            f"Problem has {len(C)} distinct series, {self.nvars} decision variables (including {self.nbins} binary).")
 
         return None
 
@@ -1062,7 +1061,6 @@ 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
@@ -1070,23 +1068,22 @@ 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"]
-        Czx = self.C["zx"]
-        Czm = self.C["zm"]
+        Cz = self.C["z"]
 
         spLo = 1 - self.lambdha
         spHi = 1 + self.lambdha
 
+        oppCostX = options.get("oppCostX", 0.)
+        xnet = 1 - oppCostX/100.
+
         tau_ijn = np.zeros((Ni, Nj, Nn))
         for i in range(Ni):
             for j in range(Nj):
@@ -1105,79 +1102,37 @@ class Plan(object):
         ###################################################################
         # Inequality constraint matrix with upper and lower bound vectors.
         A = abc.ConstraintMatrix(self.nvars)
-        B = abc.Bounds(self.nvars)
+        B = abc.Bounds(self.nvars, self.nbins)
 
-        # 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...
+        # RMDs inequalities, only if there is an initial balance in tax-deferred account.
         for i in range(Ni):
-            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)
+            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)
 
-        # Income tax bracket range inequalities, from 0 to upper bound.
+        # Income tax bracket range inequalities.
         for t in range(Nt):
             for n in range(Nn):
-                B.set0_Ub(_q2(CF, t, n, Nt, Nn), self.DeltaBar_tn[t, n])
+                B.setRange(_q2(CF, t, n, Nt, Nn), zero, self.DeltaBar_tn[t, n])
 
         # Standard exemption range inequalities.
         for n in range(Nn):
-            B.set0_Ub(_q1(Ce, n, Nn), self.sigmaBar_n[n])
+            B.setRange(_q1(Ce, n, Nn), zero, self.sigmaBar_n[n])
 
-        # Impose withdrawal limits on all accounts.
+        # Start with no activities after passing.
         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 n in range(self.horizons[i], Nn):
+                B.setRange(_q2(Cd, i, n, Ni, Nn), zero, zero)
+                B.setRange(_q2(Cx, i, n, Ni, Nn), zero, zero)
                 for j in range(Nj):
-                    B.set0_Ub(_q3(Cw, i_d, j, n, Ni, Nj, Nn), zero)
+                    B.setRange(_q3(Cw, i, j, n, Ni, Nj, Nn), zero, zero)
 
-        # Roth conversions bounds, equalities, and inequalities.
-        # Condition "file" supercedes everything else.
+        # Roth conversions equalities/inequalities.
+        # This condition 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):
@@ -1196,8 +1151,9 @@ class Plan(object):
                     # self.mylog.vprint('Limiting Roth conversions to:', u.d(rhsopt))
                     for i in range(Ni):
                         for n in range(self.horizons[i]):
-                            #  Should we adjust Roth conversion cap with inflation?
-                            B.set0_Ub(_q2(Cx, i, n, Ni, Nn), rhsopt)
+                            # MOSEK chokes if completely zero. Add a 1 cent slack.
+                            # Should we adjust Roth conversion cap with inflation?
+                            B.setRange(_q2(Cx, i, n, Ni, Nn), zero, rhsopt + 0.01)
 
             # Process startRothConversions option.
             if "startRothConversions" in options:
@@ -1209,7 +1165,7 @@ class Plan(object):
                 for i in range(Ni):
                     nstart = min(yearn, self.horizons[i])
                     for n in range(0, nstart):
-                        B.set0_Ub(_q2(Cx, i, n, Ni, Nn), zero)
+                        B.setRange(_q2(Cx, i, n, Ni, Nn), zero, zero)
 
             # Process noRothConversions option. Also valid when N_i == 1, why not?
             if "noRothConversions" in options and options["noRothConversions"] != "None":
@@ -1220,15 +1176,63 @@ class Plan(object):
                     raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:")
 
                 for n in range(Nn):
-                    B.set0_Ub(_q2(Cx, i_x, n, Ni, Nn), zero)
+                    B.setRange(_q2(Cx, i_x, n, Ni, Nn), zero, zero)
 
-        # Set initial balances through constraints.
+        # 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)
+            B.setRange(_q1(Cg, 0, Nn), spending, spending)
+
+        # Set initial balances through bounds or 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)
+                # A.addNewRow({_q3(Cb, i, j, 0, Ni, Nj, Nn + 1): 1}, rhs, rhs)
+                B.setRange(_q3(Cb, i, j, 0, Ni, Nj, Nn + 1), rhs, rhs)
 
-        # Link cash flow surplus and taxable account deposits even for Ni=1.
+        # Link surplus and taxable account deposits regardless of Ni.
         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):
@@ -1240,7 +1244,20 @@ class Plan(object):
                 A.addNewRow(rowDic, zero, zero)
 
         # No surplus allowed during the last year to be used as a tax loophole.
-        B.set0_Ub(_q1(Cs, Nn - 1, Nn), zero)
+        B.setRange(_q1(Cs, Nn - 1, Nn), zero, zero)
+
+        if Ni == 2:
+            # No conversion during last year.
+            # B.setRange(_q2(Cx, i_d, nd-1, Ni, Nn), zero, zero)
+            # B.setRange(_q2(Cx, i_s, Nn-1, Ni, Nn), zero, 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.setRange(_q2(Cd, i_d, n, Ni, Nn), zero, zero)
+                B.setRange(_q2(Cx, i_d, n, Ni, Nn), zero, zero)
+                for j in range(Nj):
+                    B.setRange(_q3(Cw, i_d, j, n, Ni, Nj, Nn), zero, zero)
 
         # Account balances carried from year to year.
         # Considering spousal asset transfer at passing of a spouse.
@@ -1248,45 +1265,44 @@ class Plan(object):
         for i in range(Ni):
             for j in range(Nj):
                 for n in range(Nn):
-                    # 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]
+                    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
+
                     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_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(_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(
                         _q2(Cx, i, n, Ni, Nn),
-                        -(u.krond(j, 2) - u.krond(j, 1)) * fac1_ijn,
+                        -fac1 * (xnet*u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i, j, n],
                     )
 
                     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_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(_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(
                             _q2(Cx, i_d, n, Ni, Nn),
-                            -(u.krond(j, 2) - u.krond(j, 1)) * fac2_idjn,
+                            -fac2 * (xnet*u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i_d, j, n],
                         )
                     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
 
-        # Cash flow for net spending.
+        # Net cash flow.
         for n in range(Nn):
-            rhs = 0
-            row = A.newRow()
-            row.addElem(_q1(Cg, n, Nn), 1)
-            row.addElem(_q1(Cm, n, Nn), 1)
+            rhs = -self.M_n[n]
+            row = A.newRow({_q1(Cg, n, Nn): 1})
+            row.addElem(_q1(Cs, n, Nn), 1)
             for i in range(Ni):
                 fac = self.psi * self.alpha_ijkn[i, 0, 0, n]
                 rhs += (
@@ -1298,13 +1314,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), -1 + fac * (tau_0prev[n] - self.mu))
+                row.addElem(_q3(Cw, i, 0, n, Ni, Nj, Nn), fac * (tau_0prev[n] - self.mu) - 1)
                 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):
@@ -1312,10 +1328,10 @@ class Plan(object):
 
             A.addRow(row, rhs, rhs)
 
-        # Enforce income profile.
+        # Impose 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)
+            rowDic = {_q1(Cg, 0, Nn): spLo * self.xiBar_n[n], _q1(Cg, n, Nn): -self.xiBar_n[0]}
+            A.addNewRow(rowDic, -inf, zero)
             rowDic = {_q1(Cg, 0, Nn): spHi * self.xiBar_n[n], _q1(Cg, n, Nn): -self.xiBar_n[0]}
             A.addNewRow(rowDic, zero, inf)
 
@@ -1331,102 +1347,33 @@ class Plan(object):
                 row.addElem(_q2(Cx, i, n, Ni, Nn), -1)
 
                 # Taxable returns on securities in taxable account.
-                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)
+                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)
 
             for t in range(Nt):
                 row.addElem(_q2(CF, t, n, Nt, Nn), 1)
 
             A.addRow(row, rhs, rhs)
 
-        # 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.
+        # Configure binary variables.
         for i in range(Ni):
             for n in range(self.horizons[i]):
-                # Configure binary variables.
-                for z in range(Nz):
-                    B.setBinary(_q3(Czx, i, n, z, Ni, Nn, Nz))
+                # for z in range(Nz):
+                #     B.setBinary(_q3(Cz, i, n, z, Ni, Nn, Nz))
 
                 # Exclude simultaneous deposits and withdrawals from taxable or tax-free accounts.
                 A.addNewRow(
-                    {_q3(Czx, i, n, 0, Ni, Nn, Nz): bigM, _q1(Cs, n, Nn): -1},
+                    {_q3(Cz, i, n, 0, Ni, Nn, Nz): bigM, _q1(Cs, n, Nn): -1},
                     zero,
                     bigM,
                 )
 
                 A.addNewRow(
                     {
-                        _q3(Czx, i, n, 0, Ni, Nn, Nz): bigM,
+                        _q3(Cz, 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,
                     },
@@ -1436,17 +1383,21 @@ class Plan(object):
 
                 # Exclude simultaneous Roth conversions and tax-exempt withdrawals.
                 A.addNewRow(
-                    {_q3(Czx, i, n, 1, Ni, Nn, Nz): bigM, _q2(Cx, i, n, Ni, Nn): -1},
+                    {_q3(Cz, i, n, 1, Ni, Nn, Nz): bigM, _q2(Cx, i, n, Ni, Nn): -1},
                     zero,
                     bigM,
                 )
 
                 A.addNewRow(
-                    {_q3(Czx, i, n, 1, Ni, Nn, Nz): bigM, _q3(Cw, i, 2, n, Ni, Nj, Nn): 1},
+                    {_q3(Cz, i, n, 1, Ni, Nn, Nz): bigM, _q3(Cw, i, 2, n, Ni, Nj, Nn): 1},
                     zero,
                     bigM,
                 )
 
+            for n in range(self.horizons[i], Nn):
+                B.setRange(_q3(Cz, i, n, 0, Ni, Nn, Nz), zero, zero)
+                B.setRange(_q3(Cz, i, n, 1, Ni, Nn, Nz), zero, zero)
+
         # Now build a solver-neutral objective vector.
         c = abc.Objective(self.nvars)
         if objective == "maxSpending":
@@ -1668,7 +1619,7 @@ class Plan(object):
 
     @_checkConfiguration
     @_timer
-    def solve(self, objective, options=None):
+    def solve(self, objective, options={}):
         """
         This function builds the necessary constaints and
         runs the optimizer.
@@ -1693,7 +1644,8 @@ class Plan(object):
 
         # Check objective and required options.
         knownObjectives = ["maxBequest", "maxSpending"]
-        knownSolvers = ["HiGHS", "MOSEK"]
+        knownSolvers = ["HiGHS", "PuLP/CBC", "MOSEK"]
+
         knownOptions = [
             "bequest",
             "bigM",
@@ -1706,12 +1658,10 @@ class Plan(object):
             "startRothConversions",
             "units",
             "withMedicare",
+            "oppCostX",
         ]
-        # We will modify options if required.
-        if options is None:
-            myoptions = {}
-        else:
-            myoptions = dict(options)
+        # We might modify options if required.
+        myoptions = dict(options)
 
         for opt in myoptions:
             if opt not in knownOptions:
@@ -1734,41 +1684,104 @@ class Plan(object):
         if objective == "maxSpending" and "bequest" not in myoptions:
             self.mylog.vprint("Using bequest of $1.")
 
-        self.prevMAGIs = np.zeros(3)
+        self.prevMAGI = np.zeros(3)
         if "previousMAGIs" in myoptions:
             magi = myoptions["previousMAGIs"]
             if len(magi) != 3:
                 raise ValueError("previousMAGIs must have 3 values.")
 
             units = u.getUnits(options.get("units", "k"))
-            self.prevMAGIs = units * np.array(magi)
+            self.prevMAGI = units * np.array(magi)
 
-        self.lambdha = 0
-        if "spendingSlack" in myoptions:
-            lambdha = myoptions["spendingSlack"]
-            if lambdha < 0 or lambdha > 50:
-                raise ValueError(f"Slack value out of range {lambdha}.")
-            self.lambdha = lambdha / 100
+        lambdha = myoptions.get("spendingSlack", 0)
+        if lambdha < 0 or lambdha > 50:
+            raise ValueError(f"Slack value out of range {lambdha}.")
+        self.lambdha = lambdha / 100
 
         self._adjustParameters()
 
-        if "solver" in options:
-            solver = myoptions["solver"]
-            if solver not in knownSolvers:
-                raise ValueError(f"Unknown solver {solver}.")
-        else:
-            solver = self.defaultSolver
+        solver = myoptions.get("solver", self.defaultSolver)
+        if solver not in knownSolvers:
+            raise ValueError(f"Unknown solver {solver}.")
 
         if solver == "HiGHS":
-            self._milpSolve(objective, myoptions)
+            solverMethod = self._milpSolve
+        elif solver == "PuLP/CBC":
+            solverMethod = self._pulpSolve
         elif solver == "MOSEK":
-            self._mosekSolve(objective, myoptions)
+            solverMethod = self._mosekSolve
+        else:
+            raise RuntimeError("Internal error in defining solverMethod.")
+
+        self._scSolve(objective, options, solverMethod)
 
         self.objective = objective
         self.solverOptions = myoptions
 
         return None
 
+    def _scSolve(self, objective, options, solverMethod):
+        """
+        Self-consistent loop, regardless of solver.
+        """
+        withMedicare = options.get("withMedicare", True)
+
+        if objective == "maxSpending":
+            objFac = -1 / self.xi_n[0]
+        else:
+            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)
+        while True:
+            solution, xx, solverSuccess, solverMsg = solverMethod(objective, options)
+
+            if not solverSuccess:
+                break
+
+            if not withMedicare:
+                break
+
+            self._estimateMedicare(xx)
+
+            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution * objFac, f=2)}")
+
+            delta = xx - 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 - 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)
+            old_x = xx
+
+        if solverSuccess:
+            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
+            self.mylog.vprint(solverMsg)
+            self.mylog.vprint(f"Objective: {u.d(solution * 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")
+            self.caseStatus = "solved"
+        else:
+            self.mylog.vprint("WARNING: Optimization failed:", solverMsg, solverSuccess)
+            self.caseStatus = "unsuccessful"
+
+        return None
+
     def _milpSolve(self, objective, options):
         """
         Solve problem using scipy HiGHS solver.
@@ -1786,27 +1799,74 @@ class Plan(object):
 
         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("Solution successful.")
-            self.mylog.vprint(solution.message)
-            if objective == "maxSpending":
-                objFac = -1 / self.xi_n[0]
+        solution = optimize.milp(
+            c,
+            integrality=integrality,
+            constraints=constraint,
+            bounds=bounds,
+            options=milpOptions,
+        )
+
+        return solution.fun, solution.x, solution.success, solution.message
+
+    def _pulpSolve(self, objective, options):
+        """
+        Solve problem using scipy PuLP solver.
+        """
+        import pulp
+
+        self._buildConstraints(objective, options)
+        Alu, lbvec, ubvec = self.A.arrays()
+        ckeys = self.A.keys()
+        Lb, Ub = self.B.arrays()
+        vkeys = self.B.keys()
+        c = self.c.arrays()
+        c_list = c.tolist()
+
+        prob = pulp.LpProblem(self._name.replace(" ", "_"), pulp.LpMinimize)
+
+        x = []
+        for i in range(self.nvars - self.nbins):
+            if vkeys[i] == "ra":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
+            elif vkeys[i] == "lo":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=None)]
+            elif vkeys[i] == "up":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=None, upBound=Ub[i])]
+            elif vkeys[i] == "fr":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=None, upBound=None)]
+            elif vkeys[i] == "fx":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
             else:
-                objFac = -1 / self.gamma_n[-1]
+                raise RuntimeError(f"Internal error: Variable with wierd bound f{vkeys[i]}.")
 
-            self.mylog.vprint(f"Objective: {u.d(solution.fun * objFac)}")
-            # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
-            self._aggregateResults(options, solution.x)
-            self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
-            self.caseStatus = "solved"
-        else:
-            self.mylog.vprint("WARNING: Optimization failed:", solution.message, solution.success)
-            self.caseStatus = "unsuccessful"
+        x.extend([pulp.LpVariable(f"z_{i}", cat="Binary") for i in range(self.nbins)])
 
-        return None
+        prob += pulp.lpDot(c_list, x)
+
+        for r in range(self.A.ncons):
+            row = Alu[r].tolist()
+            if ckeys[r] in ["lo", "ra"] and lbvec[r] != -np.inf:
+                prob += pulp.lpDot(row, x) >= lbvec[r]
+            if ckeys[r] in ["up", "ra"] and ubvec[r] != np.inf:
+                prob += pulp.lpDot(row, x) <= ubvec[r]
+            if ckeys[r] == "fx":
+                prob += pulp.lpDot(row, x) == ubvec[r]
+
+        # prob.writeLP("C:\\Users\\marti\\Downloads\\pulp.lp")
+        # prob.writeMPS("C:\\Users\\marti\\Downloads\\pulp.mps", rename=True)
+        # solver_list = pulp.listSolvers(onlyAvailable=True)
+        # print("Available solvers:", solver_list)
+        # solver = pulp.getSolver("MOSEK")
+        # prob.solve(solver)
+
+        prob.solve(pulp.PULP_CBC_CMD(msg=False))
+        # Filter out None values and convert to array.
+        xx = np.array([0 if x[i].varValue is None else x[i].varValue for i in range(self.nvars)])
+        solution = np.dot(c, xx)
+        success = (pulp.LpStatus[prob.status] == "Optimal")
+
+        return solution, xx, success, pulp.LpStatus[prob.status]
 
     def _mosekSolve(self, objective, options):
         """
@@ -1822,6 +1882,11 @@ class Plan(object):
             "up": mosek.boundkey.up,
         }
 
+        solverMsg = str()
+
+        def _streamPrinter(text, msg=solverMsg):
+            msg += text
+
         self._buildConstraints(objective, options)
         Aind, Aval, clb, cub = self.A.lists()
         ckeys = self.A.keys()
@@ -1831,7 +1896,7 @@ class Plan(object):
         cind, cval = self.c.lists()
 
         task = mosek.Task()
-        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-5)
+        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-6)
         # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
         # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
         task.appendcons(self.A.ncons)
@@ -1853,33 +1918,17 @@ class Plan(object):
         task.putobjsense(mosek.objsense.minimize)
         task.optimize()
 
+        # Problem MUST contain binary variables to make these calls.
         solsta = task.getsolsta(mosek.soltype.itg)
-        # prosta = task.getprosta(mosek.soltype.itg)
+        solverSuccess = (solsta == mosek.solsta.integer_optimal)
 
+        xx = np.array(task.getxx(mosek.soltype.itg))
+        solution = task.getprimalobj(mosek.soltype.itg)
         task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
+        task.solutionsummary(mosek.streamtype.msg)
         # task.writedata(self._name+'.ptf')
-        if solsta == mosek.solsta.integer_optimal:
-            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(options, xx)
-            self._timestamp = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
-        else:
-            self.mylog.vprint("WARNING: Optimization failed:", "Infeasible or unbounded.")
-            task.solutionsummary(mosek.streamtype.msg)
-            self.caseStatus = "unsuccessful"
-
-        return None
+        return solution, xx, solverSuccess, solverMsg
 
     def _estimateMedicare(self, x=None, withMedicare=True):
         """
@@ -1896,11 +1945,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.prevMAGIs, self.gamma_n[:-1], self.N_n)
+        self.M_n = tx.mediCosts(self.yobs, self.horizons, MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
 
         return None
 
-    def _aggregateResults(self, options, x):
+    def _aggregateResults(self, x):
         """
         Utility function to aggregate results from solver.
         Process all results from solution vector.
@@ -1910,7 +1959,6 @@ 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
@@ -1920,12 +1968,10 @@ 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"]
-        Czx = self.C["zx"]
-        Czm = self.C["zm"]
+        Cz = self.C["z"]
 
         x = u.roundCents(x)
 
@@ -1944,28 +1990,19 @@ 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:Cm])
-
-        if options.get("withMedicare", True):
-            self.m_n = np.array(x[Cm:Cs])
-        else:
-            self.m_n = np.zeros(Nn)
+        self.g_n = np.array(x[Cg: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:Czx])
+        self.x_in = np.array(x[Cx:Cz])
         self.x_in = self.x_in.reshape((Ni, Nn))
 
-        # 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))
+        # self.z_inz = np.array(x[Cz:])
+        # self.z_inz = self.z_inz.reshape((Ni, Nn, Nz))
+        # print(self.z_inz)
 
         # Partial distribution at the passing of first spouse.
         if Ni == 2 and n_d < Nn:
@@ -2154,10 +2191,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)}"
 
-        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)}"
+        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)}"
 
         if self.N_i == 2 and self.n_d < self.N_n:
             p_j = self.partialEstate_j * (1 - self.phi_j)
@@ -2610,12 +2647,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]) + "\\$)"
 
@@ -2750,7 +2787,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")
@@ -2766,7 +2803,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)
@@ -3062,13 +3099,3 @@ def _formatSpreadsheet(ws, ftype):
                 cell.number_format = fstring
 
     return None
-
-
-def _streamPrinter(text):
-    """
-    Define a stream printer to grab output from MOSEK.
-    """
-    import sys
-
-    sys.stdout.write(text)
-    sys.stdout.flush()

owlplanner/tax2025.py

@@ -42,15 +42,14 @@ taxBrackets_TCJA = np.array(
 
 irmaaBrackets = np.array(
     [
-        [0, 106000, 133000, 167000, 200000, 500000, 9999999],
-        [0, 212000, 266000, 334000, 400000, 750000, 9999999],
+        [0, 106000, 133000, 167000, 200000, 500000],
+        [0, 212000, 266000, 334000, 400000, 750000],
     ]
 )
 
 # Index [0] stores the standard Medicare part B premium.
 # Following values are incremental IRMAA part B monthly fees.
 irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
-irmaaCosts = np.cumsum(irmaaFees)
 
 # Make projection for non-TCJA using 2017 to current year.
 # taxBrackets_2017 = np.array(
@@ -83,34 +82,6 @@ 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.28"
+__version__ = "2025.05.02"

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.4.28
+Version: 2025.5.2
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -719,8 +719,7 @@ 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.
@@ -759,8 +758,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
@@ -773,18 +772,16 @@ 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 costs and federal income tax over the next few years,
+an approach also considering Medicare and federal income tax over the next few years,
 then Owl is definitely a tool that can help guide your decisions.
 
 --------------------------------------------------------------------------------------
 ## Capabilities
-Owl can optimize for either the maximum net spending amount under the constraint
-of a given bequest (which can be zero),
+Owl can optimize for either maximum net spending under the constraint of a given bequest (which can be zero),
 or maximize the after-tax value of a bequest under the constraint of a desired net spending profile,
-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.
+and under the assumption of a heirs marginal tax rate.
+Roth conversions are also considered, subject to an optional maximum conversion amount,
+and optimized to suit the goals of the selected objective function.
 All calculations are indexed for inflation, which is either provided as a fixed rate,
 or through historical values, as are all other rates used for the calculations.
 These rates can be used for backtesting different scenarios by choosing
@@ -842,29 +839,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.
 
-Federal income tax, Medicare part B premiums, and IRMAA calculations are part of the optimization.
+Medicare and IRMAA calculations are performed through a self-consistent loop on cash flow constraints.
 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 always performed and calculated,
-but tables for spouses more than 10 years apart are not included.
+- Required minimum distributions are calculated, but tables for spouses more than 10 years apart are not included.
 These cases are detected and will generate an error message.
 - 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 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.
+- 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.
 - 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.
-- 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.
+- Future tax brackets are pure speculations derived from the little we know now and projected to the next 30 years.
+Your guesses are as good as mine.
 
 The solution from an optimization algorithm has only two states: feasible and infeasible.
 Therefore, unlike event-driven simulators that can tell you that your distribution strategy runs
@@ -877,8 +874,7 @@ 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).
 
@@ -895,7 +891,7 @@ assets to support, even with no estate being left.
 
 ---------------------------------------------------------------------
 
-Copyright © 2025 - Martin-D. Lacasse
+Copyright © 2024 - 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.28.dist-info → owlplanner-2025.5.2.dist-info}/RECORD

@@ -1,17 +1,17 @@
 owlplanner/__init__.py,sha256=QqrdT0Qks20osBTg7h0vJHAxpP9lL7DA99xb0nYbtw4,254
-owlplanner/abcapi.py,sha256=xf5233Ph952y7O-m1vc0WmbTz3RlQtDemfqD40edlZ4,6710
+owlplanner/abcapi.py,sha256=Lt8OUgbrfOPzAw0HyxyT2wT-IXI3d9Zo26MwyqdX56Y,6617
 owlplanner/config.py,sha256=F6GS3n02VeFX0GCVeM4J7Ra0in4N632W6TZIXk7Yj2w,12519
 owlplanner/logging.py,sha256=tYMw04O-XYSzjTj36fmKJGLcE1VkK6k6oJNeqtKXzuc,2530
-owlplanner/plan.py,sha256=_9MQWUEcElLbdZ-J0DqmcMim3Q9KrVmUpFPHtSiatZA,118775
+owlplanner/plan.py,sha256=MiKPvyLE6GQCIz4OgmsMCXsAJEEBfGOyjahGtHVvz9U,119073
 owlplanner/progress.py,sha256=8jlCvvtgDI89zXVNMBg1-lnEyhpPvKQS2X5oAIpoOVQ,384
 owlplanner/rates.py,sha256=gJaoe-gJqWCQV5qVLlHp-Yn9TSJs-PJzeTbOwMCbqWs,15682
-owlplanner/tax2025.py,sha256=yxpFhETe2fmo1qosKSrIX81z4fMMu4VcKSBd-ePSrTw,8913
+owlplanner/tax2025.py,sha256=JDBtFFAf2bWtKUMuE3W5F0nBhYaKBjmdJj0iayM2iGA,7829
 owlplanner/timelists.py,sha256=tYieZU67FT6TCcQQis36JaXGI7dT6NqD7RvdEjgJL4M,4026
 owlplanner/utils.py,sha256=WpJgn79YZfH8UCkcmhd-AZlxlGuz1i1-UDBRXImsY6I,2485
-owlplanner/version.py,sha256=vGljB4UJ5r4pxBlvSDiQ77nNw16bav9YeZM-RB6mrPo,28
+owlplanner/version.py,sha256=UedHid5K_TIr2csXNt34h9ScX8Qk40-BCQcUtqPIwG0,28
 owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
-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,,
+owlplanner-2025.5.2.dist-info/METADATA,sha256=WBjjlcC7pqqncmR2fN4oE6urUT6nLH042AwKwMix2oA,53926
+owlplanner-2025.5.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.5.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.5.2.dist-info/RECORD,,