From 9283858a41b5e6726b25f24adf3bb32bb62844d3 Mon Sep 17 00:00:00 2001
From: Aaron Fenyes <aaron.fenyes@fareycircles.ooo>
Date: Thu, 27 Feb 2025 23:12:46 -0800
Subject: [PATCH] Move the frozen entry test; tidy up other tests

The other tidying is:
- Dropping a redundant type hint.
- Finding an expected dimension instead of hard-coding it.
---
 app-proto/src/engine.rs | 86 +++++++++++++++++++++--------------------
 1 file changed, 45 insertions(+), 41 deletions(-)

diff --git a/app-proto/src/engine.rs b/app-proto/src/engine.rs
index eee19ac..b18c4bf 100644
--- a/app-proto/src/engine.rs
+++ b/app-proto/src/engine.rs
@@ -523,7 +523,7 @@ mod tests {
             entries
         });
         let config = {
-            let a: f64 = 0.75_f64.sqrt();
+            let a = 0.75_f64.sqrt();
             DMatrix::from_columns(&[
                 sphere(1.0, 0.0, 0.0, a),
                 sphere(-0.5, a, 0.0, a),
@@ -534,6 +534,40 @@ mod tests {
         assert!(state.loss.abs() < f64::EPSILON);
     }
     
+    // at the frozen indices, the optimization steps should have exact zeros,
+    // and the realized configuration should match the initial guess
+    #[test]
+    fn frozen_entry_test() {
+        let gram = {
+            let mut gram_to_be = PartialMatrix::new();
+            for j in 0..2 {
+                for k in j..2 {
+                    gram_to_be.push_sym(j, k, if (j, k) == (1, 1) { 1.0 } else { 0.0 });
+                }
+            }
+            gram_to_be
+        };
+        let guess = DMatrix::from_columns(&[
+            point(0.0, 0.0, 2.0),
+            sphere(0.0, 0.0, 0.0, 1.0)
+        ]);
+        let frozen = [(3, 0), (3, 1)];
+        println!();
+        let (config, _, success, history) = realize_gram(
+            &gram, guess.clone(), &frozen,
+            1.0e-12, 0.5, 0.9, 1.1, 200, 110
+        );
+        assert_eq!(success, true);
+        for base_step in history.base_step.into_iter() {
+            for index in frozen {
+                assert_eq!(base_step[index], 0.0);
+            }
+        }
+        for index in frozen {
+            assert_eq!(config[index], guess[index]);
+        }
+    }
+    
     #[test]
     fn irisawa_hexlet_test() {
         // solve Irisawa's problem
@@ -574,12 +608,8 @@ mod tests {
         assert_eq!(success, true);
         assert_eq!(history.scaled_loss.len(), 1);
         
-        // confirm that the tangent space has dimension five or less
-        assert_eq!(tangent.basis_std.len(), 5);
-        
-        // confirm that the tangent space contains all the motions we expect it
-        // to. since we've already bounded the dimension of the tangent space,
-        // this confirms that the tangent space is what we expect it to be
+        // list some motions that should form a basis for the tangent space of
+        // the solution variety
         const UNIFORM_DIM: usize = 4;
         let element_dim = guess.nrows();
         let assembly_dim = guess.ncols();
@@ -605,6 +635,14 @@ mod tests {
                 0.0, 0.0, -1.0,  0.25,  1.0
             ])
         ];
+        
+        // confirm that the dimension of the tangent space is no greater than
+        // expected
+        assert_eq!(tangent.basis_std.len(), tangent_motions_std.len());
+        
+        // confirm that the tangent space contains all the motions we expect it
+        // to. since we've already bounded the dimension of the tangent space,
+        // this confirms that the tangent space is what we expect it to be
         let tol_sq = ((element_dim * assembly_dim) as f64) * SCALED_TOL * SCALED_TOL;
         for (motion_unif, motion_std) in tangent_motions_unif.into_iter().zip(tangent_motions_std) {
             let motion_proj: DMatrix<_> = motion_unif.column_iter().enumerate().map(
@@ -826,38 +864,4 @@ mod tests {
         let tol_sq = ((guess_orig.nrows() * guess_orig.ncols()) as f64) * SCALED_TOL_TFM * SCALED_TOL_TFM;
         assert!((motion_proj_tfm - motion_tfm_proj).norm_squared() < tol_sq);
     }
-    
-    // at the frozen indices, the optimization steps should have exact zeros,
-    // and the realized configuration should match the initial guess
-    #[test]
-    fn frozen_entry_test() {
-        let gram = {
-            let mut gram_to_be = PartialMatrix::new();
-            for j in 0..2 {
-                for k in j..2 {
-                    gram_to_be.push_sym(j, k, if (j, k) == (1, 1) { 1.0 } else { 0.0 });
-                }
-            }
-            gram_to_be
-        };
-        let guess = DMatrix::from_columns(&[
-            point(0.0, 0.0, 2.0),
-            sphere(0.0, 0.0, 0.0, 1.0)
-        ]);
-        let frozen = [(3, 0), (3, 1)];
-        println!();
-        let (config, _, success, history) = realize_gram(
-            &gram, guess.clone(), &frozen,
-            1.0e-12, 0.5, 0.9, 1.1, 200, 110
-        );
-        assert_eq!(success, true);
-        for base_step in history.base_step.into_iter() {
-            for index in frozen {
-                assert_eq!(base_step[index], 0.0);
-            }
-        }
-        for index in frozen {
-            assert_eq!(config[index], guess[index]);
-        }
-    }
 }
\ No newline at end of file