Struct MultiOptInstance 

pub struct MultiOptInstance<VM: ManageVars = BasicVarManager> { /* private fields */ }

Available on crate feature multiopt only.

Type representing a multi-objective optimization instance. The constraints are represented as a SatInstance struct.

Implementations

impl<VM: ManageVars> MultiOptInstance<VM>

pub fn new_with_manager(n_objs: usize, var_manager: VM) -> Self

Creates a new optimization instance with a specific var manager

pub fn compose(constraints: SatInstance<VM>, objectives: Vec<Objective>) -> Self

Creates a new optimization instance from constraints and objectives

Examples found in repository

examples/mcnf2opb.rs (line 44)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

examples/opb2mcnf.rs (line 45)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/gbmosplit.rs (line 332)

fn split<VM: ManageVars>(
    so_inst: OptInstance<VM>,
    cli: &Cli,
) -> (MultiOptInstance<VM>, SplitStats) {
    let (constr, obj) = so_inst.decompose();

    if !obj.weighted() {
        cli.warning("objective is unweighted, can't split");
        let obj_stats = ObjStats {
            n_softs: obj.n_softs(),
            weight_sum: obj.weight_sum(),
            min_weight: obj.min_weight(),
            max_weight: obj.max_weight(),
            multiplier: 1,
        };
        return (
            MultiOptInstance::compose(constr, vec![obj]),
            SplitStats {
                obj_stats: vec![obj_stats],
            },
        );
    }

    let (softs, offset) = obj.into_soft_cls();

    if offset != 0 {
        cli.warning(&format!(
            "objective offset is not zero ({offset}), will be added to the lowest ranking objective"
        ));
    }

    let mut sorted_clauses: Vec<_> = softs.into_iter().collect();
    sorted_clauses.sort_by(|wc1, wc2| wc1.1.cmp(&wc2.1));

    let (mut objs, split_stats) = match cli.split_alg {
        SplitAlg::Bmo => split_bmo(sorted_clauses),
        SplitAlg::Gcd => split_gbmo(sorted_clauses, cli),
        SplitAlg::Gbmo => split_gbmo(sorted_clauses, cli),
    };

    // add offset of original objective to last objective
    objs.last_mut().unwrap().set_offset(offset);

    (MultiOptInstance::compose(constr, objs), split_stats)
}

fn perform_split(
    sorted_clauses: Vec<(Clause, usize)>,
    split_ends: Vec<usize>,
) -> (Vec<Objective>, SplitStats) {
    // split objectives and collect stats
    let mut objs = vec![];
    let mut split_start = 0;
    let mut split_stats = SplitStats { obj_stats: vec![] };
    for split_end in split_ends {
        let softs = &sorted_clauses[split_start..split_end + 1];
        let w_gcd = softs
            .iter()
            .fold(softs[0].1, |w_gcd, (_, w)| gcd(w_gcd, *w));
        let obj = Objective::from_iter(softs.iter().cloned().map(|(c, w)| (c, w / w_gcd)));
        split_stats.obj_stats.push(ObjStats {
            n_softs: obj.n_softs(),
            weight_sum: obj.weight_sum(),
            min_weight: obj.min_weight(),
            max_weight: obj.max_weight(),
            multiplier: w_gcd,
        });
        objs.push(obj);
        split_start = split_end + 1;
    }
    let softs = &sorted_clauses[split_start..];
    let w_gcd = softs
        .iter()
        .fold(softs[0].1, |w_gcd, (_, w)| gcd(w_gcd, *w));
    let obj = Objective::from_iter(softs.iter().cloned().map(|(c, w)| (c, w / w_gcd)));
    split_stats.obj_stats.push(ObjStats {
        n_softs: obj.n_softs(),
        weight_sum: obj.weight_sum(),
        min_weight: obj.min_weight(),
        max_weight: obj.max_weight(),
        multiplier: w_gcd,
    });
    objs.push(obj);
    (objs, split_stats)
}

fn split_bmo(sorted_clauses: Vec<(Clause, usize)>) -> (Vec<Objective>, SplitStats) {
    let mut multipliers = vec![sorted_clauses.first().unwrap().1];
    let mut split_ends = vec![];
    let mut sum = 0;
    for (idx, (_, w)) in sorted_clauses.iter().enumerate() {
        if w > multipliers.last().unwrap() {
            if *w <= sum {
                // instance not BMO, return original instance
                split_ends.clear();
                break;
            } else {
                multipliers.push(*w);
                split_ends.push(idx - 1);
            }
        }
        sum += *w;
    }
    perform_split(sorted_clauses, split_ends)
}

