owlplanner 2025.4.26__tar.gz → 2025.5.1__tar.gz

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/PKG-INFO

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

owlplanner-2025.5.1/git-cheats

@@ -0,0 +1,11 @@
+# Restore older version as HEAD
+git checkout <thursday good commit hash>
+git checkout -b fix-branch
+git cherry-pick <another good commit hash>
+
+(repeat cherry pick for each commit you want)
+Now you have a branch with just the commits you want. You can merge it back into master like this:
+
+git merge --strategy=ours master
+git checkout master
+git merge fix-branch

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "owlplanner"
-version = "2025.04.26"
+version = "2025.05.01"
 authors = [
   { name="Martin-D. Lacasse", email="martin.d.lacasse@gmail.com" },
 ]

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/src/owlplanner/abcapi.py

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

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/src/owlplanner/plan.py

@@ -1026,7 +1026,7 @@ class Plan(object):
         Utility function to map variables to a block vector.
         Refer to companion document for explanations.
         """
-        # Stack all variables in a single block vector.
+        # Stack all variables in a single block vector with all binary variables at the end.
         C = {}
         C["b"] = 0
         C["d"] = _qC(C["b"], self.N_i, self.N_j, self.N_n + 1)
@@ -1038,9 +1038,13 @@ class Plan(object):
         C["x"] = _qC(C["w"], self.N_i, self.N_j, self.N_n)
         C["z"] = _qC(C["x"], self.N_i, self.N_n)
         self.nvars = _qC(C["z"], self.N_i, self.N_n, self.N_z)
+        self.nbins = self.nvars - C["z"]
+        # # self.nvars = _qC(C["x"], self.N_i, self.N_n)
+        # # self.nbins = 0
 
         self.C = C
-        self.mylog.vprint(f"Problem has {len(C)} distinct time series forming {self.nvars} decision variables.")
+        self.mylog.vprint(
+            f"Problem has {len(C)} distinct series, {self.nvars} decision variables (including {self.nbins} binary).")
 
         return None
 
@@ -1095,7 +1099,7 @@ class Plan(object):
         ###################################################################
         # Inequality constraint matrix with upper and lower bound vectors.
         A = abc.ConstraintMatrix(self.nvars)
-        B = abc.Bounds(self.nvars)
+        B = abc.Bounds(self.nvars, self.nbins)
 
         # RMDs inequalities, only if there is an initial balance in tax-deferred account.
         for i in range(Ni):
@@ -1110,11 +1114,19 @@ class Plan(object):
         # Income tax bracket range inequalities.
         for t in range(Nt):
             for n in range(Nn):
-                B.set0_Ub(_q2(CF, t, n, Nt, Nn), self.DeltaBar_tn[t, n])
+                B.setRange(_q2(CF, t, n, Nt, Nn), zero, self.DeltaBar_tn[t, n])
 
         # Standard exemption range inequalities.
         for n in range(Nn):
-            B.set0_Ub(_q1(Ce, n, Nn), self.sigmaBar_n[n])
+            B.setRange(_q1(Ce, n, Nn), zero, self.sigmaBar_n[n])
+
+        # 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.
@@ -1136,8 +1148,9 @@ class Plan(object):
                     # self.mylog.vprint('Limiting Roth conversions to:', u.d(rhsopt))
                     for i in range(Ni):
                         for n in range(self.horizons[i]):
-                            #  Should we adjust Roth conversion cap with inflation?
-                            B.set0_Ub(_q2(Cx, i, n, Ni, Nn), rhsopt)
+                            # MOSEK chokes if completely zero. Add a 1 cent slack.
+                            # Should we adjust Roth conversion cap with inflation?
+                            B.setRange(_q2(Cx, i, n, Ni, Nn), zero, rhsopt + 0.01)
 
             # Process startRothConversions option.
             if "startRothConversions" in options:
@@ -1149,7 +1162,7 @@ class Plan(object):
                 for i in range(Ni):
                     nstart = min(yearn, self.horizons[i])
                     for n in range(0, nstart):
-                        B.set0_Ub(_q2(Cx, i, n, Ni, Nn), zero)
+                        B.setRange(_q2(Cx, i, n, Ni, Nn), zero, zero)
 
             # Process noRothConversions option. Also valid when N_i == 1, why not?
             if "noRothConversions" in options and options["noRothConversions"] != "None":
@@ -1160,7 +1173,7 @@ class Plan(object):
                     raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:")
 
                 for n in range(Nn):
-                    B.set0_Ub(_q2(Cx, i_x, n, Ni, Nn), zero)
+                    B.setRange(_q2(Cx, i_x, n, Ni, Nn), zero, zero)
 
         # Impose withdrawal limits on taxable and tax-exempt accounts.
         for i in range(Ni):
@@ -1206,13 +1219,15 @@ class Plan(object):
             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)
+            # A.addNewRow({_q1(Cg, 0, Nn): 1}, spending, spending)
+            B.setRange(_q1(Cg, 0, Nn), spending, spending)
 
-        # Set initial balances through constraints.
+        # Set initial balances through bounds or constraints.
         for i in range(Ni):
             for j in range(Nj):
                 rhs = self.beta_ij[i, j]
-                A.addNewRow({_q3(Cb, i, j, 0, Ni, Nj, Nn + 1): 1}, rhs, rhs)
+                # A.addNewRow({_q3(Cb, i, j, 0, Ni, Nj, Nn + 1): 1}, rhs, rhs)
+                B.setRange(_q3(Cb, i, j, 0, Ni, Nj, Nn + 1), rhs, rhs)
 
         # Link surplus and taxable account deposits regardless of Ni.
         for i in range(Ni):
@@ -1226,20 +1241,20 @@ class Plan(object):
                 A.addNewRow(rowDic, zero, zero)
 
         # No surplus allowed during the last year to be used as a tax loophole.
-        B.set0_Ub(_q1(Cs, Nn - 1, Nn), zero)
+        B.setRange(_q1(Cs, Nn - 1, Nn), zero, zero)
 
         if Ni == 2:
             # No conversion during last year.
-            # B.set0_Ub(_q2(Cx, i_d, nd-1, Ni, Nn), zero)
-            # B.set0_Ub(_q2(Cx, i_s, Nn-1, Ni, Nn), zero)
+            # 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.set0_Ub(_q2(Cd, i_d, n, Ni, Nn), zero)
-                B.set0_Ub(_q2(Cx, i_d, n, Ni, Nn), zero)
+                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.set0_Ub(_q3(Cw, i_d, j, n, Ni, Nj, Nn), zero)
+                    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.
@@ -1312,8 +1327,8 @@ class Plan(object):
 
         # Impose income profile.
         for n in range(1, Nn):
-            rowDic = {_q1(Cg, 0, Nn): -spLo * self.xiBar_n[n], _q1(Cg, n, Nn): self.xiBar_n[0]}
-            A.addNewRow(rowDic, zero, inf)
+            rowDic = {_q1(Cg, 0, Nn): spLo * self.xiBar_n[n], _q1(Cg, n, Nn): -self.xiBar_n[0]}
+            A.addNewRow(rowDic, -inf, zero)
             rowDic = {_q1(Cg, 0, Nn): spHi * self.xiBar_n[n], _q1(Cg, n, Nn): -self.xiBar_n[0]}
             A.addNewRow(rowDic, zero, inf)
 
@@ -1343,8 +1358,8 @@ class Plan(object):
         # Configure binary variables.
         for i in range(Ni):
             for n in range(self.horizons[i]):
-                for z in range(Nz):
-                    B.setBinary(_q3(Cz, i, n, z, Ni, Nn, Nz))
+                # for z in range(Nz):
+                #     B.setBinary(_q3(Cz, i, n, z, Ni, Nn, Nz))
 
                 # Exclude simultaneous deposits and withdrawals from taxable or tax-free accounts.
                 A.addNewRow(
@@ -1376,6 +1391,10 @@ class Plan(object):
                     bigM,
                 )
 
+            for n in range(self.horizons[i], Nn):
+                B.setRange(_q3(Cz, i, n, 0, Ni, Nn, Nz), zero, zero)
+                B.setRange(_q3(Cz, i, n, 1, Ni, Nn, Nz), zero, zero)
+
         # Now build a solver-neutral objective vector.
         c = abc.Objective(self.nvars)
         if objective == "maxSpending":
@@ -1597,7 +1616,7 @@ class Plan(object):
 
     @_checkConfiguration
     @_timer
-    def solve(self, objective, options=None):
+    def solve(self, objective, options={}):
         """
         This function builds the necessary constaints and
         runs the optimizer.
