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

owlplanner/plan.py

@@ -22,7 +22,6 @@ from functools import wraps
 from openpyxl import Workbook
 from openpyxl.utils.dataframe import dataframe_to_rows
 import time
-import io
 
 from owlplanner import utils as u
 from owlplanner import tax2025 as tx
@@ -32,6 +31,7 @@ from owlplanner import config
 from owlplanner import timelists
 from owlplanner import logging
 from owlplanner import progress
+from owlplanner import plots
 
 
 # This makes all graphs to have the same height.
@@ -248,10 +248,14 @@ class Plan(object):
         self.defaultSolver = "HiGHS"
 
         self.N_i = len(yobs)
-        assert 0 < self.N_i and self.N_i <= 2, f"Cannot support {self.N_i} individuals."
-        assert self.N_i == len(expectancy), f"Expectancy must have {self.N_i} entries."
-        assert self.N_i == len(inames), f"Names for individuals must have {self.N_i} entries."
-        assert inames[0] != "" or (self.N_i == 2 and inames[1] == ""), "Name for each individual must be provided."
+        if not (0 <= self.N_i <= 2):
+            raise ValueError(f"Cannot support {self.N_i} individuals.")
+        if self.N_i != len(expectancy):
+            raise ValueError(f"Expectancy must have {self.N_i} entries.")
+        if self.N_i != len(inames):
+            raise ValueError(f"Names for individuals must have {self.N_i} entries.")
+        if inames[0] == "" or (self.N_i == 2 and inames[1] == ""):
+            raise ValueError("Name for each individual must be provided.")
 
         self.filingStatus = ["single", "married"][self.N_i - 1]
         # Default year TCJA is speculated to expire.
@@ -263,10 +267,9 @@ class Plan(object):
         # Reference time is starting date in the current year and all passings are assumed at the end.
         thisyear = date.today().year
         self.horizons = self.yobs + self.expectancy - thisyear + 1
-        # self.horizons = [yobs[i] + expectancy[i] - thisyear + 1 for i in range(self.N_i)]
         self.N_n = np.max(self.horizons)
         self.year_n = np.linspace(thisyear, thisyear + self.N_n - 1, self.N_n, dtype=np.int32)
-        # Year in the plan (if any) where individuals turn 59. For 10% withdrawal penalty.
+        # Year index in the plan (if any) where individuals turn 59. For 10% withdrawal penalty.
         self.n59 = 59 - thisyear + self.yobs
         self.n59[self.n59 < 0] = 0
         # Handle passing of one spouse before the other.
@@ -377,7 +380,7 @@ class Plan(object):
             refdate = date.today()
             self.startDate = refdate.strftime("%Y-%m-%d")
         else:
-            mydatelist = mydate.split("-")
+            mydatelist = mydate.replace("/", "-").split("-")
             if len(mydatelist) == 2 or len(mydatelist) == 3:
                 self.startDate = mydate
                 # Ignore the year provided.
@@ -433,7 +436,8 @@ class Plan(object):
         where s_n is the surplus amount. Here d_0n is the taxable account
         deposit for the first spouse while d_1n is for the second spouse.
         """
-        assert 0 <= eta and eta <= 1, "Fraction must be between 0 and 1."
+        if not (0 <= eta <= 1):
+            raise ValueError("Fraction must be between 0 and 1.")
         if self.N_i != 2:
             self.mylog.vprint("Deposit fraction can only be 0 for single individuals.")
             eta = 0
@@ -452,11 +456,12 @@ class Plan(object):
 
     def setDividendRate(self, mu):
         """
-        Set dividend rate on equities. Rate is in percent. Default 2%.
+        Set dividend tax rate. Rate is in percent. Default 2%.
         """
-        assert 0 <= mu and mu <= 100, "Rate must be between 0 and 100."
+        if not (0 <= mu <= 100):
+            raise ValueError("Rate must be between 0 and 100.")
         mu /= 100
-        self.mylog.vprint(f"Dividend return rate on equities set to {u.pc(mu, f=1)}.")
+        self.mylog.vprint(f"Dividend tax rate set to {u.pc(mu, f=0)}.")
         self.mu = mu
         self.caseStatus = "modified"
 
@@ -473,7 +478,8 @@ class Plan(object):
         """
         Set long-term income tax rate. Rate is in percent. Default 15%.
         """
-        assert 0 <= psi and psi <= 100, "Rate must be between 0 and 100."
+        if not (0 <= psi <= 100):
+            raise ValueError("Rate must be between 0 and 100.")
         psi /= 100
         self.mylog.vprint(f"Long-term capital gain income tax set to {u.pc(psi, f=0)}.")
         self.psi = psi
@@ -484,10 +490,11 @@ class Plan(object):
         Set fractions of savings accounts that is left to surviving spouse.
         Default is [1, 1, 1] for taxable, tax-deferred, adn tax-exempt accounts.
         """
-        assert len(phi) == self.N_j, f"Fractions must have {self.N_j} entries."
+        if len(phi) != self.N_j:
+            raise ValueError(f"Fractions must have {self.N_j} entries.")
         for j in range(self.N_j):
-            assert 0 <= phi[j] <= 1, "Fractions must be between 0 and 1."
-
+            if not (0 <= phi[j] <= 1):
+                raise ValueError("Fractions must be between 0 and 1.")
         self.phi_j = np.array(phi, dtype=np.float32)
         self.mylog.vprint("Spousal beneficiary fractions set to",
                           ["{:.2f}".format(self.phi_j[j]) for j in range(self.N_j)])
@@ -502,20 +509,24 @@ class Plan(object):
         Set the heirs tax rate on the tax-deferred portion of the estate.
         Rate is in percent. Default is 30%.
         """
-        assert 0 <= nu and nu <= 100, "Rate must be between 0 and 100."
+        if not (0 <= nu <= 100):
+            raise ValueError("Rate must be between 0 and 100.")
         nu /= 100
         self.mylog.vprint(f"Heirs tax rate on tax-deferred portion of estate set to {u.pc(nu, f=0)}.")
         self.nu = nu
         self.caseStatus = "modified"
 
-    def setPension(self, amounts, ages, indexed=[False, False], units="k"):
+    def setPension(self, amounts, ages, indexed=(False, False), units="k"):
         """
         Set value of pension for each individual and commencement age.
         Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
-        assert len(amounts) == self.N_i, f"Amounts must have {self.N_i} entries."
-        assert len(ages) == self.N_i, f"Ages must have {self.N_i} entries."
-        assert len(indexed) >= self.N_i, f"Indexed list must have at least {self.N_i} entries."
+        if len(amounts) != self.N_i:
+            raise ValueError(f"Amounts must have {self.N_i} entries.")
+        if len(ages) != self.N_i:
+            raise ValueError(f"Ages must have {self.N_i} entries.")
+        if len(indexed) < self.N_i:
+            raise ValueError(f"Indexed list must have at least {self.N_i} entries.")
 
         fac = u.getUnits(units)
         amounts = u.rescale(amounts, fac)
