attempt to fix CI

.github/workflows/lib.yml

@@ -7,10 +7,10 @@ jobs:
     strategy:
       matrix:
         include:
-          - os: macos-13
+          - os: macos-15-intel
             name: x86_64-macosx.dylib
             path: target/release/librsdd.dylib
-          - os: macos-14
+          - os: macos-15
             name: aarch64-macosx.dylib
             path: target/release/librsdd.dylib
           - os: windows-latest

Cargo.toml

@@ -9,7 +9,7 @@ description = "Rust decision diagrams."
 resolver = "2"
 
 [dependencies]
-rand = { version = "0.8.5", features = [ "small_rng" ] }
+rand = { version = "0.10" }
 dimacs = "0.2.0"
 primal = "0.3.0"
 pretty = "0.3.3"
@@ -21,14 +21,14 @@ bit-set = "0.5.3"
 segment-tree = "2.0.0"
 bumpalo = "3.11.1"
 petgraph = "0.5.1"
-rand_chacha = "0.3.1"
+rand_chacha = "0.10"
 rational = "1.2.2"
 # optional: only used to build [[bin]]
 clap = { version = "4.2.1", features = ["derive"], optional = true }
 serde_json = { version = "1.0.81", optional = true }
 
 [target.'cfg(target_arch = "wasm32")'.dependencies]
-getrandom = { version = "0.2", features = ["js"] }
+getrandom = { version = "0.4.2", features = ["wasm_js"] }
 serde_json = { version = "1.0.81" }
 serde-wasm-bindgen = { version = "0.4" }
 wasm-bindgen = { version = "0.2.84" }

examples/marginal_map_experiment.rs

@@ -1,7 +1,7 @@
 use std::{collections::HashMap, fs};
 
 use clap::Parser;
-use rand::Rng;
+use rand::RngExt;
 use rsdd::{
     builder::{bdd::RobddBuilder, cache::AllIteTable, BottomUpBuilder},
     repr::{BddPtr, Cnf, VarLabel, WmcParams},
@@ -37,10 +37,10 @@ fn gen_all_weights(
         );
     }
 
