Revert "fix: filter reachable vertecies in nfarpq"

This reverts commit 13284b4.

Author: VanyaGlazunov

build.rs

@@ -71,7 +71,6 @@ fn regenerate_bindings() {
         .allowlist_function("GrB_Vector_new")
         .allowlist_function("GrB_Vector_free")
         .allowlist_function("GrB_Vector_setElement_BOOL")
-        .allowlist_function("GrB_Vector_extractElement_BOOL")
         .allowlist_function("GrB_Vector_nvals")
         .allowlist_function("GrB_Vector_extractTuples_BOOL")
         .allowlist_function("GrB_vxm")

src/graph/mod.rs

@@ -149,22 +149,6 @@ impl GraphblasVector {
         Ok(nvals)
     }
 
-    /// Checks if a specific index has a stored value.
-    pub fn contains(&self, i: GrB_Index) -> Result<bool, GraphError> {
-        let mut value: bool = false;
-        let info = unsafe { GrB_Vector_extractElement_BOOL(&mut value, self.inner, i) };
-        match info {
-            GrB_Info::GrB_SUCCESS => Ok(true),
-            GrB_Info::GrB_NO_VALUE => Ok(false),
-            _ => Err(GraphError::GraphBlas(info)),
-        }
-    }
-
-    /// Stores a boolean value at the given index.
-    pub fn set_bool(&mut self, i: GrB_Index, value: bool) -> Result<(), GraphError> {
-        grb_ok!(GrB_Vector_setElement_BOOL(self.inner, value, i))
-    }
-
     /// Extracts all stored indices from boolean vector.
     pub fn indices(&self) -> Result<Vec<GrB_Index>, GraphError> {
         let nvals = self.nvals()?;

src/lagraph_sys_generated.rs

@@ -139,9 +139,6 @@ unsafe extern "C" {
 unsafe extern "C" {
     pub fn GrB_Vector_setElement_BOOL(w: GrB_Vector, x: bool, i: GrB_Index) -> GrB_Info;
 }
-unsafe extern "C" {
-    pub fn GrB_Vector_extractElement_BOOL(x: *mut bool, v: GrB_Vector, i: GrB_Index) -> GrB_Info;
-}
 unsafe extern "C" {
     pub fn GrB_Vector_extractTuples_BOOL(
         I_: *mut GrB_Index,

src/rpq/nfarpq.rs

@@ -2,8 +2,8 @@
 
 use crate::graph::{GraphDecomposition, GraphblasVector, LagraphGraph, ensure_grb_init};
 use crate::la_ok;
-use crate::lagraph_sys::LAGraph_Kind;
 use crate::lagraph_sys::*;
+use crate::lagraph_sys::LAGraph_Kind;
 use crate::rpq::{Endpoint, PathExpr, RpqError, RpqEvaluator, RpqQuery};
 use rustfst::algorithms::closure::{ClosureType, closure};
 use rustfst::algorithms::concat::concat;
@@ -223,7 +223,7 @@ impl RpqEvaluator for NfaRpqEvaluator {
         let nfa_matrices = nfa.build_lagraph_matrices()?;
 
         let src_id = resolve_endpoint(&query.subject, graph)?;
-        let dst_id = resolve_endpoint(&query.object, graph)?;
+        let _dst_id = resolve_endpoint(&query.object, graph)?;
 
         let n = graph.num_nodes();
 
@@ -258,24 +258,8 @@ impl RpqEvaluator for NfaRpqEvaluator {
 
         let result_vec = GraphblasVector { inner: reachable };
 
-        let filtered_vec = match dst_id {
-            Some(target_idx) => {
-                let target = target_idx as GrB_Index;
-                let is_reachable = result_vec.contains(target)?;
-
-                let mut filtered = unsafe { GraphblasVector::new_bool(n as GrB_Index) }?;
-
-                if is_reachable {
-                    filtered.set_bool(target, true)?;
-                }
-
-                filtered
-            }
-            None => result_vec,
-        };
-
         Ok(NfaRpqResult {
-            reachable: filtered_vec,
+            reachable: result_vec,
         })
     }
 }

tests/nfarpq_tests.rs

@@ -90,7 +90,8 @@ fn run_la_n_egg_case(case_name: &str) {
 
         let actual_nnz = result.reachable.nvals().expect("failed to get nvals");
         assert_eq!(
-            actual_nnz, *expected_nnz,
+            actual_nnz,
+            *expected_nnz,
             "case '{case_name}' query #{i} nnz mismatch\n  query:    {query:?}\n  expected: {expected_nnz}\n  actual:   {actual_nnz}",
         );
     }
@@ -142,10 +143,7 @@ fn test_single_label_named_source() {
         .evaluate(&rq(named_ep("A"), label("knows"), var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let b_id = graph.get_node_id("B").expect("B should exist");
     assert!(
         indices.contains(&(b_id as GrB_Index)),
@@ -183,10 +181,7 @@ fn test_sequence_path_named_source() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let c_id = graph.get_node_id("C").expect("C should exist");
     assert!(
         indices.contains(&(c_id as GrB_Index)),
@@ -207,10 +202,7 @@ fn test_alternative_path() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let b_id = graph.get_node_id("B").expect("B should exist");
     let c_id = graph.get_node_id("C").expect("C should exist");
     assert!(
@@ -236,10 +228,7 @@ fn test_zero_or_more_path() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let a_id = graph.get_node_id("A").expect("A should exist");
     let b_id = graph.get_node_id("B").expect("B should exist");
     let c_id = graph.get_node_id("C").expect("C should exist");
@@ -271,10 +260,7 @@ fn test_one_or_more_path() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let a_id = graph.get_node_id("A").expect("A should exist");
     let b_id = graph.get_node_id("B").expect("B should exist");
     let c_id = graph.get_node_id("C").expect("C should exist");
@@ -306,10 +292,7 @@ fn test_zero_or_one_path() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let a_id = graph.get_node_id("A").expect("A should exist");
     let b_id = graph.get_node_id("B").expect("B should exist");
     let c_id = graph.get_node_id("C").expect("C should exist");
@@ -419,10 +402,7 @@ fn test_complex_path() {
         .evaluate(&rq(named_ep("A"), path, var("y")), &graph)
         .expect("evaluate should succeed");
 
-    let indices = result
-        .reachable
-        .indices()
-        .expect("failed to extract indices");
+    let indices = result.reachable.indices().expect("failed to extract indices");
     let d_id = graph.get_node_id("D").expect("D should exist");
     assert!(
         indices.contains(&(d_id as GrB_Index)),