@@ -546,8 +557,10 @@ class Plan(object):
         Set value of social security for each individual and commencement age.
         Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
-        assert len(amounts) == self.N_i, f"Amounts must have {self.N_i} entries."
-        assert len(ages) == self.N_i, f"Ages must have {self.N_i} entries."
+        if len(amounts) != self.N_i:
+            raise ValueError(f"Amounts must have {self.N_i} entries.")
+        if len(ages) != self.N_i:
+            raise ValueError(f"Ages must have {self.N_i} entries.")
 
         fac = u.getUnits(units)
         amounts = u.rescale(amounts, fac)
@@ -582,10 +595,14 @@ class Plan(object):
         as a second argument. Default value is 60%.
         Dip and increase are percent changes in the smile profile.
         """
-        assert 0 <= percent and percent <= 100, f"Survivor value {percent} outside range."
-        assert 0 <= dip and dip <= 100, f"Dip value {dip} outside range."
-        assert -100 <= increase and increase <= 100, f"Increase value {increase} outside range."
-        assert 0 <= delay and delay <= self.N_n - 2, f"Delay value {delay} outside year range."
+        if not (0 <= percent <= 100):
+            raise ValueError(f"Survivor value {percent} outside range.")
+        if not (0 <= dip <= 100):
+            raise ValueError(f"Dip value {dip} outside range.")
+        if not (-100 <= increase <= 100):
+            raise ValueError(f"Increase value {increase} outside range.")
+        if not (0 <= delay <= self.N_n - 2):
+            raise ValueError(f"Delay value {delay} outside year range.")
 
         self.chi = percent / 100
 
@@ -676,7 +693,8 @@ class Plan(object):
             raise RuntimeError("A rate method needs to be first selected using setRates(...).")
 
         thisyear = date.today().year
-        assert year > thisyear, "Internal error in forwardValue()."
+        if year <= thisyear:
+            raise RuntimeError("Internal error in forwardValue().")
         span = year - thisyear
 
         return amount * self.gamma_n[span]
@@ -688,9 +706,12 @@ class Plan(object):
         one entry. Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
         plurals = ["", "y", "ies"][self.N_i]
-        assert len(taxable) == self.N_i, f"taxable must have {self.N_i} entr{plurals}."
-        assert len(taxDeferred) == self.N_i, f"taxDeferred must have {self.N_i} entr{plurals}."
-        assert len(taxFree) == self.N_i, f"taxFree must have {self.N_i} entr{plurals}."
+        if len(taxable) != self.N_i:
+            raise ValueError(f"taxable must have {self.N_i} entr{plurals}.")
+        if len(taxDeferred) != self.N_i:
+            raise ValueError(f"taxDeferred must have {self.N_i} entr{plurals}.")
+        if len(taxFree) != self.N_i:
+            raise ValueError(f"taxFree must have {self.N_i} entr{plurals}.")
 
         fac = u.getUnits(units)
         taxable = u.rescale(taxable, fac)
@@ -766,13 +787,17 @@ class Plan(object):
         if allocType == "account":
             # Make sure we have proper input.
             for item in [taxable, taxDeferred, taxFree]:
-                assert len(item) == self.N_i, f"{item} must have one entry per individual."
+                if len(item) != self.N_i:
+                    raise ValueError(f"{item} must have one entry per individual.")
                 for i in range(self.N_i):
                     # Initial and final.
-                    assert len(item[i]) == 2, f"{item}[{i}] must have 2 lists (initial and final)."
+                    if len(item[i]) != 2:
+                        raise ValueError(f"{item}[{i}] must have 2 lists (initial and final).")
                     for z in range(2):
-                        assert len(item[i][z]) == self.N_k, f"{item}[{i}][{z}] must have {self.N_k} entries."
-                        assert abs(sum(item[i][z]) - 100) < 0.01, "Sum of percentages must add to 100."
+                        if len(item[i][z]) != self.N_k:
+                            raise ValueError(f"{item}[{i}][{z}] must have {self.N_k} entries.")
+                        if abs(sum(item[i][z]) - 100) > 0.01:
+                            raise ValueError("Sum of percentages must add to 100.")
 
             for i in range(self.N_i):
                 self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
@@ -799,13 +824,17 @@ class Plan(object):
             self.boundsAR["tax-free"] = taxFree
 
         elif allocType == "individual":
-            assert len(generic) == self.N_i, "generic must have one list per individual."
+            if len(generic) != self.N_i:
+                raise ValueError("generic must have one list per individual.")
             for i in range(self.N_i):
                 # Initial and final.
-                assert len(generic[i]) == 2, f"generic[{i}] must have 2 lists (initial and final)."
+                if len(generic[i]) != 2:
+                    raise ValueError(f"generic[{i}] must have 2 lists (initial and final).")
                 for z in range(2):
-                    assert len(generic[i][z]) == self.N_k, f"generic[{i}][{z}] must have {self.N_k} entries."
-                    assert abs(sum(generic[i][z]) - 100) < 0.01, "Sum of percentages must add to 100."
+                    if len(generic[i][z]) != self.N_k:
+                        raise ValueError(f"generic[{i}][{z}] must have {self.N_k} entries.")
+                    if abs(sum(generic[i][z]) - 100) > 0.01:
+                        raise ValueError("Sum of percentages must add to 100.")
 
             for i in range(self.N_i):
                 self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
@@ -817,30 +846,26 @@ class Plan(object):
                     start = generic[i][0][k] / 100
                     end = generic[i][1][k] / 100
                     dat = self._interpolator(start, end, Nin)
-                    for j in range(self.N_j):
-                        self.alpha_ijkn[i, j, k, :Nin] = dat[:]
+                    self.alpha_ijkn[i, :, k, :Nin] = dat[:]
 
             self.boundsAR["generic"] = generic
 
         elif allocType == "spouses":
-            assert len(generic) == 2, "generic must have 2 entries (initial and final)."
+            if len(generic) != 2:
+                raise ValueError("generic must have 2 entries (initial and final).")
             for z in range(2):
-                assert len(generic[z]) == self.N_k, f"generic[{z}] must have {self.N_k} entries."
-                assert abs(sum(generic[z]) - 100) < 0.01, "Sum of percentages must add to 100."
-
-            self.mylog.vprint(f"Setting gliding allocation ratios (%) to {allocType}.")
-            self.mylog.vprint(f"\t{generic[0]} -> {generic[1]}")
-
-            # Use longest-lived spouse for both time scales.
-            Nxn = max(self.horizons) + 1
+                if len(generic[z]) != self.N_k:
+                    raise ValueError(f"generic[{z}] must have {self.N_k} entries.")
+                if abs(sum(generic[z]) - 100) > 0.01:
+                    raise ValueError("Sum of percentages must add to 100.")
 
-            for k in range(self.N_k):
-                start = generic[0][k] / 100
-                end = generic[1][k] / 100
-                dat = self._interpolator(start, end, Nxn)
-                for i in range(self.N_i):
-                    for j in range(self.N_j):
-                        self.alpha_ijkn[i, j, k, :Nxn] = dat[:]
+            for i in range(self.N_i):
+                Nin = self.horizons[i] + 1
+                for k in range(self.N_k):
+                    start = generic[0][k] / 100
+                    end = generic[1][k] / 100
+                    dat = self._interpolator(start, end, Nin)
+                    self.alpha_ijkn[i, :, k, :Nin] = dat[:]
 
             self.boundsAR["generic"] = generic
 
@@ -873,8 +898,7 @@ class Plan(object):
         try:
             filename, self.timeLists = timelists.read(filename, self.inames, self.horizons, self.mylog)
         except Exception as e:
-            raise Exception(f"Unsuccessful read of contributions: {e}")
-            return False
+            raise Exception(f"Unsuccessful read of contributions: {e}") from e
 
         self.timeListsFileName = filename
         self.setContributions()
@@ -971,9 +995,7 @@ class Plan(object):
         a linear interpolation.
         """
         # num goes one more year as endpoint=True.