fn gcd(mut a: usize, mut b: usize) -> usize {
    // Euclid's algorithm
    while b != 0 {
        a %= b;
        std::mem::swap(&mut a, &mut b);
    }
    a
}

fn get_sums_pot_splits_gcds(
    sorted_clauses: &[(Clause, usize)],
) -> (Vec<usize>, Vec<usize>, Vec<usize>) {
    let mut sums = vec![];
    let mut pot_split_ends = vec![];
    let mut sum = 0;
    // find sums and potential splits
    for idx in 0..sorted_clauses.len() {
        sum += sorted_clauses[idx].1;
        sums.push(sum);
        if idx < sorted_clauses.len() - 1 && sorted_clauses[idx + 1].1 > sum {
            pot_split_ends.push(idx);
        }
    }
    // calculate gcds backwards
    let mut gcds = vec![sorted_clauses.last().unwrap().1];
    for (_, w) in sorted_clauses.iter().rev().skip(1) {
        gcds.push(gcd(*gcds.last().unwrap(), *w));
    }
    (sums, pot_split_ends, gcds.into_iter().rev().collect())
}

fn check_split_thorough_gbmo(
    right_partition: &[(Clause, usize)],
    left_sum: usize,
    cli: &Cli,
) -> bool {
    // first check immediate weight distances (fail fast)
    for idx in 0..right_partition.len() - 1 {
        let dist = right_partition[idx + 1].1 - right_partition[idx].1;
        if dist != 0 && dist < left_sum {
            return false;
        }
    }
    // Check all weight combinations (disclaimer: exponential runtime).
    let right_sum = right_partition.iter().fold(0, |s, (_, w)| s + w);
    let mut all_weight_combs: BTreeSet<usize> = BTreeSet::new();
    for (_, w) in right_partition {
        let w = *w;
        // add w to all previous weight combs and compare to adjacent weight combs.
        // copy existing weight combs to iterate over while modifying set.
        for weight_comb in all_weight_combs.iter().copied().collect::<Vec<_>>() {
            let new_comb = weight_comb + w;
            if !all_weight_combs.insert(new_comb) {
                // weight combination already in set
                continue;
            }
            let next_lower = all_weight_combs.range(0..new_comb).last().unwrap();
            if new_comb - *next_lower <= left_sum {
                // lower difference between new comb and next lower known comb
                return false;
            }
            if let Some(next_higher) = all_weight_combs.range(new_comb + 1..right_sum + 1).next() {
                if next_higher - new_comb <= left_sum {
                    // lower difference between new comb and next higher known comb
                    return false;
                }
            }
            if all_weight_combs.len() > cli.max_combs {
                cli.warning(&format!(
                    "thorough GBMO check terminated after {} checked weight combinations",
                    all_weight_combs.len()
                ));
                return false;
            }
        }
        if !all_weight_combs.insert(w) {
            // weight combination already in set
            continue;
        }
        if let Some(next_lower) = all_weight_combs.range(0..w).last() {
            if w - *next_lower <= left_sum {
                // lower difference between w and next lower known comb
                return false;
            }
        }
        if let Some(next_higher) = all_weight_combs.range(w + 1..right_sum).next() {
            if next_higher - w <= left_sum {
                // lower difference between w and next higher known comb
                return false;
            }
        }
        if all_weight_combs.len() > cli.max_combs {
            cli.warning(&format!(
                "thorough GBMO check terminated after {} checked weight combinations",
                all_weight_combs.len()
            ));
            return false;
        }
    }
    true
}

fn split_gbmo(sorted_clauses: Vec<(Clause, usize)>, cli: &Cli) -> (Vec<Objective>, SplitStats) {
    let (sums, pot_split_ends, gcds) = get_sums_pot_splits_gcds(&sorted_clauses);
    let mut split_ends = vec![];
    for split_end in pot_split_ends {
        // checking strictly for truly separate objectives
        if sums[split_end] < gcds[split_end + 1]
            || (cli.split_alg == SplitAlg::Gbmo
                && check_split_thorough_gbmo(
                    &sorted_clauses[split_end + 1..],
                    sums[split_end],
                    cli,
                ))
        {
            split_ends.push(split_end);
        }
    }
    perform_split(sorted_clauses, split_ends)
}

