RsBundle  Check-in [2c9472f892]

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

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







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

    /// The error returned by the master problem.
    type Err;

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

    /// Set the number of subproblems.

}

/// A builder for creating a master problem solvers.
pub trait Builder {
    /// The master problem to be build.
    type MasterProblem: MasterProblem;

    /// Type of errors.
    type Err;

    /// Create a new master problem.
    fn build(&mut self) -> Result<Self::MasterProblem, Self::Err>;
}

impl<B> master::Builder for Builder<B>
where
    B: master::unconstrained::Builder,
    B::MasterProblem: UnconstrainedMasterProblem,
{
    type MasterProblem = BoxedMasterProblem<B::MasterProblem>;

    type Err = B::Err;

    fn build(&mut self) -> Result<Self::MasterProblem, Self::Err> {
        self.0.build().map(BoxedMasterProblem::with_master)
    }
}

#[derive(Default)]
pub struct Builder;

impl unconstrained::Builder for Builder {
    type MasterProblem = CplexMaster;

    type Err = CplexMasterError;

    fn build(&mut self) -> Result<CplexMaster> {
        CplexMaster::new()
    }
}

}

pub struct Builder;

impl unconstrained::Builder for Builder {
    type MasterProblem = MinimalMaster;

    type Err = MinimalMasterError;

    fn build(&mut self) -> Result<MinimalMaster, Self::Err> {
        MinimalMaster::new()
    }
}

// along with this program.  If not, see  <http://www.gnu.org/licenses/>
//

use crate::{DVector, Minorant, Real};

use super::SubgradientExtension;



/**
 * Trait for master problems without box constraints.
 *
 * Implementors of this trait are supposed to solve quadratic
 * optimization problems of the form
 *
 * \\[ \min \left\\{ \hat{f}(d) + \frac{u}{2} \\| d \\|\^2 \colon

 * \alpha_i = 1 \right\\}$. Note, the unconstrained solver is expected
 * to compute *dual* optimal solutions, i.e. the solver must compute
 * optimal coefficients $\bar{\alpha}$ for the dual problem
 *
 * \\[ \max_{\alpha \in \Delta} \min_{d \in \mathbb{R}\^n}
 *     \sum_{i=1}\^k \alpha_i \ell_i(d) + \frac{u}{2} \\| d \\|\^2. \\]
 */
pub trait UnconstrainedMasterProblem {
    /// Unique index for a minorant.
    type MinorantIndex: Copy + Eq;

    /// Error type for this master problem.
    type Err;

    /// Return a new instance of the unconstrained master problem.
    fn new() -> Result<Self, Self::Err>
    where
        Self: Sized;

    /// Return the number of subproblems.

}

/// A builder for creating unconstrained master problem solvers.
pub trait Builder {
    /// The master problem to be build.
    type MasterProblem: UnconstrainedMasterProblem;

    /// Type of errors.
    type Err;

    /// Create a new master problem.
    fn build(&mut self) -> Result<Self::MasterProblem, Self::Err>;
}

/// Trait for implementing a first-order problem description.
///
/// All computations made by an implementation are supposed to
/// be asynchronous. Hence, the interface is slightly different
/// compared with [`crate::FirstOrderProblem`].
pub trait FirstOrderProblem {
    /// Error raised by this oracle.
    type Err: Send + 'static;

    /// The primal information associated with a minorant.
    type Primal: Aggregatable + Send + 'static;

    /// Return the number of variables.
    fn num_variables(&self) -> usize;

    /// This is actually the time of the last call to `Solver::init`.
    start_time: Instant,
}

impl<P, T, W, M> Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    P::Err: std::error::Error,
    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Default,
    M: master::Builder + Default,
    M::Err: Into<Box<dyn std::error::Error + Send + Sync + 'static>>,
    M::MasterProblem: MasterProblem<MinorantIndex = usize> + Send + 'static,
    <M::MasterProblem as MasterProblem>::Err: Into<Box<dyn std::error::Error + Send + Sync + 'static>> + Send,
{
    /// Create a new parallel bundle solver.
    pub fn new(problem: P) -> Self {
        Solver {
            params: Parameters::default(),
            terminator: Default::default(),
            weighter: Default::default(),

    T,
    SolverError<<P as FirstOrderProblem>::Err, <<M as master::Builder>::MasterProblem as MasterProblem>::Err>,
>;

impl<P, T, W, M> Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    P::Err: Into<Box<std::error::Error + Send + Sync + 'static>>,
    T: for<'a> Terminator<BundleState<'a>> + Default,
    W: for<'a> Weighter<BundleState<'a>> + Default,
    M: master::Builder + Default,
    M::Err: Into<Box<std::error::Error + Send + Sync + 'static>>,
    M::MasterProblem: MasterProblem<MinorantIndex = usize>,
    <M::MasterProblem as master::MasterProblem>::Err: Into<Box<std::error::Error + Send + Sync + 'static>>,
{
    /**
     * Create a new solver for the given problem.
     *
     * Note that the solver owns the problem, so you cannot use the
     * same problem description elsewhere as long as it is assigned to
     * the solver. However, it is possible to get a reference to the