RsBundle  Check-in [fa31409d9b]

    slv.weighter.set_weight_bounds(1e-1, 100.0);
    slv.terminator.termination_precision = 1e-6;
    slv.solve()?;

    let costs: f64 = (0..slv.problem().num_subproblems())
        .map(|i| {
            let aggr_primals = slv.aggregated_primal(i).unwrap();
            slv.problem().get_primal_costs(i, &[aggr_primals])
        })
        .sum();
    info!("Primal costs: {}", costs);
    Ok(())
}

fn solve_sync<M>(master: M, mmcf: MMCFProblem) -> Result<(), Box<dyn Error>>
where
    M: Builder<Minorant>,
    M::MasterProblem: MasterProblem<Minorant, MinorantIndex = usize>,
{
    let mut slv = SyncSolver::<_, StandardTerminator, HKWeighter, M>::with_master(mmcf, master);
    slv.weighter.set_weight_bounds(1e-1, 100.0);
    slv.terminator.termination_precision = 1e-6;
    slv.solve()?;

    let costs: f64 = (0..slv.problem().num_subproblems())
        .map(|i| {
            let aggr_primals = slv.aggregated_primal(i).unwrap();
            slv.problem().get_primal_costs(i, &[aggr_primals])
        })
        .sum();
    info!("Primal costs: {}", costs);
    Ok(())
}

fn main() -> Result<(), Box<dyn Error>> {

            info!("Use rs-graph network simplex solver");
            MMCFProblem::read_mnetgen_with_solver::<mcf::NetSpxSolver>(&filename)?
        } else {
            info!("Use Cplex network simplex solver");
            MMCFProblem::read_mnetgen_with_solver::<mcf::CplexSolver>(&filename)?
        };
        mmcf.set_separate_constraints(args.separate);
        mmcf.multimodel = true;

        let mut master = FullMasterBuilder::default();
        if args.aggregated {
            master.max_bundle_size(if args.bundle_size <= 1 { 50 } else { args.bundle_size });
            master.use_full_aggregation();
        } else {
            master.max_bundle_size(if args.bundle_size <= 1 { 5 } else { args.bundle_size });

            params.set_l_guess_factor(args.l_guess_factor);

            solve_parallel(master, mmcf, params)?;
        }
    } else {
        let mut mmcf = MMCFProblem::read_mnetgen(&filename)?;
        mmcf.set_separate_constraints(args.separate);
        mmcf.multimodel = true;

        let master = MinimalMasterBuilder::default();
        if args.sync {
            solve_sync(master, mmcf)?;
        } else {
            let mut params = Parameters::default();
            params.guess_model = if args.nearest_guess {

/// The current implementation always keeps a list of all potential
/// coupling constraints but, depending on the separation choice, the
/// may not be in the model. If separation is used a list of "active"
/// constraints is maintained holding the list of those constraints
/// that are in the model. "inactive" constraints may be separated
/// later on.
pub struct MMCFProblem {
    pub multimodel: bool,

    /// The list of subproblems (single network flows)
    subs: Vec<Arc<RwLock<Subproblem>>>,
    /// The coupling constraints for each subproblem.
    subdatas: Vec<Arc<SubData>>,
    /// The list of currently active constraints
    active_constraints: Arc<RwLock<Vec<usize>>>,
    /// The list of inactive constraints

            .into_iter()
            .map(|net| Subproblem { net, c: dvec![] })
            .map(RwLock::new)
            .map(Arc::new)
            .collect();

        Ok(MMCFProblem {
            multimodel: false,
            subs: subproblems,
            subdatas,
            active_constraints: Arc::new(RwLock::new((0..ncaps).collect())),
            inactive_constraints: Arc::new(RwLock::new(vec![])),
            pool: None,
        })
    }

        } else {
            self.active_constraints = Arc::new(RwLock::new((0..nconstrs).collect()));
            self.inactive_constraints.write().unwrap().clear();
        }
    }

    /// Compute costs for a primal solution.
    pub fn get_primal_costs(&self, fidx: usize, primals: &[DVector]) -> Real {
        let sub = &self.subdatas[fidx];
        if self.multimodel {
            primals[0].iter().enumerate().map(|(i, x)| x * sub.cbase[i]).sum()
        } else {
            let mut sum = 0.0;
            for p in primals {
                for (i, x) in p.iter().enumerate() {
                    sum += x * sub.cbase[i];
                }
            }
            sum
        }
    }

    /// Aggregate primal vectors.
    pub fn aggregate_primals_ref(&self, primals: &[(Real, &Vec<DVector>)]) -> Vec<DVector> {
        let mut aggr = primals[0]
            .1
            .iter()