macro_rules! is_one_of {
    ($a:expr, $($b:expr),*) => {
        $( $a == $b || )* false
    }
}

fn parse_instance(
    path: &Option<PathBuf>,
    file_format: InputFormat,
    opb_opts: fio::opb::Options,
) -> anyhow::Result<(OptInstance, WriteFormat)> {
    match file_format {
        InputFormat::Infer => {
            if let Some(path) = path {
                if let Some(ext) = path.extension() {
                    let path_without_compr = path.with_extension("");
                    let ext = if is_one_of!(ext, "gz", "bz2", "xz") {
                        // Strip compression extension
                        match path_without_compr.extension() {
                            Some(ext) => ext,
                            None => anyhow::bail!("no file extension after compression extension"),
                        }
                    } else {
                        ext
                    };
                    if is_one_of!(ext, "wcnf") {
                        OptInstance::from_dimacs_path(path).map(|inst| (inst, WriteFormat::Mcnf))
                    } else if is_one_of!(ext, "opb") {
                        OptInstance::from_opb_path(path, opb_opts)
                            .map(|inst| (inst, WriteFormat::Opb))
                    } else {
                        anyhow::bail!("unknown file extension")
                    }
                } else {
                    anyhow::bail!("no file extension")
                }
            } else {
                anyhow::bail!("cannot infer file format from stdin")
            }
        }
        InputFormat::Wcnf => {
            if let Some(path) = path {
                OptInstance::from_dimacs_path(path).map(|inst| (inst, WriteFormat::Mcnf))
            } else {
                OptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
                    .map(|inst| (inst, WriteFormat::Mcnf))
            }
        }
        InputFormat::Opb => {
            if let Some(path) = path {
                OptInstance::from_opb_path(path, opb_opts).map(|inst| (inst, WriteFormat::Opb))
            } else {
                OptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
                    .map(|inst| (inst, WriteFormat::Opb))
            }
        }
    }
}

macro_rules! handle_error {
    ($res:expr, $cli:expr) => {{
        match $res {
            Ok(val) => val,
            Err(err) => {
                $cli.error(&err);
                anyhow::bail!(err)
            }
        }
    }};
}

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

examples/check-solution.rs (line 122)

fn parse_instance(
    inst_path: PathBuf,
    file_format: FileFormat,
    opb_opts: fio::opb::Options,
) -> anyhow::Result<MultiOptInstance> {
    match file_format {
        FileFormat::Infer => {
            if let Some(ext) = inst_path.extension() {
                let path_without_compr = inst_path.with_extension("");
                let ext = if is_one_of!(ext, "gz", "bz2", "xz") {
                    // Strip compression extension
                    match path_without_compr.extension() {
                        Some(ext) => ext,
                        None => anyhow::bail!("no file extension after compression extension"),
                    }
                } else {
                    ext
                };
                let inst = if is_one_of!(ext, "cnf", "dimacs") {
                    let inst = SatInstance::from_dimacs_path(inst_path)?;
                    MultiOptInstance::compose(inst, vec![])
                } else if is_one_of!(ext, "wcnf") {
                    let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
                    MultiOptInstance::compose(inst, vec![obj])
                } else if is_one_of!(ext, "mcnf") {
                    MultiOptInstance::from_dimacs_path(inst_path)?
                } else if is_one_of!(ext, "opb", "mopb", "pbmo") {
                    MultiOptInstance::from_opb_path(inst_path, opb_opts)?
                } else {
                    anyhow::bail!("unknown file extension")
                };
                Ok(inst)
            } else {
                anyhow::bail!("no file extension")
            }
        }
        FileFormat::Cnf => {
            let inst = SatInstance::from_dimacs_path(inst_path)?;
            Ok(MultiOptInstance::compose(inst, vec![]))
        }
        FileFormat::Wcnf => {
            let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
            Ok(MultiOptInstance::compose(inst, vec![obj]))
        }
        FileFormat::Mcnf => MultiOptInstance::from_dimacs_path(inst_path),
        FileFormat::Opb => MultiOptInstance::from_opb_path(inst_path, opb_opts),
    }
}

pub fn decompose(self) -> (SatInstance<VM>, Vec<Objective>)

Decomposes the optimization instance to a SatInstance and Objectives

Examples found in repository

