Added: Initial implementation of la-stack crate

Adds the initial implementation of the `la-stack` crate,
providing stack-allocated linear algebra for fixed dimensions.
Includes `Vector`, `Matrix`, and `Lu` types, along with basic
functionality and examples. Also sets up `justfile` for
development workflow and a license file.

Author: acgetchell

.gitignore

@@ -1 +1,2 @@
 /target
+/.cspellcache

LICENSE

@@ -0,0 +1,28 @@
+# BSD 3-Clause License
+
+Copyright (c) 2025, Adam Getchell
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are met:
+
+1. Redistributions of source code must retain the above copyright notice, this
+   list of conditions and the following disclaimer.
+
+2. Redistributions in binary form must reproduce the above copyright notice,
+   this list of conditions and the following disclaimer in the documentation
+   and/or other materials provided with the distribution.
+
+3. Neither the name of the copyright holder nor the names of its
+   contributors may be used to endorse or promote products derived from
+   this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
+AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
+IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
+FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
+DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
+SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
+CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
+OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.

README.md

@@ -0,0 +1,98 @@
+# la-stack
+
+[![Crates.io](https://img.shields.io/crates/v/la-stack.svg)](https://crates.io/crates/la-stack)
+[![Downloads](https://img.shields.io/crates/d/la-stack.svg)](https://crates.io/crates/la-stack)
+[![License](https://img.shields.io/crates/l/la-stack.svg)](LICENSE)
+[![Docs.rs](https://docs.rs/la-stack/badge.svg)](https://docs.rs/la-stack)
+[![CI](https://github.com/acgetchell/la-stack/actions/workflows/ci.yml/badge.svg)](https://github.com/acgetchell/la-stack/actions/workflows/ci.yml)
+[![rust-clippy analyze](https://github.com/acgetchell/la-stack/actions/workflows/rust-clippy.yml/badge.svg)](https://github.com/acgetchell/la-stack/actions/workflows/rust-clippy.yml)
+[![Audit dependencies](https://github.com/acgetchell/la-stack/actions/workflows/audit.yml/badge.svg)](https://github.com/acgetchell/la-stack/actions/workflows/audit.yml)
+
+Fast, stack-allocated linear algebra for fixed dimensions in Rust.
+
+This crate exists primarily to support the [`delaunay`](https://crates.io/crates/delaunay) crate’s needs while keeping the API intentionally small and explicit.
+
+## 📐 Introduction
+
+`la-stack` provides a handful of const-generic, stack-backed building blocks:
+
+- `Vector<const D: usize>` for fixed-length vectors (`[f64; D]` today)
+- `Matrix<const D: usize>` for fixed-size square matrices (`[[f64; D]; D]` today)
+- `Lu<const D: usize>` for LU factorization with partial pivoting (solve + det)
+
+## ✨ Design goals
+
+- ✅ Const-generic dimensions (no dynamic sizes)
+- ✅ Stack storage only (no heap allocation in core types)
+- ✅ `Copy` types where possible
+- ✅ Explicit algorithms (LU, solve, determinant)
+- ✅ `unsafe` forbidden
+- ✅ No runtime dependencies (dev-dependencies are for contributors only)
+
+## 🔢 Scalar types
+
+Today, the core types are implemented for `f64`. The intent is to support `f32` and `f64` (and `f128` if/when Rust gains a stable primitive for it). Longer term, we may add optional arbitrary-precision support (e.g. via `rug`) depending on performance.
+
+## 🚀 Quickstart
+
+Add this to your `Cargo.toml`:
+
+```toml
+[dependencies]
+la-stack = "0.1"
+```
+
+Solve a 3×3 system via LU:
+
+```rust
+use la_stack::{LaError, Matrix, Vector, DEFAULT_PIVOT_TOL};
+
+fn main() -> Result<(), LaError> {
+    // Requires pivoting (a[0][0] = 0), so it's a good LU demo.
+    let a = Matrix::<3>::from_rows([[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0]]);
+    let b = Vector::<3>::new([5.0, 4.0, 3.0]);
+
+    let lu = a.lu(DEFAULT_PIVOT_TOL)?;
+    let x = lu.solve_vec(b)?.into_array();
+
+    println!("x = {x:?}");
+    Ok(())
+}
+```
+
+## 🧩 API at a glance
+
+| Type | Storage | Purpose | Key methods |
+|---|---|---|---|
+| `Vector<D>` | `[f64; D]` | Fixed-length vector | `new`, `zero`, `dot`, `norm2_sq` |
+| `Matrix<D>` | `[[f64; D]; D]` | Fixed-size square matrix | `from_rows`, `zero`, `identity`, `lu`, `det` |
+| `Lu<D>` | `Matrix<D>` + pivot array | Factorization for solves/det | `solve_vec`, `det` |
+
+Storage shown above reflects the current `f64` implementation.
+
+## 📋 Examples
+
+The `examples/` directory contains small, runnable programs:
+
+```bash
+just examples
+# or:
+cargo run --example solve_3x3
+cargo run --example det_3x3
+```
+
+## 🤝 Contributing
+
+A short contributor workflow:
+
+```bash
+cargo install just
+just ci           # lint + fast tests + bench compile
+just commit-check # lint + all tests + examples
+```
+
+For the full set of developer commands, see `just --list` and `WARP.md`.
+
+## 📄 License
+
+BSD 3-Clause License. See [LICENSE](LICENSE).

WARP.md

@@ -4,14 +4,18 @@ This file provides guidance to WARP (warp.dev) when working with code in this re
 
 ## Common commands
 
-- Build (debug): `cargo build`
-- Build (release): `cargo build --release`
-- Fast compile check (no binary produced): `cargo check`
-- Run tests: `cargo test`
+- Build (debug): `cargo build` (or `just build`)
+- Build (release): `cargo build --release` (or `just build-release`)
+- Fast compile check (no binary produced): `cargo check` (or `just check`)
+- Run tests: `cargo test` (or `just test`)
 - Run a single test (by name filter): `cargo test solve_2x2_basic` (or the full path: `cargo test lu::tests::solve_2x2_basic`)
-- Format: `cargo fmt`
-- Lint (Clippy): `cargo clippy --all-targets --all-features -- -D warnings`
-- Run benchmarks: `cargo bench`
+- Format: `cargo fmt` (or `just fmt`)
+- Lint (Clippy): `cargo clippy --all-targets --all-features -- -D warnings` (or `just clippy`)
+- Spell check: `just spell-check` (uses `cspell.json` at repo root; keep the `words` list sorted lexicographically)
+- Run benchmarks: `cargo bench` (or `just bench`)
+- Run examples: `just examples` (or `cargo run --example det_3x3`)
+- CI simulation (lint + tests + bench compile): `just ci`
+- Pre-commit validation: `just commit-check`
 
 ## Code structure (big picture)
 
@@ -21,6 +25,7 @@ This file provides guidance to WARP (warp.dev) when working with code in this re
   - `src/vector.rs`: `Vector<const D: usize>` (`[f64; D]`)
   - `src/matrix.rs`: `Matrix<const D: usize>` (`[[f64; D]; D]`) + helpers (`get`, `set`, `inf_norm`, `det`)
   - `src/lu.rs`: `Lu<const D: usize>` factorization with partial pivoting (`solve_vec`, `det`)
+- A minimal `justfile` exists for common workflows (see `just --list`).
 - The public API re-exports these items from `src/lib.rs`.
 - Dev-only benchmarks live in `benches/vs_nalgebra.rs` (Criterion + nalgebra comparison).
 

cspell.json

@@ -0,0 +1,33 @@
+{
+  "version": "0.2",
+  "language": "en",
+  "words": [
+    "Clippy",
+    "clippy",
+    "const",
+    "elif",
+    "f128",
+    "f32",
+    "f64",
+    "generics",
+    "Getchell",
+    "Justfile",
+    "justfile",
+    "lu",
+    "MSRV",
+    "msvc",
+    "mult",
+    "nalgebra",
+    "pipefail",
+    "pivoting",
+    "println",
+    "rug",
+    "RUSTDOCFLAGS",
+    "shellcheck",
+    "usize"
+  ],
+  "ignorePaths": [
+    "target",
+    "Cargo.lock"
+  ]
+}

examples/det_3x3.rs

@@ -0,0 +1,14 @@
+//! Compute the determinant of a 3×3 matrix via explicit LU factorization.
+
+use la_stack::{DEFAULT_PIVOT_TOL, LaError, Matrix};
+
+fn main() -> Result<(), LaError> {
+    let a = Matrix::<3>::from_rows([[1.0, 2.0, 3.0], [0.0, 4.0, 5.0], [1.0, 0.0, 6.0]]);
+
+    // Compute via explicit LU factorization.
+    let lu = a.lu(DEFAULT_PIVOT_TOL)?;
+    let det = lu.det();
+
+    println!("det = {det}");
+    Ok(())
+}

examples/solve_3x3.rs

@@ -0,0 +1,15 @@
+//! Solve a 3×3 linear system via LU factorization (with pivoting).
+
+use la_stack::{DEFAULT_PIVOT_TOL, LaError, Matrix, Vector};
+
+fn main() -> Result<(), LaError> {
+    // This system requires pivoting (a[0][0] = 0), so it's a good LU demo.
+    let a = Matrix::<3>::from_rows([[0.0, 1.0, 1.0], [1.0, 0.0, 1.0], [1.0, 1.0, 0.0]]);
+    let b = Vector::<3>::new([5.0, 4.0, 3.0]);
+
+    let lu = a.lu(DEFAULT_PIVOT_TOL)?;
+    let x = lu.solve_vec(b)?.into_array();
+
+    println!("x = [{:.6}, {:.6}, {:.6}]", x[0], x[1], x[2]);
+    Ok(())
+}

justfile

@@ -0,0 +1,118 @@
+# shellcheck disable=SC2148
+# Justfile for la-stack development workflow
+# Install just: https://github.com/casey/just
+# Usage: just <command> or just --list
+
+# Use bash with strict error handling for all recipes
+set shell := ["bash", "-euo", "pipefail", "-c"]
+
+# Default recipe shows available commands
+default:
+    @just --list
+
+# Build commands
+build:
+    cargo build
+
+build-release:
+    cargo build --release
+
+check:
+    cargo check
+
+# Code quality and formatting
+fmt:
+    cargo fmt
+
+fmt-check:
+    cargo fmt --check
+
+clippy:
+    cargo clippy --all-targets --all-features -- -D warnings
+
+doc-check:
+    RUSTDOCFLAGS='-D warnings' cargo doc --no-deps
+
+# Lint groups (delaunay-style)
+lint: lint-code lint-docs lint-config
+
+lint-code: fmt-check clippy doc-check
+
+lint-docs: spell-check
+
+lint-config: action-lint
+
+# Testing (delaunay-style split)
+# - test: lib + doc tests (fast)
+# - test-integration: tests/ (if present)
+# - test-all: everything in Rust
+
+test:
+    cargo test --lib --verbose
+    cargo test --doc --verbose
+
+test-integration:
+    cargo test --tests --verbose
+
+test-all: test test-integration
+    @echo "✅ All tests passed"
+
+# Benchmarks
+bench:
+    cargo bench
+
+bench-compile:
+    cargo bench --no-run
+
+# Examples
+examples:
+    cargo run --quiet --example det_3x3
+    cargo run --quiet --example solve_3x3
+
+# CI simulation (matches delaunay's `just ci` shape)
+ci: lint test test-integration bench-compile
+    @echo "🎯 CI simulation complete!"
+
+# Pre-commit workflow: comprehensive validation before committing
+# Runs: linting + all Rust tests (lib + doc + integration) + examples
+commit-check: lint test-all examples
+    @echo "🚀 Ready to commit! All checks passed!"
+
+# GitHub Actions workflow validation (optional)
+action-lint:
+    #!/usr/bin/env bash
+    set -euo pipefail
+    if ! command -v actionlint >/dev/null; then
+        echo "⚠️ 'actionlint' not found. Install: https://github.com/rhysd/actionlint"
+        exit 0
+    fi
+    files=()
+    while IFS= read -r -d '' file; do
+        files+=("$file")
+    done < <(git ls-files -z '.github/workflows/*.yml' '.github/workflows/*.yaml')
+    if [ "${#files[@]}" -gt 0 ]; then
+        printf '%s\0' "${files[@]}" | xargs -0 actionlint
+    else
+        echo "No workflow files found to lint."
+    fi
+
+# Spell check (cspell)
+#
+# Requires either:
+# - `cspell` on PATH (recommended: `npm i -g cspell`), or
+# - `npx` (will run cspell without a global install)
+spell-check:
+    #!/usr/bin/env bash
+    set -euo pipefail
+    if command -v cspell >/dev/null; then
+        cspell lint --config cspell.json --no-progress --gitignore --cache --exclude cspell.json .
+    elif command -v npx >/dev/null; then
+        npx cspell lint --config cspell.json --no-progress --gitignore --cache --exclude cspell.json .
+    else
+        echo "❌ cspell not found. Install via npm (recommended): npm i -g cspell"
+        echo "   Or ensure npx is available (Node.js)."
+        exit 1
+    fi
+
+clean:
+    cargo clean