Skip to content

SolidCraft: an open-source parametric 3D CAD application built in pure Rust. Desktop, web, and automation through MCP.

Sketch solver: eliminate row by row on slices, so the dense solve vectorises (#8631)

semmelrinde5241c64aa666
diff --git a/crates/sketch/src/linalg.rs b/crates/sketch/src/linalg.rs
index 3954c9b8fc..04c138e89b 100644
--- a/crates/sketch/src/linalg.rs
+++ b/crates/sketch/src/linalg.rs
@@ -39,7 +39,7 @@ impl Mat {
/// Solve `A x = b` (A square). Returns `None` when singular.
pub fn solve(mut a: Mat, mut b: Vec<f64>) -> Option<Vec<f64>> {
let n = a.rows;
- if a.cols != n || b.len() != n {
+ if a.cols != n || b.len() != n || n.checked_mul(n) != Some(a.data.len()) {
return None;
}
for k in 0..n {
@@ -57,18 +57,23 @@ pub fn solve(mut a: Mat, mut b: Vec<f64>) -> Option<Vec<f64>> {
}
a.swap_rows(k, piv);
b.swap(k, piv);
- let d = a.get(k, k);
- for r in k + 1..n {
- let f = a.get(r, k) / d;
+ // Row by row on slices, so the update vectorises: the same operations in the same
+ // order as element by element (the solution is bit for bit the same).
+ let (above, below) = a.data.split_at_mut_checked((k + 1) * n)?;
+ let pivot = above.get(k * n + k..)?;
+ let d = *pivot.first()?;
+ let (b_above, b_below) = b.split_at_mut_checked(k + 1)?;
+ let bk = *b_above.last()?;
+ for (row, br) in below.chunks_exact_mut(n).zip(b_below.iter_mut()) {
+ let row = row.get_mut(k..)?;
+ let f = *row.first()? / d;
if f == 0.0 {
continue;
}
- for c in k..n {
- let v = a.get(k, c);
- a.add(r, c, -f * v);
+ for (x, v) in row.iter_mut().zip(pivot) {
+ *x += -f * v;
}
- let bk = *b.get(k)?;
- *b.get_mut(r)? -= f * bk;
+ *br -= f * bk;
}
}
let mut x = vec![0.0; n];
@@ -168,6 +173,80 @@ mod tests {
assert!(solve(s, vec![1.0, 1.0]).is_none());
}
+ /// The elimination element by element, as `solve` did before it worked on row slices.
+ fn solve_by_elements(mut a: Mat, mut b: Vec<f64>) -> Option<Vec<f64>> {
+ let n = a.rows;
+ for k in 0..n {
+ let mut piv = k;
+ let mut best = a.get(k, k).abs();
+ for r in k + 1..n {
+ if a.get(r, k).abs() > best {
+ best = a.get(r, k).abs();
+ piv = r;
+ }
+ }
+ if !(best > 1e-300) || !best.is_finite() {
+ return None;
+ }
+ a.swap_rows(k, piv);
+ b.swap(k, piv);
+ let d = a.get(k, k);
+ for r in k + 1..n {
+ let f = a.get(r, k) / d;
+ if f == 0.0 {
+ continue;
+ }
+ for c in k..n {
+ let v = a.get(k, c);
+ a.add(r, c, -f * v);
+ }
+ let bk = b[k];
+ b[r] -= f * bk;
+ }
+ }
+ let mut x = vec![0.0; n];
+ for k in (0..n).rev() {
+ let mut s = b[k];
+ for (c, xc) in x.iter().enumerate().skip(k + 1) {
+ s -= a.get(k, c) * xc;
+ }
+ x[k] = s / a.get(k, k);
+ }
+ x.iter().all(|v| v.is_finite()).then_some(x)
+ }
+
+ #[test]
+ fn row_slices_solve_bit_for_bit_as_elements_did() {
+ let mut seed = 0x2545_f491_4f6c_dd1d_u64;
+ let mut next = || {
+ seed ^= seed << 13;
+ seed ^= seed >> 7;
+ seed ^= seed << 17;
+ (seed >> 11) as f64 / (1u64 << 53) as f64 - 0.5
+ };
+ for n in [1, 2, 3, 7, 16, 41, 120] {
+ for sparse in [false, true] {
+ let mut a = Mat::zeros(n, n);
+ for r in 0..n {
+ for c in 0..n {
+ let v = next();
+ // Sparse rows (as a sketch's Jacobian has) skip most updates: f == 0.
+ if !sparse || r == c || v.abs() < 0.1 {
+ a.set(r, c, if r == c { v + 4.0 } else { v });
+ }
+ }
+ }
+ let b: Vec<f64> = (0..n).map(|_| next()).collect();
+ let new = solve(a.clone(), b.clone()).unwrap();
+ let old = solve_by_elements(a, b).unwrap();
+ assert!(new.iter().zip(&old).all(|(x, y)| x.to_bits() == y.to_bits()), "n {n}, sparse {sparse}");
+ }
+ }
+ // Wrong shapes are refused, not read past.
+ assert!(solve(Mat { rows: 2, cols: 2, data: vec![1.0; 3] }, vec![1.0, 1.0]).is_none());
+ assert!(solve(Mat::zeros(2, 3), vec![1.0, 1.0]).is_none());
+ }
+
#[test]
fn rank_and_determined() {
// x0 + x1 = .., x2 = .. ; x0 and x1 not individually determined.