examples/mcnf2opb.rs (line 39)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

examples/opb2mcnf.rs (line 37)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/check-solution.rs (line 60)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.opb_first_var_idx,
        ..OpbOptions::default()
    };
    let (constrs, objs) = parse_instance(args.instance, args.file_format, opb_opts)?.decompose();

    let mut reader = if let Some(solution) = args.solution {
        fio::open_compressed_uncompressed_read(solution)?
    } else {
        Box::new(io::BufReader::new(io::stdin()))
    };

    let mut sol = Assignment::default();
    loop {
        let mut buf = String::new();
        let read = reader.read_line(&mut buf)?;
        if read == 0 {
            break;
        }
        if buf.starts_with('v') {
            sol.extend_from_vline(&buf)?;
        }
    }

    if let Some(constr) = constrs.unsat_constraint(&sol) {
        println!("unsatisfied constraint: {constr}");
        std::process::exit(1);
    }
    print!("objective values: ");
    for i in 0..objs.len() {
        if i < objs.len() - 1 {
            print!("{}, ", objs[i].evaluate(&sol))
        } else {
            print!("{}", objs[i].evaluate(&sol));
        }
    }
    println!();
    Ok(())
}

examples/gbmosplit.rs (line 651)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn n_objectives(&self) -> usize

Returns the number of objectives in the instance

Examples found in repository

examples/gbmosplit.rs (line 632)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn constraints_mut(&mut self) -> &mut SatInstance<VM>

Gets a mutable reference to the hard constraints for modifying them

Examples found in repository

examples/opb2mcnf.rs (line 46)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/gbmosplit.rs (line 639)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn constraints_ref(&self) -> &SatInstance<VM>

Gets a reference to the hard constraints

Examples found in repository

examples/shuffledimacs.rs (line 54)

fn main() -> anyhow::Result<()> {
    let in_path = PathBuf::from(&std::env::args().nth(1).unwrap_or_else(|| print_usage!()));
    let out_path = PathBuf::from(&std::env::args().nth(2).unwrap_or_else(|| print_usage!()));

    match determine_file_type(&in_path) {
        FileType::Cnf => {
            let inst = instances::SatInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse CNF")?;
            let n_vars = inst.n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write CNF")?;
        }
        FileType::Wcnf => {
            let inst = instances::OptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse WCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write WCNF")?;
        }
        FileType::Mcnf => {
            let inst = instances::MultiOptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse MCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write MCNF")?;
        }
    }
    Ok(())
}

pub fn new_var(&mut self) -> Var

Reserves a new variable in the internal variable manager. This is a shortcut for inst.get_constraints().var_manager().new_var().

pub fn new_lit(&mut self) -> Lit

Reserves a new variable in the internal variable manager. This is a shortcut for inst.get_constraints().var_manager().new_lit().

pub fn max_var(&self) -> Option<Var>

Gets the used variable with the highest index. This is a shortcut for inst.get_constraints().var_manager().max_var().

pub fn objective_mut(&mut self, obj_idx: usize) -> &mut Objective

Gets a mutable reference to the objective with index obj_idx for modifying it. Make sure obj_idx does not exceed the number of objectives in the instance.

Panics

If obj_idx exceeds the number of objectives in the instance.

pub fn objective_ref(&self, obj_idx: usize) -> &Objective

Gets a reference to the objective with index obj_idx. Make sure obj_idx does not exceed the number of objectives in the instance.

Panics

If obj_idx exceeds the number of objectives in the instance.

pub fn iter_obj(&self) -> impl Iterator<Item = &Objective>

Returns an iterator over references to the objectives

pub fn iter_obj_mut(&mut self) -> impl Iterator<Item = &mut Objective>

Returns an iterator over mutable references to the objectives

pub fn into_hard_cls_soft_cls(self) -> (Cnf, Vec<(impl WClsIter, isize)>, VM)

Converts the instance to a set of hard and soft clauses

Panic

This might panic if the conversion to Cnf runs out of memory.

pub fn into_hard_cls_soft_lits(self) -> (Cnf, Vec<(impl WLitIter, isize)>, VM)

Converts the instance to a set of hard clauses and soft literals

Panic

This might panic if the conversion to Cnf runs out of memory.

pub fn change_var_manager<VM2, VMC>( self, vm_converter: VMC, ) -> (MultiOptInstance<VM2>, VM)