@@ -1622,7 +1641,8 @@ class Plan(object):
 
         # Check objective and required options.
         knownObjectives = ["maxBequest", "maxSpending"]
-        knownSolvers = ["HiGHS", "MOSEK"]
+        knownSolvers = ["HiGHS", "PuLP/CBC", "MOSEK"]
+
         knownOptions = [
             "bequest",
             "bigM",
@@ -1636,11 +1656,8 @@ class Plan(object):
             "units",
             "withMedicare",
         ]
-        # We will modify options if required.
-        if options is None:
-            myoptions = {}
-        else:
-            myoptions = dict(options)
+        # We might modify options if required.
+        myoptions = dict(options)
 
         for opt in myoptions:
             if opt not in knownOptions:
@@ -1672,91 +1689,70 @@ class Plan(object):
             units = u.getUnits(options.get("units", "k"))
             self.prevMAGI = units * np.array(magi)
 
-        self.lambdha = 0
-        if "spendingSlack" in myoptions:
-            lambdha = myoptions["spendingSlack"]
-            if lambdha < 0 or lambdha > 50:
-                raise ValueError(f"Slack value out of range {lambdha}.")
-            self.lambdha = lambdha / 100
+        lambdha = myoptions.get("spendingSlack", 0)
+        if lambdha < 0 or lambdha > 50:
+            raise ValueError(f"Slack value out of range {lambdha}.")
+        self.lambdha = lambdha / 100
 
         self._adjustParameters()
 