-        dat = np.linspace(a, b, numPoints)
-
-        return dat
+        return np.linspace(a, b, numPoints)
 
     def _tanhInterp(self, a, b, numPoints):
         """
@@ -1051,259 +1073,217 @@ class Plan(object):
     def _buildConstraints(self, objective, options):
         """
         Utility function that builds constraint matrix and vectors.
-        Refer to companion document for notation and detailed explanations.
-        """
-        # Bounds values.
-        zero = 0
-        inf = np.inf
+        Refactored for clarity and maintainability.
+        """
+        self._setup_constraint_shortcuts(options)
+
+        self.A = abc.ConstraintMatrix(self.nvars)
+        self.B = abc.Bounds(self.nvars, self.nbins)
+
+        self._add_rmd_inequalities()
+        self._add_tax_bracket_bounds()
+        self._add_standard_exemption_bounds()
+        self._add_defunct_constraints()
+        self._add_roth_conversion_constraints(options)
+        self._add_withdrawal_limits()
+        self._add_conversion_limits()
+        self._add_objective_constraints(objective, options)
+        self._add_initial_balances()
+        self._add_surplus_deposit_linking()
+        self._add_account_balance_carryover()
+        self._add_net_cash_flow()
+        self._add_income_profile()
+        self._add_taxable_income()
+        self._configure_binary_variables(options)
+        self._build_objective_vector(objective)
 
-        # Simplified notation.
-        Ni = self.N_i
-        Nj = self.N_j
-        Nk = self.N_k
-        Nn = self.N_n
-        Nt = self.N_t
-        Nz = self.N_z
-        i_d = self.i_d
-        i_s = self.i_s
-        n_d = self.n_d
-
-        Cb = self.C["b"]
-        Cd = self.C["d"]
-        Ce = self.C["e"]
-        CF = self.C["F"]
-        Cg = self.C["g"]
-        Cs = self.C["s"]
-        Cw = self.C["w"]
-        Cx = self.C["x"]
-        Cz = self.C["z"]
-
-        spLo = 1 - self.lambdha
-        spHi = 1 + self.lambdha
+        return None
 
+    def _setup_constraint_shortcuts(self, options):
+        # Set up all the local variables as attributes for use in helpers
         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):
-                for n in range(Nn):
-                    tau_ijn[i, j, n] = np.sum(self.alpha_ijkn[i, j, :, n] * self.tau_kn[:, n], axis=0)
-
-        # Weights are normalized on k: sum_k[alpha*(1 + tau)] = 1 + sum_k(alpha*tau).
-        Tau1_ijn = 1 + tau_ijn
-        Tauh_ijn = 1 + tau_ijn / 2
+        self.xnet = 1 - oppCostX / 100.
+        self.optionsUnits = u.getUnits(options.get("units", "k"))
 
-        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, self.nbins)
-
-        # RMDs inequalities, only if there is an initial balance in tax-deferred account.
-        for i in range(Ni):
+    def _add_rmd_inequalities(self):
+        for i in range(self.N_i):
             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],
+                        _q3(self.C["w"], i, 1, n, self.N_i, self.N_j, self.N_n): 1,
+                        _q3(self.C["b"], i, 1, n, self.N_i, self.N_j, self.N_n + 1): -self.rho_in[i, n],
                     }
-                    A.addNewRow(rowDic, zero, inf)
+                    self.A.addNewRow(rowDic, 0, np.inf)
 
-        # Income tax bracket range inequalities.
-        for t in range(Nt):
-            for n in range(Nn):
-                B.setRange(_q2(CF, t, n, Nt, Nn), zero, self.DeltaBar_tn[t, n])
+    def _add_tax_bracket_bounds(self):
+        for t in range(self.N_t):
+            for n in range(self.N_n):
+                self.B.setRange(_q2(self.C["F"], t, n, self.N_t, self.N_n), 0, self.DeltaBar_tn[t, n])
 
-        # Standard exemption range inequalities.
-        for n in range(Nn):
-            B.setRange(_q1(Ce, n, Nn), zero, self.sigmaBar_n[n])
+    def _add_standard_exemption_bounds(self):
+        for n in range(self.N_n):
+            self.B.setRange(_q1(self.C["e"], n, self.N_n), 0, self.sigmaBar_n[n])
 
-        # Start with no activities after passing.
-        for i in range(Ni):
-            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.setRange(_q3(Cw, i, j, n, Ni, Nj, Nn), zero, zero)
-
-        # Roth conversions equalities/inequalities.
-        # This condition supercedes everything else.
+    def _add_defunct_constraints(self):
+        if self.N_i == 2:
+            for n in range(self.n_d, self.N_n):
+                self.B.setRange(_q2(self.C["d"], self.i_d, n, self.N_i, self.N_n), 0, 0)
+                self.B.setRange(_q2(self.C["x"], self.i_d, n, self.N_i, self.N_n), 0, 0)
+                for j in range(self.N_j):
+                    self.B.setRange(_q3(self.C["w"], self.i_d, j, n, self.N_i, self.N_j, self.N_n), 0, 0)
+
+    def _add_roth_conversion_constraints(self, options):
         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):
+            for i in range(self.N_i):
                 for n in range(self.horizons[i]):
                     rhs = self.myRothX_in[i][n]
-                    B.setRange(_q2(Cx, i, n, Ni, Nn), rhs, rhs)
+                    self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), rhs, rhs)
         else:
             if "maxRothConversion" in options:
                 rhsopt = options["maxRothConversion"]
