owlplanner 2025.5.3__py3-none-any.whl → 2025.5.12__py3-none-any.whl

owlplanner/plan.py

@@ -16,26 +16,21 @@ Disclaimer: This program comes with no guarantee. Use at your own risk.
 ###########################################################################
 import numpy as np
 import pandas as pd
-import matplotlib.pyplot as plt
 from datetime import date, datetime
 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
-from owlplanner import abcapi as abc
-from owlplanner import rates
-from owlplanner import config
-from owlplanner import timelists
-from owlplanner import logging
-from owlplanner import progress
-
-
-# This makes all graphs to have the same height.
-plt.rcParams.update({'figure.autolayout': True})
+from . import utils as u
+from . import tax2025 as tx
+from . import abcapi as abc
+from . import rates
+from . import config
+from . import timelists
+from . import mylogging as log
+from . import progress
+from .plotting.factory import PlotFactory
 
 
 def _genGamma_n(tau):
@@ -246,14 +241,20 @@ class Plan(object):
         self._description = ''
         self.defaultPlots = "nominal"
         self.defaultSolver = "HiGHS"
+        self._plotterName = None
+        self.setPlotBackend("matplotlib")
 
         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."
-
-        self.filingStatus = ["single", "married"][self.N_i - 1]
+        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.
         self.yTCJA = 2026
         self.inames = inames
@@ -263,10 +264,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.
@@ -311,7 +311,7 @@ class Plan(object):
         self.lambdha = 0
 
         # Scenario starts at the beginning of this year and ends at the end of the last year.
-        s = ["", "s"][self.N_i - 1]
+        s = ("", "s")[self.N_i - 1]
         self.mylog.vprint(f"Preparing scenario of {self.N_n} years for {self.N_i} individual{s}.")
         for i in range(self.N_i):
             endyear = thisyear + self.horizons[i] - 1
@@ -346,7 +346,7 @@ class Plan(object):
         self.mylog = logger
 
     def setLogstreams(self, verbose, logstreams):
-        self.mylog = logging.Logger(verbose, logstreams)
+        self.mylog = log.Logger(verbose, logstreams)
         # self.mylog.vprint(f"Setting logstreams to {logstreams}.")
 
     def logger(self):
@@ -400,13 +400,11 @@ class Plan(object):
         if value is None:
             return self.defaultPlots
 
-        opts = ["nominal", "today"]
-        if value in opts:
-            return value
+        opts = ("nominal", "today")
+        if value not in opts:
+            raise ValueError(f"Value type must be one of: {opts}")
 
-        raise ValueError(f"Value type must be one of: {opts}")
-
-        return None
+        return value
 
     def rename(self, newname):
         """
@@ -433,7 +431,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
@@ -450,13 +449,26 @@ class Plan(object):
         self.defaultPlots = self._checkValue(value)
         self.mylog.vprint(f"Setting plots default value to {value}.")
 
+    def setPlotBackend(self, backend: str):
+        """
+        Set plotting backend.
+        """
+
+        if backend not in ("matplotlib", "plotly"):
+            raise ValueError(f"Backend {backend} not a valid option.")
+
+        if backend != self._plotterName:
+            self._plotter = PlotFactory.createBackend(backend)
+            self.mylog.vprint(f"Setting plotting backend to {backend}.")
+
     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 +485,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 +497,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 +516,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 +564,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 +602,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 +700,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 +713,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 +794,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 +831,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 +853,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."
+                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.")
 
-            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
-
-            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 +905,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 +1002,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 +1080,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.
+        self.xnet = 1 - oppCostX / 100.
+        self.optionsUnits = u.getUnits(options.get("units", "k"))
 
-        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
-
-        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,122 +1299,113 @@ 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):
         """
         Run historical scenarios on plan over a range of years.
         """
+
         if yend + self.N_n > self.year_n[0]:
             yend = self.year_n[0] - self.N_n - 1
             self.mylog.vprint(f"Warning: Upper bound for year range re-adjusted to {yend}.")
-        N = yend - ystart + 1
 
+        if yend < ystart:
+            raise ValueError(f"Starting year is too large to support a lifespan of {self.N_n} years.")
+
+        N = yend - ystart + 1
         self.mylog.vprint(f"Running historical range from {ystart} to {yend}.")
 
         self.mylog.setVerbose(verbose)
@@ -1438,7 +1416,7 @@ class Plan(object):
             columns = ["partial", "final"]
         else:
             self.mylog.print(f"Invalid objective {objective}.")
-            return None
+            raise ValueError(f"Invalid objective {objective}.")
 
         df = pd.DataFrame(columns=columns)
 
@@ -1461,7 +1439,9 @@ class Plan(object):
 
         progcall.finish()
         self.mylog.resetVerbose()
-        fig, description = self._showResults(objective, df, N, figure)
+
+        fig, description = self._plotter.plot_histogram_results(objective, df, N, self.year_n,
+                                                                self.n_d, self.N_i, self.phi_j)
         self.mylog.print(description.getvalue())
 
         if figure:
@@ -1474,7 +1454,7 @@ class Plan(object):
         """
         Run Monte Carlo simulations on plan.
         """
-        if self.rateMethod not in ["stochastic", "histochastic"]:
+        if self.rateMethod not in ("stochastic", "histochastic"):
             self.mylog.print("It is pointless to run Monte Carlo simulations with fixed rates.")
             return
 
@@ -1517,7 +1497,9 @@ class Plan(object):
 
         progcall.finish()
         self.mylog.resetVerbose()
-        fig, description = self._showResults(objective, df, N, figure)
+
+        fig, description = self._plotter.plot_histogram_results(objective, df, N, self.year_n,
+                                                                self.n_d, self.N_i, self.phi_j)
         self.mylog.print(description.getvalue())
 
         if figure:
@@ -1525,90 +1507,6 @@ class Plan(object):
 
         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 +1517,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 +1559,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:
@@ -1739,7 +1638,8 @@ class Plan(object):
         while True:
             solution, xx, solverSuccess, solverMsg = solverMethod(objective, options)
 
-            if not solverSuccess:
+            if not solverSuccess or solution is None:
+                self.mylog.vprint("Solver failed:", solverMsg, solverSuccess)
                 break
 
             if not withMedicare:
@@ -1789,8 +1689,13 @@ class Plan(object):
         """
         from scipy import optimize
 