where VM2: ManageVars + Default, VMC: Fn(&VM) -> VM2,

Converts the included variable manager to a different type

pub fn reindex<R: ReindexVars>(self, reindexer: R) -> MultiOptInstance<R>

Re-indexes all variables in the instance with a re-indexing variable manager

Examples found in repository

examples/shuffledimacs.rs (line 56)

fn main() -> anyhow::Result<()> {
    let in_path = PathBuf::from(&std::env::args().nth(1).unwrap_or_else(|| print_usage!()));
    let out_path = PathBuf::from(&std::env::args().nth(2).unwrap_or_else(|| print_usage!()));

    match determine_file_type(&in_path) {
        FileType::Cnf => {
            let inst = instances::SatInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse CNF")?;
            let n_vars = inst.n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write CNF")?;
        }
        FileType::Wcnf => {
            let inst = instances::OptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse WCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write WCNF")?;
        }
        FileType::Mcnf => {
            let inst = instances::MultiOptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse MCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write MCNF")?;
        }
    }
    Ok(())
}

pub fn var_set(&self) -> BTreeSet<Var>

Gets the set of variables in the instance

pub fn reindex_ordered<R: ReindexVars>( self, reindexer: R, ) -> MultiOptInstance<R>

Re-index all variables in the instance in order

If the re-indexing variable manager produces new free variables in order, this results in the variable order being preserved with gaps in the variable space being closed

pub fn shuffle(self) -> Self

Available on crate feature rand only.

Randomly shuffles the order of constraints and the objective

Examples found in repository

examples/shuffledimacs.rs (line 57)

fn main() -> anyhow::Result<()> {
    let in_path = PathBuf::from(&std::env::args().nth(1).unwrap_or_else(|| print_usage!()));
    let out_path = PathBuf::from(&std::env::args().nth(2).unwrap_or_else(|| print_usage!()));

    match determine_file_type(&in_path) {
        FileType::Cnf => {
            let inst = instances::SatInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse CNF")?;
            let n_vars = inst.n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write CNF")?;
        }
        FileType::Wcnf => {
            let inst = instances::OptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse WCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write WCNF")?;
        }
        FileType::Mcnf => {
            let inst = instances::MultiOptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse MCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write MCNF")?;
        }
    }
    Ok(())
}

pub fn write_dimacs_path<P: AsRef<Path>>(&self, path: P) -> Result<()>

Writes the instance to a DIMACS MCNF file at a path

This requires that the instance is clausal, i.e., does not contain any non-converted cardinality of pseudo-boolean constraints. If necessary, the instance can be converted by SatInstance::convert_to_cnf or SatInstance::convert_to_cnf_with_encoders first.

Errors

• If the instance is not clausal, returns RequiresClausal
• Returns io::Error on errors during writing

Examples found in repository

examples/opb2mcnf.rs (line 49)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/shuffledimacs.rs (line 58)

fn main() -> anyhow::Result<()> {
    let in_path = PathBuf::from(&std::env::args().nth(1).unwrap_or_else(|| print_usage!()));
    let out_path = PathBuf::from(&std::env::args().nth(2).unwrap_or_else(|| print_usage!()));

    match determine_file_type(&in_path) {
        FileType::Cnf => {
            let inst = instances::SatInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse CNF")?;
            let n_vars = inst.n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write CNF")?;
        }
        FileType::Wcnf => {
            let inst = instances::OptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse WCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write WCNF")?;
        }
        FileType::Mcnf => {
            let inst = instances::MultiOptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse MCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write MCNF")?;
        }
    }
    Ok(())
}

examples/gbmosplit.rs (line 642)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn write_dimacs<W: Write>(&self, writer: &mut W) -> Result<()>

Write to DIMACS MCNF

This requires that the instance is clausal, i.e., does not contain any non-converted cardinality of pseudo-boolean constraints. If necessary, the instance can be converted by SatInstance::convert_to_cnf or SatInstance::convert_to_cnf_with_encoders first.

Performance

For performance, consider using a std::io::BufWriter instance.

Errors

• If the instance is not clausal, returns RequiresClausal
• Returns io::Error on errors during writing

Examples found in repository

examples/opb2mcnf.rs (line 52)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/gbmosplit.rs (line 645)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn write_opb_path<P: AsRef<Path>>( &self, path: P, opts: Options, ) -> Result<()>

