pyclsp 1.0.0__py3-none-any.whl

clsp/__init__.py

@@ -0,0 +1,8 @@
+__version__ = "1.0.0"
+
+from .clsp import CLSP
+
+__all__ = [
+    "CLSP",
+    "__version__"
+]

clsp/clsp.py

@@ -0,0 +1,232 @@
+import warnings
+import copy
+import numpy        as np
+import scipy.linalg as la
+import scipy.stats  as stats
+import cvxpy        as cp
+from types          import MethodType
+from .errors        import CLSPError
+from .utils         import CLSPCanonicalForm, CLSPCorrelogram, CLSPTTest
+from .solver        import CLSPSolve
+
+class CLSP:
+    def __init__(self):
+        """
+        Instantiate a CLSP (Convex Least Squares Programming) object.
+
+        This class initiates and stores the results of a two-stage estimation
+        process for constrained least-squares problems under a canonical matrix
+        structure. The approach is designed for underdetermined, ill-posed, or
+        structurally constrained systems.
+
+        Stage 1 estimates the solution z from the system A·z = b using a
+        pseudoinverse method. Depending on the projection matrix Z, this may
+        be the Moore–Penrose inverse (Z = I) or the Bott–Duffin inverse (Z ≠ I).
+        If r > 1, the pseudoinverse solution is iteratively refined using an
+        updated slack matrix Q to improve numerical stability and feasibility.
+
+        Stage 2 optionally refines the estimate using a convex optimization
+        step centered around the pseudoinverse estimate ẑ. Regularization is
+        governed by the user-specified parameter α:
+            • α = 0      → Lasso (ℓ₁ norm),
+            • α = 1      → Ridge (ℓ₂ norm),
+            • 0 < α < 1  → Elastic Net (ℓ₁ and ℓ₂ combined).
+
+        The class also supports diagnostic routines such as Monte Carlo
+        hypothesis testing and row-wise deletion sensitivity analysis.
+
+        Attributes
+        ----------
+        A : np.ndarray or None
+            Canonical design matrix with block structure A = [C | S; M | Q].
+
+        C_idx : tuple
+            Pair of integers defining the row and column ranges of the
+            C block inside A. Used for matrix slicing and partitioning.
+
+        b : np.ndarray or None
+            Right-hand side vector for the linear system A·z = b.
+
+        Z : np.ndarray or None
+            Projection matrix for Bott–Duffin inversion. Must be symmetric
+            and idempotent. Defaults to identity for Moore–Penrose.
+
+        zhat : np.ndarray or None
+            Unregularized pseudoinverse estimate of z from Step 1.
+
+        final : bool
+            Whether to run the second-stage convex refinement. If True,
+            the estimate is regularized via convex programming.
+
+        alpha : float
+            Regularization parameter:
+            - α = 0: Lasso (L1 penalty),
+            - α = 1: Ridge (L2 penalty),
+            - 0 < α < 1: Elastic Net combination.
+
+        z : np.ndarray or None
+            Final estimate of z after regularization (if final is True).
+            If skipped, z = zhat.
+
+        x : np.ndarray or None
+            Variable component extracted from z, reshaped into m × p.
+
+        y : np.ndarray or None
+            Slack component of z representing inequality residuals.
+
+        r : int
+            Number of refinement iterations performed during Step 1.
+            Iteration stops when NRMSE stabilizes or exceeds the limit.
+
+        kappaC : float or None
+            Condition number of the constraint block C (upper-left block
+            in A).
+
+        kappaB : float or None
+            Condition number of the projected estimator B^(r) = pinv(C)·A,
+            calculated during refinement.
+
+        kappaA : float or None
+            Condition number of the full canonical matrix A^(r) after
+            refinement step r.
+
+        rmsa : float or None
+            Total RMSA (Root Mean Square Adjustment) over all rows.
+
+        rmsa_i : list of float
+            Change in RMSA caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dkappaC : list of float
+            Change in κ(C) caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dkappaB : list of float
+            Change in κ(B) caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dkappaA : list of float
+            Change in κ(A) caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dnrmse : list of float
+            Change in NRMSE caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dzhat : list of float
+            Change in zhat caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dz : list of float
+            Change in z caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        rmsa_dx : list of float
+            Change in x caused by removing each row from [C | S]
+            and re-estimating the CLSP solution.
+
+        r2_partial : float or None
+            R² statistic computed over the M block. Reflects partial
+            goodness-of-fit in structured systems.
+
+        nrmse : float or None
+            Normalized RMSE between A·z and b, computed over full system.
+
+        nrmse_partial : float or None
+            NRMSE computed only over M block rows.
+
+        nrmse_ttest : list of float
+            NRMSE samples generated via simulation under the null, used
+            for empirical t-testing.
+
+        z_lower : np.ndarray or None
+            Lower bound of confidence band on z. Computed from κ(A) and
+            residual norm.
+
+        z_upper : np.ndarray or None
+            Upper bound of confidence band on z. Symmetric to z_lower.
+
+        seed : int
+            Random seed used for reproducible Monte Carlo diagnostics.
+
+        rng : np.random.Generator
+            Random number generator initialized using `seed`.
+
+        distribution : callable
+            Function that generates random samples for simulation.
+            Must accept a single integer argument `n`.
+
+        Methods
+        -------
+        error : method
+            Raise a CLSPError with optional diagnostics or contextual details.
+        
+        canonize : method
+            Construct matrix A = [C | S; M | Q] and define constraint partitions.
+        
+        solve : method
+            Main estimation routine performing pseudoinverse and convex steps.
+        
+        corr : method
+            Compute RMSA and condition diagnostics via leave-one-out row deletion
+            on [C | S]. Populates all `self.rmsa_*` lists. Output is external.
+        
+        ttest : method
+            Monte Carlo t-test for NRMSE using user-defined distribution. Returns
+            one-sided and two-sided p-values based on simulated means.
+        """
+        # Variables
+        self.A             : np.ndarray | None = None # design matrix, [C|S;M|Q]
+        self.C_idx         : tuple[int  | None,  int  | None]                  \
+                            = (None, None)            # indices of the C block
+        self.b             : np.ndarray | None = None # right-hand side
+        self.Z             : np.ndarray | None = None # B-D subspace matrix
+        self.r             : int               = 0    # number of iterations
+        self.zhat          : np.ndarray | None = None # first-step estimate
+        self.final         : bool              = True # inclusion of second step
+        self.alpha         : float             = 1.0  # regularization parameter
+        self.z             : np.ndarray | None = None # final solution
+        self.x             : np.ndarray | None = None # variable component of z
+        self.y             : np.ndarray | None = None # slack component of z
+        self.kappaC        : float      | None = None # spectral κ() for C_canon
+        self.kappaB        : float      | None = None # spectral κ() for B^(r)
+        self.kappaA        : float      | None = None # spectral κ() for A^(r)
+        self.rmsa          : float      | None = None # total RMSA
+        self.rmsa_i        : list[float]       = []   # list of row RMSA
+        self.rmsa_dkappaC  : list[float]       = []   # list of Δκ(C)
+        self.rmsa_dkappaB  : list[float]       = []   # list of Δκ(B)
+        self.rmsa_dkappaA  : list[float]       = []   # list of Δκ(A)
+        self.rmsa_dnrmse   : list[float]       = []   # list of ΔNRMSE
+        self.rmsa_dzhat    : list[float]       = []   # list of Δzhat
+        self.rmsa_dz       : list[float]       = []   # list of Δz
+        self.rmsa_dx       : list[float]       = []   # list of Δx
+        self.r2_partial    : float      | None = None # R^2   for the M block
+        self.nrmse         : float      | None = None # NRMSE for A
+        self.nrmse_partial : float      | None = None # NRMSE for the M block
+        self.nrmse_ttest   : list[float]       = []   # list of NRMSE
+        self.z_lower       : np.ndarray | None = None # lower confidence band
+        self.z_upper       : np.ndarray | None = None # upper confidence band
+        self.seed          : int               = 123456789    # Monte Carlo
+        self.rng           = np.random.default_rng(self.seed)
+        self.distribution  = lambda n: self.rng.normal(loc=0, scale=1, size=n)
+
+        # Methods
+        self.error         = CLSPError
+        self.canonize      = MethodType(CLSPCanonicalForm, self)
+        self.solve         = MethodType(CLSPSolve,         self)
+        self.corr          = MethodType(CLSPCorrelogram,   self)
+        self.ttest         = MethodType(CLSPTTest,         self)
+
+    def __repr__(self):
+        """
+        Return a formatted string representation of the CLSP object
+        """
+        if self.z is None:
+            return "<CLSP: z=None, x=None, y=None>"
+
+        z_str = (np.array2string(self.z, max_line_width=80))
+        x_str = (np.array2string(self.x, max_line_width=80)
+                 if self.x is not None else "None")
+        y_str = (np.array2string(self.y, max_line_width=80)
+                 if self.y is not None else "None")
+        return f"<CLSP:\n z={z_str},\n x={x_str},\n y={y_str}>"

