lumpy-la 0.1.0__py3-none-any.whl

lumpy/__init__.py

@@ -0,0 +1,8 @@
+from .constructors import * 
+from .core import *
+from .spaces import *
+from .geometry import *
+from .utils import *
+from .equations import *
+
+from numpy.linalg import qr, eig, inv 

lumpy/constructors.py

@@ -0,0 +1,60 @@
+import numpy as np
+from .utils import is_vector
+
+def mat(*columns, dtype=float):
+    """"
+    Construct a matrix from columns.
+
+    Lists are interpreted as column entries. Existing column
+    vectors may also be passed directly.
+    """
+    processed = []
+    
+    for col in columns:
+        # Python list -> column vector
+        if isinstance(col, list):
+            col = np.array(col, dtype=dtype).reshape(-1,1)
+
+        if col.ndim != 2 or col.shape[1] != 1:
+            raise ValueError("mat() expects columns: lists or column vectors.")
+
+        processed.append(col)
+
+    if not processed:
+        raise ValueError("mat() requires at least one column.")
+
+    return np.hstack(processed).astype(dtype)
+
+def matt(*rows, dtype=float):
+    """
+    Construct a matrix from rows.
+
+    matt() preserves the usual visual layout of matrices,
+    while mat() preserves Lumpy's column-oriented semantics.
+    """
+    if not rows:
+        raise ValueError("matt() requires at least one row.")
+    return mat(*rows, dtype=dtype).T
+
+def vec(*entries, dtype=float):
+    """Construct a column vector."""
+    return mat(list(entries), dtype=dtype)
+
+def eye(n, dtype=float):
+    """Construct the n x n identity matrix."""
+    return np.eye(n, dtype=dtype)
+
+def e(n, i, dtype=float):
+    """
+    e(n, i) returns the standard basis vector corresponding
+    to the mathematical vector e_(i+1) in R^n.
+
+    Indexing is 0-based to remain consistent with Python/NumPy.
+    """
+    e = np.zeros((n,1), dtype=dtype)
+    e[i] = 1
+    return e
+
+def diag(*entries, dtype=float):
+    """Construct a diagonal matrix with given entries."""
+    return np.diag(entries).astype(dtype)

lumpy/core.py

@@ -0,0 +1,41 @@
+import numpy as np
+from .utils import is_vector
+
+def col(A, i):
+    """Return column i as a column vector."""
+    return A[:, [i]]
+
+def row(A, i):
+    """Return row i as a row matrix."""
+    return A[[i], :]
+
+def inner(A,B):
+    """Inner product of matrices."""
+    return A.T @ B
+
+def dot(u,v):
+    """Dot product of vectors."""
+    if not(is_vector(u) and is_vector(v)):
+        raise ValueError("dot() requires column vectors.")
+    return (u.T @ v).item()
+    
+def norm(v):
+    """Euclidean norm of a column vector."""
+    return np.linalg.norm(v)
+
+
+def T(A):
+    """Transpose of A."""
+    return A.T
+
+def tr(A):
+    """Trace of A."""
+    return np.trace(A)
+
+def adj(A):
+    """Adjoint (conjugate transpose) of A."""
+    return A.conj().T
+
+def det(A):
+    """Determinant of A."""
+    return np.linalg.det(A)

lumpy/decompositions.py

@@ -0,0 +1,17 @@
+import numpy as np
+
+def svd(A, full_matrices=False, tol=1e-12):
+    """
+    Return the singular value decomposition of A.
+
+    By default, returns only the rank-relevant singular directions:
+
+        A = U @ diag(s) @ Vt
+
+    If full_matrices=True, returns NumPy's full SVD.
+    """
+    U, s, Vt = np.linalg.svd(A, full_matrices=full_matrices)
+    if not full_matrices:
+        rank = np.sum(s > tol)
+        return U[:,:rank], s[:rank], Vt[:rank,:]
+    return U, s, Vt

lumpy/equations.py

@@ -0,0 +1,15 @@
+import numpy as np
+
+def solve(A, b):
+    """
+    Solve Ax = b.
+    Prefer solve() over explicitly computing inv(A) @ b.
+    """
+    return np.linalg.solve(A, b)
+
+def lstsq(A, b, rcond=None):
+    """
+    Return the least-squares solution to Ax ≈ b.
+    """
+    x, residuals, rank, s = np.linalg.lstsq(A, b, rcond=rcond)
+    return x

lumpy/geometry.py