-        # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
-        milpOptions = {"disp": False, "mip_rel_gap": 1e-7}
+        # Optimize solver parameters
+        milpOptions = {
+            "disp": False,
+            "mip_rel_gap": 1e-7,
+            "presolve": True,
+            "node_limit": 10000  # Limit search nodes for faster solutions
+        }
 
         self._buildConstraints(objective, options)
         Alu, lbvec, ubvec = self.A.arrays()
@@ -2161,10 +2066,10 @@ class Plan(object):
         dic[f"Net spending for year {now}"] = u.d(self.g_n[0] / self.yearFracLeft)
         dic[f"Net spending remaining in year {now}"] = u.d(self.g_n[0])
 
-        totIncome = np.sum(self.g_n, axis=0)
-        totIncomeNow = np.sum(self.g_n / self.gamma_n[:-1], axis=0)
-        dic["Total net spending"] = f"{u.d(totIncomeNow)}"
-        dic["[Total net spending]"] = f"{u.d(totIncome)}"
+        totSpending = np.sum(self.g_n, axis=0)
+        totSpendingNow = np.sum(self.g_n / self.gamma_n[:-1], axis=0)
+        dic["Total net spending"] = f"{u.d(totSpendingNow)}"
+        dic["[Total net spending]"] = f"{u.d(totSpending)}"
 
         totRoth = np.sum(self.x_in, axis=(0, 1))
         totRothNow = np.sum(np.sum(self.x_in, axis=0) / self.gamma_n[:-1], axis=0)
@@ -2260,58 +2165,29 @@ 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",
-        ]
+        fig = self._plotter.plot_rates_correlations(self._name, self.tau_kn, self.N_n, self.rateMethod,
+                                                    self.rateFrm, self.rateTo, tag, shareRange)
 
-        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
+        if figure:
+            return fig
 
-        g.fig.suptitle(title, y=1.08)
+        self._plotter.jupyter_renderer(fig)
+        return None
 
+    def showRatesDistributions(self, frm=rates.FROM, to=rates.TO, figure=False):
+        """
+        Plot histograms of the rates distributions.
+        """
+        fig = self._plotter.plot_rates_distributions(frm, to, rates.SP500, rates.BondsBaa,
+                                                     rates.TNotes, rates.Inflation, rates.FROM)
         if figure:
-            return g.fig
+            return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     def showRates(self, tag="", figure=False):
@@ -2320,54 +2196,17 @@ 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 = self._plotter.plot_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
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     def showProfile(self, tag="", figure=False):
@@ -2379,20 +2218,15 @@ class Plan(object):
         if self.xi_n is None:
             self.mylog.vprint("Warning: Profile must be selected before plotting.")
             return None
-
         title = self._name + "\nSpending Profile"
-        if tag != "":
+        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 = self._plotter.plot_profile(self.year_n, self.xi_n, title, self.inames)
 
         if figure:
             return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     @_checkCaseStatus
@@ -2406,28 +2240,15 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-
         title = self._name + "\nNet Available Spending"
-        if tag != "":
+        if tag:
             title += " - " + tag
