Comparison and check functions to simplify tests

Author: vigna

webgraph/CHANGELOG.md

@@ -4,12 +4,20 @@
 
 ### New
 
-* `SequentialLabeling::eq_sorted` associated function that checks
-  equality between labelings.
+* `labels::eq_sorted` function that checks equality between sorted labelings.
 
-* `RandomAccessLabeling::check_impl` associated function that checks
-  that the sequential and random-access implementations return the
-  same results.
+* `labels::check_impl` associated function that checks that the sequential and
+  random-access implementations of a random-access labeling return the same
+  results.
+
+* `graph::eq` function that checks equality between graphs with sorted lenders.
+
+* `graph::eq_labeled` function that checks equality between labeled graphs with
+  sorted lenders.
+
+### Fixed
+
+* The successors of `LabeledVecGraph` now implement `SortedIterator`.
 
 ## [0.3.0] - 2025-05-23
 

webgraph/src/graphs/csr_graph.rs

@@ -368,9 +368,9 @@ mod test {
 
         let csr = <CsrGraph>::from_seq_graph(&g);
         dbg!(&csr);
-        check_graph_equivalence(&g, &csr);
+        //super::labels::eq(&g, &csr);
 
-        let csr = CompressedCsrGraph::from_graph(&g);
+        //let csr = CompressedCsrGraph::from_graph(&g);
         //check_graph_equivalence(&g, &csr);
     }
 

webgraph/src/graphs/vec_graph.rs

@@ -264,9 +264,11 @@ impl<'a, L: Clone + 'static> IntoLender for &'a LabeledVecGraph<L> {
 impl<L: Clone + 'static> LabeledSequentialGraph<L> for LabeledVecGraph<L> {}
 
 impl<L: Clone + 'static> RandomAccessLabeling for LabeledVecGraph<L> {
-    type Labels<'succ> = core::iter::Map<
-        core::iter::Cloned<core::slice::Iter<'succ, LabelledArc<L>>>,
-        fn(LabelledArc<L>) -> (usize, L),
+    type Labels<'succ> = SortedIter<
+        core::iter::Map<
+            core::iter::Cloned<core::slice::Iter<'succ, LabelledArc<L>>>,
+            fn(LabelledArc<L>) -> (usize, L),
+        >,
     >;
     #[inline(always)]
     fn num_arcs(&self) -> u64 {
@@ -280,7 +282,7 @@ impl<L: Clone + 'static> RandomAccessLabeling for LabeledVecGraph<L> {
 
     #[inline(always)]
     fn labels(&self, node: usize) -> <Self as RandomAccessLabeling>::Labels<'_> {
-        self.succ[node].iter().cloned().map(Into::into)
+        unsafe { SortedIter::new(self.succ[node].iter().cloned().map(Into::into)) }
     }
 }
 

webgraph/src/traits/graph.rs

@@ -59,6 +59,36 @@ struct this_method_cannot_be_called_use_successors_instead;
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait SequentialGraph: SequentialLabeling<Label = usize> {}
 
+/// Returns true if the two provided graphs with sorted lenders are equal.
+///
+/// This associated function can be used to compare graphs with [sorted
+/// lenders](crate::lenders::SortedLender), but whose iterators [are not
+/// sorted](crate::lenders::SortedIterator). If the graphs are sorted,
+/// [`SequentialLabeling::eq_sorted`] should be used instead.
+pub fn eq<G0: SequentialGraph, G1: SequentialGraph>(g0: &G0, g1: &G1) -> bool
+where
+    for<'a> G0::Lender<'a>: SortedLender,
+    for<'a> G1::Lender<'a>: SortedLender,
+{
+    // In theory we should be able to implement this function using eq_labeled,
+    // but due to current limitations of the borrow checker, we would need to
+    // make G0 and G1 'static.
+    if g0.num_nodes() != g1.num_nodes() {
+        return false;
+    }
+    for_!(((node0, succ0), (node1, succ1)) in g0.iter().zip(g1.iter()) {
+        debug_assert_eq!(node0, node1);
+        let mut succ0 = succ0.into_iter().collect::<Vec<_>>();
+        let mut succ1 = succ1.into_iter().collect::<Vec<_>>();
+        succ0.sort();
+        succ1.sort();
+        if succ0 != succ1 {
+            return false;
+        }
+    });
+    true
+}
+
 /// Convenience type alias for the iterator over the successors of a node
 /// returned by the [`iter_from`](SequentialLabeling::iter_from) method.
 pub type Successors<'succ, 'node, S> =