clsp/errors.py

@@ -0,0 +1,22 @@
+class CLSPError(Exception):
+    """
+    Exception class for CLSP-related errors.
+
+    Represents internal failures in Convex Least Squares Programming
+    routines. Supports structured messaging and optional diagnostic
+    augmentation.
+
+    Parameters
+    ----------
+    message : str, optional
+        Description of the error. Defaults to a generic CLSP message.
+
+    code : int or str, optional
+        Optional error code or identifier for downstream handling.
+
+    Usage
+    -----
+    raise CLSPError("Matrix A and b are incompatible", code=101)
+    """
+    def __init__(self, message: str = "An error occurred in CLSP"):
+        super().__init__(message)

clsp/solver.py

@@ -0,0 +1,274 @@
+import warnings
+import numpy        as np
+import scipy.linalg as la
+import cvxpy        as cp
+
+def CLSPSolve(
+    self, problem:         str   = "",   C: np.ndarray |  None  = None,
+          S: np.ndarray |  None  = None, M: np.ndarray |  None  = None,
+                                         b: np.ndarray |  None  = None,
+          m:     int    |  None  = None, p: int        |  None  = None,
+          i:     int             = 1,    j: int                 = 1,
+          zero_diagonal:   bool  = False,
+          r:     int             = 1,    Z: np.ndarray |  None  = None,
+          tolerance:       float                       |  None  = None,
+          iteration_limit: int                         |  None  = None,
+          final: bool   |  None  = None, alpha: float  |  None  = None,
+          *args, **kwargs
+) -> "CLSP":
+    """
+    Solve the Convex Least Squares Programming (CLSP) problem.
+
+    This method performs a two-step estimation:
+    (1) a pseudoinverse-based solution using either the Moore–Penrose or
+        Bott–Duffin inverse, optionally iterated for convergence;
+    (2) a convex-programming correction using Lasso, Ridge, or Elastic Net
+        regularization (if enabled).
+
+    Parameters
+    ----------
+    problem : str, optional
+        Structural template for matrix construction. One of:
+        - 'ap'   or 'tm' : allocation or transaction matrix problem.
+        - 'cmls' or 'rp' : constrained modular least squares or RP-type.
+        - ''     or other: General CLSP problems (user-defined C and/or M).
+
+    C, S, M : np.ndarray or None
+        Blocks of the constraint matrix A = [C | S; M | Q].
+        If `C` and/or `M` are provided, the matrix A is constructed
+        accordingly. If both are None and A is not yet defined, an error
+        is raised.
+
+    b : np.ndarray or None
+        Right-hand side vector. Must have as many rows as A. Required.
+
+    m, p : int or None
+        Dimensions of X ∈ ℝ^{m×p}, relevant for allocation problems ('ap').
+
+    i, j : int, default = 1
+        Grouping sizes for row and column sum constraints in AP problems.
+
+    zero_diagonal : bool, default = False
+        If True, enforces structural zero diagonals via identity truncation.
+
+    r : int, default = 1
+        Number of refinement iterations for the pseudoinverse-based estimator.
+        When `r > 1`, the slack block Q is updated iteratively to improve
+        feasibility in underdetermined or ill-posed systems.
+
+    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 to the Moore–Penrose case.
+
+    tolerance : float, optional
+        Convergence tolerance for NRMSE change between iterations. Default is
+        √(machine epsilon).
+
+    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 weight in the final convex program:
+        - α = 0: Lasso (L1 norm)
+        - α = 1: Ridge (L2 norm)
+        - 0 < α < 1: Elastic Net
+
+    *args, **kwargs : optional
+        Additional arguments passed to the CVXPY solver backend.
+
+    Attributes Set
+    ---------------
+    self.A : np.ndarray
+        Canonical design matrix constructed from (C, S, M, Q).
+
+    self.b : np.ndarray
+        Conformable right-hand side vector.
+
+    self.Z : np.ndarray
+        Projector matrix used for Bott–Duffin inversion.
+
+    self.zhat : np.ndarray
+        First-step solution (unregularized pseudoinverse estimate).
+
+    self.z : np.ndarray
+        Final estimate after optional convex refinement.
+
+    self.x, self.y : np.ndarray
+        Variable and slack components reshaped from `z`.
+
+    self.nrmse : float
+        Normalized root mean squared error over the full system.
+
+    self.r2_partial : float or np.nan
+        R² for the M block (if applicable), computed from partial residuals.
+
+    self.nrmse_partial : float
+        NRMSE over the M block, if defined.
+
+    self.kappaA, self.kappaB, self.kappaC : float
+        Condition numbers for the full, projected, and constrained system.
+
+    self.z_lower, self.z_upper : np.ndarray
+        Condition-weighted confidence band for z.
+
+    self.r : int
+        Number of refinement iterations performed.
+
+    Raises
+    ------
+    CLSPError
+        If the design matrix A or right-hand side b is malformed, inconsistent,
+        or incompatible with the structural assumptions of the problem.
+    """
+    # (A), (b) Construct a conformable canonical form for the CLSP estimator
+    if b is not None:
+        self.b = b
+    elif self.b is None:
+        raise self.error("Right-hand side vector b must be provided.")
+    if C is not None or M is not None:
+        self.canonize(problem, C, S, M, None, self.b.reshape(-1, 1),
+                                m, p, i, j, zero_diagonal)
+    elif self.A is None:
+        raise self.error("At least one of C or M must be provided.")
+    if self.A.shape[0] != self.b.shape[0]:
+        raise self.error(f"The matrix A and vector b must have the same "
+                         f"number of rows: A has {self.A.shape[0]}, but "
+                         f"b has {self.b.shape[0]}")
+
+    # (zhat) (Iterated if r > 1) first-step estimate
+    if r < 1:
+        raise self.error("Number of refinement iterations r must be ≥ 1.")
+    if Z is not None:
+        self.Z = Z
+    elif self.Z is None:
+        self.Z = np.eye(self.A.shape[1])
+    if tolerance       is not None:
+        self.tolerance       = tolerance
+    if iteration_limit is not None:
+        self.iteration_limit = iteration_limit
+    try:
+        if (not np.allclose(self.Z,          self.Z.T, atol=tolerance) or
+            not np.allclose(self.Z @ self.Z, self.Z,   atol=tolerance) or
+            self.Z.shape[0] != self.A.shape[1]):
+            raise ValueError
+    except ValueError:
+        raise self.error(f"Matrix Z must be symmetric, idempotent and "
+                         f"match the number of columns in A: expected "
+                         f"({self.A.shape[1]}, {self.A.shape[1]}), "
+                         f"got {self.Z.shape}")
+    for n_iter in range(1, 1 +
+                           (r if self.A.shape[0] > self.C_idx[0] else 1)):
+        # save A, zhat, and NRMSE from the previous step, construct Q
+        if n_iter > 1:
+            A_prev     = self.A.copy()
+            zhat_prev  = self.zhat.copy()
+            nrmse_prev = (np.linalg.norm(self.b  - self.A @ self.zhat) /
+                          np.sqrt(self.b.shape[0]) / np.std(self.b))
+            Q          = np.diagflat(-np.sign(self.b -
+                                     self.A @ self.zhat)[self.C_idx[0]:])
+            self.canonize(problem, C, S, M, Q, b.reshape(-1, 1),
+                                   m, p, i, j, zero_diagonal)
+        # solve via the Bott–Duffin inverse
+        self.zhat      = (la.pinv(self.Z @ (self.A.T @ self.A) @ self.Z) @
+                          self.Z @ self.A.T) @ self.b
+        self.nrmse     = (lambda residuals, sd:
+                          np.linalg.norm(residuals) / np.sqrt(sd.shape[0]) /
+                          np.std(sd) if not np.isclose(np.std(sd), 0) else
+                          np.inf)(self.b - self.A @ self.zhat, self.b)
+        # break on convergence
+        self.r         = n_iter
+        if n_iter > 1:
+            if (abs(self.nrmse - nrmse_prev) < self.tolerance or
+                n_iter                       > self.iteration_limit):
+                del A_prev, zhat_prev, nrmse_prev, Q
+                break
+    if not np.all(np.isfinite(self.zhat)):
+        self.zhat = np.nan
+        raise self.error("Pseudoinverse estimate zhat failed")
+
+    # (z) Final solution (if available), or set self.z = self.zhat
+    if final is not None:
+        self.final = final
+    if alpha is not None:
+        self.alpha = alpha
+    self.alpha = max(0, min(1, self.alpha))
+    if self.final:
+        # build a convex problem (p_cvx) and its solver (c_cvx)
+        z_cvx = cp.Variable(self.A.shape[1])
+        d_cvx = z_cvx - self.zhat.flatten()
+        if   np.isclose(self.alpha, 0):                # Lasso
+            f_obj = cp.norm1(d_cvx)
+            s_cvx = cp.ECOS
+        elif np.isclose(self.alpha, 1):                # Ridge
+            f_obj = cp.sum_squares(d_cvx)
+            s_cvx = cp.OSQP
+        else:                                          # Elastic Net
+            f_obj = ((1 - self.alpha) * cp.norm1(d_cvx)      +
+                     self.alpha       * cp.sum_squares(d_cvx))
+            s_cvx = cp.SCS
+        c_cvx = [self.A @ z_cvx == self.b.flatten()]
+        p_cvx = cp.Problem(cp.Minimize(f_obj), c_cvx)
+        # solve
+        try:
+            p_cvx.solve(solver=s_cvx, verbose=False,
+                                      *args, **kwargs) # pass arguments
+            if z_cvx.value is None:
+                warnings.warn(
+                    f"Step 2 infeasible ({p_cvx.status}); falling back to Step 1.",
+                    category=RuntimeWarning
+                )
+                self.z     = self.zhat
+            else:
+                self.z     = z_cvx.value
+                self.nrmse = (lambda residuals, sd:
+                          np.linalg.norm(residuals) / np.sqrt(sd.shape[0]) /
+                          np.std(sd) if not np.isclose(np.std(sd), 0) else
+                          np.inf)(self.b - self.A @ self.z,    self.b)
+        except (cp.SolverError, ValueError):
+            self.z = self.zhat
+    else:
+        self.z = self.zhat
+
+    # (x), (y) Variable and slack components of z
+    self.x = self.z[:self.C_idx[0]].reshape(m if m is not None else -1,
+                                            p if p is not None else  1)
+    self.y = self.z[self.C_idx[0]:]
+
+    # (kappaC), (kappaB), (kappaA) Condition numbers
+    self.kappaC            = np.linalg.cond(        self.A[:self.C_idx[0], :])
+    self.kappaB            = np.linalg.cond(la.pinv(self.A[:self.C_idx[0], :]) @
+                                            self.A)
+    self.kappaA            = np.linalg.cond(        self.A)
+
+    # (r2_partial), (nrmse_partial) M-block-based statistics
+    if self.A.shape[0]     > self.C_idx[0]:
+        M                  = self.A[self.C_idx[0]:, :self.C_idx[1]]
+        b_M                = self.b[-M.shape[0]:]
+        residuals_M        = b_M - M @ self.x.reshape(-1, 1)
+        self.r2_partial    = (lambda residuals, sd:
+                          1  -  (np.linalg.norm(residuals) ** 2            /
+                          np.linalg.norm(sd - np.mean(sd)) ** 2)
+                          if not np.isclose(np.std(sd), 0) else
+                          np.nan)(residuals_M,                 b_M)
+        self.nrmse_partial = (lambda residuals, sd:
+                          np.linalg.norm(residuals) / np.sqrt(sd.shape[0]) /
+                          np.std(sd) if not np.isclose(np.std(sd), 0) else
+                          np.inf)(residuals_M,                 b_M)
+        del M, b_M, residuals_M
+
+    # (z_lower), (z_upper) Condition-weighted confidence band
+    dz           = (self.kappaA                              * 
+                    np.linalg.norm(self.b - self.A @ self.z) /
+                    np.linalg.norm(self.b)
+                    if not np.isclose(np.linalg.norm(self.b), 0) else
+                    np.inf)
+    self.z_lower = self.z * (1 - dz)
+    self.z_upper = self.z * (1 + dz)
+
+return self