-                assert isinstance(rhsopt, (int, float)), "Specified maxRothConversion is not a number."
-                rhsopt *= units
-                if rhsopt < 0:
-                    # self.mylog.vprint('Unlimited Roth conversions (<0)')
-                    pass
-                else:
-                    # self.mylog.vprint('Limiting Roth conversions to:', u.d(rhsopt))
-                    for i in range(Ni):
+                if not isinstance(rhsopt, (int, float)):
+                    raise ValueError(f"Specified maxRothConversion {rhsopt} is not a number.")
+
+                if rhsopt >= 0:
+                    rhsopt *= self.optionsUnits
+                    for i in range(self.N_i):
                         for n in range(self.horizons[i]):
-                            # 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)
+                            self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), 0, rhsopt + 0.01)
 
-            # Process startRothConversions option.
             if "startRothConversions" in options:
                 rhsopt = options["startRothConversions"]
-                assert isinstance(rhsopt, (int, float)), "Specified startRothConversions is not a number."
+                if not isinstance(rhsopt, (int, float)):
+                    raise ValueError(f"Specified startRothConversions {rhsopt} is not a number.")
                 thisyear = date.today().year
                 yearn = max(rhsopt - thisyear, 0)
-
-                for i in range(Ni):
+                for i in range(self.N_i):
                     nstart = min(yearn, self.horizons[i])
                     for n in range(0, nstart):
-                        B.setRange(_q2(Cx, i, n, Ni, Nn), zero, zero)
+                        self.B.setRange(_q2(self.C["x"], i, n, self.N_i, self.N_n), 0, 0)
 
-            # Process noRothConversions option. Also valid when N_i == 1, why not?
             if "noRothConversions" in options and options["noRothConversions"] != "None":
                 rhsopt = options["noRothConversions"]
                 try:
                     i_x = self.inames.index(rhsopt)
-                except ValueError:
-                    raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:")
-
-                for n in range(Nn):
-                    B.setRange(_q2(Cx, i_x, n, Ni, Nn), zero, zero)
+                except ValueError as e:
+                    raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:") from e
+                for n in range(self.N_n):
+                    self.B.setRange(_q2(self.C["x"], i_x, n, self.N_i, self.N_n), 0, 0)
 
-        # Impose withdrawal limits on taxable and tax-exempt accounts.
-        for i in range(Ni):
+    def _add_withdrawal_limits(self):
+        for i in range(self.N_i):
             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)
+                for n in range(self.N_n):
+                    rowDic = {_q3(self.C["w"], i, j, n, self.N_i, self.N_j, self.N_n): -1,
+                              _q3(self.C["b"], i, j, n, self.N_i, self.N_j, self.N_n + 1): 1}
+                    self.A.addNewRow(rowDic, 0, np.inf)
 
-        # Impose withdrawals and conversion limits on tax-deferred account.
-        for i in range(Ni):
-            for n in range(Nn):
+    def _add_conversion_limits(self):
+        for i in range(self.N_i):
+            for n in range(self.N_n):
                 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,
+                    _q2(self.C["x"], i, n, self.N_i, self.N_n): -1,
+                    _q3(self.C["w"], i, 1, n, self.N_i, self.N_j, self.N_n): -1,
+                    _q3(self.C["b"], i, 1, n, self.N_i, self.N_j, self.N_n + 1): 1,
                 }
-                A.addNewRow(rowDic, zero, inf)
+                self.A.addNewRow(rowDic, 0, np.inf)
 
-        # Constraints depending on objective function.
+    def _add_objective_constraints(self, objective, options):
         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]