-
-        style = {"net": "-", "target": ":"}
-        if value == "nominal":
-            series = {"net": self.g_n, "target": (self.g_n[0] / self.xi_n[0]) * self.xiBar_n}
-            yformat = "\\$k (nominal)"
-        else:
-            series = {
-                "net": self.g_n / self.gamma_n[:-1],
-                "target": (self.g_n[0] / self.xi_n[0]) * self.xi_n,
-            }
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat)
-
+        fig = self._plotter.plot_net_spending(self.year_n, self.g_n, self.xi_n, self.xiBar_n,
+                                              self.gamma_n, value, title, self.inames)
         if figure:
             return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     @_checkCaseStatus
@@ -2444,42 +2265,37 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
+        figures = self._plotter.plot_asset_distribution(self.year_n, self.inames, self.b_ijkn,
+                                                        self.gamma_n, value, self._name, tag)
+        if figure:
+            return figures
 
-        if value == "nominal":
-            yformat = "\\$k (nominal)"
-            infladjust = 1
-        else:
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-            infladjust = self.gamma_n
-
-        years_n = np.array(self.year_n)
-        years_n = np.append(years_n, [years_n[-1] + 1])
-        y2stack = {}
-        jDic = {"taxable": 0, "tax-deferred": 1, "tax-free": 2}
-        kDic = {"stocks": 0, "C bonds": 1, "T notes": 2, "common": 3}
-        figures = []
-        for jkey in jDic:
-            stackNames = []
-            for kkey in kDic:
-                name = kkey + " / " + jkey
-                stackNames.append(name)
-                y2stack[name] = np.zeros((self.N_i, self.N_n + 1))
-                for i in range(self.N_i):
-                    y2stack[name][i][:] = self.b_ijkn[i][jDic[jkey]][kDic[kkey]][:] / infladjust
+        for fig in figures:
+            self._plotter.jupyter_renderer(fig)
+        return None
 
-            title = self._name + "\nAssets Distribution - " + jkey
-            if tag != "":
-                title += " - " + tag
+    @_checkCaseStatus
+    def showGrossIncome(self, tag="", value=None, figure=False):
+        """
+        Plot income tax and taxable income over time horizon.
 
-            fig, ax = _stackPlot(
-                years_n, self.inames, title, range(self.N_i), y2stack, stackNames, "upper left", yformat
-            )
-            figures.append(fig)
+        A tag string can be set to add information to the title of the plot.
 
+        The value parameter can be set to *nominal* or *today*, overriding
+        the default behavior of setDefaultPlots().
+        """
+        value = self._checkValue(value)
+        tax_brackets = tx.taxBrackets(self.N_i, self.n_d, self.N_n, self.yTCJA)
+        title = self._name + "\nTaxable Ordinary Income vs. Tax Brackets"
+        if tag:
+            title += " - " + tag
+        fig = self._plotter.plot_gross_income(
+            self.year_n, self.G_n, self.gamma_n, value, title, tax_brackets
+        )
         if figure:
