docs: add LDLT example, solve_exact README snippet, and sync examples

- Add examples/ldlt_solve_3x3.rs: 3×3 SPD tridiagonal LDLT solve + det
- Add solve_exact_f64 code example to README exact arithmetic section
- Add missing examples to justfile (ldlt_solve_3x3, exact_det_3x3,
  exact_solve_3x3)
- Add lu.rs and ldlt.rs test macro references to AGENTS.md
- Fix stale "partial pivoting" → "first-non-zero pivoting" in AGENTS.md
  code structure
- Drop "current" from README storage note

Author: acgetchell

AGENTS.md

@@ -93,6 +93,8 @@ testable.
 #### Reference examples
 
 - `src/matrix.rs` — `gen_public_api_matrix_tests!`
+- `src/lu.rs` — `gen_public_api_pivoting_solve_vec_and_det_tests!`, `gen_public_api_tridiagonal_smoke_solve_vec_and_det_tests!`
+- `src/ldlt.rs` — `gen_public_api_ldlt_identity_tests!`, `gen_public_api_ldlt_diagonal_tests!`
 - `src/exact.rs` — `gen_det_exact_tests!`, `gen_det_exact_f64_tests!`, `gen_solve_exact_tests!`, `gen_solve_exact_f64_tests!`
 
 #### When single-dimension tests are acceptable
@@ -143,7 +145,8 @@ just examples         # Run all examples
 - Run a single test (by name filter): `cargo test solve_2x2_basic` (or the full path: `cargo test lu::tests::solve_2x2_basic`)
 - Run exact-feature tests: `cargo test --features exact --verbose` (or `just test-exact`)
 - Run examples: `just examples` (or `cargo run --example det_5x5` / `cargo run --example solve_5x5` /
-  `cargo run --example const_det_4x4` / `cargo run --features exact --example exact_det_3x3` /
+  `cargo run --example ldlt_solve_3x3` / `cargo run --example const_det_4x4` /
+  `cargo run --features exact --example exact_det_3x3` /
   `cargo run --features exact --example exact_sign_3x3` /
   `cargo run --features exact --example exact_solve_3x3`)
 - Spell check: `just spell-check` (uses `typos.toml` at repo root; add false positives to `[default.extend-words]`)
@@ -202,7 +205,7 @@ When creating or updating issues:
     - Determinants: `det_exact()`, `det_exact_f64()`, `det_sign_exact()` via Bareiss in
       `BigRational`; `det_sign_exact()` adds a Shewchuk-style f64 filter for fast sign resolution
     - Linear system solve: `solve_exact()`, `solve_exact_f64()` via Gaussian elimination
-      with partial pivoting in `BigRational`
+      with first-non-zero pivoting in `BigRational`
 - Rust tests are inline `#[cfg(test)]` modules in each `src/*.rs` file.
 - Python tests live in `scripts/tests/` and run via `just test-python` (`uv run pytest`).
 - The public API re-exports these items from `src/lib.rs`.

README.md

@@ -160,6 +160,7 @@ la-stack = { version = "0.2.2", features = ["exact"] }
 ```rust,ignore
 use la_stack::prelude::*;
 
+// Exact determinant
 let m = Matrix::<3>::from_rows([
     [1.0, 2.0, 3.0],
     [4.0, 5.0, 6.0],
@@ -169,6 +170,13 @@ assert_eq!(m.det_sign_exact().unwrap(), 0); // exactly singular
 
 let det = m.det_exact().unwrap();
 assert_eq!(det, BigRational::from_integer(0.into())); // exact zero
+
+// Exact linear system solve
+let a = Matrix::<2>::from_rows([[1.0, 2.0], [3.0, 4.0]]);
+let b = Vector::<2>::new([5.0, 11.0]);
+let x = a.solve_exact_f64(b).unwrap().into_array();
+assert!((x[0] - 1.0).abs() <= f64::EPSILON);
+assert!((x[1] - 2.0).abs() <= f64::EPSILON);
 ```
 
 `BigRational` is re-exported from the crate root and prelude when the `exact`