-        if "solver" in options:
-            solver = myoptions["solver"]
-            if solver not in knownSolvers:
-                raise ValueError(f"Unknown solver {solver}.")
-        else:
-            solver = self.defaultSolver
+        solver = myoptions.get("solver", self.defaultSolver)
+        if solver not in knownSolvers:
+            raise ValueError(f"Unknown solver {solver}.")
 
         if solver == "HiGHS":
-            self._milpSolve(objective, myoptions)
+            solverMethod = self._milpSolve
+        elif solver == "PuLP/CBC":
+            solverMethod = self._pulpSolve
         elif solver == "MOSEK":
-            self._mosekSolve(objective, myoptions)
+            solverMethod = self._mosekSolve
+        else:
+            raise RuntimeError("Internal error in defining solverMethod.")
+
+        self._scSolve(objective, options, solverMethod)
 
         self.objective = objective
         self.solverOptions = myoptions
 
         return None
 
-    def _milpSolve(self, objective, options):
+    def _scSolve(self, objective, options, solverMethod):
         """
-        Solve problem using scipy HiGHS solver.
+        Self-consistent loop, regardless of solver.
         """
-        from scipy import optimize
-
-        withMedicare = True
-        if "withMedicare" in options and options["withMedicare"] is False:
-            withMedicare = False
+        withMedicare = options.get("withMedicare", True)
 
         if objective == "maxSpending":
             objFac = -1 / self.xi_n[0]
         else:
             objFac = -1 / self.gamma_n[-1]
 
-        # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
-        milpOptions = {"disp": False, "mip_rel_gap": 1e-7}
-
         it = 0
         absdiff = np.inf
         old_x = np.zeros(self.nvars)
         old_solutions = [np.inf]
         self._estimateMedicare(None, withMedicare)
         while True:
-            self._buildConstraints(objective, options)
-            Alu, lbvec, ubvec = self.A.arrays()
-            Lb, Ub = self.B.arrays()
-            integrality = self.B.integralityArray()
-            c = self.c.arrays()
-
-            bounds = optimize.Bounds(Lb, Ub)
-            constraint = optimize.LinearConstraint(Alu, lbvec, ubvec)
-            solution = optimize.milp(
-                c,
-                integrality=integrality,
-                constraints=constraint,
-                bounds=bounds,
-                options=milpOptions,
-            )
-            it += 1
+            solution, xx, solverSuccess, solverMsg = solverMethod(objective, options)
 
-            if not solution.success:
+            if not solverSuccess:
                 break
 
             if not withMedicare:
                 break
 
-            self._estimateMedicare(solution.x)
+            self._estimateMedicare(xx)
 
-            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution.fun * objFac, f=2)}")
+            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution * objFac, f=2)}")
 
-            delta = solution.x - old_x
+            delta = xx - old_x
             absdiff = np.sum(np.abs(delta), axis=0)
             if absdiff < 1:
                 self.mylog.vprint("Converged on full solution.")
                 break
 
             # Avoid oscillatory solutions. Look only at most recent solutions. Within $10.
