Merge branch 'main' into feat/impl-bindings-independencies-minimal-dseparator

Author: mdrazak2001

.github/workflows/ci.yml

@@ -12,7 +12,7 @@ jobs:
     runs-on: ${{ matrix.os }}
     strategy:
       matrix:
-        os: [ubuntu-latest, macos-latest]
+        os: [ubuntu-latest, macos-latest, windows-latest]
 
     steps:
     - name: Checkout code

r_bindings/causalgraphs/src/rust/Cargo.toml

@@ -11,9 +11,9 @@ name = 'rcausalgraphs'
 
 [dependencies]
 
-# rust_core = { git = "https://github.com/pgmpy/causalgraphs.git", branch = "main", package = "rust_core" }
+rust_core = { git = "https://github.com/pgmpy/causalgraphs.git", branch = "main", package = "rust_core" }
 
 # For local development, comment out the Git line above and uncomment this:
-rust_core = { path = "../../../../rust_core" }
+# rust_core = { path = "../../../../rust_core" }
 
 extendr-api = '*'

r_bindings/causalgraphs/tests/testthat/test.R

@@ -5,14 +5,108 @@ test_that("basic DAG operations", {
   dag <- RDAG$new()
   dag$add_node("A", FALSE)
   dag$add_node("B", FALSE)
-  dag$add_edge("A", "B", NULL)
+  dag$add_edge("A", "B", 20)
+
   expect_setequal(dag$nodes(), c("A", "B"))
-  expect_equal(dag$node_count(), 2)
-  expect_equal(dag$edge_count(), 1)
+  expect_equal(dag$node_count(), 2L)
+  expect_equal(dag$edge_count(), 1L)
+
   expect_equal(dag$get_parents("B"), "A")
   expect_equal(dag$get_children("A"), "B")
+
+  e <- dag$edges()
+  expect_true(is.list(e) && all(c("from", "to") %in% names(e)))
+  expect_equal(length(e$from), 1L)
+  expect_equal(paste0(e$from, "->", e$to), "A->B")
+})
+
+test_that("add_nodes_from with and without latent mask", {
+  # With latent mask
+  dag1 <- RDAG$new()
+  dag1$add_nodes_from(c("X", "Y", "Z"), c(TRUE, FALSE, TRUE))
+  expect_setequal(dag1$nodes(), c("X", "Y", "Z"))
+  expect_setequal(dag1$latents(), c("X", "Z"))
+
+  # Without latent mask (all observed). Pass NULL explicitly.
+  dag2 <- RDAG$new()
+  dag2$add_nodes_from(c("A", "B", "C"), NULL)
+  expect_setequal(dag2$nodes(), c("A", "B", "C"))
+  expect_length(dag2$latents(), 0L)
+})
+
+test_that("add_node defaults latent=FALSE and duplicate adds are no-ops", {
+  dag <- RDAG$new()
+  dag$add_node("L", FALSE)
+  dag$add_node("L", TRUE)
+  expect_setequal(dag$nodes(), "L")
+  expect_length(dag$latents(), 0L)
+  expect_equal(dag$node_count(), 1L)
+})
+
+test_that("add_edge auto-adds missing nodes; optional weight works", {
+  dag <- RDAG$new()
+
+  dag$add_edge("S", "T", NULL)
+  expect_setequal(dag$nodes(), c("S", "T"))
+  expect_equal(dag$node_count(), 2L)
+  expect_equal(dag$edge_count(), 1L)
+  expect_equal(dag$get_parents("T"), "S")
+  expect_equal(dag$get_children("S"), "T")
+
+  # another edge with an explicit weight
+  dag$add_edge("T", "U", 0.5)
+  expect_equal(dag$edge_count(), 2L)
+
+  # edge list is order-insensitive for assertions
+  e <- dag$edges()
+  got <- paste0(e$from, "->", e$to)
+  expect_setequal(got, c("S->T", "T->U"))
 })
 
