RsBundle  Diff

use std::error::Error;
use std::fmt;
use std::result;

/// Error type for master problems.
#[derive(Debug)]
pub enum MasterProblemError<E> {
    /// Extension of the subgradient failed with some user error.
    SubgradientExtension(E),
    /// No minorants available when solving the master problem
    NoMinorants,
    /// An error in the solver backend occurred.
    Solver(Box<dyn Error + Send + Sync>),
    /// A custom error (specific to the master problem solver) occurred.
    Custom(Box<dyn Error + Send + Sync>),
}

impl<E> fmt::Display for MasterProblemError<E>
where
    E: fmt::Display,
{
    fn fmt(&self, fmt: &mut fmt::Formatter) -> result::Result<(), fmt::Error> {
        use self::MasterProblemError::*;
        match self {
            SubgradientExtension(err) => write!(fmt, "Subgradient extension failed: {}", err),
            NoMinorants => write!(fmt, "No minorants when solving the master problem"),
            Solver(err) => write!(fmt, "Solver error: {}", err),
            Custom(err) => err.fmt(fmt),
        }
    }
}

impl<E> Error for MasterProblemError<E>
where
    E: Error + 'static,
{
    fn source(&self) -> Option<&(dyn Error + 'static)> {
        use self::MasterProblemError::*;
        match self {
            SubgradientExtension(err) => Some(err),
            Solver(err) | Custom(err) => Some(err.as_ref()),
            NoMinorants => None,
        }
    }
}

/// Result type of master problems.
pub type Result<T, E> = result::Result<T, MasterProblemError<E>>;

/// Callback for subgradient extensions.
pub type SubgradientExtension<'a, I, E> = FnMut(usize, I, &[usize]) -> result::Result<DVector, E> + 'a;


pub trait MasterProblem {
    /// Unique index for a minorant.
    type MinorantIndex: Copy + Eq;

    /// Error returned by the subgradient-extension callback.
    type SubgradientExtensionErr;

    /// Create a new master problem.
    fn new() -> Result<Self, Self::SubgradientExtensionErr>
    where
        Self: Sized;

    /// Set the number of subproblems.
    fn set_num_subproblems(&mut self, n: usize) -> Result<(), Self::SubgradientExtensionErr>;

    /// Set the lower and upper bounds of the variables.
    fn set_vars(
        &mut self,
        nvars: usize,
        lb: Option<DVector>,
        ub: Option<DVector>,
    ) -> Result<(), Self::SubgradientExtensionErr>;

    /// Return the current number of minorants of subproblem `fidx`.
    fn num_minorants(&self, fidx: usize) -> usize;

    /// Return the current weight of the quadratic term.
    fn weight(&self) -> Real;

    /// Set the weight of the quadratic term, must be > 0.
    fn set_weight(&mut self, weight: Real) -> Result<(), Self::SubgradientExtensionErr>;

    /// Set the maximal number of inner iterations.
    fn set_max_updates(&mut self, max_updates: usize) -> Result<(), Self::SubgradientExtensionErr>;

    /// Return the current number of inner iterations.
    fn cnt_updates(&self) -> usize;

    /// Add or move some variables with bounds.
    ///
    /// If an index is specified, existing variables are moved,
    /// otherwise new variables are generated.
    fn add_vars(
        &mut self,
        bounds: &[(Option<usize>, Real, Real)],
        extend_subgradient: &mut SubgradientExtension<Self::MinorantIndex, Self::SubgradientExtensionErr>,
    ) -> Result<(), Self::SubgradientExtensionErr>;

    /// Add a new minorant to the model.
    ///
    /// The function returns a unique (among all minorants of all
    /// subproblems) index of the minorant. This index must remain
    /// valid until the minorant is aggregated.
    fn add_minorant(
        &mut self,
        fidx: usize,
        minorant: Minorant,
    ) -> Result<Self::MinorantIndex, Self::SubgradientExtensionErr>;

    /// Solve the master problem.
    fn solve(&mut self, cur_value: Real) -> Result<(), Self::SubgradientExtensionErr>;

    /// Aggregate the given minorants according to the current
    /// solution.
    ///
    /// The (indices of the) minorants to be aggregated get invalid
    /// after this operation. The function returns the index of the
    /// aggregated minorant along with the coefficients of the convex
    /// combination. The index of the new aggregated minorant might or
    /// might not be one of indices of the original minorants.
    ///
    /// # Error The indices of the minorants `mins` must belong to
    /// subproblem `fidx`.
    fn aggregate(
        &mut self,
        fidx: usize,
        mins: &[usize],
    ) -> Result<(Self::MinorantIndex, DVector), Self::SubgradientExtensionErr>;

    /// Return the (primal) optimal solution $\\|d\^*\\|$.
    fn get_primopt(&self) -> DVector;

    /// Return the value of the linear model in the optimal solution.
    ///
    /// This is the term $\langle g\^*, d\^* \rangle$ where $g^\*$ is