Writes the instance to an OPB file at a path

This requires that the objective does not contain soft clauses. If it does, use Objective::convert_to_soft_lits first.

Errors

• If the objective contains soft literals, returns RequiresSoftLits
• Returns io::Error on errors during writing

Examples found in repository

examples/mcnf2opb.rs (line 47)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

examples/gbmosplit.rs (line 658)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn write_opb<W: Write>(&self, writer: &mut W, opts: Options) -> Result<()>

Writes the instance to an OPB file

This requires that the objective does not contain soft clauses. If it does, use Objective::convert_to_soft_lits first.

Performance

For performance, consider using a std::io::BufWriter instance(crate).

Errors

• If the objective contains soft literals, returns RequiresSoftLits
• Returns io::Error on errors during writing

Examples found in repository

examples/mcnf2opb.rs (line 50)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

examples/gbmosplit.rs (line 661)

fn main() -> anyhow::Result<()> {
    let cli = Cli::init();

    if let Some(path) = &cli.in_path {
        cli.info(&format!("finding splits in {}", path.display()));
    }

    let (so_inst, write_format) = handle_error!(
        parse_instance(&cli.in_path, cli.input_format, cli.opb_opts),
        cli
    );

    let (mut mo_inst, split_stats) = split(so_inst, &cli);

    if cli.out_path.is_some() {
        cli.print_split_stats(split_stats);
    }

    let found_split = mo_inst.n_objectives() > 1;

    let write_format = cli.output_format.infer(write_format);

    if found_split || cli.always_dump {
        match write_format {
            WriteFormat::Mcnf => {
                mo_inst.constraints_mut().convert_to_cnf();
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing mcnf to {}", path.display()));
                    handle_error!(mo_inst.write_dimacs_path(path), cli);
                } else {
                    handle_error!(
                        mo_inst.write_dimacs(&mut io::BufWriter::new(io::stdout())),
                        cli
                    );
                }
            }
            WriteFormat::Opb => {
                let (mut constrs, mut objs) = mo_inst.decompose();
                for obj in &mut objs {
                    obj.convert_to_soft_lits(constrs.var_manager_mut());
                }
                let mo_inst = MultiOptInstance::compose(constrs, objs);
                if let Some(path) = &cli.out_path {
                    cli.info(&format!("writing opb to {}", path.display()));
                    handle_error!(mo_inst.write_opb_path(path, cli.opb_opts), cli);
                } else {
                    handle_error!(
                        mo_inst.write_opb(&mut io::BufWriter::new(io::stdout()), cli.opb_opts),
                        cli
                    );
                }
            }
        }
    }

    if found_split {
        std::process::exit(0);
    }
    std::process::exit(1);
}

pub fn cost(&self, assign: &Assignment) -> Option<Vec<isize>>

Calculates the objective values of an assignment. Returns None if the assignment is not a solution.

impl<VM: ManageVars + Default> MultiOptInstance<VM>

pub fn new(n_objs: usize) -> Self

Creates a new optimization instance

pub fn from_dimacs<R: BufRead>(reader: &mut R) -> Result<Self>

Parse a DIMACS instance from a reader object.

File Format

The file format expected by this reader is an extension of the new DIMACS WCNF format to multiple objectives, which we call DIMACS MCNF. An example of this file format is the following:

c <comment>
h 1 2 3 0
o1 5 1 0
o2 7 2 3 0

Comments start with c, as in other DIMACS formats. Hard clauses start with an h, as in WCNF files. Soft clauses are of the following form o<obj idx> <weight> <lit 1> ... <lit n> 0. The first token must be a positive number preceded by an o, indicating what objective this soft clause belongs to. After that, the format is identical to a soft clause in a WCNF file.

Errors

Parsing errors from nom or io::Error.

Examples found in repository

examples/mcnf2opb.rs (line 35)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

pub fn from_dimacs_path<P: AsRef<Path>>(path: P) -> Result<Self>

Parses a DIMACS instance from a file path. For more details see OptInstance::from_dimacs.

Errors

Parsing errors from nom or io::Error.

Examples found in repository

