lumpy-la 0.1.0__tar.gz

lumpy_la-0.1.0/PKG-INFO

@@ -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/README.md

@@ -0,0 +1,337 @@
+# Lumpy
+
+**Very elegant. Very Lumpy.**
+
+Lumpy is a tiny semantic linear algebra wrapper over NumPy.
+
+NumPy is excellent, but its core abstraction is the n-dimensional array, not the mathematical vector or matrix. Lumpy uses NumPy underneath while enforcing a more linear-algebraic convention:
+
+- vectors are column vectors
+- matrices are built from columns
+- rows are transposes or row slices
+- projections are onto column spaces
+- subspace tools return bases as columns
+
+## Installation
+
+```bash
+pip install lumpy-la
+```
+
+## Basic usage 
+
+```python
+import lumpy as la
+```
+
+## Vectors 
+
+```python
+v = la.vec(1, 2, 3)
+
+v.shape
+# (3, 1)
+```
+
+Vectors are always column vectors. 
+
+$$
+\mathbf{v}\in \mathbb{R}^{n\times 1}
+$$
+
+```python
+v.T
+# array([[1., 2., 3.]])
+```
+
+$$
+\mathbf{v}^{T}\in \mathbb{R}^{1\times n}
+$$
+
+## Matrices are built from columns
+
+```python 
+A = la.mat(
+    [1, 2, 3],
+    [4, 5, 6]
+)
+
+A
+# array([[1., 4.],
+#        [2., 5.],
+#        [3., 6.]])
+```
+
+You can also pass existing column vectors:
+
+```python 
+u = la.vec(1, 2, 3)
+v = la.vec(4, 5, 6)
+
+A = la.mat(u, v) 
+```
+
+## Matrices from rows
+
+`mat()` constructs matrices from columns. Sometimes, though, it is useful to type a matrix in the same visual layout used on paper.
+
+```python
+A = la.matt(
+    [1, 2, 3],
+    [4, 5, 6]
+)
+
+A
+# array([[1., 2., 3.],
+#        [4., 5., 6.]])
+```
+
+```matt()``` preserves the usual visual layout of matrices, while ```mat()``` preserves Lumpy’s column-oriented semantics.
+
+## Standard basis vectors 
+
+Lumpy uses Python-style zero-indexing.
+
+```python
+la.e(3, 0)
+# array([[1.],
+#        [0.],
+#        [0.]])
+```
+
+So ```la.e(n, i)``` corresponds to the mathematical basis vector $\mathbf{e}_{i+1}\in \mathbb{R}^{n}$ .
+
+## Basic operations
+
+```python
+u = la.vec(1, 2, 3)
+v = la.vec(4, 5, 6)
+
+la.inner(u, v)
+# array([[32.]])
+
+la.dot(u, v)
+# 32.0
+
+la.norm(v)
+# 8.774964387392123
+```
+
+```inner``` preserves matrix structure. 
+
+$$
+\langle \mathbf{u},\mathbf{v} \rangle = [\mathbf{u}\cdot \mathbf{v}]\in \mathbb{R}^{1\times 1}
+$$
+
+```dot``` returns a scalar. 
+
+$$
+\mathbf{u} \cdot  \mathbf{v} \in \mathbb{R}
+$$
+
+## Unit vectors and normalization 
+
+```python 
+v = la.vec(3, 4)
+
+la.unit(v)
+# array([[0.6],
+#        [0.8]])
+```
+
+For matrices, ```normalize``` normalizes each column:
+
+```python 
+A = la.mat(
+    [3, 4],
+    [5, 12]
+)
+
+la.normalize(A)
+# array([[0.6       , 0.38461538],
+#        [0.8       , 0.92307692]])
+```
+
+## Columns and rows 
+
+```python 
+A = la.mat(
+    [1, 2, 3],
+    [4, 5, 6]
+)
+
+la.col(A, 0)
+# array([[1.],
+#        [2.],
+#        [3.]])
+
+la.row(A, 1)
+# array([[2., 5.]])
+```
+
+```col``` preserves column-vector shape.
+
+## Projection 
+
+Project onto the column space of a matrix:
+
+```python
+A = la.mat(
+    [1, 0, 0],
+    [0, 1, 0]
+)
+
+v = la.vec(3, 4, 5)
+
+la.proj(A, v)
+# array([[3.],
+#        [4.],
+#        [0.]])
+```
+
+This projects $\mathbf{v}$  onto the $xy$-plane.
+
+Vector projection is just the rank-one case:
+
+```python
+u = la.vec(1, 1, 0)
+v = la.vec(2, 3, 4)
+
+la.proj(u, v)
+```
+
+## Subspaces
+
+```python
+A = la.mat(
+    [1, 2],
+    [2, 4]
+)
+
+la.rank(A)
+# 1
+
+la.independent(A)
+# False
+```
+
+An orthonormal basis for the column space:
+
+```python 
+Q = la.orth(A)
+
+Q.T @ Q
+# approximately identity
+```
+
+Nullspace basis:
+
+```python 
+N = la.null(A)
+
+A @ N
+# approximately zero
+```
+
+Lumpy returns subspace bases as columns.
+
+```python
+
+A = la.matt(
+    [1, 2, 3],
+    [2, 4, 6]
+)
+
+la.row_space(A)
+```
+
+The left nullspace is the nullspace of $A^{T}$:
+
+$$
+\mathrm{Null}\left(A^{T}\right)
+$$
+
+```python
+la.left_null(A)
+```
+
+## SVD 
+
+By default, Lumpy's SVD returns only rank-relevant singular directions:
+
+```python 
+U, s, Vt = la.svd(A)
+```
+
+For full ambient bases:
+
+```python 
+U, s, Vt = la.svd(A, full_matrices=True)
+```
+
+Many Lumpy subspace functions use a numerical tolerance, defaulting to `tol=1e-12`, to decide which singular values count as nonzero.
+
+## Geometry 
+
+```python 
+u = la.vec(1, 0)
+v = la.vec(0, 1)
+
+la.angle(u, v)
+# 1.5707963267948966
+
+la.dist(u, v)
+# 1.4142135623730951
+```
+
+## Solving systems
+
+Prefer `solve()` over explicitly computing an inverse.
+
+```python
+
+A = la.matt(
+    [2, 0],
+    [0, 3]
+)
+
+b = la.vec(4, 9)
+la.solve(A, b)
+
+# array([[2.],
+#        [3.]])
+```
+
+For overdetermined systems, use least squares:
+
+```python
+A = la.matt(
+    [1, 1],
+    [1, 2],
+    [1, 3]
+)
+
+b = la.vec(1, 2, 2)
+
+la.lstsq(A, b)
+```
+
+## Running tests 
+
+```bash 
+python -m pytest
+```
+
+## Design principle 
+
+Lumpy is not trying to replace NumPy. 
+
+It is a small semantic layer for doing linear algebra with conventions that feel closer to the math.
+
+```python 
+import numpy as np
+import lumpy as la
+```
+
+Use NumPy for general arrays.  
+Use Lumpy when you want vectors, matrices, projections, and subspaces to behave like linear algebra objects.