-            return figures
+            return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     def showAllocations(self, tag="", figure=False):
@@ -2490,45 +2306,16 @@ class Plan(object):
 
         A tag string can be set to add information to the title of the plot.
         """
-        count = self.N_i
-        if self.ARCoord == "spouses":
-            acList = [self.ARCoord]
-            count = 1
-        elif self.ARCoord == "individual":
-            acList = [self.ARCoord]
-        elif self.ARCoord == "account":
-            acList = ["taxable", "tax-deferred", "tax-free"]
-        else:
-            raise ValueError(f"Unknown coordination {self.ARCoord}.")
-
-        figures = []
-        assetDic = {"stocks": 0, "C bonds": 1, "T notes": 2, "common": 3}
-        for i in range(count):
-            y2stack = {}
-            for acType in acList:
-                stackNames = []
-                for key in assetDic:
-                    aname = key + " / " + acType
-                    stackNames.append(aname)
-                    y2stack[aname] = np.zeros((count, self.N_n))
-                    y2stack[aname][i][:] = self.alpha_ijkn[i, acList.index(acType), assetDic[key], : self.N_n]
-
-                    title = self._name + "\nAsset Allocation (%) - " + acType
-                    if self.ARCoord == "spouses":
-                        title += " spouses"
-                    else:
-                        title += " " + self.inames[i]
-
-                if tag != "":
-                    title += " - " + tag
-
-                fig, ax = _stackPlot(self.year_n, self.inames, title, [i], y2stack, stackNames, "upper left", "percent")
-                figures.append(fig)
-
+        title = self._name + "\nAsset Allocation"
+        if tag:
+            title += " - " + tag
+        figures = self._plotter.plot_allocations(self.year_n, self.inames, self.alpha_ijkn,
+                                                 self.ARCoord, title)
         if figure:
             return figures
 
-        plt.show()
+        for fig in figures:
+            self._plotter.jupyter_renderer(fig)
         return None
 
     @_checkCaseStatus
@@ -2542,30 +2329,15 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-
         title = self._name + "\nSavings Balance"
-        if tag != "":
+        if tag:
             title += " - " + tag
-
-        stypes = self.savings_in.keys()
-        # Add one year for estate.
-        year_n = np.append(self.year_n, [self.year_n[-1] + 1])
-
-        if value == "nominal":
-            yformat = "\\$k (nominal)"
-            savings_in = self.savings_in
-        else:
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-            savings_in = {}
-            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 = self._plotter.plot_accounts(self.year_n, self.savings_in, self.gamma_n,
+                                          value, title, self.inames)
         if figure:
             return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     @_checkCaseStatus
@@ -2579,58 +2351,15 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-
         title = self._name + "\nRaw Income Sources"
-        stypes = self.sources_in.keys()
-        # stypes = [item for item in stypes if "RothX" not in item]
-
-        if tag != "":
+        if tag:
             title += " - " + tag
-
-        if value == "nominal":
-            yformat = "\\$k (nominal)"
-            sources_in = self.sources_in
-        else:
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-            sources_in = {}
-            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 = self._plotter.plot_sources(self.year_n, self.sources_in, self.gamma_n,
+                                         value, title, self.inames)
         if figure:
             return fig
 
-        plt.show()
-        return None
-
-    @_checkCaseStatus
-    def _showFeff(self, tag=""):
-        """
-        Plot income tax paid over time.
-
-        A tag string can be set to add information to the title of the plot.
-        """
-        title = self._name + "\nEff f "
-        if tag != "":
-            title += " - " + tag
-
-        various = ["-", "--", "-.", ":"]
-        style = {}
-        series = {}
-        q = 0
-        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="")
-
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
     @_checkCaseStatus
@@ -2644,87 +2373,17 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-
-        style = {"income taxes": "-", "Medicare": "-."}
-
-        if value == "nominal":
-            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],
-            }
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-
         title = self._name + "\nIncome Tax"
-        if tag != "":
+        if tag:
             title += " - " + tag
-
-        fig, ax = _lineIncomePlot(self.year_n, series, style, title, yformat)
-
+        fig = self._plotter.plot_taxes(self.year_n, self.T_n, self.M_n, self.gamma_n,
+                                       value, title, self.inames)
         if figure:
             return fig
 
-        plt.show()
+        self._plotter.jupyter_renderer(fig)
         return None
 
-    @_checkCaseStatus
-    def showGrossIncome(self, tag="", value=None, figure=False):
-        """
-        Plot income tax and taxable income over time horizon.
-
-        A tag string can be set to add information to the title of the plot.
-
-        The value parameter can be set to *nominal* or *today*, overriding
-        the default behavior of setDefaultPlots().
-        """
-        value = self._checkValue(value)
-
-        style = {"taxable income": "-"}
-
-        if value == "nominal":
-            series = {"taxable income": self.G_n}
-            yformat = "\\$k (nominal)"
-            infladjust = self.gamma_n[:-1]
-        else:
-            series = {"taxable income": self.G_n / self.gamma_n[:-1]}
-            yformat = "\\$k (" + str(self.year_n[0]) + "\\$)"
-            infladjust = 1
-
-        title = self._name + "\nTaxable Ordinary Income vs. Tax Brackets"
-        if tag != "":
-            title += " - " + tag
-
-        fig, ax = _lineIncomePlot(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:
-            data_adj = data[key] * infladjust
-            ax.plot(self.year_n, data_adj, label=key, ls=":")
-
-        plt.grid(visible="both")
-        ax.legend(loc="upper left", reverse=True, fontsize=8, framealpha=0.3)
-
-        if figure:
-            return fig
-
-        plt.show()
-        return None
-
-    # @_checkCaseStatus
-    def saveConfig(self, basename=None):
-        """
-        Save parameters in a configuration file.
-        """
-        if basename is None:
-            basename = "case_" + self._name
-
-        config.saveConfig(self, basename, self.mylog)
-
-        return None
-
-    @_checkCaseStatus
     def saveWorkbook(self, overwrite=False, *, basename=None, saveToFile=True):
         """
         Save instance in an Excel spreadsheet.
@@ -2826,7 +2485,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 = {
@@ -2846,7 +2505,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,
@@ -2963,73 +2622,20 @@ 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 saveConfig(self, basename=None):
+        """
+        Save parameters in a configuration file.
+        """
+        if basename is None:
+            basename = "case_" + self._name
 
-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}.")
+        config.saveConfig(self, basename, self.mylog)
 
-    return fig, ax
+        return None
 
 
 def _saveWorkbook(wb, basename, overwrite, mylog):
@@ -3051,7 +2657,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)
@@ -3062,7 +2668,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