pub fn random_bitvectors(rng: &mut impl Rng, num_vars: usize, num_vectors: usize) -> Vec<Vec<OptBool>> {

    let mut vectors = Vec::new();

    for _ in 0..rng.random_range(0..num_vectors) {

        let mut vec = Vec::new();

        for _ in 0..num_vars {

            vec.push(if rng.random_bool(0.5) {

                OptBool::True

                OptBool::False

        vectors.push(vec);

    vectors

}

pub fn from_iter<'a>(

    manager_ref: &BDDManagerRef,

    variables: &[BDDFunction],

    vectors: impl Iterator<Item = &'a Vec<OptBool>>,

) -> Result<BDDFunction, MercError> {

    let mut bdd = manager_ref.with_manager_shared(|manager| BDDFunction::f(manager));

    for bits in vectors {

        let mut cube = manager_ref.with_manager_shared(|manager| BDDFunction::t(manager));

        for (i, bit) in bits.iter().enumerate() {

            let var = variables[i].clone();

            let literal = match *bit {

                OptBool::True => var,

                OptBool::False => var.not()?,

            cube = cube.and(&literal)?;

        bdd = bdd.or(&cube)?;

    Ok(bdd)

}

pub fn random_bdd(

    manager_ref: &BDDManagerRef,

    rng: &mut impl Rng,

    variables: &[BDDFunction],

) -> Result<BDDFunction, MercError> {

    let bitvectors = random_bitvectors(rng, variables.len(), 100);

    from_iter(manager_ref, variables, bitvectors.iter())

}

pub fn create_variables(manager_ref: &BDDManagerRef, num_vars: u32) -> Result<Vec<BDDFunction>, MercError> {

    Ok(manager_ref.with_manager_exclusive(|manager| {

        manager

            .add_vars(num_vars)

            .map(|i| BDDFunction::var(manager, i))

            .collect::<Result<Vec<_>, _>>()

    })?)

}