api: change Matrix::set to return Option<()> instead of bool

[acgetchell]

Dependencies

• chore: bump MSRV to Rust 1.95 and adopt new stable features #67
• perf: integer-only forward elimination for gauss_solve (BigInt hybrid) #72
• perf: improve exact arithmetic benchmark coverage with diverse inputs #80
• docs: strengthen LDLT symmetry precondition documentation #84
• bug: inf_norm silently returns 0.0 for matrices containing NaN #85
• feat: const-ify Lu::det, Ldlt::det, inf_norm, det_errbound, and solve methods #86

Summary

Matrix::set returns bool for bounds-check success/failure. The idiomatic Rust pattern for fallible setters is Option<()> (or panicking like [] indexing). A bool return is easy to silently ignore, potentially masking out-of-bounds bugs.

Current State

pub const fn set(&mut self, r: usize, c: usize, value: f64) -> bool {
    if r < D && c < D {
        self.rows[r][c] = value;
        true
    } else {
        false
    }
}

Callers can write m.set(10, 0, 1.0); and silently do nothing. The #[must_use] attribute on the struct doesn't help here since the return is a primitive bool on a method, not the struct itself.

Proposed Changes

Change the return type to Option<()>:

pub const fn set(&mut self, r: usize, c: usize, value: f64) -> Option<()> {
    if r < D && c < D {
        self.rows[r][c] = value;
        Some(())
    } else {
        None
    }
}

This enables m.set(r, c, v)? in fallible contexts and triggers #[must_use] warnings from Option when the result is ignored (since Option itself is #[must_use]).

Alternatively, consider a panicking API matching standard indexing:

pub const fn set(&mut self, r: usize, c: usize, value: f64) {
    assert!(r < D && c < D, "index out of bounds");
    self.rows[r][c] = value;
}

This matches the behavior users expect from matrix[r][c] = value and is consistent with get returning Option (try-access) vs set being unconditional (assert-access).

Benefits

• Idiomatic Rust API
• Compiler warnings when the bounds-check result is ignored
• Consistent with Option/Result conventions in the Rust ecosystem

Implementation Notes

• This is a breaking change (return type change)
• get returning Option<f64> is already idiomatic — this brings set in line
• Existing callers using assert!(m.set(...)) would change to m.set(...).unwrap() or assert!(m.set(...).is_some())
• Also gated on generic_const_exprs stabilization for the full v0.5.0 API revision

[acgetchell]

Blocked by v0.4.1 release (all v0.4.1 issues should ship first). Also gated on generic_const_exprs stabilization for the full API revision.