non-riemannian-opt: comparison src/cube.rs

-:cac6978dc7dd
+:90cc221eb52b
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Serialize_repr, Deserialize_repr)]
 #[repr(u8)]
 pub enum Face {F1 = 1, F2 = 2, F3 = 3, F4 = 4, F5 = 5, F6 = 6}
 use Face::*;
+/// General point in 2D
 pub type Point = Loc<f64, 2>;
+/// Types for faces adjacent to a given face.
 pub type AdjacentFaces = [Face; 4];
+/// Types of paths on a cube
 #[derive(Clone, Debug, Serialize)]
 pub enum Path {
+/// Direct path from an unindicated source face to a `destination` face.
 Direct { destination : Face },
+/// Indirect path from an unindicated source face to a `destination` face,
+/// via an `intermediate` face.
 Indirect { destination : Face, intermediate : Face },
 }
 /// An iterator over paths on a cube, from a source face to a destination face.
 #[derive(Clone, Debug)]
 pub enum PathIter {
+/// Direct path to a destination.
 Same {
+/// Deistination face
 destination : Face,
+/// Indicator whether the only possible [`Path::Direct`] has already been returned.
 exhausted : bool
 },
+/// Path via several possible intermedite faces.
+/// This is used to generate several [`Path::Indirect`].
 Indirect {
+/// Destination face
 destination : Face,
+/// Possible intermediate faces
 intermediate : AdjacentFaces,
+/// Intermediate face index counter.
 current : usize
 }
 }
 impl std::iter::Iterator for PathIter {
 }
 }
 }
 /// Indicates whether an unfolded point `p` is on this face, i.e.,
-/// has coordinates in [0,1]².
+/// has coordinates in $\[0,1\]^2$.
 pub fn is_in_face(&self, p: &Point) -> bool {
 p.iter().all(|t| 0.0 <= *t && *t <= 1.0)
 }
 /// Given an unfolded point `p` and a destination point `d` in unfolded coordinates,
 F6 => [x, y, 1.0],
 })
 }
 }
+/// Point on a the surface of the unit cube $\[0,1\]^3$.
 #[derive(Clone, Debug, PartialEq, Serialize)]
 pub struct OnCube {
 face : Face,
 point : Point,
 }
 #[cfg(test)]
 mod tests {
 use super::*;
+/// Tests that the distancse between the centers of all the faces are correctly calculated.
 #[test]
 fn center_distance() {
 let center = Loc([0.5, 0.5]);
 for f1 in Face::all() {
 }
 }
 }
 }
+/// Tests that the distances between points on the boundaries of distinct faces are
+/// correctly calculated.
 #[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]);
 assert_eq!(pu.dist_to(&ao), 1.5);
 }
 }
+/// Tests that the conversions between the coordinate systems of each face is working correctly.
 #[test]
 fn convert_adjacent() {
 let point = Loc([0.4, 0.6]);
 for f1 in Face::all() {
 //             }
 //         }
 //     }
 // }
+/// Tests that the logarithmic map is working correctly between adjacent faces.
 #[test]
 fn log_adjacent() {
 let p1 = OnCube{ face : F1, point : Loc([0.5, 0.5])};
 let p2 = OnCube{ face : F2, point : Loc([0.5, 0.5])};
 assert_eq!(p1.log(&p2).norm(L2), 1.0);
 }
+/// Tests that the logarithmic map is working correctly between opposing faces.
 #[test]
 fn log_opposing_equal() {
 let p1 = OnCube{ face : F1, point : Loc([0.5, 0.5])};
 let p2 = OnCube{ face : F6, point : Loc([0.5, 0.5])};
 assert_eq!(p1.log(&p2).norm(L2), 2.0);
 }
+/// Tests that the logarithmic map is working correctly between opposing faces when there
+/// is a unique shortest geodesic.
 #[test]
 fn log_opposing_unique_shortest() {
 let p1 = OnCube{ face : F1, point : Loc([0.3, 0.25])};
 let p2 = OnCube{ face : F6, point : Loc([0.3, 0.25])};

Mercurial > repos > non-riemannian-opt / file comparison

comparison: src/cube.rs

src/cube.rs