+                if not isinstance(bequest, (int, float)):
+                    raise ValueError(f"Desired bequest {bequest} is not a number.")
+                bequest *= self.optionsUnits * 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))
+            row = self.A.newRow()
+            for i in range(self.N_i):
+                row.addElem(_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
+                row.addElem(_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1 - self.nu)
+                row.addElem(_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
+            self.A.addRow(row, bequest, 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):
+            if not isinstance(spending, (int, float)):
+                raise ValueError(f"Desired spending provided {spending} is not a number.")
+            spending *= self.optionsUnits * self.yearFracLeft
+            self.B.setRange(_q1(self.C["g"], 0, self.N_n), spending, spending)
+
+    def _add_initial_balances(self):
+        for i in range(self.N_i):
+            for j in range(self.N_j):
                 rhs = self.beta_ij[i, j]
-                # 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)
+                self.B.setRange(_q3(self.C["b"], i, j, 0, self.N_i, self.N_j, self.N_n + 1), rhs, rhs)
 
-        # Link surplus and taxable account deposits regardless of Ni.
-        for i in range(Ni):
+    def _add_surplus_deposit_linking(self):
+        for i in range(self.N_i):
             fac1 = u.krond(i, 0) * (1 - self.eta) + u.krond(i, 1) * self.eta
-            for n in range(n_d):
-                rowDic = {_q2(Cd, i, n, Ni, Nn): 1, _q1(Cs, n, Nn): -fac1}
-                A.addNewRow(rowDic, zero, zero)
+            for n in range(self.n_d):
+                rowDic = {_q2(self.C["d"], i, n, self.N_i, self.N_n): 1, _q1(self.C["s"], n, self.N_n): -fac1}
+                self.A.addNewRow(rowDic, 0, 0)
             fac2 = u.krond(self.i_s, i)
-            for n in range(n_d, Nn):
-                rowDic = {_q2(Cd, i, n, Ni, Nn): 1, _q1(Cs, n, Nn): -fac2}
-                A.addNewRow(rowDic, zero, zero)
-
-        # No surplus allowed during the last year to be used as a tax loophole.
-        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.
-        # 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))
+            for n in range(self.n_d, self.N_n):
+                rowDic = {_q2(self.C["d"], i, n, self.N_i, self.N_n): 1, _q1(self.C["s"], n, self.N_n): -fac2}
+                self.A.addNewRow(rowDic, 0, 0)
+        # Prevent surplus on last year.
+        self.B.setRange(_q1(self.C["s"], self.N_n - 1, self.N_n), 0, 0)
+
+    def _add_account_balance_carryover(self):
+        tau_ijn = np.zeros((self.N_i, self.N_j, self.N_n))
+        for i in range(self.N_i):
+            for j in range(self.N_j):
+                for n in range(self.N_n):
+                    tau_ijn[i, j, n] = np.sum(self.alpha_ijkn[i, j, :, n] * self.tau_kn[:, n], axis=0)
+
+        # Weights are normalized on k: sum_k[alpha*(1 + tau)] = 1 + sum_k[alpha*tau]
+        Tau1_ijn = 1 + tau_ijn
+        Tauh_ijn = 1 + tau_ijn / 2
+
+        for i in range(self.N_i):
+            for j in range(self.N_j):
+                for n in range(self.N_n):
+                    if self.N_i == 2 and self.n_d < self.N_n and i == self.i_d and n == self.n_d - 1:
                         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 * 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 = self.A.newRow()
+                    row.addElem(_q3(self.C["b"], i, j, n + 1, self.N_i, self.N_j, self.N_n + 1), 1)
+                    row.addElem(_q3(self.C["b"], i, j, n, self.N_i, self.N_j, self.N_n + 1), -fac1 * Tau1_ijn[i, j, n])
+                    row.addElem(_q3(self.C["w"], i, j, n, self.N_i, self.N_j, self.N_n), fac1 * Tau1_ijn[i, j, n])
+                    row.addElem(_q2(self.C["d"], i, n, self.N_i, self.N_n), -fac1 * u.krond(j, 0) * Tau1_ijn[i, 0, n])
                     row.addElem(
-                        _q2(Cx, i, n, Ni, Nn),
-                        -fac1 * (xnet*u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i, j, n],
+                        _q2(self.C["x"], i, n, self.N_i, self.N_n),
+                        -fac1 * (self.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:
+                    if self.N_i == 2 and self.n_d < self.N_n and i == self.i_s and n == self.n_d - 1:
                         fac2 = self.phi_j[j]
-                        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])
+                        rhs += fac2 * self.kappa_ijn[self.i_d, j, n] * Tauh_ijn[self.i_d, j, n]
+                        row.addElem(_q3(self.C["b"], self.i_d, j, n, self.N_i, self.N_j, self.N_n + 1),
+                                    -fac2 * Tau1_ijn[self.i_d, j, n])
+                        row.addElem(_q3(self.C["w"], self.i_d, j, n, self.N_i, self.N_j, self.N_n),
+                                    fac2 * Tau1_ijn[self.i_d, j, n])
+                        row.addElem(_q2(self.C["d"], self.i_d, n, self.N_i, self.N_n),
+                                    -fac2 * u.krond(j, 0) * Tau1_ijn[self.i_d, 0, n])
                         row.addElem(
-                            _q2(Cx, i_d, n, Ni, Nn),
-                            -fac2 * (xnet*u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[i_d, j, n],
+                            _q2(self.C["x"], self.i_d, n, self.N_i, self.N_n),
+                            -fac2 * (self.xnet * u.krond(j, 2) - u.krond(j, 1)) * Tau1_ijn[self.i_d, j, n],
                         )
-                    A.addRow(row, rhs, rhs)
+                    self.A.addRow(row, rhs, rhs)
 
+    def _add_net_cash_flow(self):
         tau_0prev = np.roll(self.tau_kn[0, :], 1)
         tau_0prev[tau_0prev < 0] = 0
-
-        # Net cash flow.
-        for n in range(Nn):
+        for n in range(self.N_n):
             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):
+            row = self.A.newRow({_q1(self.C["g"], n, self.N_n): 1})
+            row.addElem(_q1(self.C["s"], n, self.N_n), 1)
+            for i in range(self.N_i):
                 fac = self.psi * self.alpha_ijkn[i, 0, 0, n]
                 rhs += (
                     self.omega_in[i, n]
@@ -1312,112 +1292,99 @@ class Plan(object):
                     + self.Lambda_in[i, n]
                     - 0.5 * fac * self.mu * self.kappa_ijn[i, 0, n]
                 )
-
-                row.addElem(_q3(Cb, i, 0, n, Ni, Nj, 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(self.C["b"], i, 0, n, self.N_i, self.N_j, self.N_n + 1), fac * self.mu)
+                row.addElem(_q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n), 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):
-                row.addElem(_q2(CF, t, n, Nt, Nn), self.theta_tn[t, n])
+                row.addElem(_q3(self.C["w"], i, 1, n, self.N_i, self.N_j, self.N_n), -1 + penalty)
+                row.addElem(_q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n), -1 + penalty)
+                row.addElem(_q2(self.C["d"], i, n, self.N_i, self.N_n), fac * self.mu)
 
-            A.addRow(row, rhs, rhs)
+            for t in range(self.N_t):
+                row.addElem(_q2(self.C["F"], t, n, self.N_t, self.N_n), self.theta_tn[t, n])
 
-        # 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, -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)
+            self.A.addRow(row, rhs, rhs)
 
-        # Taxable ordinary income.
-        for n in range(Nn):
+    def _add_income_profile(self):
+        spLo = 1 - self.lambdha
+        spHi = 1 + self.lambdha
+        for n in range(1, self.N_n):
+            rowDic = {_q1(self.C["g"], 0, self.N_n): spLo * self.xiBar_n[n],
+                      _q1(self.C["g"], n, self.N_n): -self.xiBar_n[0]}
+            self.A.addNewRow(rowDic, -np.inf, 0)
+            rowDic = {_q1(self.C["g"], 0, self.N_n): spHi * self.xiBar_n[n],
+                      _q1(self.C["g"], n, self.N_n): -self.xiBar_n[0]}
+            self.A.addNewRow(rowDic, 0, np.inf)
+
+    def _add_taxable_income(self):
+        for n in range(self.N_n):
             rhs = 0
-            row = A.newRow()
-            row.addElem(_q1(Ce, n, Nn), 1)
-            for i in range(Ni):
+            row = self.A.newRow()
+            row.addElem(_q1(self.C["e"], n, self.N_n), 1)
+            for i in range(self.N_i):
                 rhs += self.omega_in[i, n] + 0.85 * self.zetaBar_in[i, n] + self.piBar_in[i, n]
-                # Taxable income from tax-deferred withdrawals.
-                row.addElem(_q3(Cw, i, 1, n, Ni, Nj, Nn), -1)
-                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)
+                row.addElem(_q3(self.C["w"], i, 1, n, self.N_i, self.N_j, self.N_n), -1)
+                row.addElem(_q2(self.C["x"], i, n, self.N_i, self.N_n), -1)
+                fak = np.sum(self.tau_kn[1:self.N_k, n] * self.alpha_ijkn[i, 0, 1:self.N_k, 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)
+                row.addElem(_q3(self.C["b"], i, 0, n, self.N_i, self.N_j, self.N_n + 1), -fak)
+                row.addElem(_q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n), fak)
+                row.addElem(_q2(self.C["d"], i, n, self.N_i, self.N_n), -fak)
+            for t in range(self.N_t):
+                row.addElem(_q2(self.C["F"], t, n, self.N_t, self.N_n), 1)
+            self.A.addRow(row, rhs, rhs)
+
+    def _configure_binary_variables(self, options):
+        bigM = options.get("bigM", 5e6)
+        if not isinstance(bigM, (int, float)):
+            raise ValueError(f"bigM {bigM} is not a number.")
 
-        # Configure binary variables.
-        for i in range(Ni):
+        for i in range(self.N_i):
             for n in range(self.horizons[i]):
-                # 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(Cz, i, n, 0, Ni, Nn, Nz): bigM, _q1(Cs, n, Nn): -1},
-                    zero,
+                self.A.addNewRow(
+                    {_q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z): bigM,
+                     _q1(self.C["s"], n, self.N_n): -1},
+                    0,
                     bigM,
                 )
-
-                A.addNewRow(
+                self.A.addNewRow(
                     {
-                        _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,
+                        _q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z): bigM,
+                        _q3(self.C["w"], i, 0, n, self.N_i, self.N_j, self.N_n): 1,
+                        _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1,
                     },
-                    zero,
+                    0,
                     bigM,
                 )
