pylppinv 1.0.3__tar.gz

pylppinv-1.0.3/LICENSE

@@ -0,0 +1,7 @@
+Copyright 2021 econcz
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

pylppinv-1.0.3/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: pylppinv
+Version: 1.0.3
+Summary: Linear Programming via Pseudoinverse Estimation
+Author-email: The Economist <29724411+econcz@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/econcz/pylppinv
+Project-URL: Bug Tracker, https://github.com/econcz/pylppinv/issues
+Keywords: linear-programing,convex-optimization,least-squares,generalized-inverse,regularization
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyclsp>=1.1.2
+Dynamic: license-file
+
+# Linear Programming via Pseudoinverse Estimation
+
+The **Linear Programming via Pseudoinverse Estimation (LPPinv)** is a two-stage estimation method that reformulates linear programs as structured least-squares problems. Based on the [Convex Least Squares Programming (CLSP)](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming") framework, LPPinv solves linear inequality, equality, and bound constraints by (1) constructing a canonical constraint system and computing a pseudoinverse projection, followed by (2) a convex-programming correction stage to refine the solution under additional regularization (e.g., Lasso, Ridge, or Elastic Net).  
+LPPinv is intended for **underdetermined** and **ill-posed** linear problems, for which standard solvers fail.
+
+## Installation
+
+```bash
+pip install pylppinv
+```
+
+## Quick Example
+
+```python
+from lppinv import lppinv
+import numpy as np
+
+# Define inequality constraints A_ub @ x <= b_ub
+A_ub = [
+    [1, 1],
+    [2, 1]
+]
+b_ub = [5, 8]
+
+# Define equality constraints A_eq @ x = b_eq
+A_eq = [
+    [1, -1]
+]
+b_eq = [1]
+
+# Define bounds for x1 and x2
+bounds = [(0, 5), (0, None)]
+
+# Run the LP via CLSP
+result = lppinv(
+    c      = [1, 1],  # not used in CLSP but included for compatibility
+    A_ub   = A_ub,
+    b_ub   = b_ub,
+    A_eq   = A_eq,
+    b_eq   = b_eq,
+    bounds = bounds
+)
+
+# Output solution
+print("Solution vector (x):")
+print(result.x.flatten())
+```
+
+## User Reference
+
+For comprehensive information on the estimator’s capabilities, advanced configuration options, and implementation details, please refer to the [pyclsp module](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming"), on which LPPinv is based.
+
+**LPPINV Parameters:**
+
+`c` : *array_like* of shape *(p,)*, optional  
+Objective function coefficients. Accepted for API parity; not used by CLSP.
+
+`A_ub` : *array_like* of shape *(i, p)*, optional  
+Matrix for inequality constraints `A_ub @ x <= b_ub`.
+
+`b_ub` : *array_like* of shape *(i,)*, optional  
+Right-hand side vector for inequality constraints.
+
+`A_eq` : *array_like* of shape *(j, p)*, optional  
+Matrix for equality constraints `A_eq @ x = b_eq`.
+
+`b_eq` : *array_like* of shape *(j,)*, optional  
+Right-hand side vector for equality constraints.
+
+`bounds` : *sequence* of *(low, high)*, optional  
+Bounds on variables. If a single tuple **(low, high)** is given, it is applied to all variables. If None, defaults to *(0, None)* for each variable (non-negativity).
+
+Please note that either `A_ub` and `b_ub` or `A_eq` and `b_eq` must be provided.
+
+**CLSP Parameters:**  
+
+`r` : *int*, default = *1*  
+Number of refinement iterations for the pseudoinverse-based estimator.
+
+`Z` : *np.ndarray* or *None*  
+A symmetric idempotent matrix (projector) defining the subspace for Bott–Duffin pseudoinversion. If *None*, the identity matrix is used, reducing the Bott–Duffin inverse to the Moore–Penrose case.
+
+`tolerance` : *float*, default = *square root of machine epsilon*  
+Convergence tolerance for NRMSE change between refinement iterations.
+
+`iteration_limit` : *int*, default = *50*  
+Maximum number of iterations allowed in the refinement loop.
+
+`final` : *bool*, default = *True*  
+If *True*, a convex programming problem is solved to refine `zhat`. The resulting solution `z` minimizes a weighted L1/L2 norm around `zhat` subject to `Az = b`.
+
+`alpha` : *float*, default = *1.0*  
+Regularization parameter (weight) in the final convex program:  
+- `α = 0`: Lasso (L1 norm)  
+- `α = 1`: Tikhonov Regularization/Ridge (L2 norm)  
+- `0 < α < 1`: Elastic Net
+
+`*args`, `**kwargs` : optional  
+CVXPY arguments passed to the CVXPY solver.
+
+**Returns:**  
+*self*
+
+`self.A`             : *np.ndarray*  
+Design matrix `A` = [`C` | `S`; `M` | `Q`], where `Q` is either a zero matrix or *S_residual*.
+
+`self.b`             : *np.ndarray*  
+Vector of the right-hand side.
+
+`self.zhat`          : *np.ndarray*  
+Vector of the first-step estimate.
+
+`self.r`             : *int*  
+Number of refinement iterations performed in the first step.
+
+`self.z`             : *np.ndarray*  
+Vector of the final solution. If the second step is disabled, it equals `self.zhat`.
+
+`self.x`             : *np.ndarray*  
+`m × p` matrix or vector containing the variable component of `z`.
+
+`self.y`             : *np.ndarray*  
+Vector containing the slack component of `z`.
+
+`self.kappaC`        : *float*  
+Spectral κ() for *C_canon*.
+
+`self.kappaB`        : *float*  
+Spectral κ() for *B* = *C_canon^+ A*.
+
+`self.kappaA`        : *float*  
+Spectral κ() for `A`.
+
+`self.rmsa`          : *float*  
+Total root mean square alignment (RMSA).
+
+`self.r2_partial`    : *float*  
+R² for the `M` block in `A`.
+
+`self.nrmse`         : *float*  
+Mean square error calculated from `A` and normalized by standard deviation (NRMSE).
+
+`self.nrmse_partial` : *float*  
+Mean square error from the `M` block in `A` and normalized by standard deviation (NRMSE).
+
+`self.z_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.z_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+## Bibliography
+
+To be added.
+
+## License
+
+MIT License — see the [LICENSE](LICENSE) file.

pylppinv-1.0.3/README.md

@@ -0,0 +1,170 @@
+# Linear Programming via Pseudoinverse Estimation
+
+The **Linear Programming via Pseudoinverse Estimation (LPPinv)** is a two-stage estimation method that reformulates linear programs as structured least-squares problems. Based on the [Convex Least Squares Programming (CLSP)](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming") framework, LPPinv solves linear inequality, equality, and bound constraints by (1) constructing a canonical constraint system and computing a pseudoinverse projection, followed by (2) a convex-programming correction stage to refine the solution under additional regularization (e.g., Lasso, Ridge, or Elastic Net).  
+LPPinv is intended for **underdetermined** and **ill-posed** linear problems, for which standard solvers fail.
+
+## Installation
+
+```bash
+pip install pylppinv
+```
+
+## Quick Example
+
+```python
+from lppinv import lppinv
+import numpy as np
+
+# Define inequality constraints A_ub @ x <= b_ub
+A_ub = [
+    [1, 1],
+    [2, 1]
+]
+b_ub = [5, 8]
+
+# Define equality constraints A_eq @ x = b_eq
+A_eq = [
+    [1, -1]
+]
+b_eq = [1]
+
+# Define bounds for x1 and x2
+bounds = [(0, 5), (0, None)]
+
+# Run the LP via CLSP
+result = lppinv(
+    c      = [1, 1],  # not used in CLSP but included for compatibility
+    A_ub   = A_ub,
+    b_ub   = b_ub,
+    A_eq   = A_eq,
+    b_eq   = b_eq,
+    bounds = bounds
+)
+
+# Output solution
+print("Solution vector (x):")
+print(result.x.flatten())
+```
+
+## User Reference
+
+For comprehensive information on the estimator’s capabilities, advanced configuration options, and implementation details, please refer to the [pyclsp module](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming"), on which LPPinv is based.
+
+**LPPINV Parameters:**
+
+`c` : *array_like* of shape *(p,)*, optional  
+Objective function coefficients. Accepted for API parity; not used by CLSP.
+
+`A_ub` : *array_like* of shape *(i, p)*, optional  
+Matrix for inequality constraints `A_ub @ x <= b_ub`.
+
+`b_ub` : *array_like* of shape *(i,)*, optional  
+Right-hand side vector for inequality constraints.
+
+`A_eq` : *array_like* of shape *(j, p)*, optional  
+Matrix for equality constraints `A_eq @ x = b_eq`.
+
+`b_eq` : *array_like* of shape *(j,)*, optional  
+Right-hand side vector for equality constraints.
+
+`bounds` : *sequence* of *(low, high)*, optional  
+Bounds on variables. If a single tuple **(low, high)** is given, it is applied to all variables. If None, defaults to *(0, None)* for each variable (non-negativity).
+
+Please note that either `A_ub` and `b_ub` or `A_eq` and `b_eq` must be provided.
+
+**CLSP Parameters:**  
+
+`r` : *int*, default = *1*  
+Number of refinement iterations for the pseudoinverse-based estimator.
+
+`Z` : *np.ndarray* or *None*  
+A symmetric idempotent matrix (projector) defining the subspace for Bott–Duffin pseudoinversion. If *None*, the identity matrix is used, reducing the Bott–Duffin inverse to the Moore–Penrose case.
+
+`tolerance` : *float*, default = *square root of machine epsilon*  
+Convergence tolerance for NRMSE change between refinement iterations.
+
+`iteration_limit` : *int*, default = *50*  
+Maximum number of iterations allowed in the refinement loop.
+
+`final` : *bool*, default = *True*  
+If *True*, a convex programming problem is solved to refine `zhat`. The resulting solution `z` minimizes a weighted L1/L2 norm around `zhat` subject to `Az = b`.
+
+`alpha` : *float*, default = *1.0*  
+Regularization parameter (weight) in the final convex program:  
+- `α = 0`: Lasso (L1 norm)  
+- `α = 1`: Tikhonov Regularization/Ridge (L2 norm)  
+- `0 < α < 1`: Elastic Net
+
+`*args`, `**kwargs` : optional  
+CVXPY arguments passed to the CVXPY solver.
+
+**Returns:**  
+*self*
+
+`self.A`             : *np.ndarray*  
+Design matrix `A` = [`C` | `S`; `M` | `Q`], where `Q` is either a zero matrix or *S_residual*.
+
+`self.b`             : *np.ndarray*  
+Vector of the right-hand side.
+
+`self.zhat`          : *np.ndarray*  
+Vector of the first-step estimate.
+
+`self.r`             : *int*  
+Number of refinement iterations performed in the first step.
+
+`self.z`             : *np.ndarray*  
+Vector of the final solution. If the second step is disabled, it equals `self.zhat`.
+
+`self.x`             : *np.ndarray*  
+`m × p` matrix or vector containing the variable component of `z`.
+
+`self.y`             : *np.ndarray*  
+Vector containing the slack component of `z`.
+
+`self.kappaC`        : *float*  
+Spectral κ() for *C_canon*.
+
+`self.kappaB`        : *float*  
+Spectral κ() for *B* = *C_canon^+ A*.
+
+`self.kappaA`        : *float*  
+Spectral κ() for `A`.
+
+`self.rmsa`          : *float*  
+Total root mean square alignment (RMSA).
+
+`self.r2_partial`    : *float*  
+R² for the `M` block in `A`.
+
+`self.nrmse`         : *float*  
+Mean square error calculated from `A` and normalized by standard deviation (NRMSE).
+
+`self.nrmse_partial` : *float*  
+Mean square error from the `M` block in `A` and normalized by standard deviation (NRMSE).
+
+`self.z_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.z_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+## Bibliography
+
+To be added.
+
+## License
+
+MIT License — see the [LICENSE](LICENSE) file.

pylppinv-1.0.3/lppinv/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "1.0.3"
+
+from .lppinv import lppinv
+
+__all__ = [
+    "lppinv",
+    "__version__"
+]

pylppinv-1.0.3/lppinv/lppinv.py

@@ -0,0 +1,158 @@
+import numpy                           as np
+from   typing          import Sequence
+from   collections.abc import Sequence as sq
+from   clsp            import CLSP
+
+class LPPinvInputError(Exception):
+    """
+    Exception class for LPPinv-related input errors.
+
+    Represents internal failures in Linear Programming via Pseudoinversion
+    routines due to malformed or incompatible input. Supports structured
+    messaging and optional diagnostic augmentation.
+
+    Parameters
+    ----------
+    message : str, optional
+        Description of the error. Defaults to a generic LPPinv message.
+
+    code : int or str, optional
+        Optional error code or identifier for downstream handling.
+
+    Usage
+    -----
+    raise LPPinvInputError("A_ub and b_ub are incompatible", code=201)
+    """
+    
+    def __init__(self, message: str = "An error occurred in LPPinv",
+                 code: int | str | None = None):
+        self.message = message
+        self.code    = code
+        full_message = f"{message} (Code: {code})" if code is not None         \
+                                                   else message
+        super().__init__(full_message)
+        
+    def __str__(self) -> str:
+        return self.message if self.code is None                               \
+                            else f"{self.message} [Code: {self.code}]"
+    
+    def as_dict(self) -> dict:
+        """
+        Return the error as a dictionary for structured logging or JSON output.
+        """
+        return {"error": self.message, "code": self.code}
+
+def lppinv(
+    c:      Sequence[float]                         | None = None,
+    A_ub:   Sequence[Sequence[float]]               | None = None,
+    b_ub:   Sequence[float]                         | None = None,
+    A_eq:   Sequence[Sequence[float]]               | None = None,
+    b_eq:   Sequence[float]                         | None = None,
+    bounds: list[tuple[float | None, float | None]] |                          \
+                 tuple[float | None, float | None]  | None = None,
+    *args, **kwargs
+) -> CLSP:
+    """
+    Solve a linear program via Convex Least Squares Programming (CLSP)
+    estimator.
+
+    Parameters (SciPy linprog-compatible)
+    -------------------------------------
+    c : array_like of shape (p,), optional
+        Objective function coefficients. Accepted for API parity; not used
+        by CLSP.
+    A_ub : array_like of shape (i, p), optional
+        Matrix for inequality constraints A_ub @ x <= b_ub.
+    b_ub : array_like of shape (i,), optional
+        Right-hand side vector for inequality constraints.
+    A_eq : array_like of shape (j, p), optional
+        Matrix for equality constraints A_eq @ x = b_eq.
+    b_eq : array_like of shape (j,), optional
+        Right-hand side vector for equality constraints.
+    bounds : sequence of (low, high), optional
+        Bounds on variables. If a single tuple (low, high) is given, it is
+        applied to all variables. If None, defaults to (0, None) for each
+        variable (non-negativity).
+
+    Returns
+    -------
+    CLSP
+        The fitted CLSP object. Consult https://pypi.org/project/pyclsp/
+    """
+    # assert conformability of constraint sets (A_ub, b_ub) and (A_eq, b_eq)
+    if  not ((A_ub is not None and b_ub is not None) or
+             (A_eq is not None and b_eq is not None)):
+        raise LPPinvInputError("At least one complete constraint set "
+                               "(A_ub, b_ub) or (A_eq, b_eq) must be "
+                               "provided.")
+    if  A_ub is not None:
+        A_ub = np.asarray(A_ub, dtype=np.float64)
+        if A_ub.ndim == 1:
+            A_ub = A_ub.reshape(1, -1)
+        b_ub = np.asarray(b_ub, dtype=np.float64).reshape(-1, 1)
+        if A_ub.shape[0] != b_ub.shape[0]:
+            raise LPPinvInputError(f"A_ub and b_ub must have the same number "
+                                   f"of rows: "
+                                   f"{A_ub.shape[0]} vs {b_ub.shape[0]}")
+        n_vars = A_ub.shape[1]                         # number of variables
+    if  A_eq is not None:
+        A_eq = np.asarray(A_eq, dtype=np.float64)
+        if A_eq.ndim == 1:
+            A_eq = A_eq.reshape(1, -1)
+        b_eq = np.asarray(b_eq, dtype=np.float64).reshape(-1, 1)
+        if A_eq.shape[0] != b_eq.shape[0]:
+            raise LPPinvInputError(f"A_eq and b_eq must have the same number "
+                                   f"of rows: "
+                                   f"{A_eq.shape[0]} vs {b_eq.shape[0]}")
+        n_vars = A_eq.shape[1]                         # number of variables
+
+    # (b) Construct the right-hand side vector
+    if  bounds is None:                                # normalize bounds
+        bounds = (0, None)
+    if  isinstance(bounds, tuple):
+        bounds = [bounds] * n_vars                     # replicate (low, high)
+    elif   isinstance(bounds, sq):
+        if len(bounds) > 1 and len(bounds) != n_vars:
+            raise LPPinvInputError(f"Bounds length {len(bounds)} does not "
+                                   f"match number of variables {n_vars}.")
+        elif len(bounds) == 1:
+            bounds = bounds * n_vars                   # replicate (low, high)
+    if any((l is not None and l < 0) or
+           (h is not None and h < 0) for l, h in bounds):
+        raise LPPinvInputError("Negative lower or upper bounds are not "
+                               "allowed in linear programs.")
+    b = np.empty((0, 1))
+    if b_ub is not None:
+        b = b_ub
+    if b_eq is not None:
+        b = np.vstack([b, b_eq])
+    b = np.vstack([b, np.array([l if l is not None else 0      for l, h
+                                in bounds]).reshape(-1, 1),
+                      np.array([h if h is not None else np.inf for l, h
+                                in bounds]).reshape(-1, 1)])
+
+    # (C), (S) Construct conformable blocks for the design matrix A
+    if  A_ub is not None and A_eq is not None:
+        if A_ub.shape[1] != A_eq.shape[1]:
+            raise LPPinvInputError(f"A_ub and A_eq must have the same number "
+                                   f"of columns: "
+                                   f"{A_ub.shape[1]} vs {A_eq.shape[1]}")
+    C = np.empty((0, n_vars))
+    S = np.empty((0, 0))
+    if  A_ub is not None:
+        C = A_ub
+        S = np.eye(A_ub.shape[0])
+    if  A_eq is not None:
+        C = np.vstack([C, A_eq])
+        S = np.vstack([S, np.zeros((A_eq.shape[0], S.shape[1]))])
+    C = np.vstack([C, np.tile(np.eye(n_vars), (2,1))])
+    S = np.vstack([np.hstack([S, np.zeros((S.shape[0],  n_vars))]), np.tile(
+                   np.hstack([np.zeros((n_vars, S.shape[1])), np.eye(n_vars)]),
+                   (2,1))])
+
+    # perform estimation and return the result
+    finite_rows = np.isfinite(b).ravel()               # drop rows with np.inf
+    return CLSP().solve(problem='general', C=C[finite_rows, :],
+                                           S=S[finite_rows, :],
+                                           b=b[finite_rows],
+                        *args, **kwargs)

pylppinv-1.0.3/pylppinv.egg-info/PKG-INFO

@@ -0,0 +1,193 @@
+Metadata-Version: 2.4
+Name: pylppinv
+Version: 1.0.3
+Summary: Linear Programming via Pseudoinverse Estimation
+Author-email: The Economist <29724411+econcz@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/econcz/pylppinv
+Project-URL: Bug Tracker, https://github.com/econcz/pylppinv/issues
+Keywords: linear-programing,convex-optimization,least-squares,generalized-inverse,regularization
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Classifier: Topic :: Scientific/Engineering :: Information Analysis
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: pyclsp>=1.1.2
+Dynamic: license-file
+
+# Linear Programming via Pseudoinverse Estimation
+
+The **Linear Programming via Pseudoinverse Estimation (LPPinv)** is a two-stage estimation method that reformulates linear programs as structured least-squares problems. Based on the [Convex Least Squares Programming (CLSP)](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming") framework, LPPinv solves linear inequality, equality, and bound constraints by (1) constructing a canonical constraint system and computing a pseudoinverse projection, followed by (2) a convex-programming correction stage to refine the solution under additional regularization (e.g., Lasso, Ridge, or Elastic Net).  
+LPPinv is intended for **underdetermined** and **ill-posed** linear problems, for which standard solvers fail.
+
+## Installation
+
+```bash
+pip install pylppinv
+```
+
+## Quick Example
+
+```python
+from lppinv import lppinv
+import numpy as np
+
+# Define inequality constraints A_ub @ x <= b_ub
+A_ub = [
+    [1, 1],
+    [2, 1]
+]
+b_ub = [5, 8]
+
+# Define equality constraints A_eq @ x = b_eq
+A_eq = [
+    [1, -1]
+]
+b_eq = [1]
+
+# Define bounds for x1 and x2
+bounds = [(0, 5), (0, None)]
+
+# Run the LP via CLSP
+result = lppinv(
+    c      = [1, 1],  # not used in CLSP but included for compatibility
+    A_ub   = A_ub,
+    b_ub   = b_ub,
+    A_eq   = A_eq,
+    b_eq   = b_eq,
+    bounds = bounds
+)
+
+# Output solution
+print("Solution vector (x):")
+print(result.x.flatten())
+```
+
+## User Reference
+
+For comprehensive information on the estimator’s capabilities, advanced configuration options, and implementation details, please refer to the [pyclsp module](https://pypi.org/project/pyclsp/ "Convex Least Squares Programming"), on which LPPinv is based.
+
+**LPPINV Parameters:**
+
+`c` : *array_like* of shape *(p,)*, optional  
+Objective function coefficients. Accepted for API parity; not used by CLSP.
+
+`A_ub` : *array_like* of shape *(i, p)*, optional  
+Matrix for inequality constraints `A_ub @ x <= b_ub`.
+
+`b_ub` : *array_like* of shape *(i,)*, optional  
+Right-hand side vector for inequality constraints.
+
+`A_eq` : *array_like* of shape *(j, p)*, optional  
+Matrix for equality constraints `A_eq @ x = b_eq`.
+
+`b_eq` : *array_like* of shape *(j,)*, optional  
+Right-hand side vector for equality constraints.
+
+`bounds` : *sequence* of *(low, high)*, optional  
+Bounds on variables. If a single tuple **(low, high)** is given, it is applied to all variables. If None, defaults to *(0, None)* for each variable (non-negativity).
+
+Please note that either `A_ub` and `b_ub` or `A_eq` and `b_eq` must be provided.
+
+**CLSP Parameters:**  
+
+`r` : *int*, default = *1*  
+Number of refinement iterations for the pseudoinverse-based estimator.
+
+`Z` : *np.ndarray* or *None*  
+A symmetric idempotent matrix (projector) defining the subspace for Bott–Duffin pseudoinversion. If *None*, the identity matrix is used, reducing the Bott–Duffin inverse to the Moore–Penrose case.
+
+`tolerance` : *float*, default = *square root of machine epsilon*  
+Convergence tolerance for NRMSE change between refinement iterations.
+
+`iteration_limit` : *int*, default = *50*  
+Maximum number of iterations allowed in the refinement loop.
+
+`final` : *bool*, default = *True*  
+If *True*, a convex programming problem is solved to refine `zhat`. The resulting solution `z` minimizes a weighted L1/L2 norm around `zhat` subject to `Az = b`.
+
+`alpha` : *float*, default = *1.0*  
+Regularization parameter (weight) in the final convex program:  
+- `α = 0`: Lasso (L1 norm)  
+- `α = 1`: Tikhonov Regularization/Ridge (L2 norm)  
+- `0 < α < 1`: Elastic Net
+
+`*args`, `**kwargs` : optional  
+CVXPY arguments passed to the CVXPY solver.
+
+**Returns:**  
+*self*
+
+`self.A`             : *np.ndarray*  
+Design matrix `A` = [`C` | `S`; `M` | `Q`], where `Q` is either a zero matrix or *S_residual*.
+
+`self.b`             : *np.ndarray*  
+Vector of the right-hand side.
+
+`self.zhat`          : *np.ndarray*  
+Vector of the first-step estimate.
+
+`self.r`             : *int*  
+Number of refinement iterations performed in the first step.
+
+`self.z`             : *np.ndarray*  
+Vector of the final solution. If the second step is disabled, it equals `self.zhat`.
+
+`self.x`             : *np.ndarray*  
+`m × p` matrix or vector containing the variable component of `z`.
+
+`self.y`             : *np.ndarray*  
+Vector containing the slack component of `z`.
+
+`self.kappaC`        : *float*  
+Spectral κ() for *C_canon*.
+
+`self.kappaB`        : *float*  
+Spectral κ() for *B* = *C_canon^+ A*.
+
+`self.kappaA`        : *float*  
+Spectral κ() for `A`.
+
+`self.rmsa`          : *float*  
+Total root mean square alignment (RMSA).
+
+`self.r2_partial`    : *float*  
+R² for the `M` block in `A`.
+
+`self.nrmse`         : *float*  
+Mean square error calculated from `A` and normalized by standard deviation (NRMSE).
+
+`self.nrmse_partial` : *float*  
+Mean square error from the `M` block in `A` and normalized by standard deviation (NRMSE).
+
+`self.z_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.z_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.x_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_lower`       : *np.ndarray*  
+Lower bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+`self.y_upper`       : *np.ndarray*  
+Upper bound of the diagnostic interval (confidence band) based on κ(`A`).
+
+## Bibliography
+
+To be added.
+
+## License
+
+MIT License — see the [LICENSE](LICENSE) file.

pylppinv-1.0.3/pylppinv.egg-info/SOURCES.txt

@@ -0,0 +1,10 @@
+LICENSE
+README.md
+pyproject.toml
+lppinv/__init__.py
+lppinv/lppinv.py
+pylppinv.egg-info/PKG-INFO
+pylppinv.egg-info/SOURCES.txt
+pylppinv.egg-info/dependency_links.txt
+pylppinv.egg-info/requires.txt
+pylppinv.egg-info/top_level.txt

pylppinv-1.0.3/pylppinv.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

pylppinv-1.0.3/pylppinv.egg-info/requires.txt

@@ -0,0 +1,2 @@
+numpy>=1.24
+pyclsp>=1.1.2

pylppinv-1.0.3/pylppinv.egg-info/top_level.txt

@@ -0,0 +1 @@
+lppinv

pylppinv-1.0.3/pyproject.toml

@@ -0,0 +1,42 @@
+[project]
+name = "pylppinv"
+version = "1.0.3"
+description = "Linear Programming via Pseudoinverse Estimation"
+readme = "README.md"
+requires-python = ">=3.10"
+license = "MIT"
+license-files = ["LICENSE"]
+authors = [
+  { name = "The Economist", email = "29724411+econcz@users.noreply.github.com" }
+]
+keywords = [
+  "linear-programing",
+  "convex-optimization",
+  "least-squares",
+  "generalized-inverse",
+  "regularization"
+]
+classifiers = [
+  "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Operating System :: OS Independent",
+  "Topic :: Scientific/Engineering :: Mathematics",
+  "Topic :: Scientific/Engineering :: Information Analysis"
+]
+dependencies = [
+  "numpy>=1.24",
+  "pyclsp>=1.1.2"
+]
+
+[project.urls]
+Homepage = "https://github.com/econcz/pylppinv"
+"Bug Tracker" = "https://github.com/econcz/pylppinv/issues"
+
+[build-system]
+requires = ["setuptools>=77", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[tool.setuptools]
+packages = ["lppinv"]

pylppinv-1.0.3/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+