-            isclosenough = abs(-solution.fun - min(old_solutions[int(it / 2) :])) < 10 * self.xi_n[0]
+            isclosenough = abs(-solution - min(old_solutions[int(it / 2) :])) < 10 * self.xi_n[0]
             if isclosenough:
                 self.mylog.vprint("Converged through selecting minimum oscillating objective.")
                 break
@@ -1765,39 +1761,114 @@ class Plan(object):
                 self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
                 break
 
-            old_solutions.append(-solution.fun)
-            old_x = solution.x
+            old_solutions.append(-solution)
+            old_x = xx
 
-        if solution.success:
+        if solverSuccess:
             self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
-            self.mylog.vprint(solution.message)
-            self.mylog.vprint(f"Objective: {u.d(solution.fun * objFac)}")
+            self.mylog.vprint(solverMsg)
+            self.mylog.vprint(f"Objective: {u.d(solution * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
-            self._aggregateResults(solution.x)
+            self._aggregateResults(xx)
             self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
             self.caseStatus = "solved"
         else:
-            self.mylog.vprint("WARNING: Optimization failed:", solution.message, solution.success)
+            self.mylog.vprint("WARNING: Optimization failed:", solverMsg, solverSuccess)
             self.caseStatus = "unsuccessful"
 
         return None
 
-    def _mosekSolve(self, objective, options):
+    def _milpSolve(self, objective, options):
         """
-        Solve problem using MOSEK solver.
+        Solve problem using scipy HiGHS solver.
         """
-        import mosek
+        from scipy import optimize
 
-        withMedicare = True
-        if "withMedicare" in options and options["withMedicare"] is False:
-            withMedicare = False
+        # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
+        milpOptions = {"disp": False, "mip_rel_gap": 1e-7}
 
-        if objective == "maxSpending":
-            objFac = -1 / self.xi_n[0]
-        else:
-            objFac = -1 / self.gamma_n[-1]
+        self._buildConstraints(objective, options)
+        Alu, lbvec, ubvec = self.A.arrays()
+        Lb, Ub = self.B.arrays()
+        integrality = self.B.integralityArray()
+        c = self.c.arrays()
+
+        bounds = optimize.Bounds(Lb, Ub)
+        constraint = optimize.LinearConstraint(Alu, lbvec, ubvec)
+        solution = optimize.milp(
+            c,
+            integrality=integrality,
+            constraints=constraint,
+            bounds=bounds,
+            options=milpOptions,
+        )
 
-        # mip_rel_gap smaller than 1e-6 can lead to oscillatory solutions.
+        return solution.fun, solution.x, solution.success, solution.message
+
+    def _pulpSolve(self, objective, options):
+        """
+        Solve problem using scipy PuLP solver.
+        """
+        import pulp
+
+        self._buildConstraints(objective, options)
+        Alu, lbvec, ubvec = self.A.arrays()
+        ckeys = self.A.keys()
+        Lb, Ub = self.B.arrays()
+        vkeys = self.B.keys()
+        c = self.c.arrays()
+        c_list = c.tolist()
+
+        prob = pulp.LpProblem(self._name.replace(" ", "_"), pulp.LpMinimize)
+
+        x = []
+        for i in range(self.nvars - self.nbins):
+            if vkeys[i] == "ra":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
+            elif vkeys[i] == "lo":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=None)]
+            elif vkeys[i] == "up":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=None, upBound=Ub[i])]
+            elif vkeys[i] == "fr":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=None, upBound=None)]
+            elif vkeys[i] == "fx":
+                x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
+            else:
+                raise RuntimeError(f"Internal error: Variable with wierd bound f{vkeys[i]}.")
+
+        x.extend([pulp.LpVariable(f"z_{i}", cat="Binary") for i in range(self.nbins)])
+
+        prob += pulp.lpDot(c_list, x)
+
+        for r in range(self.A.ncons):
+            row = Alu[r].tolist()
+            if ckeys[r] in ["lo", "ra"] and lbvec[r] != -np.inf:
+                prob += pulp.lpDot(row, x) >= lbvec[r]
+            if ckeys[r] in ["up", "ra"] and ubvec[r] != np.inf:
+                prob += pulp.lpDot(row, x) <= ubvec[r]
+            if ckeys[r] == "fx":
+                prob += pulp.lpDot(row, x) == ubvec[r]
+
+        # prob.writeLP("C:\\Users\\marti\\Downloads\\pulp.lp")
+        # prob.writeMPS("C:\\Users\\marti\\Downloads\\pulp.mps", rename=True)
+        # solver_list = pulp.listSolvers(onlyAvailable=True)
+        # print("Available solvers:", solver_list)
+        # solver = pulp.getSolver("MOSEK")
+        # prob.solve(solver)
+
+        prob.solve(pulp.PULP_CBC_CMD(msg=False))
+        # Filter out None values and convert to array.
+        xx = np.array([0 if x[i].varValue is None else x[i].varValue for i in range(self.nvars)])
+        solution = np.dot(c, xx)
+        success = (pulp.LpStatus[prob.status] == "Optimal")
+
+        return solution, xx, success, pulp.LpStatus[prob.status]
+
+    def _mosekSolve(self, objective, options):
+        """
+        Solve problem using MOSEK solver.
+        """
+        import mosek
 
         bdic = {
             "fx": mosek.boundkey.fx,
@@ -1807,95 +1878,53 @@ class Plan(object):
             "up": mosek.boundkey.up,
         }
 