-
-                # 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},
-                    zero,
+                self.A.addNewRow(
+                    {_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z): bigM,
+                     _q2(self.C["x"], i, n, self.N_i, self.N_n): -1},
+                    0,
                     bigM,
                 )
-
-                A.addNewRow(
-                    {_q3(Cz, i, n, 1, Ni, Nn, Nz): bigM, _q3(Cw, i, 2, n, Ni, Nj, Nn): 1},
-                    zero,
+                self.A.addNewRow(
+                    {_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z): bigM,
+                     _q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n): 1},
+                    0,
                     bigM,
                 )
+            for n in range(self.horizons[i], self.N_n):
+                self.B.setRange(_q3(self.C["z"], i, n, 0, self.N_i, self.N_n, self.N_z), 0, 0)
+                self.B.setRange(_q3(self.C["z"], i, n, 1, self.N_i, self.N_n, self.N_z), 0, 0)
 
-            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.
+    def _build_objective_vector(self, objective):
         c = abc.Objective(self.nvars)
         if objective == "maxSpending":
-            # c.setElem(_q1(Cg, 0, Nn), -1) # Only OK in implemention without slack.
-            for n in range(Nn):
-                c.setElem(_q1(Cg, n, Nn), -1/self.gamma_n[n])
+            for n in range(self.N_n):
+                c.setElem(_q1(self.C["g"], n, self.N_n), -1/self.gamma_n[n])
         elif objective == "maxBequest":
-            for i in range(Ni):
-                c.setElem(_q3(Cb, i, 0, Nn, Ni, Nj, Nn + 1), -1)
-                c.setElem(_q3(Cb, i, 1, Nn, Ni, Nj, Nn + 1), -(1 - self.nu))
-                c.setElem(_q3(Cb, i, 2, Nn, Ni, Nj, Nn + 1), -1)
+            for i in range(self.N_i):
+                c.setElem(_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1), -1)
+                c.setElem(_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1), -(1 - self.nu))
+                c.setElem(_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1), -1)
         else:
             raise RuntimeError("Internal error in objective function.")
-
-        self.A = A
-        self.B = B
         self.c = c
 
-        return None
-
     @_timer
     def runHistoricalRange(self, objective, options, ystart, yend, *, verbose=False, figure=False, progcall=None):
         """
@@ -1461,10 +1428,11 @@ class Plan(object):
 
         progcall.finish()
         self.mylog.resetVerbose()
-        fig, description = self._showResults(objective, df, N, figure)
-        self.mylog.print(description.getvalue())
 
         if figure:
+            fig, description = plots.show_histogram_results(objective, df, N, self.year_n,
+                                                            self.n_d, self.N_i, self.phi_j)
+            self.mylog.print(description.getvalue())
             return fig, description.getvalue()
 
         return N, df
@@ -1517,98 +1485,15 @@ class Plan(object):
 
         progcall.finish()
         self.mylog.resetVerbose()
-        fig, description = self._showResults(objective, df, N, figure)
-        self.mylog.print(description.getvalue())
 
         if figure:
+            fig, description = plots.show_histogram_results(objective, df, N, self.year_n,
+                                                            self.n_d, self.N_i, self.phi_j)
+            self.mylog.print(description.getvalue())
             return fig, description.getvalue()
 
         return N, df
 
-    def _showResults(self, objective, df, N, figure):
-        """
-        Show a histogram of values from runMC() and runHistoricalRange().
-        """
-        import seaborn as sbn
-
-        description = io.StringIO()
-
-        pSuccess = u.pc(len(df) / N)
-        print(f"Success rate: {pSuccess} on {N} samples.", file=description)
-        title = f"$N$ = {N}, $P$ = {pSuccess}"
-        means = df.mean(axis=0, numeric_only=True)
-        medians = df.median(axis=0, numeric_only=True)
-
-        my = 2 * [self.year_n[-1]]
-        if self.N_i == 2 and self.n_d < self.N_n:
-            my[0] = self.year_n[self.n_d - 1]
-
-        # Don't show partial bequest of zero if spouse is full beneficiary,
-        # or if solution led to empty accounts at the end of first spouse's life.
-        if np.all(self.phi_j == 1) or medians.iloc[0] < 1:
-            if medians.iloc[0] < 1:
-                print(f"Optimized solutions all have null partial bequest in year {my[0]}.", file=description)
-            df.drop("partial", axis=1, inplace=True)
-            means = df.mean(axis=0, numeric_only=True)
-            medians = df.median(axis=0, numeric_only=True)
-
-        df /= 1000
-        if len(df) > 0:
-            thisyear = self.year_n[0]
-            if objective == "maxBequest":
-                fig, axes = plt.subplots()
-                # Show both partial and final bequests in the same histogram.
-                sbn.histplot(df, multiple="dodge", kde=True, ax=axes)
-                legend = []
-                # Don't know why but legend is reversed from df.
-                for q in range(len(means) - 1, -1, -1):
-                    dmedian = u.d(medians.iloc[q], latex=True)
-                    dmean = u.d(means.iloc[q], latex=True)
-                    legend.append(f"{my[q]}: $M$: {dmedian}, $\\bar{{x}}$: {dmean}")
-                plt.legend(legend, shadow=True)
-                plt.xlabel(f"{thisyear} $k")
-                plt.title(objective)
-                leads = [f"partial {my[0]}", f"  final {my[1]}"]
-            elif len(means) == 2:
-                # Show partial bequest and net spending as two separate histograms.
-                fig, axes = plt.subplots(1, 2, figsize=(10, 5))
-                cols = ["partial", objective]
-                leads = [f"partial {my[0]}", objective]
-                for q in range(2):
-                    sbn.histplot(df[cols[q]], kde=True, ax=axes[q])
-                    dmedian = u.d(medians.iloc[q], latex=True)
-                    dmean = u.d(means.iloc[q], latex=True)
-                    legend = [f"$M$: {dmedian}, $\\bar{{x}}$: {dmean}"]
-                    axes[q].set_label(legend)
-                    axes[q].legend(labels=legend)
-                    axes[q].set_title(leads[q])
-                    axes[q].set_xlabel(f"{thisyear} $k")
-            else:
-                # Show net spending as single histogram.
-                fig, axes = plt.subplots()
-                sbn.histplot(df[objective], kde=True, ax=axes)
-                dmedian = u.d(medians.iloc[0], latex=True)
-                dmean = u.d(means.iloc[0], latex=True)
-                legend = [f"$M$: {dmedian}, $\\bar{{x}}$: {dmean}"]
-                plt.legend(legend, shadow=True)
-                plt.xlabel(f"{thisyear} $k")
-                plt.title(objective)
-                leads = [objective]
-
-            plt.suptitle(title)
-            # plt.show()
-
-        for q in range(len(means)):
-            print(f"{leads[q]:>12}: Median ({thisyear} $): {u.d(medians.iloc[q])}", file=description)
-            print(f"{leads[q]:>12}:   Mean ({thisyear} $): {u.d(means.iloc[q])}", file=description)
-            mmin = 1000 * df.iloc[:, q].min()
-            mmax = 1000 * df.iloc[:, q].max()
-            print(f"{leads[q]:>12}:           Range: {u.d(mmin)} - {u.d(mmax)}", file=description)
-            nzeros = len(df.iloc[:, q][df.iloc[:, q] < 0.001])
-            print(f"{leads[q]:>12}:    N zero solns: {nzeros}", file=description)
-
-        return fig, description
-
     def resolve(self):
         """
         Solve a plan using saved options.