@@ -216,7 +224,7 @@ exposed for advanced use cases.
 | `Lu<D>` | `Matrix<D>` + pivot array | Factorization for solves/det | `solve_vec`, `det` |
 | `Ldlt<D>` | `Matrix<D>` | Factorization for symmetric SPD/PSD solves/det | `solve_vec`, `det` |
 
-Storage shown above reflects the current `f64` implementation.
+Storage shown above reflects the `f64` implementation.
 
 `Matrix<D>` key methods: `lu`, `ldlt`, `det`, `det_direct`, `det_errbound`,
 `det_exact`¹, `det_exact_f64`¹, `det_sign_exact`¹, `solve_exact`¹, `solve_exact_f64`¹.
@@ -229,6 +237,7 @@ The `examples/` directory contains small, runnable programs:
 
 - **`solve_5x5`** — solve a 5×5 system via LU with partial pivoting
 - **`det_5x5`** — determinant of a 5×5 matrix via LU
+- **`ldlt_solve_3x3`** — solve a 3×3 symmetric positive definite system via LDLT
 - **`const_det_4x4`** — compile-time 4×4 determinant via `det_direct()`
 - **`exact_det_3x3`** — exact determinant value of a near-singular 3×3 matrix (requires `exact` feature)
 - **`exact_sign_3x3`** — exact determinant sign of a near-singular 3×3 matrix (requires `exact` feature)
@@ -239,6 +248,7 @@ just examples
 # or individually:
 cargo run --example solve_5x5
 cargo run --example det_5x5
+cargo run --example ldlt_solve_3x3
 cargo run --example const_det_4x4
 cargo run --features exact --example exact_det_3x3
 cargo run --features exact --example exact_sign_3x3

examples/ldlt_solve_3x3.rs

@@ -0,0 +1,44 @@
+//! Solve a 3×3 symmetric positive definite system via LDLT factorization.
+//!
+//! LDLT is the natural choice for SPD matrices (e.g. Gram matrices, covariance
+//! matrices, stiffness matrices).  It avoids the row swaps of LU and exploits
+//! symmetry, using roughly half the work.
+//!
+//! Run with: `cargo run --example ldlt_solve_3x3`
+
+use la_stack::prelude::*;
+
+fn main() -> Result<(), LaError> {
+    // Symmetric positive definite 3×3 matrix (classic SPD tridiagonal).
+    let a = Matrix::<3>::from_rows([[4.0, -1.0, 0.0], [-1.0, 4.0, -1.0], [0.0, -1.0, 4.0]]);
+
+    // Choose x = [1, 2, 3].  Then b = A x = [2, 4, 10].
+    let b = Vector::<3>::new([2.0, 4.0, 10.0]);
+
+    let ldlt = a.ldlt(DEFAULT_SINGULAR_TOL)?;
+    let x = ldlt.solve_vec(b)?.into_array();
+    let det = ldlt.det();
+
+    println!("A (3×3 SPD tridiagonal):");
+    for r in 0..3 {
+        print!("  [");
+        for c in 0..3 {
+            if c > 0 {
+                print!(", ");
+            }
+            print!("{:5.1}", a.get(r, c).unwrap());
+        }
+        println!("]");
+    }
+    println!(
+        "b = [{}, {}, {}]",
+        b.as_array()[0],
+        b.as_array()[1],
+        b.as_array()[2]
+    );
+    println!();
+    println!("x   = [{:.6}, {:.6}, {:.6}]", x[0], x[1], x[2]);
+    println!("det = {det}");
+
+    Ok(())
+}

justfile

@@ -211,8 +211,11 @@ doc-check:
 examples:
     cargo run --quiet --example det_5x5
     cargo run --quiet --example solve_5x5
+    cargo run --quiet --example ldlt_solve_3x3
     cargo run --quiet --example const_det_4x4
+    cargo run --quiet --features exact --example exact_det_3x3
     cargo run --quiet --features exact --example exact_sign_3x3
+    cargo run --quiet --features exact --example exact_solve_3x3
 
 # Fix (mutating): apply formatters/auto-fixes
 fix: toml-fmt fmt python-fix shell-fmt markdown-fix yaml-fix