vector-structure 1.0.0__py3-none-any.whl

vector_structure/__init__.py

@@ -0,0 +1,5 @@
+from .structure import VectorStructure
+
+__all__ = [
+    "VectorStructure",
+]

vector_structure/structure.py

@@ -0,0 +1,67 @@
+from typing import Sequence
+
+
+class SimpleSlice:
+    """Represents a contiguous range.
+
+    Behaves like a `slice` object.
+    """
+
+    def __init__(self, start: int, stop: int):
+        self.start = start
+        self.stop = stop
+
+    step = 1
+
+    @staticmethod
+    def from_slice(sl: slice) -> "SimpleSlice":
+        """Translate a `slice` into a SimpleSlice."""
+        if sl.step not in (1, None):
+            raise ValueError()
+        return SimpleSlice(sl.start, sl.stop)
+
+    def __len__(self):
+        return self.start - self.stop
+
+
+class VectorStructure:
+    """Helper class to describe block vectors and block matrices."""
+
+    def __init__(self, sizes: Sequence[tuple[str, int]]):
+        cuts = {}
+        start = 0
+        for k, v in sizes:
+            cuts[k] = slice(start, start + v)
+            start += v
+        self.size = start
+        self.cuts = cuts
+
+    def __getitem__(self, idx: str | Sequence[str] | slice) -> SimpleSlice:
+        if isinstance(idx, str):
+            return self.cuts[idx]
+        elif isinstance(idx, slice):
+            if idx.step is not None:
+                raise ValueError("slice step [start:stop:step] not supported")
+            start, stop = None, None
+            if idx.start is None:
+                start = 0
+            if idx.stop is None:
+                stop = self.size
+            for name, cut in self.cuts.items():
+                if name == idx.start:
+                    start = cut.start
+                if name == idx.stop:
+                    stop = cut.start
+                    break
+            if start is None or stop is None:
+                raise ValueError(f"{idx.start} or {idx.stop} not found")
+            return SimpleSlice(start, stop)
+        else:
+            first, *more = idx
+            start = self.cuts[first].start
+            stop = self.cuts[first].stop
+            for idx in more:
+                next_cut = self.cuts[idx]
+                assert next_cut.start == stop
+                stop = next_cut.stop
+            return SimpleSlice(start, stop)

vector_structure-1.0.0.dist-info/METADATA

@@ -0,0 +1,54 @@
+Metadata-Version: 2.4
+Name: vector-structure
+Version: 1.0.0
+Project-URL: Homepage, https://github.com/warggr/vector-structure
+Project-URL: Issues, https://github.com/warggr/vector-structure/issues
+Author-email: Pierre Ballif <pierre@ballif.eu>
+License-Expression: MIT
+License-File: LICENSE
+Keywords: block,matrix,structure,vector
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python
+Classifier: Programming Language :: Python :: 3
+Requires-Python: >=3.5
+Description-Content-Type: text/markdown
+
+# vector-structure
+
+Lightweight utilities for working with _structured flat vectors_ and _block matrices_ in NumPy.
+
+# Example usage
+
+Consider a Newton algorithm for solving the KKT conditions, as described [here](https://won-j.github.io/M1399_000200-2021fall/lectures/22-newton/newton_constr.html):
+
+$$\begin{pmatrix}
+    \nabla^2 f(x) & \color{gray}{Df(x)^T} & A^T \\
+    \color{gray}{-diag(\lambda) Df(x)} & \color{gray}{-diag(f(x))} & \color{gray}{0} \\
+    A & \color{gray}{0} & 0
+\end{pmatrix} \begin{pmatrix} x^* \\ \color{gray}{\lambda^\*} \\ v^\* \end{pmatrix} = \begin{pmatrix} \\ \dots \\
+\end{pmatrix}$$
+
+where the grey components are only required when inequality constraints are present.
+
+```python
+from vector_structure import VectorStructure
+
+structure = [("x", n)]
+if ineq_constraints:
+    structure.append(("lambda", m))
+structure.append(("mu", p))
+
+vs = VectorStructure(structure)
+
+M = np.zeros((vs.size, vs.size))
+M[vs["x"], vs["x"]] = nabla2(f)(x)
+if ineq_constraints:
+    M[vs["x"], vs["lambda"]] = Df(x).T
+M[vs["x"], vs["mu"]] = A
+...
+
+x_lambda_mu = np.linalg.solve(M, r)
+x = x_lambda_mu[vs["x"]]
+if ineq_constraints:
+    lambda = x_lambda_mu[vs["lambda"]]
+```

vector_structure-1.0.0.dist-info/RECORD

@@ -0,0 +1,6 @@
+vector_structure/__init__.py,sha256=3PBOBBrSYXwXkrGVUjUPOtR78CWEPyCBUCl8c8U5ztY,77
+vector_structure/structure.py,sha256=absSkXx2tLGKInDujESm5g3H0AcIplpnQHBVCXnYHEM,2052
+vector_structure-1.0.0.dist-info/METADATA,sha256=6Qn2Hw8vldA09BFM_0ksRrkIHbb4Nt0u7EHywhzkZRM,1716
+vector_structure-1.0.0.dist-info/WHEEL,sha256=QccIxa26bgl1E6uMy58deGWi-0aeIkkangHcxk2kWfw,87
+vector_structure-1.0.0.dist-info/licenses/LICENSE,sha256=9vbyUaxsJ032bytdPkeCRKdQ8e7dWKXgFVKL7sEjYno,1070
+vector_structure-1.0.0.dist-info/RECORD,,

vector_structure-1.0.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.29.0
+Root-Is-Purelib: true
+Tag: py3-none-any

vector_structure-1.0.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Pierre Ballif
+
+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.