lumpy_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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_la-0.1.0/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/lumpy_la.egg-info/PKG-INFO

@@ -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/lumpy_la.egg-info/SOURCES.txt

@@ -0,0 +1,16 @@
+README.md
+pyproject.toml
+lumpy/__init__.py
+lumpy/constructors.py
+lumpy/core.py
+lumpy/decompositions.py
+lumpy/equations.py
+lumpy/geometry.py
+lumpy/spaces.py
+lumpy/utils.py
+lumpy_la.egg-info/PKG-INFO
+lumpy_la.egg-info/SOURCES.txt
+lumpy_la.egg-info/dependency_links.txt
+lumpy_la.egg-info/requires.txt
+lumpy_la.egg-info/top_level.txt
+tests/test_lumpy.py

lumpy_la-0.1.0/lumpy_la.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

lumpy_la-0.1.0/lumpy_la.egg-info/requires.txt

@@ -0,0 +1 @@
+numpy

lumpy_la-0.1.0/lumpy_la.egg-info/top_level.txt

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

lumpy_la-0.1.0/pyproject.toml

@@ -0,0 +1,13 @@
+[build-system]
+requires = ["setuptools>=61"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "lumpy-la"
+version = "0.1.0"
+description = "Very elegant. Very Lumpy."
+requires-python = ">=3.14"
+dependencies = ["numpy"]
+
+[tool.setuptools]
+packages = ["lumpy"]

lumpy_la-0.1.0/setup.cfg

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

lumpy_la-0.1.0/tests/test_lumpy.py

@@ -0,0 +1,523 @@
+import numpy as np
+import lumpy as la
+
+
+def assert_close(A, B):
+    assert np.allclose(A, B)
+
+
+# =========================
+# Constructors
+# =========================
+
+def test_vec_is_column_vector():
+    v = la.vec(1, 2, 3)
+
+    assert v.shape == (3, 1)
+
+    expected = np.array([
+        [1],
+        [2],
+        [3]
+    ], dtype=float)
+
+    assert_close(v, expected)
+
+
+def test_mat_from_lists():
+    A = la.mat(
+        [1, 2, 3],
+        [4, 5, 6]
+    )
+
+    expected = np.array([
+        [1, 4],
+        [2, 5],
+        [3, 6]
+    ], dtype=float)
+
+    assert A.shape == (3, 2)
+
+    assert_close(A, expected)
+
+
+def test_mat_mixed_inputs():
+    v = la.vec(1, 2, 3)
+
+    A = la.mat(
+        v,
+        [4, 5, 6]
+    )
+
+    expected = np.array([
+        [1, 4],
+        [2, 5],
+        [3, 6]
+    ], dtype=float)
+
+    assert_close(A, expected)
+
+def test_matt_from_rows():
+    A = la.matt(
+        [1, 2, 3],
+        [4, 5, 6]
+    )
+
+    expected = np.array([
+        [1, 2, 3],
+        [4, 5, 6]
+    ], dtype=float)
+
+    assert_close(A, expected)
+
+def test_mat_rejects_mismatched_columns():
+    try:
+        la.mat([1, 2, 3], [4, 5])
+
+    except ValueError:
+        pass
+
+    else:
+        raise AssertionError("mat() should reject mismatched column lengths")
+
+
+def test_mat_rejects_empty_input():
+    try:
+        la.mat()
+
+    except ValueError:
+        pass
+
+    else:
+        raise AssertionError("mat() should require at least one column")
+
+
+def test_eye():
+    assert_close(
+        la.eye(3),
+        np.eye(3)
+    )
+
+
+def test_diag():
+    expected = np.array([
+        [1, 0, 0],
+        [0, 2, 0],
+        [0, 0, 3]
+    ], dtype=float)
+
+    assert_close(
+        la.diag(1, 2, 3),
+        expected
+    )
+
+
+def test_e():
+    expected = np.array([
+        [0],
+        [1],
+        [0]
+    ], dtype=float)
+
+    assert_close(
+        la.e(3, 1),
+        expected
+    )
+
+
+# =========================
+# Core
+# =========================
+
+def test_col():
+    A = la.mat(
+        [1, 2, 3],
+        [4, 5, 6]
+    )
+
+    c = la.col(A, 1)
+
+    assert c.shape == (3, 1)
+
+    assert_close(
+        c,
+        la.vec(4, 5, 6)
+    )
+
+
+def test_row():
+    A = la.mat(
+        [1, 2, 3],
+        [4, 5, 6]
+    )
+
+    r = la.row(A, 1)
+
+    expected = np.array([
+        [2, 5]
+    ], dtype=float)
+
+    assert r.shape == (1, 2)
+
+    assert_close(r, expected)
+
+
+def test_inner():
+    u = la.vec(1, 2, 3)
+    v = la.vec(4, 5, 6)
+
+    result = la.inner(u, v)
+
+    assert result.shape == (1, 1)
+
+    assert_close(
+        result,
+        np.array([[32.0]])
+    )
+
+
+def test_dot():
+    u = la.vec(1, 2, 3)
+    v = la.vec(4, 5, 6)
+
+    result = la.dot(u, v)
+
+    assert isinstance(result, float)
+
+    assert result == 32.0
+
+
+def test_norm():
+    v = la.vec(3, 4)
+
+    assert la.norm(v) == 5.0
+
+
+def test_unit():
+    v = la.vec(3, 4)
+
+    result = la.unit(v)
+
+    expected = la.vec(
+        3 / 5,
+        4 / 5
+    )
+
+    assert_close(result, expected)
+
+    assert np.isclose(
+        la.norm(result),
+        1.0
+    )
+
+
+def test_unit_rejects_matrix():
+    A = la.eye(2)
+
+    try:
+        la.unit(A)
+
+    except ValueError:
+        pass
+
+    else:
+        raise AssertionError(
+            "unit() should reject matrices"
+        )
+
+
+def test_tr():
+    A = la.mat(
+        [1, 3],
+        [2, 4]
+    )
+
+    assert la.tr(A) == 5
+
+
+def test_det():
+    A = la.mat(
+        [1, 3],
+        [2, 4]
+    )
+
+    assert np.isclose(
+        la.det(A),
+        -2.0
+    )
+
+
+def test_adj():
+    A = la.mat(
+        [1, 2],
+        [3, 4]
+    )
+
+    assert_close(
+        la.adj(A),
+        A.T
+    )
+
+
+# =========================
+# Spaces
+# =========================
+
+def test_rank_full_rank():
+    A = la.eye(3)
+
+    assert la.rank(A) == 3
+
+
+def test_rank_deficient():
+    A = la.mat(
+        [1, 2, 3],
+        [2, 4, 6]
+    )
+
+    assert la.rank(A) == 1
+
+
+def test_independent_true():
+    A = la.eye(3)
+
+    assert la.independent(A)
+
+
+def test_independent_false():
+    A = la.mat(
+        [1, 2],
+        [2, 4]
+    )
+
+    assert not la.independent(A)
+
+
+def test_orth():
+    A = la.mat(
+        [1, 0],
+        [2, 0]
+    )
+
+    Q = la.orth(A)
+
+    assert Q.shape == (2, 1)
+
+    assert_close(
+        Q.T @ Q,
+        np.array([[1.0]])
+    )
+
+
+def test_proj_vector():
+    A = la.mat([1, 0])
+
+    v = la.vec(3, 4)
+
+    result = la.proj(A, v)
+
+    expected = la.vec(3, 0)
+
+    assert_close(result, expected)
+
+
+def test_proj_matrix():
+    A = la.mat(
+        [1, 0, 0],
+        [0, 1, 0]
+    )
+
+    v = la.vec(3, 4, 5)
+
+    result = la.proj(A, v)
+
+    expected = la.vec(3, 4, 0)
+
+    assert_close(result, expected)
+
+
+def test_null():
+    A = la.mat(
+        [1, 0],
+        [0, 0]
+    )
+
+    N = la.null(A)
+
+    assert N.shape == (2, 1)
+
+    assert_close(
+        A @ N,
+        np.zeros((2, 1))
+    )
+
+    assert_close(
+        N.T @ N,
+        np.array([[1.0]])
+    )
+
+def test_row_space():
+    A = la.matt(
+        [1, 2, 3],
+        [2, 4, 6]
+    )
+
+    R = la.row_space(A)
+
+    assert R.shape == (3, 1)
+    assert_close(R.T @ R, np.array([[1.0]]))
+
+
+def test_left_null():
+    A = la.matt(
+        [1, 2],
+        [2, 4],
+        [3, 6]
+    )
+
+    L = la.left_null(A)
+
+    assert_close(A.T @ L, np.zeros((2, L.shape[1])))
+
+
+# =========================
+# Geometry
+# =========================
+
+def test_normalize():
+    A = la.mat(
+        [3, 4],
+        [5, 12]
+    )
+
+    N = la.normalize(A)
+
+    assert np.isclose(
+        la.norm(la.col(N, 0)),
+        1.0
+    )
+
+    assert np.isclose(
+        la.norm(la.col(N, 1)),
+        1.0
+    )
+
+    assert_close(
+        la.proj(
+            la.col(A, 0),
+            la.col(N, 0)
+        ),
+        la.col(N, 0)
+    )
+
+    assert_close(
+        la.proj(
+            la.col(A, 1),
+            la.col(N, 1)
+        ),
+        la.col(N, 1)
+    )
+
+
+def test_normalize_rejects_zero_column():
+    A = la.mat(
+        [1, 2],
+        [0, 0]
+    )
+
+    try:
+        la.normalize(A)
+
+    except ValueError:
+        pass
+
+    else:
+        raise AssertionError(
+            "normalize() should reject zero columns"
+        )
+
+
+def test_dist():
+    u = la.vec(1, 2)
+    v = la.vec(4, 6)
+
+    assert la.dist(u, v) == 5.0
+
+
+def test_angle():
+    u = la.vec(1, 0)
+    v = la.vec(0, 1)
+
+    assert np.isclose(
+        la.angle(u, v),
+        np.pi / 2
+    )
+
+
+# =========================
+# Decompositions
+# =========================
+
+def test_svd_rank_trimmed():
+    A = la.mat(
+        [1, 0],
+        [2, 0]
+    )
+
+    U, s, Vt = la.svd(A)
+
+    assert len(s) == 1
+
+    assert U.shape == (2, 1)
+
+    assert Vt.shape == (1, 2)
+
+
+def test_svd_full_matrices():
+    A = la.mat(
+        [1, 0],
+        [2, 0]
+    )
+
+    U, s, Vt = la.svd(
+        A,
+        full_matrices=True
+    )
+
+    assert U.shape == (2, 2)
+
+    assert Vt.shape == (2, 2)
+
+# =========================
+# Equations
+# =========================
+
+def test_solve():
+    A = la.matt(
+        [2, 0],
+        [0, 3]
+    )
+
+    b = la.vec(4, 9)
+
+    x = la.solve(A, b)
+
+    assert_close(x, la.vec(2, 3))
+
+def test_lstsq():
+    A = la.matt(
+        [1, 1],
+        [1, 2],
+        [1, 3]
+    )
+
+    b = la.vec(1, 2, 2)
+
+    x = la.lstsq(A, b)
+
+    assert x.shape == (2, 1)
+
+    # Least-squares residual should be orthogonal to Col(A)
+    r = b - A @ x
+
+    assert_close(A.T @ r, np.zeros((2, 1)))