-        it = 0
-        absdiff = np.inf
-        old_x = np.zeros(self.nvars)
-        old_solutions = [np.inf]
-        self._estimateMedicare(None, withMedicare)
-        while True:
-            self._buildConstraints(objective, options)
-            Aind, Aval, clb, cub = self.A.lists()
-            ckeys = self.A.keys()
-            vlb, vub = self.B.arrays()
-            integrality = self.B.integralityList()
-            vkeys = self.B.keys()
-            cind, cval = self.c.lists()
-
-            task = mosek.Task()
-            # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-5)
-            # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
-            # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
-            task.appendcons(self.A.ncons)
-            task.appendvars(self.A.nvars)
-
-            for ii in range(len(cind)):
-                task.putcj(cind[ii], cval[ii])
-
-            for ii in range(self.nvars):
-                task.putvarbound(ii, bdic[vkeys[ii]], vlb[ii], vub[ii])
-
-            for ii in range(len(integrality)):
-                task.putvartype(integrality[ii], mosek.variabletype.type_int)
-
-            for ii in range(self.A.ncons):
-                task.putarow(ii, Aind[ii], Aval[ii])
-                task.putconbound(ii, bdic[ckeys[ii]], clb[ii], cub[ii])
-
-            task.putobjsense(mosek.objsense.minimize)
-            task.optimize()
-
-            solsta = task.getsolsta(mosek.soltype.itg)
-            # prosta = task.getprosta(mosek.soltype.itg)
-            it += 1
-
-            if solsta != mosek.solsta.integer_optimal:
-                break
+        solverMsg = str()
 
-            xx = np.array(task.getxx(mosek.soltype.itg))
-            solution = task.getprimalobj(mosek.soltype.itg)
+        def _streamPrinter(text, msg=solverMsg):
+            msg += text
 
-            if withMedicare is False:
-                break
+        self._buildConstraints(objective, options)
+        Aind, Aval, clb, cub = self.A.lists()
+        ckeys = self.A.keys()
+        vlb, vub = self.B.arrays()
+        integrality = self.B.integralityList()
+        vkeys = self.B.keys()
+        cind, cval = self.c.lists()
 
-            self._estimateMedicare(xx)
+        task = mosek.Task()
+        # task.putdouparam(mosek.dparam.mio_rel_gap_const, 1e-6)
+        # task.putdouparam(mosek.dparam.mio_tol_abs_relax_int, 1e-4)
+        # task.set_Stream(mosek.streamtype.msg, _streamPrinter)
+        task.appendcons(self.A.ncons)
+        task.appendvars(self.A.nvars)
 
-            self.mylog.vprint("Iteration:", it, "objective:", u.d(solution * objFac, f=2))
+        for ii in range(len(cind)):
+            task.putcj(cind[ii], cval[ii])
 
-            delta = xx - old_x
-            absdiff = np.sum(np.abs(delta), axis=0)
-            if absdiff < 1:
-                self.mylog.vprint("Converged on full solution.")
-                break
+        for ii in range(self.nvars):
+            task.putvarbound(ii, bdic[vkeys[ii]], vlb[ii], vub[ii])
 
-            # Avoid oscillatory solutions. Look only at most recent solutions. Within $10.
-            isclosenough = abs(-solution - min(old_solutions[int(it / 2) :])) < 10 * self.xi_n[0]
-            if isclosenough:
-                self.mylog.vprint("Converged through selecting minimum oscillating objective.")
-                break
+        for ii in range(len(integrality)):
+            task.putvartype(integrality[ii], mosek.variabletype.type_int)
 
