EffectCraft: An open-source motion graphics and compositing tool written by scratch in pure Rust
Limit camera-system Cholesky work to its matrix band
vangel76e5afbccbc7d7
diff --git a/crates/track/src/camtrack/linalg.rs b/crates/track/src/camtrack/linalg.rsindex 2efc14556..77ac8fafb 100644--- a/crates/track/src/camtrack/linalg.rs+++ b/crates/track/src/camtrack/linalg.rs@@ -317,9 +317,29 @@ fn dot_n(a: &[f64], b: &[f64]) -> f64 {/// Solve `A x = b` for a symmetric positive definite `A` (`n × n`, row-major) in place by/// Cholesky factorisation. Returns false when `A` is not positive definite.pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {+ if n.checked_mul(n) != Some(a.len()) || b.len() != n {+ return false;+ }+ let mut band = n.saturating_sub(1);+ if b.iter().all(|v| v.is_finite()) {+ band = 0;+ 'bandwidth: for i in (0..n).rev() {+ for j in 0..i.saturating_sub(band) {+ if a[i * n + j] != 0.0 {+ band = i - j;+ // Wide systems (including shared global parameters) use the dense path.+ if band >= n / 2 {+ band = n.saturating_sub(1);+ break 'bandwidth;+ }+ break;+ }+ }+ }+ }for j in 0..n {let mut d = a[j * n + j];- for k in 0..j {+ for k in j.saturating_sub(band)..j {d -= a[j * n + k] * a[j * n + k];}if d <= 0.0 || !d.is_finite() {@@ -330,14 +350,24 @@ pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {let (head, tail) = a.split_at_mut((j + 1) * n);let rowj = &head[j * n..j * n + j];// Rows below j (sequential: per-column parallel dispatch costs more than it saves).- for row in tail.chunks_mut(n) {- row[j] = (row[j] - dot_n(&row[..j], rowj)) / d;+ for (off, row) in tail.chunks_mut(n).take(band).enumerate() {+ // Removing full groups of four zero products preserves dot_n's lane order.+ let start = (j + 1 + off).saturating_sub(band) / 4 * 4;+ row[j] = (row[j] - dot_n(&row[start..j], &rowj[start..])) / d;}}// Forward: L y = b.for i in 0..n {let mut s = b[i];- for k in 0..i {+ let start = i.saturating_sub(band);+ // Subtracting signed-zero products can change -0.0 to +0.0. Preserve those+ // operations when the accumulator is zero; nonzero values are unaffected.+ if s == 0.0 {+ for k in 0..start {+ s -= a[i * n + k] * b[k];+ }+ }+ for k in start..i {s -= a[i * n + k] * b[k];}b[i] = s / a[i * n + i];@@ -345,9 +375,15 @@ pub fn cholesky_solve(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {// Back: Lᵀ x = y.for i in (0..n).rev() {let mut s = b[i];- for k in i + 1..n {+ let end = i.saturating_add(band).saturating_add(1).min(n);+ for k in i + 1..end {s -= a[k * n + i] * b[k];}+ if s == 0.0 {+ for k in end..n {+ s -= a[k * n + i] * b[k];+ }+ }b[i] = s / a[i * n + i];}b.iter().all(|v| v.is_finite())@@ -428,6 +464,119 @@ pub fn from_euler_xyz(e: V3) -> M3 {mod tests {use super::*;+ fn dense_cholesky_reference(a: &mut [f64], n: usize, b: &mut [f64]) -> bool {+ for j in 0..n {+ let mut d = a[j * n + j];+ for k in 0..j {+ d -= a[j * n + k] * a[j * n + k];+ }+ if d <= 0.0 || !d.is_finite() {+ return false;+ }+ let d = d.sqrt();+ a[j * n + j] = d;+ let (head, tail) = a.split_at_mut((j + 1) * n);+ let rowj = &head[j * n..j * n + j];+ // Rows below j (sequential: per-column parallel dispatch costs more than it saves).+ for row in tail.chunks_mut(n) {+ row[j] = (row[j] - dot_n(&row[..j], rowj)) / d;+ }+ }+ // Forward: L y = b.+ for i in 0..n {+ let mut s = b[i];+ for k in 0..i {+ s -= a[i * n + k] * b[k];+ }+ b[i] = s / a[i * n + i];+ }+ // Back: Lᵀ x = y.+ for i in (0..n).rev() {+ let mut s = b[i];+ for k in i + 1..n {+ s -= a[k * n + i] * b[k];+ }+ b[i] = s / a[i * n + i];+ }+ b.iter().all(|v| v.is_finite())+ }++ #[test]+ fn banded_cholesky_is_bit_identical_to_dense() {+ for n in [1usize, 2, 3, 4, 5, 6, 7, 8, 13, 31, 65, 127] {+ for width in [0usize, 1, 2, 5, 11, n - 1] {+ for seed in 0..3 {+ for scale in [1.0, 1e-100, 1e100] {+ let mut a = vec![0.0; n * n];+ for i in 0..n {+ for j in 0..i {+ let value = if i - j <= width {+ (((i * 13 + j * 17 + seed) % 23) as f64 - 11.0) / 128.0+ } else if (i + j) % 2 == 0 {+ -0.0+ } else {+ 0.0+ };+ a[i * n + j] = value;+ a[j * n + i] = value;+ }+ }+ for i in 0..n {+ a[i * n + i] = a[i * n..(i + 1) * n].iter().map(|v| v.abs()).sum::<f64>() + 1.0;+ }+ for value in &mut a {+ *value *= scale;+ }+ let mut rhs: Vec<f64> = (0..n).map(|i| if i % 7 == 0 { -0.0 } else { ((i * 5 + seed) % 17) as f64 - 8.0 }).collect();+ let (mut reference_a, mut reference_rhs) = (a.clone(), rhs.clone());+ assert!(dense_cholesky_reference(&mut reference_a, n, &mut reference_rhs));+ assert!(cholesky_solve(&mut a, n, &mut rhs));+ assert_eq!(+ rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ reference_rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ "n={n} width={width} seed={seed} scale={scale}"+ );+ assert_eq!(+ a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ reference_a.iter().map(|v| v.to_bits()).collect::<Vec<_>>(),+ "factor n={n} width={width}"+ );+ }+ }+ }+ }+ }++ #[test]+ fn banded_cholesky_preserves_underflow_and_signed_zero() {+ let n = 8;+ let mut a = vec![0.0; n * n];+ for i in 0..n {+ for j in 0..n {+ a[i * n + j] = if i == j {+ 1e300+ } else if (i + j) % 2 == 0 {+ -0.0+ } else {+ 0.0+ };+ }+ }+ let mut rhs = vec![-1e-300, 1e-300, -0.0, 0.0, -1e-300, 1e-300, 0.0, -0.0];+ let (mut original, mut expected) = (a.clone(), rhs.clone());+ assert!(dense_cholesky_reference(&mut original, n, &mut expected));+ assert!(cholesky_solve(&mut a, n, &mut rhs));+ assert_eq!(rhs.iter().map(|v| v.to_bits()).collect::<Vec<_>>(), expected.iter().map(|v| v.to_bits()).collect::<Vec<_>>());+ }++ #[test]+ fn cholesky_rejects_invalid_dimensions_without_indexing() {+ assert!(!cholesky_solve(&mut [], usize::MAX, &mut []));+ assert!(!cholesky_solve(&mut [1.0], 2, &mut [1.0, 1.0]));+ assert!(!cholesky_solve(&mut [1.0], 1, &mut []));+ assert!(cholesky_solve(&mut [], 0, &mut []));+ }+#[test]fn svd_reconstructs() {let a = [3.0, 1.0, 2.0, -1.0, 4.0, 0.5, 2.0, 2.0, 7.0, 0.1, -3.0, 1.0];