examples/mcnf2opb.rs (line 33)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: args.first_var_idx,
        no_negated_lits: args.avoid_negated_lits,
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_dimacs_path(in_path).context("error parsing the input file")?
    } else {
        MultiOptInstance::from_dimacs(&mut io::BufReader::new(io::stdin()))
            .context("error parsing input")?
    };

    let (mut constr, mut objs) = inst.decompose();
    for obj in &mut objs {
        let hardened = obj.convert_to_soft_lits(constr.var_manager_mut());
        constr.extend(hardened.into());
    }
    let inst = MultiOptInstance::compose(constr, objs);

    if let Some(out_path) = args.out_path {
        inst.write_opb_path(out_path, opb_opts)
            .context("error writing the output file")?;
    } else {
        inst.write_opb(&mut io::stdout(), opb_opts)
            .context("error writing the output file")?;
    }
    Ok(())
}

examples/shuffledimacs.rs (line 52)

fn main() -> anyhow::Result<()> {
    let in_path = PathBuf::from(&std::env::args().nth(1).unwrap_or_else(|| print_usage!()));
    let out_path = PathBuf::from(&std::env::args().nth(2).unwrap_or_else(|| print_usage!()));

    match determine_file_type(&in_path) {
        FileType::Cnf => {
            let inst = instances::SatInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse CNF")?;
            let n_vars = inst.n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write CNF")?;
        }
        FileType::Wcnf => {
            let inst = instances::OptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse WCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write WCNF")?;
        }
        FileType::Mcnf => {
            let inst = instances::MultiOptInstance::<BasicVarManager>::from_dimacs_path(in_path)
                .context("Could not parse MCNF")?;
            let n_vars = inst.constraints_ref().n_vars();
            let rand_reindexer = RandReindVarManager::init(n_vars);
            inst.reindex(rand_reindexer)
                .shuffle()
                .write_dimacs_path(out_path)
                .context("Could not write MCNF")?;
        }
    }
    Ok(())
}

examples/check-solution.rs (line 127)

fn parse_instance(
    inst_path: PathBuf,
    file_format: FileFormat,
    opb_opts: fio::opb::Options,
) -> anyhow::Result<MultiOptInstance> {
    match file_format {
        FileFormat::Infer => {
            if let Some(ext) = inst_path.extension() {
                let path_without_compr = inst_path.with_extension("");
                let ext = if is_one_of!(ext, "gz", "bz2", "xz") {
                    // Strip compression extension
                    match path_without_compr.extension() {
                        Some(ext) => ext,
                        None => anyhow::bail!("no file extension after compression extension"),
                    }
                } else {
                    ext
                };
                let inst = if is_one_of!(ext, "cnf", "dimacs") {
                    let inst = SatInstance::from_dimacs_path(inst_path)?;
                    MultiOptInstance::compose(inst, vec![])
                } else if is_one_of!(ext, "wcnf") {
                    let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
                    MultiOptInstance::compose(inst, vec![obj])
                } else if is_one_of!(ext, "mcnf") {
                    MultiOptInstance::from_dimacs_path(inst_path)?
                } else if is_one_of!(ext, "opb", "mopb", "pbmo") {
                    MultiOptInstance::from_opb_path(inst_path, opb_opts)?
                } else {
                    anyhow::bail!("unknown file extension")
                };
                Ok(inst)
            } else {
                anyhow::bail!("no file extension")
            }
        }
        FileFormat::Cnf => {
            let inst = SatInstance::from_dimacs_path(inst_path)?;
            Ok(MultiOptInstance::compose(inst, vec![]))
        }
        FileFormat::Wcnf => {
            let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
            Ok(MultiOptInstance::compose(inst, vec![obj]))
        }
        FileFormat::Mcnf => MultiOptInstance::from_dimacs_path(inst_path),
        FileFormat::Opb => MultiOptInstance::from_opb_path(inst_path, opb_opts),
    }
}

pub fn from_opb<R: BufRead>(reader: &mut R, opts: Options) -> Result<Self>

Parses an OPB instance from a reader object.

File Format

The file format expected by this parser is the OPB format for pseudo-boolean optimization instances with multiple objectives defined. For details on the file format see here.

Errors

Parsing errors from nom or io::Error.

Examples found in repository

examples/opb2mcnf.rs (line 33)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

pub fn from_opb_path<P: AsRef<Path>>(path: P, opts: Options) -> Result<Self>

Parses an OPB instance from a file path. For more details see MultiOptInstance::from_opb. With feature compression supports bzip2 and gzip compression, detected by the file extension.

Errors

Parsing errors from nom or io::Error.

Examples found in repository

examples/opb2mcnf.rs (line 30)