+test_that("get_parents / get_children errors on unknown node", {
+  dag <- RDAG$new()
+  dag$add_nodes_from(c("A","B"), NULL)
+  dag$add_edge("A","B", NULL)
+
+  expect_error(dag$get_parents("Z"))
+  expect_error(dag$get_children("Z"))
+})
+
+test_that("get_ancestors_of returns nodes plus all their ancestors", {
+  dag <- RDAG$new()
+  dag$add_nodes_from(c("A","B","C","D"), NULL)
+  dag$add_edge("A","B", NULL)
+  dag$add_edge("B","C", NULL)
+  dag$add_edge("D","C", NULL)
+
+  # ancestors(C) = {A, B, D, C}  (includes the node itself per implementation)
+  anc_C <- dag$get_ancestors_of(c("C"))
+  expect_setequal(anc_C, c("A","B","C","D"))
+
+  # ancestors(B, D) = {A, B, D}
+  anc_BD <- dag$get_ancestors_of(c("B","D"))
+  expect_setequal(anc_BD, c("A","B","D"))
+
+  # Unknown node should error
+  expect_error(dag$get_ancestors_of(c("C","Z")))
+})
+
+test_that("nodes(), edges(), node_count(), edge_count(), latents() remain consistent", {
+  dag <- RDAG$new()
+  dag$add_nodes_from(c("L1","O1","O2"), c(TRUE, FALSE, FALSE))
+  dag$add_edge("O1","O2", NULL)
+  dag$add_edge("L1","O2", NULL)
+
+  expect_equal(dag$node_count(), 3L)
+  expect_equal(dag$edge_count(), 2L)
+  expect_setequal(dag$latents(), "L1")
+  expect_setequal(dag$nodes(), c("L1","O1","O2"))
+
+  e <- dag$edges()
+  expect_setequal(paste0(e$from, "->", e$to), c("O1->O2","L1->O2"))
+})
+
+
 test_that("add_edges_from adds multiple edges correctly", {
   dag <- RDAG$new()
   dag$add_nodes_from(c("A", "B", "C", "D"), NULL)

wasm_bindings/js/tests/test-wasm.js

@@ -0,0 +1,125 @@
+const cg = require("../pkg-node/causalgraphs_wasm.js");
+
+// --- helpers ---
+const sortStrings = (arr) => arr.slice().sort();
+const sortPairs = (pairs) =>
+  pairs
+    .map(([a, b]) => [String(a), String(b)])
+    .sort((p, q) => (p[0] === q[0] ? p[1].localeCompare(q[1]) : p[0].localeCompare(q[0])));
+
+const latentsList = (dag) => {
+  const v = dag.latents; // exposed as a getter property
+  if (Array.isArray(v)) return sortStrings(v);
+  if (v && typeof v === "object") {
+    return sortStrings(Object.keys(v).filter((k) => v[k]));
+  }
+  return [];
+};
+
+describe("DAG wasm (CJS)", () => {
+  it("should add nodes & edges (basic)", () => {
+    const dag = new cg.DAG();
+    dag.addNode("U");
+    dag.addNode("V");
+    dag.addEdge("U", "V");
+    expect(dag.nodes()).toEqual(["U", "V"]);
+    expect(dag.nodeCount).toBe(2);
+    expect(dag.edges()).toEqual([["U", "V"]]);
+    expect(dag.edgeCount).toBe(1);
+  });
+
+  it("addNode with optional latent flag; latents getter", () => {
+    const dag = new cg.DAG();
+    dag.addNode("A");
+    dag.addNode("L", true);
+    expect(sortStrings(dag.nodes())).toEqual(["A", "L"]);
+
+    const lats = latentsList(dag);
+    expect(lats).toContain("L");
+    expect(lats).not.toContain("A");
+  });
+
+  it("addNodesFrom with optional latent mask (Uint8Array)", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["X", "Y", "Z"], [true, false, true]);
+    expect(sortStrings(dag.nodes())).toEqual(["X", "Y", "Z"]);
+
+    const lats = latentsList(dag);
+    expect(lats).toEqual(["X", "Z"]);
+  });
+
+  it("getParents and getChildren", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["A", "B", "C", "D"]);
+    dag.addEdge("A", "B");
+    dag.addEdge("A", "C");
+    dag.addEdge("B", "D");
+    dag.addEdge("C", "D");
+
+    expect(sortStrings(dag.getParents("D"))).toEqual(["B", "C"]);
+    expect(sortStrings(dag.getChildren("A"))).toEqual(["B", "C"]);
+  });
+
+  it("getAncestorsOf for a single target", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["A", "B", "C", "D"]);
+    dag.addEdge("A", "B");
+    dag.addEdge("A", "C");
+    dag.addEdge("B", "D");
+    dag.addEdge("C", "D");
+
+    const ancD = sortStrings(dag.getAncestorsOf(["D"]));
+    expect(ancD).toEqual(["A", "B", "C", "D"]);
+  });
+
+  it("getAncestorsOf for multiple targets", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["A", "B", "C", "D", "E"]);
+    dag.addEdge("A", "B");
+    dag.addEdge("B", "C");
+    dag.addEdge("A", "D");
+    dag.addEdge("D", "E");
+
+    const anc = sortStrings(dag.getAncestorsOf(["C", "E"]));
+    expect(anc).toEqual(["A", "B", "C", "D", "E"]);
+  });
+
+  it("edges reflects added edges (order-insensitive)", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["A", "B", "C"]);
+    dag.addEdge("A", "B");
+    dag.addEdge("B", "C");
+
+    const expected = sortPairs([
+      ["A", "B"],
+      ["B", "C"],
+    ]);
+    const got = dag.edges();
+    expect(Array.isArray(got)).toBe(true);
+
+    const normalized = sortPairs(got.map((e) => (Array.isArray(e) ? e.slice(0, 2) : e)));
+    expect(normalized).toEqual(expected);
+  });
+
+  it("addEdge can take an optional weight (graph relations still correct)", () => {
+    const dag = new cg.DAG();
+    dag.addNodesFrom(["S", "T"]);
+    dag.addEdge("S", "T", 0.75);
+
+    expect(dag.getParents("T")).toEqual(["S"]);
+    expect(dag.getChildren("S")).toEqual(["T"]);
+  });
+
+  it("nodeCount / edgeCount track mutations", () => {
+    const dag = new cg.DAG();
+    expect(dag.nodeCount).toBe(0);
+    expect(dag.edgeCount).toBe(0);
+
+    dag.addNodesFrom(["A", "B", "C"]);
+    expect(dag.nodeCount).toBe(3);
+
+    dag.addEdge("A", "B");
+    dag.addEdge("B", "C");
+    expect(dag.edgeCount).toBe(2);
+  });
+});

wasm_bindings/src/lib.rs

@@ -1,5 +1,6 @@
 use serde::{Deserialize, Serialize};
 use std::collections::HashSet;
+use wasm_bindgen::prelude::*;
 use rust_core::{IndependenceAssertion, Independencies};
 use js_sys::{Object, Array};
 
@@ -12,8 +13,8 @@ pub struct DAG {
 #[wasm_bindgen]
 impl DAG {
     #[wasm_bindgen(constructor)]
-    pub fn new() -> RustDAG {
-        RustDAG {
+    pub fn new() -> DAG {
+        DAG {
             inner: rust_core::RustDAG::new(),
         }
     }