clsp/utils.py

@@ -0,0 +1,314 @@
+import copy
+import numpy       as np
+import scipy.stats as stats
+
+def CLSPCanonicalForm(
+    self, problem:        str  = "",   C: np.ndarray | None = None,
+          S: np.ndarray | None = None, M: np.ndarray | None = None,
+          Q: np.ndarray | None = None, b: np.ndarray | None = None,
+          m: int        | None = None, p: int        | None = None,
+          i: int               = 1,    j: int               = 1,
+          zero_diagonal:  bool = False
+) -> None:
+    """
+    Construct the canonical design matrix A = [C | S; M | Q] for CLSP.
+
+    This method assembles the constraint matrix A from user-supplied or
+    internally generated components — C, S, M, and Q — and assigns the
+    corresponding right-hand side vector b. It is a required pre-step
+    before solving a Convex Least Squares Programming (CLSP) problem.
+
+    Depending on the specified problem type, it can generate allocation,
+    transaction, or modular constraints and enforce optional diagonal
+    exclusions. All missing blocks are padded to ensure conformability.
+
+    Parameters
+    ----------
+    problem : str, optional
+        Structural template for matrix construction. One of:
+        - 'ap'   or 'tm' : allocation or transaction matrix problem.
+        - 'cmls' or 'rp' : constrained modular least squares or RP-type.
+        - ''     or other: General CLSP problems (user-defined C and/or M).
+
+    C, S, M : np.ndarray or None
+        Blocks of the constraint matrix A = [C | S; M | Q].
+        If `C` and/or `M` are provided, the matrix A is constructed
+        accordingly. If both are None and A is not yet defined, an error
+        is raised.
+
+    Q : np.ndarray or None
+        Externally supplied residual slack matrix used to adjust inequality
+        constraints in M. Required only when r > 1. Encodes the sign pattern
+        of residuals from the previous iteration and is used to construct the
+        [C | S; M | Q] canonical form. Defaults to a conformable zero matrix
+        on the first iteration.
+
+    b : np.ndarray or None
+        Right-hand side vector. Must have as many rows as A. Required.
+
+    m, p : int or None
+        Dimensions of X ∈ ℝ^{m×p}, relevant for allocation problems ('ap').
+
+    i, j : int, default = 1
+        Grouping sizes for row and column sum constraints in AP problems.
+
+    zero_diagonal : bool, default = False
+        If True, enforces structural zero diagonals via identity truncation.
+
+    Attributes Set
+    ---------------
+    self.A : np.ndarray
+        Canonical design matrix constructed from (C, S, M, Q).
+
+    self.C_idx : tuple
+        Tuple (rows, cols) indicating the size of the C block.
+
+    self.b : np.ndarray
+        Conformable right-hand side vector.
+
+    Raises
+    ------
+    CLSPError
+        If the design matrix A or right-hand side b is malformed, inconsistent,
+        or incompatible with the structural assumptions of the problem.
+    """
+    # (b) Ensure the right-hand side is defined and set `self.b`
+    if b is None:
+        raise self.error("Right-hand side vector b must be provided.")
+    self.b = b
+
+    # (A) Option 1. AP (TM) problems with an optional zero diagonal
+    if 'ap' in problem.lower() or 'tm' in problem.lower():
+        if m is None or p is None:
+            raise self.error("Both m and p must be specified.")
+        if m % i != 0:
+            raise self.error(f"m = {m} must be divisible by i = {i}")
+        if p % j != 0:
+            raise self.error(f"p = {p} must be divisible by j = {j}")
+        # construct the C block using Kronecker product
+        row_groups = np.kron(np.kron(np.eye(m // i), np.ones((1, i))),
+                             np.ones((1, p)))
+        col_groups = np.kron(np.ones((1, m)), np.kron(np.eye(p // j),
+                                                      np.ones((1, j))))
+        C = np.vstack([row_groups, col_groups])
+        # append an optional identity matrix to M, remove duplicates
+        if zero_diagonal:
+            M_diag = np.hstack([np.diagflat(np.eye(1, m, k))
+                                for k in range(p)])
+            M = (M_diag.copy() if M is None or M.size == 0 else
+                 np.unique(np.vstack([M, M_diag]),  axis=0))
+            b = np.vstack([b, np.zeros((m, 1))])
+            del M_diag
+
+    # (A) Option 2. CMLS and RP problems
+    if 'cmls' in problem.lower() or 'rp' in problem.lower():
+        if C is None or M is None:
+            raise self.error("Both C and M must be provided.")
+        if C.shape[0] % M.shape[0] != 0:
+            raise self.error(f"Row mismatch: rows(C) = {C.shape[0]} must be "
+                             f"divisible by rows(M) = {M.shape[0]}")
+
+    # (A) Option 3. General problems
+    if C is None and M is None:
+        raise self.error("At least one of C or M must be provided.")
+
+    # (A) Convert missing blocks to conformable zero matrices
+    n_col = C.shape[1] if C is not None else M.shape[1]
+    C     = C          if C is not None else np.zeros((0, n_col))
+    M     = M          if M is not None else np.zeros((0, n_col))
+    S     = S          if S is not None else np.zeros((C.shape[0], 0))
+    Q     = Q          if Q is not None else np.zeros((M.shape[0], 0))
+    if C.shape[0] != S.shape[0]:
+        raise self.error(f"C and S must have the same number of rows: "
+                         f"{C.shape[0]} vs {S.shape[0]}")
+    if C.shape[1] != M.shape[1]:
+        raise self.error(f"C and M must have the same number of columns: "
+                         f"{C.shape[1]} vs {M.shape[1]}")
+
+    # (A) Pad C and Q with zeros and set `self.A` and `self.C_idx`
+    self.A     = np.vstack([
+        np.hstack([C, S, np.zeros((C.shape[0], Q.shape[1]))]),
+        np.hstack([M,    np.zeros((M.shape[0], S.shape[1])),   Q])
+    ])
+    self.C_idx = C.shape
+
+def CLSPCorrelogram(
+    self, reset:       bool = False,       threshold:    float = 0,
+) -> dict[str, list[float]]:
+    """
+    Compute the structural correlogram of the CLSP constraint system.
+
+    This method performs a row-deletion sensitivity analysis on the canonical
+    constraint matrix [C | S], denoted as C_canon, and evaluates the marginal
+    effect of each constraint row on numerical stability, angular alignment,
+    and estimator sensitivity.
+
+    For each row i in C_canon, it computes:
+    - The Root Mean Square Alignment (RMSA_i) with all other rows j ≠ i.
+    - The change in condition numbers κ(C), κ(B), and κ(A) when row i is
+      deleted.
+    - The effect on estimation quality: changes in NRMSE, zhat, z, and x.
+
+    Additionally, it computes the total RMSA statistic across all rows,
+    summarizing the overall angular alignment of the constraint block.
+
+    Parameters
+    ----------
+    reset : bool, default = False
+        If True, forces recomputation of all diagnostic values.
+
+    threshold : float, default = 0
+        If positive, limits the output to constraints with RMSA_i ≥ threshold.
+
+    Returns
+    -------
+    dict of list
+        A dictionary containing per-row diagnostic values:
+        {
+            "constraint"   : [1, 2, ..., k],  # 1-based indices
+            "rmsa_i"       : list of RMSA_i values,
+            "rmsa_dkappaC" : list of Δκ(C) after deleting row i,
+            "rmsa_dkappaB" : list of Δκ(B) after deleting row i,
+            "rmsa_dkappaA" : list of Δκ(A) after deleting row i,
+            "rmsa_dnrmse"  : list of ΔNRMSE after deleting row i,
+            "rmsa_dzhat"   : list of Δzhat after deleting row i,
+            "rmsa_dz"      : list of Δz after deleting row i,
+            "rmsa_dx"      : list of Δx after deleting row i,
+        }
+    """
+    # (RMSA) Total RMSA
+    if self.rmsa        == None          or reset:
+        k                        = self.C_idx[0]
+        p                        = self.C_idx[1]
+        C_canon                  = self.A[:k]
+        norms                    = np.linalg.norm(C_canon, axis=1)
+        self.rmsa                = (lambda C:     np.sqrt(np.sum([(np.dot(
+                                           C[i] / norms[i], C[j] / norms[j])
+                                    ) ** 2 for i  in range(0,     k - 1)
+                                           for j  in range(i + 1, k    )
+                                   ]) * 2 / k / (k - 1)))(C_canon)
+
+    # (RMSA) Constraint-wise RMSA, changes in condition numbers, and GoF
+    if len(self.rmsa_i) != self.C_idx[0] or reset:
+        tmp                      = copy.deepcopy(self)
+        k                        = self.C_idx[0]
+        p                        = self.C_idx[1]
+        C_canon                  = self.A[:k]
+        norms                    = np.linalg.norm(C_canon, axis=1)
+        self.rmsa_i              = [None] * k
+        self.rmsa_dkappaC        = [None] * k
+        self.rmsa_dkappaB        = [None] * k
+        self.rmsa_dkappaA        = [None] * k
+        self.rmsa_dnrmse         = [None] * k
+        self.rmsa_dzhat          = [None] * k
+        self.rmsa_dz             = [None] * k
+        self.rmsa_dx             = [None] * k
+        for i in range(k):
+            tmp.A                = np.delete(self.A, i, axis=0)
+            tmp.b                = np.delete(self.b, i, axis=0)
+            tmp.C_idx            = (k - 1, p)
+            tmp.solve()
+            self.rmsa_i[i]       = (lambda C,  i: np.sqrt(np.sum([(np.dot(
+                                           C[i] / norms[i], C[j] / norms[j])
+                                    ) ** 2 for j  in range(k) if j != i
+                                   ]) / (k - 1)))(C_canon, i)
+            self.rmsa_dkappaC[i] = tmp.kappaC - self.kappaC
+            self.rmsa_dkappaB[i] = tmp.kappaB - self.kappaB
+            self.rmsa_dkappaA[i] = tmp.kappaA - self.kappaA
+            self.rmsa_dnrmse[i]  = tmp.nrmse  - self.nrmse
+            self.rmsa_dzhat[i]   = tmp.zhat   - self.zhat
+            self.rmsa_dz[i]      = tmp.z      - self.z
+            self.rmsa_dx[i]      = tmp.x      - self.x
+
+    # Return the correlogram
+    indices = [i for i, r in enumerate(self.rmsa_i) if r >= threshold]
+    return {
+        "constraint"  : [i + 1 for i in indices],      # 1-based indexing
+        "rmsa_i"      : [self.rmsa_i[i]       for i in indices],
+        "rmsa_dkappaC": [self.rmsa_dkappaC[i] for i in indices],
+        "rmsa_dkappaB": [self.rmsa_dkappaB[i] for i in indices],
+        "rmsa_dkappaA": [self.rmsa_dkappaA[i] for i in indices],
+        "rmsa_dnrmse" : [self.rmsa_dnrmse[i]  for i in indices],
+        "rmsa_dzhat"  : [self.rmsa_dzhat[i]   for i in indices],
+        "rmsa_dz"     : [self.rmsa_dz[i]      for i in indices],
+        "rmsa_dx"     : [self.rmsa_dx[i]      for i in indices],
+    }
+
+def CLSPTTest(
+    self, reset:       bool = False,       sample_size:  int   = 50,
+          seed:        int  | None = None, distribution: str   | None = None
+) -> dict[str, float]:
+    """
+    Perform Monte Carlo t-tests on the NRMSE statistic from the CLSP estimator.
+
+    This function generates synthetic right-hand side vectors `b` using a 
+    user-defined or default distribution and recomputes the estimator. It 
+    tests whether the observed NRMSE significantly deviates from the null 
+    distribution of simulated NRMSE values.
+
+    Parameters
+    ----------
+    reset : bool, default = False
+        If True, forces recomputation of the NRMSE null distribution.
+
+    sample_size : int, default = 50
+        Size of the Monte Carlo simulated sample under H₀.
+
+    seed : int or None, optional
+        Optional random seed to override the default.
+
+    distribution : str or None
+        Distribution for generating synthetic b vectors. One of:
+        'normal', 'uniform', 'laplace'. Defaults to standard normal.
+
+    Returns
+    -------
+    dict
+        Dictionary with test results and null distribution statistics:
+        {
+            'p_one_left'  : P(nrmse ≤ null mean),
+            'p_one_right' : P(nrmse ≥ null mean),
+            'p_two_sided' : 2-sided t-test p-value,
+            'nrmse'       : observed value,
+            'mean_null'   : mean of null distribution,
+            'std_null'    : std of null distribution
+        }
+    """
+    # Set the seed, RNG configuration, and distribution
+    if seed is not None:
+        self.seed = seed
+        self.rng  = np.random.default_rng(self.seed)
+    if distribution is not None:
+        dist_fn   = {
+            "normal":  lambda n: self.rng.normal(loc=0, scale=1, size=(n, 1)),
+            "uniform": lambda n: self.rng.uniform(-1, 1, size=(n, 1)),
+            "laplace": lambda n: self.rng.laplace(loc=0, scale=1, size=(n, 1))
+        }.get(distribution.lower())
+        if dist_fn is None:
+            raise self.error(f"Unsupported distribution: {distribution}")
+
+    # (t-test) Simulated NRMSE distribution under H0
+    if len(self.nrmse_ttest) != sample_size or reset:
+        tmp = copy.deepcopy(self)
+        self.nrmse_ttest        = [None] * sample_size
+        for i in range(sample_size):
+            tmp.b               = dist_fn(self.b.shape[0])
+            tmp.solve()
+            self.nrmse_ttest[i] = tmp.nrmse
+
+    # Return the t-test
+    nrmse_null = np.array(self.nrmse_ttest)
+    mean_null  = np.mean(nrmse_null)
+    std_null   = np.std(nrmse_null, ddof=1)
+    t_stat     = (self.nrmse - mean_null) / (std_null / np.sqrt(sample_size))
+    p_left     = stats.t.cdf(t_stat, df=sample_size - 1)
+    p_right    = 1 - p_left
+    p_two      = stats.t.sf(abs(t_stat), df=sample_size - 1) * 2
+    return {
+        "p_one_left" : p_left,
+        "p_one_right": p_right,
+        "p_two_sided": p_two,
+        "nrmse"      : self.nrmse,
+        "mean_null"  : mean_null,
+        "std_null"   : std_null
+    }

pyclsp-1.0.0.dist-info/METADATA

@@ -0,0 +1,259 @@
+Metadata-Version: 2.4
+Name: pyclsp
+Version: 1.0.0
+Summary: Modular Two-Step Convex Optimization Estimator for Ill-Posed Problems
+Author-email: The Economist <29724411+econcz@users.noreply.github.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/econcz/clsp
+Project-URL: Bug Tracker, https://github.com/econcz/clsp/issues
+Keywords: estimators,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: scipy>=1.10
+Requires-Dist: cvxpy>=1.3
+Dynamic: license-file
+
+ # CLSP — Convex Least Squares Programming
+
+The **Convex Least Squares Programming (CLSP)** estimator is a two-step method for solving underdetermined, ill-posed, or structurally constrained least-squares problems. It combines pseudoinverse-based estimation with convex-programming correction (e.g., Lasso, Ridge, Elastic Net) to ensure numerical stability, structural coherence, and enhanced interpretability.
+
+## Installation
+
+```bash
+pip install clsp
+```
+
+## Quick Example
+
+```python
+import numpy as np
+from clsp import CLSP
+
+# Example allocation problem
+b = np.array([1, 2, 3, 7, 8, 9], dtype=float)
+
+# Initialize estimator
+model = CLSP()
+
+# Solve the system
+result = model.solve(problem='ap', b=b, m=3, p=3)
+
+# Access diagnostics
+print(model.nrmse)
+print(model.ttest())
+
+```
+
+## User Reference
+
+For comprehensive information on the estimator’s capabilities, advanced configuration options, and implementation details, please refer to the docstrings provided in each of the individual .py source files. These docstrings contain complete descriptions of available methods, their parameters, expected input formats, and output structures.
+
+### The `CLSP` Class
+
+```python
+self.__init__()
+```
+
+Stores the solution, goodness-of-fit statistics, and ancillary parameters.
+
+The class has three core methods: `solve()`, `corr()`, and `ttest()`.
+
+**Selected attributes:**  
+`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` x `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^2 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 calculated 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`).
+
+### Solver Method: `solve()`
+
+```python
+self.solve(problem, C, S, M, b, m, p, i, j, zero_diagonal, r, Z, tolerance, iteration_limit, final, alpha)
+```
+
+Solves the Convex Least Squares Programming (CLSP) problem.
+
+This method performs a two-step estimation:
+(1) a pseudoinverse-based solution using either the Moore–Penrose or Bott–Duffin inverse, optionally iterated for refinement;
+(2) a convex-programming correction using Lasso, Ridge, or Elastic Net regularization (if enabled).
+
+**Parameters:**  
+`problem` : *str*, optional  
+    Structural template for matrix construction. One of:  
+    - *'ap'* or *'tm'* : allocation (transaction) matrix problem (AP).  
+    - *'cmls'* or *'rp'* : constrained-model least squares (regression) problem.  
+    - anything else: general CLSP problem (user-defined `C` and/or `M`).
+
+`C`, `S`, `M` : *np.ndarray* or *None*  
+    Blocks of the design matrix `A` = [`C` | `S`; `M` | `Q`]. If `C` and/or `M` are provided, the matrix `A` is constructed accordingly (please note that for AP, `C` is constructed automatically and known values are specified in `M`).
+
+`b` : *np.ndarray* or *None*  
+    Right-hand side vector. Must have as many rows as `A` (please note that for AP, it should start with row sums). Required.
+
+`m`, `p` : *int* or *None*  
+    Dimensions of X ∈ ℝ^{m×p}, relevant for AP.
+
+`i`, `j` : *int*, default = *1*  
+    Grouping sizes for row and column sum constraints in AP.
+
+`zero_diagonal` : *bool*, default = *False*  
+    If *True*, enforces structural zero diagonals.
+
+`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*
+
+### Correlogram Method: `corr()`
+
+```python
+self.corr(reset, threshold)
+```
+
+Computes the structural correlogram of the CLSP constraint part.
+
+This method performs a row-deletion sensitivity analysis on the canonical constraint matrix `[C` | `S`], denoted as *C_canon*, and evaluates the marginal effect of each constraint row on numerical stability, angular alignment, and estimator sensitivity.
+
+For each row `i` in `C_canon`, it computes:  
+	- The Root Mean Square Alignment (`RMSA_i`) with all other rows `j` ≠ `i`.  
+	- The change in condition numbers κ(`C`), κ(`B`), and κ(`A`) when row `i` is deleted.  
+	- The effect on estimation quality: changes in `nrmse`, `zhat`, `z`, and `x` when row `i` is deleted.
+
+Additionally, it computes the total `rmsa` statistic across all rows, summarizing the overall angular alignment of *C_canon*.
+
+**Parameters:**  
+`reset` : *bool*, default = *False*  
+    If *True*, forces recomputation of all diagnostic values (the results are preserved for eventual reproduction after the method is called).
+
+`threshold` : *float*, default = *0*  
+    If positive, limits the output to constraints with `RMSA_i` ≥ `threshold`.
+
+**Returns:**  
+*dict* of *list*  
+    A dictionary containing per-row diagnostic values:  
+    {  
+        `"constraint"`   : `[1, 2, ..., k]`,  # 1-based indices  
+        `"rmsa_i"`       : list of `RMSA_i` values,  
+        `"rmsa_dkappaC"` : list of Δκ(`C`) after deleting row `i`,  
+        `"rmsa_dkappaB"` : list of Δκ(`B`) after deleting row `i`,  
+        `"rmsa_dkappaA"` : list of Δκ(`A`) after deleting row `i`,  
+        `"rmsa_dnrmse"`  : list of Δ`nrmse` after deleting row `i`,  
+        `"rmsa_dzhat"`   : list of Δ`zhat` after deleting row `i`,  
+        `"rmsa_dz"`      : list of Δ`z` after deleting row `i`,  
+        `"rmsa_dx"`      : list of Δ`x` after deleting row `i`,  
+    }
+
+### T-Test Method: `ttest`
+
+```python
+self.ttest(reset, sample_size, seed, distribution)
+```
+
+Performs a Monte Carlo-based one- or two-sided t-test on the NRMSE statistic.
+
+This function simulates right-hand side vectors `b` using a user-defined or default distribution and recomputes the estimator for every new `b`. It 
+tests whether the observed NRMSE significantly deviates from the null distribution (under H₀) of simulated NRMSE values. The quality of the test depends on the size of the simulated sample.
+
+**Parameters:**  
+`reset` : *bool*, default = *False*  
+    If *True*, forces recomputation of the NRMSE null distribution (under H₀) (the results are preserved for eventual reproduction after the method is called).
+
+`sample_size` : *int*, default = *50*  
+    Size of the Monte Carlo simulated sample under H₀.
+
+`seed` : *int* or *None*, optional  
+    Optional random seed to override the default.
+
+`distribution` : *str* or *None*, default = *’normal’*  
+    Distribution for generating simulated `b` vectors. One of (standard): *'normal'*, *'uniform'*, or *'laplace'*.
+
+**Returns:**  
+*dict*  
+    Dictionary with test results and null distribution statistics:  
+    {  
+        `'p_one_left'`  : P(nrmse ≤ null mean),  
+        `'p_one_right'` : P(nrmse ≥ null mean),  
+        `'p_two_sided'` : 2-sided t-test p-value,  
+        `'nrmse'`       : observed value,  
+        `'mean_null'`   : mean of the null distribution (under H₀),  
+        `'std_null'`    : standard deviation of the null distribution (under H₀)  
+    }
+
+## Bibliography
+To be added.
+
+## License
+MIT License — see the [LICENSE](LICENSE) file.

pyclsp-1.0.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+clsp/__init__.py,sha256=ShvZmk9qOrWOlrm5WKHvEj4ubZGUwU4UBtSQuX7I7FU,91
+clsp/clsp.py,sha256=P5LDe1h9jZ_tm3X8KjCd7zKafyIco1uJEq-6qVGDulc,10119
+clsp/errors.py,sha256=mpFIYB7dumi1xtVBocZcq46W-9tktWSzWjCfuI9x7JU,662
+clsp/solver.py,sha256=YD_ZsrQaOsyB7BVGaAZ9hfAUtxvrUyzGqEMldFZw6e8,11698
+clsp/utils.py,sha256=FdyGlqNwwxZ2nFLXe2tdLb9JfTDJ4ZmRa3lPCBiuXCw,13673
+pyclsp-1.0.0.dist-info/licenses/LICENSE,sha256=GBD85YooWzpjrnQL2N3DQat780nYLRoiJaGcAkv7Kl4,1070
+pyclsp-1.0.0.dist-info/METADATA,sha256=i7wJD_-qnPal6PpdWiZ-czUZBBEe1o62snS1tioSzNY,10064
+pyclsp-1.0.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+pyclsp-1.0.0.dist-info/top_level.txt,sha256=IalkNGMZVyzpHnuIj0ZFArDGGUrj4HnAnLFiGxKHEEI,5
+pyclsp-1.0.0.dist-info/RECORD,,

pyclsp-1.0.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

pyclsp-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 The Economist
+
+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.

pyclsp-1.0.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+clsp