@@ -102,8 +132,8 @@ pub trait RandomAccessGraph: RandomAccessLabeling<Label = usize> + SequentialGra
     ///
     /// Note that the default implementation performs a linear scan.
     fn has_arc(&self, src_node_id: usize, dst_node_id: usize) -> bool {
-        for neighbour_id in self.successors(src_node_id) {
-            if neighbour_id == dst_node_id {
+        for succ in self.successors(src_node_id) {
+            if succ == dst_node_id {
                 return true;
             }
         }
@@ -119,6 +149,38 @@ pub trait RandomAccessGraph: RandomAccessLabeling<Label = usize> + SequentialGra
 #[autoimpl(for<S: trait + ?Sized> &S, &mut S, Rc<S>)]
 pub trait LabeledSequentialGraph<L>: SequentialLabeling<Label = (usize, L)> {}
 
+/// Returns true if the two provided labeled graphs with sorted lenders are
+/// equal.
+///
+/// This associated function can be used to compare graphs with [sorted
+/// lenders](crate::lenders::SortedLender), but whose iterators [are not
+/// sorted](crate::lenders::SortedIterator). If the graphs are sorted,
+/// [`SequentialLabeling::eq_sorted`] should be used instead.
+pub fn eq_labeled<M, G0: LabeledSequentialGraph<M>, G1: LabeledSequentialGraph<M>>(
+    g0: &G0,
+    g1: &G1,
+) -> bool
+where
+    for<'a> G0::Lender<'a>: SortedLender,
+    for<'a> G1::Lender<'a>: SortedLender,
+    M: PartialEq,
+{
+    if g0.num_nodes() != g1.num_nodes() {
+        return false;
+    }
+    for_!(((node0, succ0), (node1, succ1)) in g0.iter().zip(g1.iter()) {
+        debug_assert_eq!(node0, node1);
+        let mut succ0 = succ0.into_iter().collect::<Vec<_>>();
+        let mut succ1 = succ1.into_iter().collect::<Vec<_>>();
+        succ0.sort_by_key(|x| x.0);
+        succ1.sort_by_key(|x| x.0);
+        if succ0 != succ1 {
+            return false;
+        }
+    });
+    true
+}
+
 /// A wrapper associating to each successor the label `()`.
 ///
 /// This wrapper can be used whenever a method requires a labeled graph, but the
@@ -241,9 +303,9 @@ pub trait LabeledRandomAccessGraph<L>: RandomAccessLabeling<Label = (usize, L)>
     /// Returns whether there is an arc going from `src_node_id` to `dst_node_id`.
     ///
     /// Note that the default implementation performs a linear scan.
-    fn has_arc(&self, src_node_id: usize, dst_node_id: usize) -> bool {
-        for (neighbour_id, _) in self.successors(src_node_id) {
-            if neighbour_id == dst_node_id {
+    fn has_arc(&self, src: usize, dst: usize) -> bool {
+        for (succ, _) in self.successors(src) {
+            if succ == dst {
                 return true;
             }
         }

webgraph/src/traits/labels.rs

@@ -24,10 +24,7 @@ and nodes identifier are in the interval [0 . . *n*).
 
 */
 
-use crate::{
-    traits::{LenderIntoIter, RandomAccessGraph},
-    utils::Granularity,
-};
+use crate::{traits::LenderIntoIter, utils::Granularity};
 
 use super::{LenderLabel, NodeLabelsLender, ParMapFold};
 
@@ -196,30 +193,33 @@ pub trait SequentialLabeling {
             thread_pool,
         )
     }
+}
 
-    /// Returns true if the two provided sorted labelings are equal.
-    fn equal_sorted<L0: SequentialLabeling, L1: SequentialLabeling<Label = L0::Label>>(
-        l0: &L0,
-        l1: &L1,
-    ) -> bool
-    where
-        for<'a> L0::Lender<'a>: SortedLender,
-        for<'a> L1::Lender<'a>: SortedLender,
-        for<'a, 'b> LenderIntoIter<'b, L0::Lender<'a>>: SortedIterator,
-        for<'a, 'b> LenderIntoIter<'b, L0::Lender<'a>>: SortedIterator,
-        L0::Label: PartialEq,
-    {
-        if l0.num_nodes() != l1.num_nodes() {
+/// Returns true if the two provided sorted labelings are equal.
+///
+/// Since graphs are labelings, this function can also be used
+/// to check whether sorted graphs are equal.
+pub fn eq_sorted<L0: SequentialLabeling, L1: SequentialLabeling<Label = L0::Label>>(
+    l0: &L0,
+    l1: &L1,
+) -> bool
+where
+    for<'a> L0::Lender<'a>: SortedLender,
+    for<'a> L1::Lender<'a>: SortedLender,
+    for<'a, 'b> LenderIntoIter<'b, L0::Lender<'a>>: SortedIterator,
+    for<'a, 'b> LenderIntoIter<'b, L0::Lender<'a>>: SortedIterator,
+    L0::Label: PartialEq,
+{
+    if l0.num_nodes() != l1.num_nodes() {
+        return false;
+    }
+    for_!(((node0, succ0), (node1, succ1)) in l0.iter().zip(l1.iter()) {
+        debug_assert_eq!(node0, node1);
+        if !succ0.into_iter().eq(succ1.into_iter()) {
             return false;
         }
-        for_!(((node0, succ0), (node1, succ1)) in l0.iter().zip(l1.iter()) {
-            debug_assert_eq!(node0, node1);
-            if !succ0.into_iter().eq(succ1.into_iter()) {
-                return false;
-            }
-        });
-        true
-    }
+    });
+    true
 }
 
 /// Convenience type alias for the iterator over the labels of a node
@@ -343,27 +343,27 @@ pub trait RandomAccessLabeling: SequentialLabeling {
 
     /// Returns the number of labels associated with a node.
     fn outdegree(&self, node_id: usize) -> usize;
+}
 
-    /// Checks the sequential vs. random-access implementation of a sorted
-    /// random-access labeling.
-    ///
-    /// Note that this method will check that the sequential and random-access
-    /// iterators on labels of each node are identical, and that the number of
-    /// nodes returned by the sequential iterator is the same as the number of
-    /// nodes returned by [`num_nodes`](SequentialLabeling::num_nodes).
-    fn check_impl<L: RandomAccessLabeling>(l: L) -> bool
-    where
-        L::Label: PartialEq,
-    {
-        let mut num_nodes = 0;
-        for_!((node, succ) in l.iter() {
-            num_nodes += 1;
-            if !succ.into_iter().eq(l.labels(node).into_iter()) {
-                return false;
-            }
-        });
-        num_nodes == l.num_nodes()
-    }
+/// Checks the sequential vs. random-access implementation of a sorted
+/// random-access labeling.
+///
+/// Note that this method will check that the sequential and random-access
+/// iterators on labels of each node are identical, and that the number of
+/// nodes returned by the sequential iterator is the same as the number of
+/// nodes returned by [`num_nodes`](SequentialLabeling::num_nodes).
+pub fn check_impl<L: RandomAccessLabeling>(l: L) -> bool
+where
+    L::Label: PartialEq,
+{
+    let mut num_nodes = 0;
+    for_!((node, succ) in l.iter() {
+        num_nodes += 1;
+        if !succ.into_iter().eq(l.labels(node).into_iter()) {
+            return false;
+        }
+    });
+    num_nodes == l.num_nodes()
 }
 
 /// A struct used to make it easy to implement sequential access

webgraph/tests/test_labels_graphs.rs

@@ -0,0 +1,37 @@
+/*
+ * SPDX-FileCopyrightText: 2025 Sebastiano Vigna
+ *
+ * SPDX-License-Identifier: Apache-2.0 OR LGPL-2.1-or-later
+ */
+
+use webgraph::graphs::vec_graph::LabeledVecGraph;
+use webgraph::graphs::vec_graph::VecGraph;
+use webgraph::prelude::*;
+
+#[test]
+fn test_eq() {
+    let arcs = vec![(0, 1), (0, 2), (1, 2), (1, 3), (2, 4), (3, 4)];
+    let g0 = VecGraph::from_arcs(arcs.iter().copied());
+    let mut g1 = g0.clone();
+    assert!(labels::eq_sorted(&g0, &g1));
+    assert!(graph::eq(&g0, &g1));
+    g1.add_arc(0, 3);
+    assert!(!labels::eq_sorted(&g0, &g1));
+    assert!(!graph::eq(&g0, &g1));
+
+    let arcs = vec![
+        (0, 1, 0),
+        (0, 2, 1),
+        (1, 2, 2),
+        (1, 3, 3),
+        (2, 4, 4),
+        (3, 4, 5),
+    ];
+    let g0 = LabeledVecGraph::<usize>::from_arcs(arcs.iter().copied());
+    let mut g1 = g0.clone();
+    assert!(labels::eq_sorted(&g0, &g1));
+    assert!(graph::eq_labeled(&g0, &g1));
+    g1.add_arc(0, 3, 6);
+    assert!(!labels::eq_sorted(&g0, &g1));
+    assert!(!graph::eq_labeled(&g0, &g1));
+}