fn main() -> anyhow::Result<()> {
    let args = Args::parse();
    let opb_opts = OpbOptions {
        first_var_idx: 0,
        ..Default::default()
    };

    let inst: MultiOptInstance = if let Some(in_path) = args.in_path {
        MultiOptInstance::from_opb_path(in_path, opb_opts)
            .context("error parsing the input file")?
    } else {
        MultiOptInstance::from_opb(&mut io::BufReader::new(io::stdin()), opb_opts)
            .context("error parsing input")?
    };

    let (constrs, objs) = inst.decompose();
    let constrs = constrs.sanitize();

    println!("c {} clauses", constrs.n_clauses());
    println!("c {} cards", constrs.n_cards());
    println!("c {} pbs", constrs.n_pbs());
    println!("c {} objectives", objs.len());

    let mut inst = MultiOptInstance::compose(constrs, objs);
    inst.constraints_mut().convert_to_cnf();

    if let Some(out_path) = args.out_path {
        inst.write_dimacs_path(out_path)
            .context("error writing the output file")?;
    } else {
        inst.write_dimacs(&mut io::stdout())
            .context("error writing to stdout")?;
    }
    Ok(())
}

examples/check-solution.rs (line 129)

fn parse_instance(
    inst_path: PathBuf,
    file_format: FileFormat,
    opb_opts: fio::opb::Options,
) -> anyhow::Result<MultiOptInstance> {
    match file_format {
        FileFormat::Infer => {
            if let Some(ext) = inst_path.extension() {
                let path_without_compr = inst_path.with_extension("");
                let ext = if is_one_of!(ext, "gz", "bz2", "xz") {
                    // Strip compression extension
                    match path_without_compr.extension() {
                        Some(ext) => ext,
                        None => anyhow::bail!("no file extension after compression extension"),
                    }
                } else {
                    ext
                };
                let inst = if is_one_of!(ext, "cnf", "dimacs") {
                    let inst = SatInstance::from_dimacs_path(inst_path)?;
                    MultiOptInstance::compose(inst, vec![])
                } else if is_one_of!(ext, "wcnf") {
                    let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
                    MultiOptInstance::compose(inst, vec![obj])
                } else if is_one_of!(ext, "mcnf") {
                    MultiOptInstance::from_dimacs_path(inst_path)?
                } else if is_one_of!(ext, "opb", "mopb", "pbmo") {
                    MultiOptInstance::from_opb_path(inst_path, opb_opts)?
                } else {
                    anyhow::bail!("unknown file extension")
                };
                Ok(inst)
            } else {
                anyhow::bail!("no file extension")
            }
        }
        FileFormat::Cnf => {
            let inst = SatInstance::from_dimacs_path(inst_path)?;
            Ok(MultiOptInstance::compose(inst, vec![]))
        }
        FileFormat::Wcnf => {
            let (inst, obj) = OptInstance::from_dimacs_path(inst_path)?.decompose();
            Ok(MultiOptInstance::compose(inst, vec![obj]))
        }
        FileFormat::Mcnf => MultiOptInstance::from_dimacs_path(inst_path),
        FileFormat::Opb => MultiOptInstance::from_opb_path(inst_path, opb_opts),
    }
}

Trait Implementations

impl<VM: Clone + ManageVars> Clone for MultiOptInstance<VM>

fn clone(&self) -> MultiOptInstance<VM>

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<VM: Debug + ManageVars> Debug for MultiOptInstance<VM>

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<VM: Default + ManageVars> Default for MultiOptInstance<VM>

fn default() -> MultiOptInstance<VM>

Returns the “default value” for a type.

impl<'de, VM> Deserialize<'de> for MultiOptInstance<VM>

where VM: Deserialize<'de> + ManageVars,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<VM: ManageVars + Default> FromIterator<McnfLine> for MultiOptInstance<VM>

fn from_iter<T: IntoIterator<Item = McnfLine>>(iter: T) -> Self

Creates a value from an iterator.

impl<VM: PartialEq + ManageVars> PartialEq for MultiOptInstance<VM>

fn eq(&self, other: &MultiOptInstance<VM>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<VM> Serialize for MultiOptInstance<VM>

where VM: Serialize + ManageVars,

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<VM: Eq + ManageVars> Eq for MultiOptInstance<VM>

impl<VM: ManageVars> StructuralPartialEq for MultiOptInstance<VM>