perf: minor optimizations — clone reduction + det_sign_exact short-circuit

[acgetchell]

Summary

Small targeted optimizations to reduce unnecessary clones and add a short-circuit path in det_sign_exact.

Proposed Changes

Clone reduction in bareiss_det

The inner loop already uses references correctly:

a[i][j] = (&a[k][k] * &a[i][j] - &a[i][k] * &a[k][j]) / &prev_pivot;

But the pivot assignment clones unconditionally:

prev_pivot = a[k][k].clone();

This clone is necessary (mutation boundary), but the intermediate pivot reference in the elimination loop can be hoisted:

let pivot_ref = &a[k][k];
// use pivot_ref in inner loop instead of re-borrowing a[k][k]

Clone reduction in gauss_solve

Same pattern — pivot = aug[k][k].clone() on line 179 can be deferred or replaced with a reference where the borrow checker allows.

Short-circuit in det_sign_exact

Currently both det_direct() and det_errbound() are always computed together:

if let (Some(det_f64), Some(err)) = (self.det_direct(), self.det_errbound()) {

Micro-optimization: compute det_direct() first, and skip det_errbound() if the magnitude is obviously large relative to machine epsilon. The permanent computation in det_errbound() is non-trivial for D=3,4.

if let Some(det_f64) = self.det_direct() {
    if det_f64.is_finite() {
        if let Some(err) = self.det_errbound() {
            if det_f64 > err { return Ok(1); }
            if det_f64 < -err { return Ok(-1); }
        }
    }
}

This is a minor restructure that avoids the errbound computation when det_f64 is non-finite (overflow case).

Benefits

• Marginal speedup from reduced cloning (most visible for large BigRational values)
• Cleaner separation of the two-stage filter in det_sign_exact
• Low risk — minimal code changes

Implementation Notes

• All existing tests must continue to pass
• These are incremental improvements, not architectural changes
• Can be done at any time (no dependencies on other issues)
• Related: perf: stack-backed storage for exact arithmetic kernels #62, perf: custom f64 → BigRational conversion via mantissa/exponent decomposition #63, perf: integer-only Bareiss determinant (BigInt path) #64, refactor: unify determinant computation pipeline #65

[acgetchell]

Analysis after #64 (integer-only Bareiss)

All three proposed optimizations are either already addressed or inapplicable after the #64 refactor:

1. Clone reduction in bareiss_det → already done

The Bareiss elimination now lives in bareiss_det_int (operates on BigInt, not BigRational). The pivot assignment already uses clone_from (efficient in-place clone):

prev_pivot.clone_from(&a[k][k]);

Hoisting &a[k][k] to a local variable is a no-op for the compiler — it already knows a[k][k] doesn't alias a[i][j] when i != k (different array indices).

2. Clone reduction in gauss_solve → can't be eliminated

let pivot = mat[k][k].clone() on line 332 is necessary because the elimination loop mutably borrows mat[i][j] while reading mat[k][j]. The borrow checker can't split the 2D array by row. This clone cannot be removed without a fundamentally different data layout.

3. Short-circuit in det_sign_exact → negligible impact

The proposal avoids computing det_errbound() when det_f64 is non-finite (overflow). But:

• det_errbound() is ~5ns of pure f64 arithmetic
• The overflow case (entries near f64::MAX) is extremely rare
• Savings: ~5ns in a rare edge case, zero in the common case

The restructured code is marginally clearer but not enough to justify a change given the test/review overhead.

Closing as addressed by #64 and the natural evolution of the codebase.