refactor!: rework cmap2 index & attribute system

honeycomb-benches/benches/core/cmap2/editing.rs

@@ -14,10 +14,7 @@
 
 // ------ IMPORTS
 
-use honeycomb_core::{
-    utils::square_cmap2, CMap2, DartIdentifier, FaceIdentifier, FloatType, Vertex2,
-    VertexIdentifier,
-};
+use honeycomb_core::{utils::square_cmap2, CMap2, DartIdentifier, FloatType};
 use iai_callgrind::{
     library_benchmark, library_benchmark_group, main, FlamegraphConfig, LibraryBenchmarkConfig,
 };
@@ -33,18 +30,18 @@ fn get_sparse_map(n_square: usize) -> CMap2<FloatType> {
     let mut map = square_cmap2::<FloatType>(n_square);
     map.set_betas(5, [0; 3]); // free dart 5
     map.remove_free_dart(5);
-    map.remove_vertex(1);
+    map.remove_vertex(1).unwrap();
     map
 }
 
-fn compute_dims(n_square: usize) -> (usize, usize) {
-    (n_square.pow(2) * 4, (n_square + 1).pow(2))
+fn compute_dims(n_square: usize) -> usize {
+    n_square.pow(2) * 4
 }
 
 #[library_benchmark]
 #[benches::with_setup(args = [16, 32, 64, 128, 256, 512], setup = compute_dims)]
-fn constructor((n_darts, n_vertices): (usize, usize)) -> CMap2<FloatType> {
-    black_box(CMap2::new(n_darts, n_vertices))
+fn constructor(n_darts: usize) -> CMap2<FloatType> {
+    black_box(CMap2::new(n_darts))
 }
 
 #[library_benchmark]
@@ -63,39 +60,12 @@ fn add_ten_darts(map: &mut CMap2<FloatType>) -> DartIdentifier {
     black_box(map.add_free_darts(10))
 }
 
-#[library_benchmark]
-#[bench::small(&mut get_map(5))]
-#[bench::medium(&mut get_map(50))]
-#[bench::large(&mut get_map(500))]
-fn add_default_vertex(map: &mut CMap2<FloatType>) -> VertexIdentifier {
-    black_box(map.add_vertex(None))
-}
-
-#[library_benchmark]
-#[bench::small(&mut get_map(5))]
-#[bench::medium(&mut get_map(50))]
-#[bench::large(&mut get_map(500))]
-fn add_vertex(map: &mut CMap2<FloatType>) -> VertexIdentifier {
-    black_box(map.add_vertex(Some(Vertex2::from((12.0, 6.0)))))
-}
-
-#[library_benchmark]
-#[bench::small(&mut get_map(5))]
-#[bench::medium(&mut get_map(50))]
-#[bench::large(&mut get_map(500))]
-fn add_10_vertices(map: &mut CMap2<FloatType>) -> VertexIdentifier {
-    black_box(map.add_vertices(10))
-}
-
 library_benchmark_group!(
     name = bench_new;
     benchmarks =
         constructor,
         add_single_dart,
         add_ten_darts,
-        add_default_vertex,
-        add_vertex,
-        add_10_vertices,
 );
 
 #[library_benchmark]
@@ -118,16 +88,8 @@ fn insert_dart_full(map: &mut CMap2<FloatType>) -> DartIdentifier {
 #[bench::small(&mut get_sparse_map(5))]
 #[bench::medium(&mut get_sparse_map(50))]
 #[bench::large(&mut get_sparse_map(500))]
-fn insert_vertex(map: &mut CMap2<FloatType>) -> VertexIdentifier {
-    black_box(map.insert_vertex(None))
-}
-
-#[library_benchmark]
-#[bench::small(&mut get_map(5))]
-#[bench::medium(&mut get_map(50))]
-#[bench::large(&mut get_map(500))]
-fn insert_vertex_full(map: &mut CMap2<FloatType>) -> VertexIdentifier {
-    black_box(map.insert_vertex(None))
+fn insert_vertex(map: &mut CMap2<FloatType>) {
+    black_box(map.insert_vertex(1, (0.0, 0.0)));
 }
 
 library_benchmark_group!(
@@ -136,29 +98,19 @@ library_benchmark_group!(
         insert_dart,
         insert_dart_full,
         insert_vertex,
-        insert_vertex_full,
 );
 
 #[library_benchmark]
 #[bench::small(&mut get_map(5))]
 #[bench::medium(&mut get_map(50))]
 #[bench::large(&mut get_map(500))]
-fn build_face(map: &mut CMap2<FloatType>) -> FaceIdentifier {
-    black_box(map.build_face(5))
-}
-
-#[library_benchmark]
-#[bench::small(&mut get_map(5))]
-#[bench::medium(&mut get_map(50))]
-#[bench::large(&mut get_map(500))]
-fn build_faces(map: &mut CMap2<FloatType>) -> usize {
-    black_box(map.build_all_faces())
+fn build_faces(map: &mut CMap2<FloatType>) {
+    black_box(map.fetch_faces());
 }
 
 library_benchmark_group!(
     name = bench_face_building;
     benchmarks =
-        build_face,
         build_faces,
 );
 

honeycomb-benches/benches/core/cmap2/reading.rs

@@ -112,24 +112,24 @@ library_benchmark_group!(
 #[bench::small(&get_map(5))]
 #[bench::medium(&get_map(50))]
 #[bench::large(&get_map(500))]
-fn zero_cell(map: &CMap2<FloatType>) -> Vec<DartIdentifier> {
-    black_box(map.i_cell::<0>(5))
+fn zero_cell(map: &CMap2<FloatType>) {
+    black_box(map.i_cell::<0>(5));
 }
 
 #[library_benchmark]
 #[bench::small(&get_map(5))]
 #[bench::medium(&get_map(50))]
 #[bench::large(&get_map(500))]
-fn one_cell(map: &CMap2<FloatType>) -> Vec<DartIdentifier> {
-    black_box(map.i_cell::<0>(5))
+fn one_cell(map: &CMap2<FloatType>) {
+    black_box(map.i_cell::<1>(5));
 }
 
 #[library_benchmark]
 #[bench::small(&get_map(5))]
 #[bench::medium(&get_map(50))]
 #[bench::large(&get_map(500))]
-fn two_cell(map: &CMap2<FloatType>) -> Vec<DartIdentifier> {
-    black_box(map.i_cell::<2>(5))
+fn two_cell(map: &CMap2<FloatType>) {
+    black_box(map.i_cell::<2>(5));
 }
 
 library_benchmark_group!(

honeycomb-benches/benches/core/cmap2/sewing.rs

@@ -15,33 +15,33 @@
 
 // ------ IMPORTS
 
-use honeycomb_core::{utils::square_cmap2, CMap2, FloatType, SewPolicy, UnsewPolicy};
+use honeycomb_core::{utils::square_cmap2, CMap2, FloatType};
 use iai_callgrind::{
     library_benchmark, library_benchmark_group, main, FlamegraphConfig, LibraryBenchmarkConfig,
 };
 use std::hint::black_box;
 
 // ------ CONTENT
 
-fn compute_dims(n_square: usize) -> (usize, usize) {
-    (n_square.pow(2) * 4, (n_square + 1).pow(2))
+fn compute_dims(n_square: usize) -> usize {
+    n_square.pow(2) * 4
 }
 
 fn get_map(n_square: usize) -> CMap2<FloatType> {
     square_cmap2::<FloatType>(n_square)
 }
 
 fn get_unstructured_map(n_square: usize) -> CMap2<FloatType> {
-    let (n_darts, n_vertices) = compute_dims(n_square);
-    CMap2::new(n_darts, n_vertices)
+    let n_darts = compute_dims(n_square);
+    CMap2::new(n_darts)
 }
 
 #[library_benchmark]
 #[bench::small(&mut get_unstructured_map(5))]
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn one_sew_left(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.one_sew(4, 6, SewPolicy::StretchLeft);
+    map.one_sew(4, 6);
     black_box(map)
 }
 
@@ -50,7 +50,7 @@ fn one_sew_left(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn one_sew_right(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.one_sew(4, 6, SewPolicy::StretchRight);
+    map.one_sew(4, 6);
     black_box(map)
 }
 
@@ -59,7 +59,7 @@ fn one_sew_right(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn one_sew_avg(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.one_sew(4, 6, SewPolicy::StretchAverage);
+    map.one_sew(4, 6);
     black_box(map)
 }
 
@@ -76,7 +76,7 @@ library_benchmark_group!(
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn two_sew_left(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.two_sew(4, 6, SewPolicy::StretchLeft);
+    map.two_sew(4, 6);
     black_box(map)
 }
 
@@ -85,7 +85,7 @@ fn two_sew_left(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn two_sew_right(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.two_sew(4, 6, SewPolicy::StretchRight);
+    map.two_sew(4, 6);
     black_box(map)
 }
 
@@ -94,7 +94,7 @@ fn two_sew_right(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_unstructured_map(50))]
 #[bench::large(&mut get_unstructured_map(500))]
 fn two_sew_avg(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.two_sew(4, 6, SewPolicy::StretchAverage);
+    map.two_sew(4, 6);
     black_box(map)
 }
 
@@ -111,7 +111,7 @@ library_benchmark_group!(
 #[bench::medium(&mut get_map(50))]
 #[bench::large(&mut get_map(500))]
 fn one_unsew_nothing(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.one_unsew(4, UnsewPolicy::DoNothing);
+    map.one_unsew(4);
     black_box(map)
 }
 
@@ -120,7 +120,7 @@ fn one_unsew_nothing(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_map(50))]
 #[bench::large(&mut get_map(500))]
 fn one_unsew_duplicate(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.one_unsew(4, UnsewPolicy::Duplicate);
+    map.one_unsew(4);
     black_box(map)
 }
 
@@ -136,7 +136,7 @@ library_benchmark_group!(
 #[bench::medium(&mut get_map(50))]
 #[bench::large(&mut get_map(500))]
 fn two_unsew_nothing(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.two_unsew(4, UnsewPolicy::DoNothing);
+    map.two_unsew(4);
     black_box(map)
 }
 
@@ -145,7 +145,7 @@ fn two_unsew_nothing(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
 #[bench::medium(&mut get_map(50))]
 #[bench::large(&mut get_map(500))]
 fn two_unsew_duplicate(map: &mut CMap2<FloatType>) -> &mut CMap2<FloatType> {
-    map.two_unsew(4, UnsewPolicy::Duplicate);
+    map.two_unsew(4);
     black_box(map)
 }
 

honeycomb-benches/benches/splitsquaremap/shift.rs

@@ -31,32 +31,38 @@ use honeycomb_core::{
 // ------ CONTENT
 
 fn offset(mut map: CMap2<FloatType>, offsets: &[Vector2<FloatType>]) {
-    (0..map.n_vertices().0).for_each(|vertex_id| {
-        let current_value = map.vertex(vertex_id as DartIdentifier);
-        let _ = map.set_vertex(
-            vertex_id as VertexIdentifier,
-            *current_value + offsets[vertex_id],
+    let n_offsets = offsets.len();
+    let vertices = map.fetch_vertices();
+    vertices.identifiers.iter().for_each(|vertex_id| {
+        let current_value = map.vertex(*vertex_id as DartIdentifier);
+        let _ = map.replace_vertex(
+            *vertex_id as VertexIdentifier,
+            current_value + offsets[*vertex_id as usize % n_offsets],
         );
     });
     black_box(&mut map);
 }
 
 fn offset_if_inner(mut map: CMap2<FloatType>, offsets: &[Vector2<FloatType>]) {
+    let n_offsets = offsets.len();
     let mut inner: BTreeSet<VertexIdentifier> = BTreeSet::new();
+    let vertices = map.fetch_vertices();
     // collect inner vertex IDs
-    (0..map.n_darts().0 as DartIdentifier).for_each(|dart_id| {
+    vertices.identifiers.iter().for_each(|vertex_id| {
         let neighbors_vertex_cell: Vec<DartIdentifier> = map
-            .i_cell::<0>(dart_id)
-            .iter()
-            .map(|d_id| map.beta::<2>(*d_id))
+            .i_cell::<0>(*vertex_id as DartIdentifier)
+            .map(|d_id| map.beta::<2>(d_id))
             .collect();
         if !neighbors_vertex_cell.contains(&NULL_DART_ID) {
-            inner.insert(map.vertexid(dart_id));
+            inner.insert(*vertex_id);
         }
     });
     inner.iter().for_each(|vertex_id| {
         let current_value = map.vertex(*vertex_id);
-        let _ = map.set_vertex(*vertex_id, *current_value + offsets[*vertex_id as usize]);
+        let _ = map.replace_vertex(
+            *vertex_id,
+            current_value + offsets[*vertex_id as usize % n_offsets],
+        );
     });
     black_box(&mut map);
 }

honeycomb-benches/benches/squaremap/shift.rs

@@ -30,32 +30,38 @@ use honeycomb_core::{
 // ------ CONTENT
 
 fn offset(mut map: CMap2<FloatType>, offsets: &[Vector2<FloatType>]) {
-    (0..map.n_vertices().0).for_each(|vertex_id| {
-        let current_value = map.vertex(vertex_id as DartIdentifier);
-        let _ = map.set_vertex(
-            vertex_id as VertexIdentifier,
-            *current_value + offsets[vertex_id],
+    let n_offsets = offsets.len();
+    let vertices = map.fetch_vertices();
+    vertices.identifiers.iter().for_each(|vertex_id| {
+        let current_value = map.vertex(*vertex_id as DartIdentifier);
+        let _ = map.replace_vertex(
+            *vertex_id,
+            current_value + offsets[*vertex_id as usize % n_offsets],
         );
     });
     black_box(&mut map);
 }
 
 fn offset_if_inner(mut map: CMap2<FloatType>, offsets: &[Vector2<FloatType>]) {
+    let n_offsets = offsets.len();
+    let vertices = map.fetch_vertices();
     let mut inner: BTreeSet<VertexIdentifier> = BTreeSet::new();
     // collect inner vertex IDs
-    (0..map.n_darts().0 as DartIdentifier).for_each(|dart_id| {
+    vertices.identifiers.iter().for_each(|vertex_id| {
         let neighbors_vertex_cell: Vec<DartIdentifier> = map
-            .i_cell::<0>(dart_id)
-            .iter()
-            .map(|d_id| map.beta::<2>(*d_id))
+            .i_cell::<0>(*vertex_id as DartIdentifier)
+            .map(|d_id| map.beta::<2>(d_id))
             .collect();
         if !neighbors_vertex_cell.contains(&NULL_DART_ID) {
-            inner.insert(map.vertexid(dart_id));
+            inner.insert(*vertex_id);
         }
     });
     inner.iter().for_each(|vertex_id| {
         let current_value = map.vertex(*vertex_id);
-        let _ = map.set_vertex(*vertex_id, *current_value + offsets[*vertex_id as usize]);
+        let _ = map.replace_vertex(
+            *vertex_id,
+            current_value + offsets[*vertex_id as usize % n_offsets],
+        );
     });
     black_box(&mut map);
 }