@@ -1619,7 +1504,7 @@ class Plan(object):
 
     @_checkConfiguration
     @_timer
-    def solve(self, objective, options={}):
+    def solve(self, objective, options=None):
         """
         This function builds the necessary constaints and
         runs the optimizer.
@@ -1661,6 +1546,7 @@ class Plan(object):
             "oppCostX",
         ]
         # We might modify options if required.
+        options = {} if options is None else options
         myoptions = dict(options)
 
         for opt in myoptions:
@@ -1765,6 +1651,7 @@ class Plan(object):
                 self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
                 break
 
+            it += 1
             old_solutions.append(-solution)
             old_x = xx
 
@@ -2259,56 +2146,15 @@ class Plan(object):
 
         A tag string can be set to add information to the title of the plot.
         """
-        import seaborn as sbn
-
         if self.rateMethod in [None, "user", "historical average", "conservative"]:
             self.mylog.vprint(f"Warning: Cannot plot correlations for {self.rateMethod} rate method.")
             return None
 
-        rateNames = [
-            "S&P500 (incl. div.)",
-            "Baa Corp. Bonds",
-            "10-y T-Notes",
-            "Inflation",
-        ]
-
-        df = pd.DataFrame()
-        for k, name in enumerate(rateNames):
-            data = 100 * self.tau_kn[k]
-            df[name] = data
-
-        g = sbn.PairGrid(df, diag_sharey=False, height=1.8, aspect=1)
-        if shareRange:
-            minval = df.min().min() - 5
-            maxval = df.max().max() + 5
-            g.set(xlim=(minval, maxval), ylim=(minval, maxval))
-        g.map_upper(sbn.scatterplot)
-        g.map_lower(sbn.kdeplot)
-        # g.map_diag(sbn.kdeplot)
-        g.map_diag(sbn.histplot, color="orange")
-
-        # Put zero axes on off-diagonal plots.
-        imod = len(rateNames) + 1
-        for i, ax in enumerate(g.axes.flat):
-            ax.axvline(x=0, color="grey", linewidth=1, linestyle=":")
-            if i % imod != 0:
-                ax.axhline(y=0, color="grey", linewidth=1, linestyle=":")
-        #    ax.tick_params(axis='both', labelleft=True, labelbottom=True)
-
-        # plt.subplots_adjust(wspace=0.3, hspace=0.3)
-
-        title = self._name + "\n"
-        title += f"Rates Correlations (N={self.N_n}) {self.rateMethod}"
-        if self.rateMethod in ["historical", "histochastic"]:
-            title += " (" + str(self.rateFrm) + "-" + str(self.rateTo) + ")"
-
-        if tag != "":
-            title += " - " + tag
-
-        g.fig.suptitle(title, y=1.08)
+        fig = plots.show_rates_correlations(self._name, self.tau_kn, self.N_n, self.rateMethod,
+                                            self.rateFrm, self.rateTo, tag, shareRange)
 
         if figure:
-            return g.fig
+            return fig
 
         plt.show()
         return None