@@ -0,0 +1,36 @@
+import numpy as np
+from .utils import is_vector
+from .core import norm, dot
+
+def dist(u, v):
+    """
+    Return the Euclidean distance between two column vectors u and v.
+    """
+    if not(is_vector(u) and is_vector(v)):
+        raise ValueError("dist() requires column vectors.")
+    return norm(u - v)
+
+def angle(u, v):
+    """
+    Return the angle in radians between two column vectors u and v.
+    """
+    if not(is_vector(u) and is_vector(v)):
+        raise ValueError("angle() requires column vectors.")
+    return np.arccos(dot(u,v)/(norm(u)*norm(v)))
+
+def normalize(A):
+    """
+    Normalize each column of A.
+    """
+    norms = np.linalg.norm(A, axis=0)
+
+    if np.any(norms == 0):
+        raise ValueError("Cannot normalize a matrix with zero columns.")
+
+    return A / norms
+
+def unit(v):
+    """Return unit vector in direction of v."""
+    if not is_vector(v):
+        raise ValueError("unit() requires a column vector.")
+    return normalize(v)

lumpy/spaces.py

@@ -0,0 +1,53 @@
+import numpy as np
+from .decompositions import svd
+
+def rank(A, tol=1e-12):
+    """
+    Return the rank of A.
+    """
+    _, s, _ = svd(A,tol=tol) 
+    return len(s)
+
+def orth(A,tol=1e-12):
+    """
+    Return an orthonormal basis for the column space of A.
+    """
+    U, _, _ = svd(A, tol=tol)
+    return U
+
+def null(A, tol=1e-12):
+    """
+    Return an orthonormal basis for the null space of A.
+    """
+    U, s, Vt = svd(A, full_matrices=True, tol=tol)
+    rank = np.sum(s > tol)
+    return Vt[rank:].T
+
+def proj(A,B,tol=1e-12):
+    """
+    Orthogonal projection of B onto the column space of A.
+    Works for vectors and matrices.
+    """
+    Q = orth(A,tol=tol)
+    return Q @ Q.T @ B
+
+def independent(A):
+    """
+    Return True if the columns of A are linearly independent.
+    """
+    return rank(A) == A.shape[1]
+
+def row_space(A, tol=1e-12):
+    """
+    Return an orthonormal basis for the row space of A as columns.
+    """
+    return orth(A.T, tol=tol)
+
+
+def left_null(A, tol=1e-12):
+    """
+    Return an orthonormal basis for the left nullspace of A as columns.
+
+    This is Null(A.T).
+    """
+    return null(A.T, tol=tol)

lumpy/utils.py

@@ -0,0 +1,5 @@
+import numpy as np
+
+def is_vector(v):
+    """Check if v is a column vector."""
+    return v.ndim == 2 and v.shape[1] == 1

lumpy_la-0.1.0.dist-info/METADATA

@@ -0,0 +1,6 @@
+Metadata-Version: 2.4
+Name: lumpy-la
+Version: 0.1.0
+Summary: Very elegant. Very Lumpy.
+Requires-Python: >=3.14
+Requires-Dist: numpy

lumpy_la-0.1.0.dist-info/RECORD

@@ -0,0 +1,12 @@
+lumpy/__init__.py,sha256=djC4qOHAGk36ucoxTLpkduYSkHdLXm1fKgYGuPIOxP0,180
+lumpy/constructors.py,sha256=KYF-ocV9gLIXcBCuFUGAwqhjq6_8XQ18x-1bC3zuhb4,1659
+lumpy/core.py,sha256=90zFaPs3AEG22mZJkFh8NZ4lg_SqyPlKLmQKYLp0msg,811
+lumpy/decompositions.py,sha256=SJugXczclrxbz6z_aug-8pVa_Uu8D-BPZwL0OryjvJg,469
+lumpy/equations.py,sha256=ZOjeVAD6IUF78WVYmVr_ZMjMoaj0Gb4zLnam3pJ8HRU,333
+lumpy/geometry.py,sha256=dbaYtrCg2lG0APtiWYzvCdzB9RfO7pNfztvAhRvGyYY,959
+lumpy/spaces.py,sha256=_WmB0XNqgFpmVhUStg-fPspO8Ya9wkC0WhCisqnzkSA,1138
+lumpy/utils.py,sha256=cRhYKts5QqK36s9AR5j8TPMtBDA7R2iXOloYQqvI4-0,121
+lumpy_la-0.1.0.dist-info/METADATA,sha256=4eM2trAVVRixNGnWCe07wJoxgmHEzJRZNoa1rwBFdks,132
+lumpy_la-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+lumpy_la-0.1.0.dist-info/top_level.txt,sha256=a9ZtsYv09s-13PjorxfmuOle25Oyvgj5mpNFysCP19U,6
+lumpy_la-0.1.0.dist-info/RECORD,,

lumpy_la-0.1.0.dist-info/WHEEL

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

lumpy_la-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+lumpy