A modular presolve engine built on the CoinPresolveAction base class, where each presolve transformation (row/column elimination, bound tightening, substitution, duplicate detection) is a self-contained, stackable action object with apply/postsolve semantics. The action-stack pattern — where each transformation records enough state to reverse itself during postsolve — is a genuinely reusable design for any solver or data-preprocessing pipeline that needs reversible, order-dependent transformations. An engineer could extract the CoinPresolveAction abstraction and the iterative presolve-pass loop into a new project with minimal modification.

A specialized matrix class implementing dynamic column generation for generalized upper bound (GUB) problems. It maintains a small working model inside the parent solver, prices candidate columns on demand, and shifts bounds/objective offsets on pivots via a chain structure (id_/backward_/next_). This is a sophisticated, self-contained pattern for embedding column generation into a simplex loop — the 'reserve slack columns, price candidate columns into a small working set, synchronize on pivot' approach generalizes to other decomposition-based optimization problems.

The OSI (Open Solver Interface) adapter wrapping ClpSimplex behind the standard OsiSolverInterface abstract API. This demonstrates a clean adapter pattern: it exposes warm/hot starts, basis manipulation, cut application, and tableau access (getBInvARow) while hiding the solver internals. The adapter's discipline — mapping a solver-specific API onto a standardized abstraction without leaking implementation details — is reusable for anyone wrapping a numerical library behind a stable interface contract.

A complete C API wrapping the C++ ClpSimplex class using opaque pointer (void*) handles. Demonstrates a clean foreign-function interface pattern: ownership semantics are explicit (Clp_new/Clp_delete), error handling is via return codes, and the API surface is deliberately small (load problem, solve, query solution). This is a textbook example of wrapping a complex C++ object model for C/FFI consumers without exposing internal types — directly reusable as a template for other C++ libraries needing C bindings.

A specialized basis factorization for network-flow problems that exploits the tree structure (parent/descendant/sibling pointers) to perform FTRAN/BTRAN and column replacement in near-linear time without general-purpose LU factorization. The algorithm — maintaining a rooted tree representation of the network basis with efficient update and walk operations — is a self-contained, non-obvious data structure pattern that generalizes to any network-structured problem (transportation, assignment, flow) and could be extracted as a standalone tree-update component.

Hand-tuned low-level dense/sparse array kernels (scatter/gather updates, dgemm with recursive blocking, prefetch via inline asm) using a macro-trick technique to generate multiple variants (add, subtract) from a single header inclusion. Demonstrates non-obvious performance engineering: explicit loop unrolling, cache blocking, and compiler intrinsics for SIMD vectors. While the specific kernels are hyper-optimized for the simplex data layout, the code-generation-via-header-reinclusion pattern and the blocking strategy are reusable lessons for any performance-critical linear algebra project.