@@ -2319,49 +2165,12 @@ class Plan(object):
 
         A tag string can be set to add information to the title of the plot.
         """
-        import matplotlib.ticker as tk
-
         if self.rateMethod is None:
             self.mylog.vprint("Warning: Rate method must be selected before plotting.")
             return None
 
-        fig, ax = plt.subplots(figsize=(6, 4))
-        plt.grid(visible="both")
-        title = self._name + "\nReturn & Inflation Rates (" + str(self.rateMethod)
-        if self.rateMethod in ["historical", "histochastic", "historical average"]:
-            title += " " + str(self.rateFrm) + "-" + str(self.rateTo)
-        title += ")"
-
-        if tag != "":
-            title += " - " + tag
-
-        rateName = [
-            "S&P500 (incl. div.)",
-            "Baa Corp. Bonds",
-            "10-y T-Notes",
-            "Inflation",
-        ]
-        ltype = ["-", "-.", ":", "--"]
-        for k in range(self.N_k):
-            if self.yearFracLeft == 1:
-                data = 100 * self.tau_kn[k]
-                years = self.year_n
-            else:
-                data = 100 * self.tau_kn[k, 1:]
-                years = self.year_n[1:]
-
-            # Use ddof=1 to match pandas.
-            label = (
-                rateName[k] + " <" + "{:.1f}".format(np.mean(data)) + " +/- {:.1f}".format(np.std(data, ddof=1)) + "%>"
-            )
-            ax.plot(years, data, label=label, ls=ltype[k % self.N_k])
-
-        ax.xaxis.set_major_locator(tk.MaxNLocator(integer=True))
-        ax.legend(loc="best", reverse=False, fontsize=8, framealpha=0.7)
-        # ax.legend(loc='upper left')
-        ax.set_title(title)
-        ax.set_xlabel("year")
-        ax.set_ylabel("%")
+        fig = plots.show_rates(self._name, self.tau_kn, self.year_n, self.yearFracLeft,
+                               self.N_k, self.rateMethod, self.rateFrm, self.rateTo, tag)
 
         if figure:
             return fig
@@ -2383,10 +2192,9 @@ class Plan(object):
         if tag != "":
             title += " - " + tag
 
-        # style = {'net': '-', 'target': ':'}
         style = {"profile": "-"}
         series = {"profile": self.xi_n}
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat="$\\xi$")
+        fig, ax = plots.line_income_plot(self.year_n, series, style, title, yformat="$\\xi$")
 
         if figure:
             return fig
@@ -2421,7 +2229,7 @@ class Plan(object):
             }
             yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
 
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat)
+        fig, ax = plots.line_income_plot(self.year_n, series, style, title, yformat)
 
         if figure:
             return fig
@@ -2470,9 +2278,8 @@ class Plan(object):
             if tag != "":
                 title += " - " + tag
 
-            fig, ax = _stackPlot(
-                years_n, self.inames, title, range(self.N_i), y2stack, stackNames, "upper left", yformat
-            )
+            fig, ax = plots.stack_plot(years_n, self.inames, title, range(self.N_i),
+                                       y2stack, stackNames, "upper left", yformat)
             figures.append(fig)
 
         if figure:
@@ -2521,7 +2328,8 @@ class Plan(object):
                 if tag != "":
                     title += " - " + tag
 
-                fig, ax = _stackPlot(self.year_n, self.inames, title, [i], y2stack, stackNames, "upper left", "percent")
+                fig, ax = plots.stack_plot(self.year_n, self.inames, title, [i],
+                                           y2stack, stackNames, "upper left", "percent")
                 figures.append(fig)
 
         if figure:
@@ -2559,7 +2367,8 @@ class Plan(object):
             for key in self.savings_in:
                 savings_in[key] = self.savings_in[key] / self.gamma_n
 
-        fig, ax = _stackPlot(year_n, self.inames, title, range(self.N_i), savings_in, stypes, "upper left", yformat)
+        fig, ax = plots.stack_plot(year_n, self.inames, title, range(self.N_i),
+                                   savings_in, stypes, "upper left", yformat)
 
         if figure:
             return fig
@@ -2581,7 +2390,6 @@ class Plan(object):
 
         title = self._name + "\nRaw Income Sources"
         stypes = self.sources_in.keys()
-        # stypes = [item for item in stypes if "RothX" not in item]
 
         if tag != "":
             title += " - " + tag
@@ -2595,9 +2403,8 @@ class Plan(object):
             for key in stypes:
                 sources_in[key] = self.sources_in[key] / self.gamma_n[:-1]
 
-        fig, ax = _stackPlot(
-            self.year_n, self.inames, title, range(self.N_i), sources_in, stypes, "upper left", yformat
-        )
+        fig, ax = plots.stack_plot(self.year_n, self.inames, title, range(self.N_i),
+                                   sources_in, stypes, "upper left", yformat)
 
         if figure:
             return fig
@@ -2623,11 +2430,10 @@ class Plan(object):
         for t in range(self.N_t):
             key = "f " + str(t)
             series[key] = self.F_tn[t] / self.DeltaBar_tn[t]
-            # print(key, series[key])
             style[key] = various[q % len(various)]
             q += 1
 
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat="")
+        fig, ax = plots.line_income_plot(self.year_n, series, style, title, yformat="")
 
         plt.show()
         return None
@@ -2660,7 +2466,7 @@ class Plan(object):
         if tag != "":
             title += " - " + tag
 
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat)
+        fig, ax = plots.line_income_plot(self.year_n, series, style, title, yformat)
 
         if figure:
             return fig
@@ -2695,7 +2501,7 @@ class Plan(object):
         if tag != "":
             title += " - " + tag
 
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat)
+        fig, ax = plots.line_income_plot(self.year_n, series, style, title, yformat)
 
         data = tx.taxBrackets(self.N_i, self.n_d, self.N_n, self.yTCJA)
         for key in data:
@@ -2825,7 +2631,7 @@ class Plan(object):
         for i in range(self.N_i):
             sname = self.inames[i] + "'s Sources"
             ws = wb.create_sheet(sname)
-            fillsheet(ws, srcDic, "currency", op=lambda x: x[i])
+            fillsheet(ws, srcDic, "currency", op=lambda x: x[i])   # noqa: B023
 
         # Account balances except final year.
         accDic = {
@@ -2845,7 +2651,7 @@ class Plan(object):
         for i in range(self.N_i):
             sname = self.inames[i] + "'s Accounts"
             ws = wb.create_sheet(sname)
-            fillsheet(ws, accDic, "currency", op=lambda x: x[i])
+            fillsheet(ws, accDic, "currency", op=lambda x: x[i])   # noqa: B023
             # Add final balances.
             lastRow = [
                 self.year_n[-1] + 1,
@@ -2962,75 +2768,11 @@ class Plan(object):
                 if key == "n":
                     break
             except Exception as e:
-                raise Exception(f"Unanticipated exception: {e}.")
+                raise Exception(f"Unanticipated exception: {e}.") from e
 
         return None
 
 
-def _lineIncomePlot(x, series, style, title, yformat="\\$k"):
-    """
-    Core line plotter function.
-    """
-    import matplotlib.ticker as tk
-
-    fig, ax = plt.subplots(figsize=(6, 4))
-    plt.grid(visible="both")
-
-    for sname in series:
-        ax.plot(x, series[sname], label=sname, ls=style[sname])
-
-    ax.legend(loc="upper left", reverse=True, fontsize=8, framealpha=0.3)
-    ax.set_title(title)
-    ax.set_xlabel("year")
-    ax.set_ylabel(yformat)
-    ax.xaxis.set_major_locator(tk.MaxNLocator(integer=True))
-    if "k" in yformat:
-        ax.get_yaxis().set_major_formatter(tk.FuncFormatter(lambda x, p: format(int(x / 1000), ",")))
-        # Give range to y values in unindexed flat profiles.
-        ymin, ymax = ax.get_ylim()
-        if ymax - ymin < 5000:
-            ax.set_ylim((ymin * 0.95, ymax * 1.05))
-
-    return fig, ax
-
-
-def _stackPlot(x, inames, title, irange, series, snames, location, yformat="\\$k"):
-    """
-    Core function for stacked plots.
-    """
-    import matplotlib.ticker as tk
-
-    nonzeroSeries = {}
-    for sname in snames:
-        for i in irange:
-            tmp = series[sname][i]
-            if sum(tmp) > 1.0:
-                nonzeroSeries[sname + " " + inames[i]] = tmp
-
-    if len(nonzeroSeries) == 0:
-        # print('Nothing to plot for', title)
-        return None, None
-
-    fig, ax = plt.subplots(figsize=(6, 4))
-    plt.grid(visible="both")
-
-    ax.stackplot(x, nonzeroSeries.values(), labels=nonzeroSeries.keys(), alpha=0.6)
-    ax.legend(loc=location, reverse=True, fontsize=8, ncol=2, framealpha=0.5)
-    ax.set_title(title)
-    ax.set_xlabel("year")
-    ax.xaxis.set_major_locator(tk.MaxNLocator(integer=True))
-    if "k" in yformat:
-        ax.set_ylabel(yformat)
-        ax.get_yaxis().set_major_formatter(tk.FuncFormatter(lambda x, p: format(int(x / 1000), ",")))
-    elif yformat == "percent":
-        ax.set_ylabel("%")
-        ax.get_yaxis().set_major_formatter(tk.FuncFormatter(lambda x, p: format(int(100 * x), ",")))
-    else:
-        raise RuntimeError(f"Unknown yformat: {yformat}.")
-
-    return fig, ax
-
-
 def _saveWorkbook(wb, basename, overwrite, mylog):
     """
     Utility function to save XL workbook.
@@ -3050,7 +2792,7 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
             mylog.vprint("Skipping save and returning.")
             return None
 
-    while True:
+    for _ in range(3):
         try:
             mylog.vprint(f'Saving plan as "{fname}".')
             wb.save(fname)
@@ -3061,7 +2803,7 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
             if key == "n":
                 break
         except Exception as e:
-            raise Exception(f"Unanticipated exception {e}.")
+            raise Exception(f"Unanticipated exception {e}.") from e
 
     return None