RsBundle  Diff

/// The minimal bundle solver.
pub type NoBundleSolver<P> = Solver<P, StandardTerminator, HKWeighter, crate::master::MinimalMasterBuilder>;

/// Error raised by the parallel bundle [`Solver`].
#[derive(Debug, Error)]
#[non_exhaustive]
pub enum Error<PErr, MErr>
pub enum Error<PErr, MErr> {
where
    PErr: 'static,
    MErr: 'static,
{
    #[error("master problem creation failed")]
    BuildMaster(#[source] MErr),
    #[error("error solving the master problem")]
    Master(#[source] MasterError<PErr, MErr>),
    #[error("iteration limit ({limit}) has been reached")]
    IterationLimit { limit: usize },
    #[error("problem evaluation failed")]

        <P as FirstOrderProblem>::Err,
        <<M as MasterBuilder<<P as FirstOrderProblem>::Minorant>>::MasterProblem as MasterProblem<
            <P as FirstOrderProblem>::Minorant,
        >>::Err,
    >,
>;

impl<PErr, MErr> From<MasterError<PErr, MErr>> for Error<PErr, MErr>
impl<PErr, MErr> From<MasterError<PErr, MErr>> for Error<PErr, MErr> {
where
    PErr: 'static,
    MErr: 'static,
{
    fn from(err: MasterError<PErr, MErr>) -> Error<PErr, MErr> {
        Error::Master(err)
    }
}

impl<PErr, MErr> From<RecvError> for Error<PErr, MErr>
impl<PErr, MErr> From<RecvError> for Error<PErr, MErr> {
where
    PErr: 'static,
    MErr: 'static,
{
    fn from(err: RecvError) -> Error<PErr, MErr> {
        Error::DisconnectedReceiver(err)
    }
}

#[derive(Debug, Clone)]
pub struct Parameters {

}

/// Implementation of a parallel bundle method.
pub struct Solver<P, T = StandardTerminator, W = HKWeighter, M = crate::master::FullMasterBuilder>
where
    P: FirstOrderProblem,
    M: MasterBuilder<P::Minorant>,
    P::Err: 'static,
{
    /// Parameters for the solver.
    pub params: Parameters,

    /// Termination predicate.
    pub terminator: T,

    /// 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: Send + 'static,
    P::Err: Send,
    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Default,
    M: MasterBuilder<P::Minorant>,
{
    /// Create a new parallel bundle solver.
    pub fn new(problem: P) -> Self
    where