-            if it > 59:
-                self.mylog.vprint("WARNING: Exiting loop on maximum iterations.")
-                break
+        for ii in range(self.A.ncons):
+            task.putarow(ii, Aind[ii], Aval[ii])
+            task.putconbound(ii, bdic[ckeys[ii]], clb[ii], cub[ii])
 
-            old_solutions.append(-solution)
-            old_x = xx
+        task.putobjsense(mosek.objsense.minimize)
+        task.optimize()
+
+        # Problem MUST contain binary variables to make these calls.
+        solsta = task.getsolsta(mosek.soltype.itg)
+        solverSuccess = (solsta == mosek.solsta.integer_optimal)
 
+        xx = np.array(task.getxx(mosek.soltype.itg))
+        solution = task.getprimalobj(mosek.soltype.itg)
         task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
+        task.solutionsummary(mosek.streamtype.msg)
         # task.writedata(self._name+'.ptf')
-        if solsta == mosek.solsta.integer_optimal:
-            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
-            task.solutionsummary(mosek.streamtype.msg)
-            self.mylog.vprint("Objective:", u.d(solution * objFac))
-            self.caseStatus = "solved"
-            # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
-            self._aggregateResults(xx)
-            self._timestamp = datetime.now().strftime("%Y/%m/%d %H:%M:%S")
-        else:
-            self.mylog.vprint("WARNING: Optimization failed:", "Infeasible or unbounded.")
-            task.solutionsummary(mosek.streamtype.msg)
-            self.caseStatus = "unsuccessful"
 
-        return None
+        return solution, xx, solverSuccess, solverMsg
 
     def _estimateMedicare(self, x=None, withMedicare=True):
         """
@@ -3066,13 +3095,3 @@ def _formatSpreadsheet(ws, ftype):
                 cell.number_format = fstring
 
     return None
-
-
-def _streamPrinter(text):
-    """
-    Define a stream printer to grab output from MOSEK.
-    """
-    import sys
-
-    sys.stdout.write(text)
-    sys.stdout.flush()

owlplanner-2025.5.1/src/owlplanner/version.py

@@ -0,0 +1 @@
+__version__ = "2025.05.01"

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/ui/Documentation.py

@@ -285,6 +285,14 @@ and past 2 years, when applicable. Values default to zero.
 These numbers are needed to calculate the Income-Related Monthly Adjusted Amounts (IRMAA).
 MAGI for current year is required as it allows plan to start in mid-year for the first year.
 
+Different solvers can be selected. This option is mostly for verification purposes. All solvers
+tested (HiGHS, COIN-OR Branch-and-Cut solver, and MOSEK) provided very similar results.
+Due to the mixed integer formulation, solver performance is sometimes unpredictable.
+In general, CBC will tend to be slower, partly because of the algorithm,
+and partly because it solves the problem through a model description saved in
+a temporary file requiring I/O.
+Using HiGHS for most cases provides very good results.
+
 The time profile modulating the net spending amount
 can be selected to either be *flat* or follow a *smile* shape.
 The smile shape has three configurable parameters: a *dip* percentage

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/ui/Optimization_Parameters.py

@@ -82,12 +82,13 @@ else:
                 if years[ii] > 0:
                     ret = kz.getNum(f"MAGI for year {years[ii]} ($k)", "MAGI" + str(ii), help=helpmsg)
 
+    st.divider()
+    st.write("##### Solver")
+    choices = ["HiGHS", "PuLP/CBC"]
     if owb.hasMOSEK():
-        st.divider()
-        st.write("##### Solver")
-        choices = ["HiGHS", "MOSEK"]
-        kz.initKey("solver", choices[0])
-        ret = kz.getRadio("Linear programming solver", choices, "solver")
+        choices += ["MOSEK"]
+    kz.initKey("solver", choices[0])
+    ret = kz.getRadio("Linear programming solver", choices, "solver")
 
     st.divider()
     st.write("##### Spending Profile")

{owlplanner-2025.4.26 → owlplanner-2025.5.1}/ui/requirements.txt

@@ -4,7 +4,8 @@ seaborn
 pandas
 openpyxl
 odfpy
+pulp
 scipy
 streamlit
 toml
-owlplanner >= 2025.04.26
+owlplanner >= 2025.05.01

owlplanner-2025.4.26/src/owlplanner/version.py

@@ -1 +0,0 @@
-__version__ = "2025.04.26"