Mercurial > repos > non-riemannian-opt / changeset

--- a/src/cube.rs	Wed Nov 06 22:27:35 2024 -0500
+++ b/src/cube.rs	Thu Nov 07 12:49:42 2024 -0500
@@ -334,6 +334,57 @@
     use super::*;
 
     #[test]
+    fn center_distance() {
+        let center = Loc([0.5, 0.5]);
+
+        for f1 in Face::all() {
+            let p1 = OnCube { face : f1, point : center.clone() };
+            for f2 in Face::all() {
+                let p2 = OnCube { face : f2, point : center.clone() };
+                if f1==f2 {
+                    assert_eq!(p1.dist_to(&p2), 0.0);
+                } else if f1.opposing_face()==f2 {
+                    assert_eq!(p1.dist_to(&p2), 2.0);
+                } else {
+                    assert_eq!(p1.dist_to(&p2), 1.0);
+                }
+            }
+        }
+    }
+
+    #[test]
+    fn boundary_distance() {
+        let left = Loc([0.0, 0.5]);
+        let right = Loc([1.0, 0.5]);
+        let down = Loc([0.5, 0.0]);
+        let up = Loc([0.5, 1.0]);
+        let center = Loc([0.5, 0.5]);
+
+        for f1 in Face::all() {
+            let pl = OnCube { face : f1, point : left.clone() };
+            let pr = OnCube { face : f1, point : right.clone() };
+            let pd = OnCube { face : f1, point : down.clone() };
+            let pu = OnCube { face : f1, point : up.clone() };
+            let a = f1.adjacent_faces();
+            let al = OnCube { face : a[0], point : center.clone() };
+            let ar = OnCube { face : a[1], point : center.clone() };
+            let ad = OnCube { face : a[2], point : center.clone() };
+            let au = OnCube { face : a[3], point : center.clone() };
+            let ao = OnCube { face : f1.opposing_face(), point : center.clone() };
+
+            assert_eq!(pl.dist_to(&al), 0.5);
+            assert_eq!(pr.dist_to(&ar), 0.5);
+            assert_eq!(pd.dist_to(&ad), 0.5);
+            assert_eq!(pu.dist_to(&au), 0.5);
+            assert_eq!(pl.dist_to(&ao), 1.5);
+            assert_eq!(pr.dist_to(&ao), 1.5);
+            assert_eq!(pd.dist_to(&ao), 1.5);
+            assert_eq!(pu.dist_to(&ao), 1.5);
+        }
+    }
+
+
+    #[test]
     fn convert_adjacent() {
         let point = Loc([0.4, 0.6]);