-    let mut rng = rand::thread_rng();
+    let mut rng = rand::rng();
 
     for index in prev_weights.len()..num_vars {
-        let weight = rng.gen_range(0.0..1.0);
+        let weight = rng.random_range(0.0..1.0);
         var_to_val.insert(
             VarLabel::new(index as u64),
             (RealSemiring(weight), RealSemiring(1.0 - weight)),

examples/semantic_top_down_experiment.rs

@@ -11,7 +11,6 @@ use rsdd::{
 };
 
 use rand::seq::SliceRandom;
-use rand::thread_rng;
 
 #[derive(Parser, Debug)]
 #[clap(author, version, about, long_about = None)]
@@ -120,7 +119,7 @@ impl Iterator for RandomVarOrders {
 
         let mut order: Vec<VarLabel> = (0..self.vars).map(VarLabel::new).collect();
 
-        order.shuffle(&mut thread_rng());
+        order.shuffle(&mut rand::rng());
 
         Some(VarOrder::new(&order))
     }

src/builder/bdd/robdd.rs

@@ -82,7 +82,6 @@ impl<'a, T: IteTable<'a, BddPtr<'a>> + Default> BddBuilder<'a> for RobddBuilder<
         r
     }
 
-
     fn cond_helper(&'a self, bdd: BddPtr<'a>, lbl: VarLabel, value: bool) -> BddPtr<'a> {
         // bdd.clear_scratch();
         let r = self.cond_with_alloc(bdd, lbl, value, &mut HashMap::new());
@@ -194,16 +193,8 @@ impl<'a, T: IteTable<'a, BddPtr<'a>> + Default> RobddBuilder<'a, T> {
 
                 // check cache
                 match cache.get(&bdd) {
-                    None => {
-                        ()
-                    },
-                    Some(v) => {
-                        return if bdd.is_neg() {
-                            v.neg()
-                        } else {
-                            *v
-                        }
-                    }
+                    None => (),
+                    Some(v) => return if bdd.is_neg() { v.neg() } else { *v },
                 };
 
                 // recurse on the children

src/ffi/bdd.rs

@@ -230,11 +230,12 @@ unsafe extern "C" fn bdd_eq(
 
 /// free the BDD manager `mgr`
 #[no_mangle]
-unsafe extern "C" fn free_bdd_manager(mgr : *mut RsddBddBuilder) -> () {
-    drop(Box::from_raw(mgr.cast::<RobddBuilder<'static, AllIteTable<BddPtr>>>()))
+unsafe extern "C" fn free_bdd_manager(mgr: *mut RsddBddBuilder) -> () {
+    drop(Box::from_raw(
+        mgr.cast::<RobddBuilder<'static, AllIteTable<BddPtr>>>(),
+    ))
 }
 
-
 #[no_mangle]
 unsafe extern "C" fn bdd_topvar(bdd: *mut BddPtr) -> u64 {
     match (*bdd).var_safe() {

src/ffi/wmc.rs

@@ -1,9 +1,9 @@
 use crate::{
     // DDNNFPtr is required for the wmc method
-    repr::{VarLabel, WmcParams, BddPtr, DDNNFPtr},
-    util::semirings::{Complex, RealSemiring, Semiring},
+    repr::{BddPtr, DDNNFPtr, VarLabel, WmcParams},
     // We import Polynomial and MAX_COEFFS from your implementation file
     util::semirings::polynomial_semiring_implementation::{Polynomial, MAX_COEFFS},
+    util::semirings::{Complex, RealSemiring, Semiring},
 };
 use std::collections::HashMap;
 use std::slice;
@@ -169,7 +169,9 @@ unsafe extern "C" fn wmc_param_poly_set_weight(
     high_coeffs: *const f64,
     high_len: usize,
 ) {
-    if weights.is_null() { return; }
+    if weights.is_null() {
+        return;
+    }
 
     let low_poly = from_c_parts(low_coeffs, low_len);
     let high_poly = from_c_parts(high_coeffs, high_len);
@@ -183,7 +185,10 @@ unsafe extern "C" fn wmc_param_poly_var_weight(
     var: u64,
 ) -> WeightPoly {
     if weights.is_null() {
-        return WeightPoly { low: std::ptr::null_mut(), high: std::ptr::null_mut() };
+        return WeightPoly {
+            low: std::ptr::null_mut(),
+            high: std::ptr::null_mut(),
+        };
     }
 
     let (l, h) = (*weights).var_weight(VarLabel::new(var));
@@ -192,12 +197,19 @@ unsafe extern "C" fn wmc_param_poly_var_weight(
     let low_ptr = Box::into_raw(Box::new(*l));
     let high_ptr = Box::into_raw(Box::new(*h));
 
-    WeightPoly { low: low_ptr, high: high_ptr }
+    WeightPoly {
+        low: low_ptr,
+        high: high_ptr,
+    }
 }
 
 #[no_mangle]
 unsafe extern "C" fn polynomial_len(p: *mut PolyWeight) -> usize {
-    if p.is_null() { 0 } else { (*p).len }
+    if p.is_null() {
+        0
+    } else {
+        (*p).len
+    }
 }
 
 #[no_mangle]
@@ -206,7 +218,9 @@ unsafe extern "C" fn polynomial_get_coeffs(
     buffer: *mut f64,
     max_len: usize,
 ) -> usize {
-    if p.is_null() || buffer.is_null() { return 0; }
+    if p.is_null() || buffer.is_null() {
+        return 0;
+    }
 
     let poly = &(*p);
     let count = poly.len.min(max_len);

src/lib.rs

@@ -22,7 +22,6 @@ pub mod plan;
 pub mod repr;
 pub mod serialize;
 
-
 #[cfg(target_arch = "wasm32")]
 pub mod wasm;
 

src/repr/bdd.rs

@@ -403,7 +403,7 @@ impl<'a> BddPtr<'a> {
                     };
                     let l_s = print_bdd_helper(l_p);
                     let h_s = print_bdd_helper(h_p);
-                    format!("({}, {}, {})", node.var.value(),  h_s, l_s)
+                    format!("({}, {}, {})", node.var.value(), h_s, l_s)
                 }
             }
         }

src/repr/cnf.rs

@@ -11,7 +11,7 @@ use crate::{
 use petgraph::graph::NodeIndex;
 use petgraph::prelude::UnGraph;
 use quickcheck::{Arbitrary, Gen};
-use rand::{self, rngs::ThreadRng, Rng};
+use rand::{self, rngs::ThreadRng, RngExt};
 use std::{
     cmp::{max, min},
     collections::HashSet,
@@ -369,12 +369,12 @@ impl Cnf {
             if num_vars > 1 {
                 let mut var_vec: Vec<Literal> = Vec::new();
                 for _ in 0..clause_size {
-                    let var = *vars.get(rng.gen_range(0..vars.len())).unwrap();
+                    let var = *vars.get(rng.random_range(0..vars.len())).unwrap();
                     var_vec.push(var);
                 }
                 clause_vec.push(var_vec);
             } else {
-                let var = *vars.get(rng.gen_range(0..vars.len())).unwrap();
+                let var = *vars.get(rng.random_range(0..vars.len())).unwrap();
                 clause_vec.push(vec![var]);
             }
         }
@@ -552,16 +552,16 @@ impl Cnf {
 
     /// Updates the CNF to a new CNF that results from conditioning on the supplied literal
     pub fn condition(&self, lit: Literal) -> Cnf {
-        let mut new_cnf  : Vec<Vec<Literal>> = Vec::new();
+        let mut new_cnf: Vec<Vec<Literal>> = Vec::new();
         'cnf: for clause in self.clauses.iter() {
             let mut new_clause = Vec::new();
             'clause: for l in clause.iter() {
                 if l.label() == lit.label() && l.polarity() == lit.polarity() {
                     // skip over this whole clause
-                    continue 'cnf
+                    continue 'cnf;
                 } else if l.label() == lit.label() && l.polarity() != lit.polarity() {
-                    // skip over this literal 
-                    continue 'clause
+                    // skip over this literal
+                    continue 'clause;
                 } else {
                     // push the literal
                     new_clause.push(*l);
@@ -726,9 +726,7 @@ fn test_cnf_wmc() {
 
 #[test]
 fn test_cond() {
-    let v = vec![vec![
-        Literal::new(VarLabel::new(0), false),
-    ]];
+    let v = vec![vec![Literal::new(VarLabel::new(0), false)]];
     let cnf = Cnf::new(&v);
     println!("{:?}", cnf.condition(Literal::new(VarLabel::new(0), true)));
 }

src/repr/ddnnf.rs

@@ -7,8 +7,8 @@ use crate::{
     },
     util::semirings::{BooleanSemiring, FiniteField, Semiring},
 };
-use rand::{Rng, SeedableRng};
-use rand_chacha::ChaCha8Rng;
+use rand::RngExt;
+use rand_chacha::{rand_core::SeedableRng, ChaCha8Rng};
 use std::{collections::HashMap, fmt::Debug, hash::Hash};
 
 /// creates a weighting that can be used for semantically hashing a DDNNF node
@@ -29,7 +29,7 @@ pub fn create_semantic_hash_map<const P: u128>(num_vars: usize) -> WmcParams<Fin
 
     let value_range: Vec<(FiniteField<P>, FiniteField<P>)> = (0..vars.len() as u128)
         .map(|_| {
-            let h = FiniteField::new(rng.gen_range(2..P));
+            let h = FiniteField::new(rng.random_range(2..P));
             let l = FiniteField::new(P - h.value() + 1);
             (l, h)
         })

src/repr/logical_expr.rs

@@ -2,7 +2,7 @@
 
 use crate::{repr::VarLabel, serialize::LogicalSExpr};
 use dimacs::*;
-use rand::{self, rngs::ThreadRng, Rng};
+use rand::{self, rngs::ThreadRng, RngExt};
 use std::collections::HashMap;
 
 #[derive(Debug, Clone, Serialize, Deserialize, PartialEq)]
@@ -156,7 +156,7 @@ impl LogicalExpr {
             if num_vars > 1 {
                 let mut var_vec: Vec<LogicalExpr> = Vec::new();
                 for _ in 0..clause_size {
-                    let var = vars.get(rng.gen_range(0..vars.len())).unwrap().clone();
+                    let var = vars.get(rng.random_range(0..vars.len())).unwrap().clone();
                     var_vec.push(var);
                 }
                 let l1 = var_vec.pop().unwrap();
@@ -168,7 +168,7 @@ impl LogicalExpr {
                     });
                 clause_vec.push(new_expr);
             } else {
-                let var = vars.get(rng.gen_range(0..vars.len())).unwrap().clone();
+                let var = vars.get(rng.random_range(0..vars.len())).unwrap().clone();
                 clause_vec.push(var);
             }
         }

src/repr/vtree.rs

@@ -9,7 +9,7 @@ use crate::{
     util::btree::{BTree, LeastCommonAncestor},
 };
 use quickcheck::{Arbitrary, Gen};
-use rand::{rngs::SmallRng, seq::SliceRandom, Rng, SeedableRng};
+use rand::{rngs::SmallRng, seq::SliceRandom, RngExt, SeedableRng};
 use rand_chacha::ChaCha8Rng;
 use std::collections::HashSet;
 
@@ -222,11 +222,11 @@ impl VTree {
             ),
             len => {
                 // clamps so we're guaranteed at least one item in l_s, r_s
-                let mut rng = ChaCha8Rng::from_entropy();
+                let mut rng = ChaCha8Rng::from_rng(&mut rand::rng());
 
                 // let mut split_index = rng.gen_range(1..(len/2+1));
                 let weighted_index =
-                    (rng.gen_range(0..len - 1) as f64 * (1.0 - rightness_bias)) as usize;
+                    (rng.random_range(0..len - 1) as f64 * (1.0 - rightness_bias)) as usize;
                 let split_index = weighted_index + 1;
 
                 let (l_s, r_s) = order.split_at(split_index);

src/util/semirings/mod.rs

@@ -2,18 +2,18 @@ mod boolean;
 mod complex;
 mod expectation;
 mod finitefield;
+pub mod polynomial_semiring_implementation;
 mod rational;
 mod realsemiring;
 mod semiring_traits;
 mod tropical;
-pub mod polynomial_semiring_implementation;
-
 
 pub use self::boolean::*;
 pub use self::complex::*;
 pub use self::expectation::*;
 pub use self::finitefield::*;
+pub use self::polynomial_semiring_implementation::*;
 pub use self::rational::*;
 pub use self::realsemiring::*;
 pub use self::semiring_traits::*;
-pub use self::polynomial_semiring_implementation::*;
+pub use self::tropical::*;

src/util/semirings/polynomial_semiring_implementation.rs

@@ -1,6 +1,6 @@
 use crate::util::semirings::Semiring;
-use std::ops;
 use core::fmt::{self, Debug, Display};
+use std::ops;
 
 // Define a maximum degree (e.g., 32 coefficients).
 // This makes the struct size predictable and allows 'Copy'.
@@ -88,7 +88,8 @@ impl<C: Semiring + Copy> ops::Mul for Polynomial<C> {
         for i in 0..self.len {
             for j in 0..rhs.len {
                 if i + j < MAX_COEFFS {
-                    new_coeffs[i + j] = new_coeffs[i + j] + (self.coefficients[i] * rhs.coefficients[j]);
+                    new_coeffs[i + j] =
+                        new_coeffs[i + j] + (self.coefficients[i] * rhs.coefficients[j]);
                 }
             }
         }
@@ -98,4 +99,4 @@ impl<C: Semiring + Copy> ops::Mul for Polynomial<C> {
             len: new_len,
         }
     }
-}
+}