RsBundle  Check-in [78b057dcc9]

/// Type of errors of the MMCFProblem.
pub type Error = crate::mcf::solver::Error;

/// Result type of the MMCFProblem.
pub type Result<T> = result::Result<T, Error>;

/// Data of a single arc read from an instance file.
#[derive(Clone, Copy, Debug)]
struct ArcInfo {
    /// The number of this arc
    arc: usize,
    /// The source node number
    src: usize,
    /// The sink node number
    snk: usize,
}

/// A single coefficient in a linear coupling constraint
#[derive(Clone, Copy, Debug)]
struct Elem {
    /// The variable (arc) index
    ind: usize,
    /// The coefficient
    val: Real,
}

/// A single MMCF subproblem, i.e. one network.
struct Subproblem {
    /// The (net, cost) pair.
    net: mcf::NetSpxSolver,
    c: DVector,
}

/// Constraint data of one subproblem.
///
/// This information is used to create the augmented objective function, i.e.
/// cbase - lhs'* y as well as the constant term rhs' * y
struct SubData {
    /// The lhs of all constraints. For each constraint this is a list of coefficients.
    lhs: Vec<Vec<Elem>>,
    /// The right-hand side of each constraint
    rhs: DVector,
    /// The base costs of each arc
    cbase: DVector,
}

unsafe impl Send for Subproblem {}
unsafe impl Sync for Subproblem {}

/// A single multi-commodity flow problem instance.
///
/// 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
    inactive_constraints: Arc<RwLock<Vec<usize>>>,
    /// The thread pool for parallel evaluation
    pool: Option<ThreadPool>,
}

impl Subproblem {
    fn evaluate<I>(&mut self, data: &SubData, y: &[Real], active: I) -> Result<(Real, DVector, DVector)>
    where
        I: IntoIterator<Item = usize>,

            subdatas,
            active_constraints: Arc::new(RwLock::new((0..ncaps).collect())),
            inactive_constraints: Arc::new(RwLock::new(vec![])),
            pool: None,
        })
    }

    /// Set whether coupling constraints should be separated.
    ///
    /// If `separate` is true than all constraints will be made
    /// inactive, otherwise all constraints will be made active.
    pub fn set_separate_constraints(&mut self, separate: bool) {
        let nconstrs = self.subdatas[0].lhs.len();
        if separate {
            self.active_constraints.write().unwrap().clear();
            self.inactive_constraints = Arc::new(RwLock::new((0..nconstrs).collect()));
        } else {
            self.active_constraints = Arc::new(RwLock::new((0..nconstrs).collect()));