RsBundle  Check-in [be42fa28cd]

/*
 * Copyright (c) 2019 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but

impl CFLProblem {
    fn new() -> CFLProblem {
        CFLProblem { pool: None }
    }
}

fn solve_facility_problem(j: usize, lambda: &[Real]) -> Result<(Real, Minorant, DVector), EvalError> {
    // facility subproblem max\{-F[j] + CAP[j] * lambda[j] * y[j] | y_j \in \{0,1\}\}
    let objective;
    let mut subg = dvec![0.0; lambda.len()];
    let primal;
    if -F[j] + CAP[j] * lambda[j] > 0.0 {
        objective = -F[j] + CAP[j] * lambda[j];
        subg[j] = CAP[j];
        primal = dvec![1.0; 1];
    } else {
        objective = 0.0;
        primal = dvec![0.0; 1];
    }

    Ok((
        objective,
        Minorant {
            constant: objective,
            linear: subg,
        },
        primal,

    ))
}

fn solve_customer_problem(i: usize, lambda: &[Real]) -> Result<(Real, Minorant, DVector), EvalError> {
    // customer subproblem
    let opt = (0..Nfac)
        .map(|j| (j, -DEMAND[i] * C[j][i] - DEMAND[i] * lambda[j]))
        .flat_map(|x| NotNan::new(x.1).map(|y| (x.0, y)))
        .max_by_key(|x| x.1)
        .ok_or(EvalError::Customer(i))?;

    let objective = opt.1.into_inner();
    let mut subg = dvec![0.0; lambda.len()];
    subg[opt.0] = -DEMAND[i];
    let mut primal = dvec![0.0; Nfac];
    primal[opt.0] = 1.0;

    Ok((
        objective,
        Minorant {
            constant: objective,
            linear: subg,
        },
        primal,

    ))
}

impl ParallelProblem for CFLProblem {
    type Err = EvalError;

    type Primal = DVector;

        self.pool.as_ref().unwrap().execute(move || {
            let res = if i < Nfac {
                solve_facility_problem(i, &y)
            } else {
                solve_customer_problem(i - Nfac, &y)
            };
            match res {
                Ok((value, minorant, primal)) => {
                    if tx.objective(value).is_err() {
                        return;
                    }
                    if tx.minorant(minorant, primal).is_err() {
                        return;
                    }
                }
                Err(err) => if tx.error(err).is_err() {},
            };
        });
        Ok(())

/*
 * Copyright (c) 2016, 2017, 2018, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but

use rustop::opts;
use std::io::Write;

use bundle::master::{Builder, FullMasterBuilder, MasterProblem, MinimalMasterBuilder};
use bundle::mcf::MMCFProblem;
use bundle::solver::asyn::Solver as AsyncSolver;
use bundle::solver::sync::Solver as SyncSolver;

use bundle::{terminator::StandardTerminator, weighter::HKWeighter};

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

fn solve_parallel<M>(master: M, mmcf: MMCFProblem) -> Result<(), Box<dyn Error>>
where
    M: Builder,
    M::MasterProblem: MasterProblem<MinorantIndex = usize>,
{
    let mut slv = AsyncSolver::<_, 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 solve_sync<M>(master: M, mmcf: MMCFProblem) -> Result<(), Box<dyn Error>>
where
    M: Builder,
    M::MasterProblem: MasterProblem<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())

/*
 * Copyright (c) 2016, 2017, 2018, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but

            }

            debug!("Evaluation at {:?}", x);
            debug!("  objective={}", objective);
            debug!("  subgradient={}", g);

            tx.objective(objective).unwrap();
            tx.minorant(
                Minorant {
                    constant: objective,
                    linear: g,

                },
                (),
            )
            .unwrap();
        });
        Ok(())
    }
}

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

/// A linear minorant of a convex function $f \colon \mathbb{R}\^n \to
/// \mathbb{R}$ is a linear function of the form
///
///   \\[ l \colon \mathbb{R}\^n \to \mathbb{R}, x \mapsto \langle g, x
///   \rangle + c \\]
///
/// such that $l(x) \le f(x)$ for all $x \in \mathbb{R}\^n$.




#[derive(Clone, Debug)]
pub struct Minorant {
    /// The constant term.
    pub constant: Real,

    /// The linear term.
    pub linear: DVector,
}











impl fmt::Display for Minorant {
    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
        write!(f, "{} + y * {}", self.constant, self.linear)?;
        Ok(())
    }
}

impl Default for Minorant {
    fn default() -> Minorant {
        Minorant {
            constant: 0.0,
            linear: dvec![],

        }
    }
}

impl Minorant {
    /// Return a new 0 minorant.
    pub fn new(constant: Real, linear: Vec<Real>) -> Minorant {
        Minorant {
            constant,
            linear: DVector(linear),

        }
    }

    /**
     * Evaluate minorant at some point.
     *
     * This function computes $c + \langle g, x \rangle$ for this minorant

    /// [`move_center`]: Minorant::move_center
    pub fn move_center_begin(&mut self, alpha: Real, d: &DVector) {
        debug_assert!(self.linear.len() >= d.len());
        self.constant += alpha * self.linear.dot_begin(d);
    }
}

impl Aggregatable for Minorant {
    fn new_scaled<A>(alpha: Real, other: A) -> Self
    where
        A: Borrow<Self>,
    {
        let m = other.borrow();
        Minorant {
            constant: alpha * m.constant,
            linear: DVector::scaled(&m.linear, alpha),

        }
    }

    fn add_scaled<A>(&mut self, alpha: Real, other: A)
    where
        A: Borrow<Self>,
    {
        let m = other.borrow();
        self.constant += alpha * m.constant;
        self.linear.add_scaled(alpha, &m.linear);

    }
}

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

pub mod unconstrained;
use self::unconstrained::UnconstrainedMasterProblem;

use super::MasterProblem;
pub use super::SubgradientExtension;
use crate::{DVector, Minorant, Real};

use either::Either;
use log::debug;
use std::f64::{EPSILON, INFINITY, NEG_INFINITY};


/**
 * Turn unconstrained master problem into box-constrained one.
 *
 * This master problem adds box constraints to an unconstrainted
 * master problem implementation. The box constraints are enforced by
 * an additional outer optimization loop.
 */
pub struct BoxedMasterProblem<M> {



    /// The unconstrained master problem solver.
    pub master: M,

    /// Maximal number of updates of box multipliers.
    pub max_updates: usize,

    /// Variable lower bounds.

    /// Model precision.
    model_eps: Real,

    need_new_candidate: bool,

    /// Current number of updates.
    cnt_updates: usize,
}



impl<M> BoxedMasterProblem<M>
where

    M: UnconstrainedMasterProblem,
{
    pub fn with_master(master: M) -> BoxedMasterProblem<M> {
        BoxedMasterProblem {
            master,
            max_updates: 50,
            lb: dvec![],
            ub: dvec![],
            eta: dvec![],
            primopt: dvec![],
            primoptval: 0.0,
            dualoptnorm2: 0.0,
            model_eps: 0.6,
            cnt_updates: 0,
            need_new_candidate: true,

        }
    }

    pub fn set_max_updates(&mut self, max_updates: usize) -> Result<(), M::Err> {
        assert!(max_updates > 0);
        self.max_updates = max_updates;
        Ok(())

     * the current box-multipliers $\eta$.
     */
    fn get_norm_subg2(&self) -> Real {
        self.eta.dot(self.master.dualopt())
    }
}

impl<M> MasterProblem for BoxedMasterProblem<M>
where

    M: UnconstrainedMasterProblem,
{
    type MinorantIndex = M::MinorantIndex;

    type Err = M::Err;

    fn new() -> Result<Self, Self::Err> {
        M::new().map(BoxedMasterProblem::with_master)

        Ok(())
    }

    fn num_minorants(&self, fidx: usize) -> usize {
        self.master.num_minorants(fidx)
    }

    fn add_minorant(&mut self, fidx: usize, minorant: Minorant) -> Result<Self::MinorantIndex, Self::Err> {
        self.master.add_minorant(fidx, minorant)
    }

    fn weight(&self) -> Real {
        self.master.weight()
    }

    fn set_weight(&mut self, weight: Real) -> Result<(), Self::Err> {
        self.master.set_weight(weight)
    }

    fn add_vars<S>(
        &mut self,
        bounds: &[(Option<usize>, Real, Real)],
        extend_subgradient: S,
    ) -> Result<(), Either<Self::Err, S::Err>>
    where
        S: SubgradientExtension<Self::MinorantIndex>,
    {
        if !bounds.is_empty() {
            for (index, l, u) in bounds.iter().filter_map(|v| v.0.map(|i| (i, v.1, v.2))) {
                self.lb[index] = l;
                self.ub[index] = u;
            }
            self.lb.extend(bounds.iter().filter(|v| v.0.is_none()).map(|x| x.1));
            self.ub.extend(bounds.iter().filter(|v| v.0.is_none()).map(|x| x.2));

    fn multiplier(&self, min: Self::MinorantIndex) -> Real {
        self.master.multiplier(min)
    }

    fn opt_multipliers<'a>(&'a self, fidx: usize) -> Box<dyn Iterator<Item = (Self::MinorantIndex, Real)> + 'a> {
        self.master.opt_multipliers(fidx)
    }





    fn move_center(&mut self, alpha: Real, d: &DVector) {
        self.need_new_candidate = true;
        self.master.move_center(alpha, d);
        self.lb.add_scaled_begin(-alpha, d);
        self.ub.add_scaled_begin(-alpha, d);
    }

/// Builder for `BoxedMasterProblem`.
///
/// `B` is a builder of the underlying `UnconstrainedMasterProblem`.
#[derive(Default)]
pub struct Builder<B>(B);

impl<B> super::Builder for Builder<B>
where

    B: unconstrained::Builder,
    B::MasterProblem: UnconstrainedMasterProblem,
{
    type MasterProblem = BoxedMasterProblem<B::MasterProblem>;

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

impl<B> std::ops::Deref for Builder<B> {
    type Target = B;

// Copyright (c) 2016, 2017, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see  <http://www.gnu.org/licenses/>
//

pub mod cpx;
pub mod minimal;

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

pub use super::SubgradientExtension;

use either::Either;
use std::error::Error;

/**
 * Trait for master problems without box constraints.
 *

 * \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: Send + 'static {
    /// Unique index for a minorant.
    type MinorantIndex: Copy + Eq;

    /// Error type for this master problem.
    type Err: Error + Send + Sync;

    /// Return a new instance of the unconstrained master problem.

    /// coefficients and indices of the compressed minorants and the index of
    /// the new minorant. The callback may be called several times.
    fn compress<F>(&mut self, f: F) -> Result<(), Self::Err>
    where
        F: FnMut(Self::MinorantIndex, &mut dyn Iterator<Item = (Self::MinorantIndex, Real)>);

    /// Add a new minorant to the model.
    fn add_minorant(&mut self, fidx: usize, minorant: Minorant) -> Result<Self::MinorantIndex, Self::Err>;

    /// Add or move some variables.
    ///
    /// The variables in `changed` have been changed, so the subgradient
    /// information must be updated. Furthermore, `nnew` new variables
    /// are added.
    fn add_vars<S>(
        &mut self,
        nnew: usize,
        changed: &[usize],
        extend_subgradient: S,
    ) -> Result<(), Either<Self::Err, S::Err>>
    where
        S: SubgradientExtension<Self::MinorantIndex>;

    /// Solve the master problem.
    fn solve(&mut self, eta: &DVector, fbound: Real, augbound: Real, relprec: Real) -> Result<(), Self::Err>;

    /// Return the current dual optimal solution.
    fn dualopt(&self) -> &DVector;

    /// 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::Err>;




    /// Move the center of the master problem along $\alpha \cdot d$.
    fn move_center(&mut self, alpha: Real, d: &DVector);
}

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

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

// Copyright (c) 2016, 2017, 2018, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see  <http://www.gnu.org/licenses/>
//

//! Master problem implementation using CPLEX.

#![allow(unused_unsafe)]

use super::{SubgradientExtension, UnconstrainedMasterProblem};

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

use c_str_macro::c_str;
use cplex_sys as cpx;
use cplex_sys::trycpx;
use either::Either;
use log::{debug, warn};

        CplexMasterError::Cplex(err)
    }
}

pub type Result<T> = std::result::Result<T, CplexMasterError>;

/// A minorant and its unique index.
struct MinorantInfo {
    minorant: Minorant,
    index: usize,
}

impl Deref for MinorantInfo {
    type Target = Minorant;
    fn deref(&self) -> &Minorant {
        &self.minorant
    }
}

impl DerefMut for MinorantInfo {
    fn deref_mut(&mut self) -> &mut Minorant {
        &mut self.minorant
    }
}

/// Maps a global index to a minorant.
#[derive(Clone, Copy)]
struct MinorantIdx {
    /// The function (subproblem) index.
    fidx: usize,
    /// The minorant index within the subproblem.
    idx: usize,
}

/// A submodel.
///
/// A submodel is a list of subproblems being aggregated in that model.
#[derive(Debug, Clone, Default)]
struct SubModel {
    /// The list of subproblems.
    subproblems: Vec<usize>,

    /// The number of minorants in this subproblem.
    ///
    /// The is the minimal number of minorants in each contained subproblem.
    num_mins: usize,
    /// The aggregated minorants of this submodel.
    ///
    /// This is just the sum of the corresponding minorants of the single
    /// functions contained in this submodel.
    minorants: Vec<Minorant>,
}

impl Deref for SubModel {
    type Target = Vec<usize>;
    fn deref(&self) -> &Vec<usize> {
        &self.subproblems
    }
}

impl DerefMut for SubModel {
    fn deref_mut(&mut self) -> &mut Vec<usize> {
        &mut self.subproblems
    }
}

pub struct CplexMaster {
    env: *mut cpx::Env,

    lp: *mut cpx::Lp,

    /// True if the QP must be updated.
    force_update: bool,

    /// The additional diagonal term to ensure positive definiteness.
    qdiag: Real,

    /// The weight of the quadratic term.
    weight: Real,

    /// The minorants for each subproblem in the model.
    minorants: Vec<Vec<MinorantInfo>>,

    /// The callback for the submodel for each subproblem.
    select_model: Arc<dyn Fn(usize) -> usize>,

    /// For each submodel the list of subproblems contained in that model.
    submodels: Vec<SubModel>,
    /// For each subproblem the submodel it is contained in.
    in_submodel: Vec<usize>,

    /// Optimal multipliers for each subproblem in the model.
    opt_mults: Vec<DVector>,
    /// Optimal aggregated minorant.
    opt_minorant: Minorant,

    /// Maximal bundle size.
    pub max_bundle_size: usize,
}

unsafe impl Send for CplexMaster {}

impl Drop for CplexMaster {
    fn drop(&mut self) {
        unsafe { cpx::freeprob(self.env, &mut self.lp) };
        unsafe { cpx::closeCPLEX(&mut self.env) };
    }
}

impl UnconstrainedMasterProblem for CplexMaster {
    type MinorantIndex = usize;

    type Err = CplexMasterError;

    fn new() -> Result<CplexMaster> {
        let env;

        trycpx!({
            let mut status = 0;
            env = cpx::openCPLEX(&mut status);
            status
        });

                let (newindex, coeffs) = self.aggregate(i, &inds)?;
                f(newindex, &mut inds.into_iter().zip(coeffs));
            }
        }
        Ok(())
    }

    fn add_minorant(&mut self, fidx: usize, minorant: Minorant) -> Result<usize> {
        debug!("Add minorant");
        debug!("  fidx={} index={}: {}", fidx, self.minorants[fidx].len(), minorant);

        debug_assert!(
            self.minorants[fidx]
                .last()
                .map_or(true, |m| m.linear.len() == minorant.linear.len()),

        // store minorant
        self.minorants[fidx].push(MinorantInfo { minorant, index });
        self.opt_mults[fidx].push(0.0);

        Ok(index)
    }

    fn add_vars<S>(
        &mut self,
        nnew: usize,
        changed: &[usize],
        mut extend_subgradient: S,
    ) -> std::result::Result<(), Either<CplexMasterError, S::Err>>
    where
        S: SubgradientExtension<Self::MinorantIndex>,
    {
        debug_assert!(!self.minorants[0].is_empty());
        if changed.is_empty() && nnew == 0 {
            return Ok(());
        }
        let noldvars = self.minorants[0][0].linear.len();
        let nnewvars = noldvars + nnew;

        let mut changedvars = vec![];
        changedvars.extend_from_slice(changed);
        changedvars.extend(noldvars..nnewvars);
        for (fidx, mins) in self.minorants.iter_mut().enumerate() {
            for m in &mut mins[..] {
                let new_subg = extend_subgradient
                    .subgradient_extension(fidx, m.index, &changedvars)
                    .map_err(Either::Right)?;
                for (&j, &g) in changed.iter().zip(new_subg.iter()) {
                    m.linear[j] = g;
                }
                m.linear.extend_from_slice(&new_subg[changed.len()..]);
            }
        }

            }
        }

        // Finally add the aggregated minorant.
        let aggr_idx = self.add_minorant(fidx, aggr)?;
        Ok((aggr_idx, aggr_coeffs))
    }










    fn move_center(&mut self, alpha: Real, d: &DVector) {
        for mins in &mut self.minorants {
            for m in mins.iter_mut() {
                m.move_center_begin(alpha, d);
            }
        }
        for submod in &mut self.submodels {
            for m in &mut submod.minorants {
                m.move_center_begin(alpha, d);
            }
        }
    }
}

impl CplexMaster {
    /// Set a custom submodel selector.
    ///
    /// For each subproblem index the selector should return a submodel index.
    /// All subproblems with the same submodel index are aggregated in a single
    /// cutting plane model.
    fn set_submodel_selection<F>(&mut self, selector: F)
    where

        Builder {
            max_bundle_size: 50,
            select_model: Arc::new(|i| i),
        }
    }
}

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

    fn build(&mut self) -> Result<CplexMaster> {
        let mut cpx = CplexMaster::new()?;
        cpx.max_bundle_size = self.max_bundle_size;
        cpx.select_model = self.select_model.clone();
        cpx.update_submodels();
        Ok(cpx)
    }
}

// Copyright (c) 2016, 2017, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but
// WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
// General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program.  If not, see  <http://www.gnu.org/licenses/>
//

use super::{SubgradientExtension, UnconstrainedMasterProblem};

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

use either::Either;
use log::debug;

use std::error::Error;
use std::f64::NEG_INFINITY;

 * is that this model can be solved explicitely and very quickly, but
 * it is only a very loose approximation of the objective function.
 *
 * Because of its properties, it can only be used if the problem to be
 * solved has a maximal number of minorants of two and only one
 * subproblem.
 */
pub struct MinimalMaster {
    /// The weight of the quadratic term.
    weight: Real,

    /// The minorants in the model.
    ///
    /// There are up to two minorants, each minorant consists of one part for
    /// each subproblem.
    ///
    /// The minorants for the i-th subproblem have the indices `2*i` and
    /// `2*i+1`.
    minorants: [Vec<Minorant>; 2],
    /// The number of minorants. Only the minorants with index less than this
    /// number are valid.
    num_minorants: usize,
    /// The number of minorants for each subproblem.
    num_minorants_of: Vec<usize>,
    /// The number of subproblems.
    num_subproblems: usize,
    /// The number of subproblems with at least 1 minorant.
    num_subproblems_with_1: usize,
    /// The number of subproblems with at least 2 minorants.
    num_subproblems_with_2: usize,
    /// Optimal multipliers.
    opt_mult: [Real; 2],
    /// Optimal aggregated minorant.
    opt_minorant: Minorant,
}

impl UnconstrainedMasterProblem for MinimalMaster {
    type MinorantIndex = usize;

    type Err = MinimalMasterError;

    fn new() -> Result<MinimalMaster, Self::Err> {
        Ok(MinimalMaster {
            weight: 1.0,
            num_minorants: 0,
            num_minorants_of: vec![],
            num_subproblems: 0,
            num_subproblems_with_1: 0,
            num_subproblems_with_2: 0,

    fn set_num_subproblems(&mut self, n: usize) -> Result<(), Self::Err> {
        self.num_subproblems = n;
        self.num_minorants = 0;
        self.num_minorants_of = vec![0; n];
        self.num_subproblems_with_1 = 0;
        self.num_subproblems_with_2 = 0;
        self.minorants = [vec![Minorant::default(); n], vec![Minorant::default(); n]];



        Ok(())
    }

    fn compress<F>(&mut self, f: F) -> Result<(), Self::Err>
    where
        F: FnMut(Self::MinorantIndex, &mut dyn Iterator<Item = (Self::MinorantIndex, Real)>),
    {

        Ok(())
    }

    fn num_minorants(&self, fidx: usize) -> usize {
        self.num_minorants_of[fidx]
    }

    fn add_minorant(&mut self, fidx: usize, minorant: Minorant) -> Result<usize, Self::Err> {
        if self.num_minorants_of[fidx] >= 2 {
            return Err(MinimalMasterError::MaxMinorants { subproblem: fidx });
        }

        let minidx = self.num_minorants_of[fidx];
        self.num_minorants_of[fidx] += 1;
        self.minorants[minidx][fidx] = minorant;

                }
                Ok(2 * fidx + 1)
            }
            _ => unreachable!("Invalid number of minorants in subproblem {}", fidx),
        }
    }

    fn add_vars<S>(
        &mut self,
        nnew: usize,
        changed: &[usize],
        mut extend_subgradient: S,
    ) -> Result<(), Either<Self::Err, S::Err>>
    where
        S: SubgradientExtension<Self::MinorantIndex>,
    {
        if self.num_subproblems_with_1 == 0 {
            return Ok(());
        }

        let noldvars = self.minorants[0][self
            .num_minorants_of
            .iter()
            .position(|&n| n > 0)
            .ok_or(MinimalMasterError::NoMinorants)
            .map_err(Either::Left)?]
        .linear
        .len();
        let mut changedvars = vec![];
        changedvars.extend_from_slice(changed);
        changedvars.extend(noldvars..noldvars + nnew);

        for fidx in 0..self.num_subproblems {
            for i in 0..self.num_minorants_of[fidx] {
                let new_subg = extend_subgradient
                    .subgradient_extension(fidx, 2 * fidx + i, &changedvars)
                    .map_err(Either::Right)?;
                let m = &mut self.minorants[i][fidx];
                for (&j, &g) in changed.iter().zip(new_subg.iter()) {
                    m.linear[j] = g;
                }
                m.linear.extend_from_slice(&new_subg[changed.len()..]);
            }
        }

            self.opt_mult
                .iter()
                .take(self.num_minorants_of[fidx])
                .enumerate()
                .map(move |(i, alpha)| (2 * fidx + i, *alpha)),
        )
    }











    fn eval_model(&self, y: &DVector) -> Real {
        let mut result = NEG_INFINITY;
        for mins in &self.minorants[0..self.num_minorants] {
            result = result.max(mins.iter().map(|m| m.eval(y)).sum());
        }
        result

impl Default for Builder {
    fn default() -> Self {
        Builder
    }
}

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

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

// Copyright (c) 2016, 2017, 2019 Frank Fischer <frank-fischer@shadow-soft.de>
//
// This program is free software: you can redistribute it and/or
// modify it under the terms of the GNU General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful, but

//! * moving the center of the linear functions $\ell_i$ (and the
//!   bounds), i.e. replacing $\hat{f}$ by $d \mapsto \hat{f}(d -
//!   \hat{d})$ for some given $\hat{d} \in \mathbb{R}\^n$.

pub mod boxed;
pub use self::boxed::BoxedMasterProblem;

pub(crate) mod primalmaster;

use crate::{DVector, Minorant, Real};
use either::Either;
use std::error::Error;
use std::result::Result;

/// Callback for subgradient extensions.
pub trait SubgradientExtension<I> {
    type Err;

    fn subgradient_extension(
        &mut self,
        fidx: usize,
        minorant_index: I,
        changed: &[usize],
    ) -> Result<DVector, Self::Err>;
}

impl<F, I, E> SubgradientExtension<I> for F
where
    F: FnMut(usize, I, &[usize]) -> Result<DVector, E>,
{
    type Err = E;

    fn subgradient_extension(
        &mut self,
        fidx: usize,
        minorant_index: I,
        changed: &[usize],
    ) -> Result<DVector, Self::Err> {
        (self)(fidx, minorant_index, changed)
    }
}

/// Trait for master problems of a proximal bundle methods.
///
/// Note that solvers are allowed to create multiple master problems potentially
/// running them in different threads. Because of this they must implement `Send
/// + 'static`, i.e. they must be quite self-contained and independent from
/// everything else.
pub trait MasterProblem: Send + 'static {
    /// Unique index for a minorant.
    type MinorantIndex: Copy + Eq;

    /// The error returned by the master problem.
    type Err: Error + Send + Sync;

    /// Create a new master problem.

    /// 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<S>(
        &mut self,
        bounds: &[(Option<usize>, Real, Real)],
        extend_subgradient: S,
    ) -> Result<(), Either<Self::Err, S::Err>>
    where
        S: SubgradientExtension<Self::MinorantIndex>;

    /// 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::Err>;

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

    /// Compress the bundle.
    ///
    /// When some minorants are compressed, the callback is called with the

    /// Return the multiplier associated with a minorant.
    fn multiplier(&self, min: Self::MinorantIndex) -> Real;

    /// Return the multipliers associated with a subproblem.
    fn opt_multipliers<'a>(&'a self, fidx: usize) -> Box<dyn Iterator<Item = (Self::MinorantIndex, Real)> + 'a>;




    /// Move the center of the master problem to $\alpha \cdot d$.
    ///
    /// The vector `d` is allowed to be shorter than the current number of
    /// variables in the master. The missing elements are assumed to be zero.
    fn move_center(&mut self, alpha: Real, d: &DVector);
}

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

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

/// The full bundle builder.
pub type FullMasterBuilder = boxed::Builder<boxed::unconstrained::cpx::Builder>;

/// The minimal bundle builder.
pub type MinimalMasterBuilder = boxed::Builder<boxed::unconstrained::minimal::Builder>;

/*
 * Copyright (c) 2019 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but
 * WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
 * General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see  <http://www.gnu.org/licenses/>
 */

//! A wrapper around master problems to handle primal information.

use super::MasterProblem;
use crate::problem::SubgradientExtender;
use crate::{Aggregatable, Minorant, Real};

use either::Either;
use std::collections::HashMap;
use std::ops::{Deref, DerefMut};

/// A wrapper around `MasterProblem` to handle primal information.
///
/// For each minorant there can be an associated (generating) primal data.
/// Typically this data arises from a Lagrangian Relaxation approach. The primal
/// data is aggregated and handled along its associated minorant. However, the
/// primal data is irrelevant for the master problem, hence it is handled in
/// this wrapper.
pub struct PrimalMaster<M, P>
where
    M: MasterProblem,
{
    master: M,
    primals: HashMap<M::MinorantIndex, P>,
}

impl<M, P> PrimalMaster<M, P>
where
    M: MasterProblem,
    M::MinorantIndex: std::hash::Hash,
    P: Aggregatable,
{
    pub fn new(master: M) -> Self {
        PrimalMaster {
            master,
            primals: HashMap::new(),
        }
    }

    pub fn add_vars<E>(
        &mut self,
        vars: Vec<(Option<usize>, Real, Real)>,
        sgext: &mut SubgradientExtender<P, E>,
    ) -> Result<(), Either<M::Err, E>> {
        let primals = &self.primals;
        self.master.add_vars(&vars, |fidx, minidx, vars: &[usize]| {
            sgext(
                fidx,
                primals
                    .get(&minidx)
                    .expect("Extension for non-existing primal requested"),
                vars,
            )
        })
    }

    pub fn add_minorant(&mut self, fidx: usize, minorant: Minorant, primal: P) -> Result<(), M::Err> {
        let index = self.master.add_minorant(fidx, minorant)?;
        let old = self.primals.insert(index, primal);
        debug_assert!(old.is_none(), "Minorant index already used");
        Ok(())
    }

    pub fn compress(&mut self) -> Result<(), M::Err> {
        let primals = &mut self.primals;
        self.master.compress(|newindex, coeffs| {
            let newprimal = Aggregatable::combine(
                coeffs.map(|(i, alpha)| (alpha, primals.remove(&i).expect("Missing primal to be compressed"))),
            );
            let old = primals.insert(newindex, newprimal);
            debug_assert!(old.is_none(), "Minorant index already used");
        })
    }

    /// Return the current aggregated primal information for a subproblem.
    ///
    /// The aggregated primal corresponds to the aggregated minorant of the last
    /// master solution.
    pub fn aggregated_primal(&self, fidx: usize) -> Result<P, M::Err> {
        Ok(P::combine(self.master.opt_multipliers(fidx).map(|(i, alpha)| {
            (alpha, self.primals.get(&i).expect("Missing primal to be aggregated"))
        })))
    }
}

impl<M, P> Deref for PrimalMaster<M, P>
where
    M: MasterProblem,
    P: Aggregatable,
{
    type Target = M;
    fn deref(&self) -> &M {
        &self.master
    }
}

impl<M, P> DerefMut for PrimalMaster<M, P>
where
    M: MasterProblem,
    P: Aggregatable,
{
    fn deref_mut(&mut self) -> &mut M {
        &mut self.master
    }
}

        let active_constraints = self.active_constraints.read().unwrap()[0..y.len()].to_vec();
        self.pool
            .as_ref()
            .unwrap()
            .execute(move || match sub.write().unwrap().evaluate(&y, active_constraints) {
                Ok((objective, subg, primal)) => {
                    tx.objective(objective).unwrap();
                    tx.minorant(
                        Minorant {
                            constant: objective,
                            linear: subg,
                        },
                        primal,
                    )

                    .unwrap();
                }
                Err(err) => tx.error(err).unwrap(),
            });
        Ok(())
    }

{
    type Err: std::error::Error + Send;

    /// Send a new objective `value`.
    fn objective(&self, value: Real) -> Result<(), Self::Err>;

    /// Send a new `minorant` with associated `primal`.
    fn minorant(&self, minorant: Minorant, primal: P::Primal) -> Result<(), Self::Err>;

    /// Send an error message.
    fn error(&self, err: P::Err) -> Result<(), Self::Err>;
}

/// The subgradient extender is a callback used to update existing minorants
/// given their associated primal data.

/*
 * Copyright (c) 2019 Frank Fischer <frank-fischer@shadow-soft.de>
 *
 * This program is free software: you can redistribute it and/or
 * modify it under the terms of the GNU General Public License as
 * published by the Free Software Foundation, either version 3 of the
 * License, or (at your option) any later version.
 *
 * This program is distributed in the hope that it will be useful, but

/// The result type of the solver.
///
/// - `T` is the value type,
/// - `P` is the `FirstOrderProblem` associated with the solver,
/// - `M` is the `MasterBuilder` associated with the solver.
pub type Result<T, P, M> = std::result::Result<
    T,




    Error<<<M as MasterBuilder>::MasterProblem as MasterProblem>::Err, <P as FirstOrderProblem>::Err>,

>;

impl<MErr, PErr> std::fmt::Display for Error<MErr, PErr>
where
    MErr: std::fmt::Display,
    PErr: std::fmt::Display,
{

}

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

    /// Termination predicate.
    pub terminator: T,

impl<P, T, W, M> Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    P::Err: Send + 'static,
    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Default,
    M: MasterBuilder,
    <M::MasterProblem as MasterProblem>::MinorantIndex: std::hash::Hash,
{
    /// Create a new parallel bundle solver.
    pub fn new(problem: P) -> Self
    where
        M: Default,
    {
        Self::with_master(problem, M::default())

            EvalResult::ObjectiveValue { index, value } => {
                debug!("Receive objective from subproblem {}: {}", index, value);
                if self.data.nxt_ubs[index].is_infinite() {
                    self.data.cnt_remaining_ubs -= 1;
                }
                self.data.nxt_ubs[index] = self.data.nxt_ubs[index].min(value);
            }
            EvalResult::Minorant {
                index,
                mut minorant,
                primal,
            } => {
                debug!("Receive minorant from subproblem {}", index);
                if self.data.nxt_cutvals[index].is_infinite() {
                    self.data.cnt_remaining_mins -= 1;
                }
                // move center of minorant to cur_y
                minorant.move_center(-1.0, &self.data.nxt_d);
                self.data.nxt_cutvals[index] = self.data.nxt_cutvals[index].max(minorant.constant);
                // add minorant to master problem
                master.add_minorant(index, minorant, primal)?;
            }
            EvalResult::Done { .. } => return Ok(false), // currently we do nothing ...
            EvalResult::Error { err, .. } => return Err(Error::Evaluation(err)),
        }

        if self.data.cnt_remaining_ubs > 0 || self.data.cnt_remaining_mins > 0 {
            // Haven't received data from all subproblems, yet.

 */

//! Implementation for `ResultSender` using channels.

use super::masterprocess::Response as MasterResponse;
use crate::master::MasterProblem;
use crate::problem::{FirstOrderProblem, ResultSender, SubgradientExtender, UpdateSender};
use crate::{Minorant, Real};

#[cfg(feature = "crossbeam")]
use rs_crossbeam::channel::{Receiver, SendError, Sender};
#[cfg(not(feature = "crossbeam"))]
use std::sync::mpsc::{Receiver, SendError, Sender};

/// A message received from a client.
///
/// The client might be either a subproblem or a master problem process.
///
/// A client may send one of two possible messages: either an evaluation result
/// or a problem update.
pub enum Message<I, P, E, MErr> {



    /// An evaluation result.
    Eval(EvalResult<I, P, E>),
    /// A problem update.
    Update(Update<I, P, E>),
    /// A master problem result.
    Master(MasterResponse<MErr, E>),
}

/// The sender for client messages.
pub type ClientSender<P, M> =


    Sender<Message<usize, <P as FirstOrderProblem>::Primal, <P as FirstOrderProblem>::Err, <M as MasterProblem>::Err>>;





/// The receiver for client messages.
pub type ClientReceiver<P, M> = Receiver<


    Message<usize, <P as FirstOrderProblem>::Primal, <P as FirstOrderProblem>::Err, <M as MasterProblem>::Err>,



>;

/// Parameters for tuning the solver.

/// Evaluation result.
///
/// The result of an evaluation is new information to be made
/// available to the solver and the master problem. There are
/// essentially two types of information:
///
///    1. The (exact) function value of a sub-function at some point.
///    2. A minorant of some sub-function.
#[derive(Debug)]
pub enum EvalResult<I, P, E> {



    /// The objective value at some point.
    ObjectiveValue { index: I, value: Real },
    /// A minorant with an associated primal.
    Minorant { index: I, minorant: Minorant, primal: P },
    /// An error occurred.
    Error { index: I, err: E },
    /// Done, no further message will be received from this evaluation.
    Done { index: I },
}

/// Problem update information.

    /// Done, no further message will be received from this evaluation.
    Done { index: I },
}

pub struct ChannelResultSender<I, P, E, M>
where
    I: Clone,

{
    index: I,
    tx: Sender<Message<I, P, E, M>>,
}

impl<I, P, E, M> ChannelResultSender<I, P, E, M>
where
    I: Clone,

{
    pub fn new(index: I, tx: Sender<Message<I, P, E, M>>) -> Self {
        ChannelResultSender { index, tx }
    }
}

impl<I, P, M> ResultSender<P> for ChannelResultSender<I, P::Primal, P::Err, M>

    fn objective(&self, value: Real) -> Result<(), Self::Err> {
        self.tx.send(Message::Eval(EvalResult::ObjectiveValue {
            index: self.index.clone(),
            value,
        }))
    }

    fn minorant(&self, minorant: Minorant, primal: P::Primal) -> Result<(), Self::Err> {
        self.tx.send(Message::Eval(EvalResult::Minorant {
            index: self.index.clone(),
            minorant,
            primal,
        }))
    }

    fn error(&self, err: P::Err) -> Result<(), Self::Err> {
        self.tx.send(Message::Eval(EvalResult::Error {
            index: self.index.clone(),
            err,
        }))
    }
}

impl<I, P, E, M> Drop for ChannelResultSender<I, P, E, M>
where
    I: Clone,

{
    fn drop(&mut self) {
        self.tx
            .send(Message::Eval(EvalResult::Done {
                index: self.index.clone(),
            }))
            .unwrap()
    }
}

pub struct ChannelUpdateSender<I, P, E, M>
where
    I: Clone,

{
    index: I,
    tx: Sender<Message<I, P, E, M>>,
}

impl<I, P, E, M> ChannelUpdateSender<I, P, E, M>
where
    I: Clone,

{
    pub fn new(index: I, tx: Sender<Message<I, P, E, M>>) -> Self {
        ChannelUpdateSender { index, tx }
    }
}

impl<I, P, M> UpdateSender<P> for ChannelUpdateSender<I, P::Primal, P::Err, M>

        }))
    }
}

impl<I, P, E, M> Drop for ChannelUpdateSender<I, P, E, M>
where
    I: Clone,

{
    fn drop(&mut self) {
        self.tx
            .send(Message::Update(Update::Done {
                index: self.index.clone(),
            }))
            .unwrap()
    }
}

use either::Either;
use log::{debug, warn};
use std::sync::Arc;
use threadpool::ThreadPool;

use super::channels::{ClientSender, Message};
use crate::master::primalmaster::PrimalMaster;
use crate::master::MasterProblem;
use crate::problem::{FirstOrderProblem, SubgradientExtender};
use crate::{DVector, Minorant, Real};

#[derive(Debug)]
pub enum Error<MErr, PErr> {
    /// The communication channel for sending requests has been disconnected.
    DisconnectedSender,
    /// The communication channel for sending responds has been disconnected.
    DisconnectedReceiver,

    /// The lower bounds on the variables.
    pub upper_bounds: Option<DVector>,
}

/// A task for the master problem.
enum MasterTask<Pr, PErr, M>
where
    M: MasterProblem,

{
    /// Add new variables to the master problem.
    AddVariables(Vec<(Option<usize>, Real, Real)>, Box<SubgradientExtender<Pr, PErr>>),

    /// Add a new minorant for a subfunction to the master problem.
    AddMinorant(usize, Minorant, Pr),

    /// Move the center of the master problem in the given direction.
    MoveCenter(Real, Arc<DVector>),

    /// Start a new computation of the master problem.
    Solve { center_value: Real },

        cnt_updates: usize,
    },
    /// An error occurred.
    Error(Error<MErr, PErr>),
}

/// Convenient type for `Response`.
pub type MasterResponse<P, M> = Response<<M as MasterProblem>::Err, <P as FirstOrderProblem>::Err>;


type ToMasterSender<P, M> = Sender<MasterTask<<P as FirstOrderProblem>::Primal, <P as FirstOrderProblem>::Err, M>>;

type ToMasterReceiver<P, M> = Receiver<MasterTask<<P as FirstOrderProblem>::Primal, <P as FirstOrderProblem>::Err, M>>;

pub struct MasterProcess<P, M>
where
    P: FirstOrderProblem,
    M: MasterProblem,
{
    /// The channel to transmit new tasks to the master problem.
    tx: ToMasterSender<P, M>,

    phantom: std::marker::PhantomData<M>,
}

impl<P, M> MasterProcess<P, M>
where
    P: FirstOrderProblem,
    P::Primal: Send + 'static,
    P::Err: Send + 'static,
    M: MasterProblem + Send + 'static,
    M::MinorantIndex: std::hash::Hash,
    M::Err: Send + 'static,
{
    pub fn start(master: M, master_config: MasterConfig, tx: ClientSender<P, M>, threadpool: &mut ThreadPool) -> Self {
        // Create a pair of communication channels.
        let (to_master_tx, to_master_rx) = channel();

        Ok(self.tx.send(MasterTask::AddVariables(vars, sgext))?)
    }

    /// Add a new minorant to the master problem model.
    ///
    /// This adds the specified `minorant` with associated `primal` data to the
    /// model of subproblem `i`.
    pub fn add_minorant(
        &mut self,
        i: usize,
        minorant: Minorant,
        primal: P::Primal,
    ) -> Result<(), Error<M::Err, P::Err>> {
        Ok(self.tx.send(MasterTask::AddMinorant(i, minorant, primal))?)
    }

    /// Move the center of the master problem.
    ///
    /// This moves the master problem's center in direction $\\alpha \\cdot d$.
    pub fn move_center(&mut self, alpha: Real, d: Arc<DVector>) -> Result<(), Error<M::Err, P::Err>> {
        Ok(self.tx.send(MasterTask::MoveCenter(alpha, d))?)

    fn master_main(
        master: M,
        master_config: MasterConfig,
        tx: &mut ClientSender<P, M>,
        rx: ToMasterReceiver<P, M>,
        subgradient_extender: &mut Option<Box<SubgradientExtender<P::Primal, P::Err>>>,
    ) -> Result<(), Error<M::Err, P::Err>> {
        let mut master = PrimalMaster::<_, P::Primal>::new(master);

        // Initialize the master problem.
        master
            .set_num_subproblems(master_config.num_subproblems)
            .map_err(Error::Master)?;
        master
            .set_vars(
                master_config.num_vars,
                master_config.lower_bounds,
                master_config.upper_bounds,
            )
            .map_err(Error::Master)?;

        // The main iteration: wait for new tasks.
        for m in rx {
            match m {
                MasterTask::AddVariables(vars, mut sgext) => {
                    debug!("master: add {} variables to the subproblem", vars.len());
                    master.add_vars(vars, &mut sgext).map_err(|err| match err {
                        Either::Left(err) => Error::Master(err),
                        Either::Right(err) => Error::SubgradientExtension(err),
                    })?;
                    *subgradient_extender = Some(sgext);
                }
                MasterTask::AddMinorant(i, mut m, primal) => {
                    debug!("master: add minorant to subproblem {}", i);
                    // It may happen the number new minorant belongs to an earlier evaluation
                    // with less variables (i.e. new variables have been added
                    // after the start of the evaluation but before the new
                    // minorant is added, i.e. now). In this case we must add
                    // extend the minorant accordingly.
                    if m.linear.len() < master.num_variables() {
                        if let Some(ref mut sgext) = subgradient_extender {
                            let newinds = (m.linear.len()..master.num_variables()).collect::<Vec<_>>();
                            let new_subg =
                                sgext(i, &primal, &newinds).map_err(Error::<M::Err, P::Err>::SubgradientExtension)?;
                            m.linear.extend(new_subg);
                        }
                    }
                    master.add_minorant(i, m, primal).map_err(Error::Master)?;
                }
                MasterTask::MoveCenter(alpha, d) => {
                    debug!("master: move center");
                    master.move_center(alpha, &d);
                }
                MasterTask::Compress => {
                    debug!("Compress bundle");
                    master.compress().map_err(Error::Master)?;
                }
                MasterTask::Solve { center_value } => {
                    debug!("master: solve with center_value {}", center_value);
                    master.solve(center_value).map_err(Error::Master)?;
                    let master_response = Response::Result {
                        nxt_d: master.get_primopt(),
                        nxt_mod: master.get_primoptval(),

                    debug!("master: set weight {}", weight);
                    master.set_weight(weight).map_err(Error::Master)?;
                }
                MasterTask::GetAggregatedPrimal { subproblem, tx } => {
                    debug!("master: get aggregated primal for {}", subproblem);
                    if tx.send(master.aggregated_primal(subproblem)).is_err() {
                        warn!("Sending of aggregated primal for {} failed", subproblem);
                    };

                }
            };
        }

        Ok(())
    }
}

/// The result type of the solver.
///
/// - `T` is the value type,
/// - `P` is the `FirstOrderProblem` associated with the solver,
/// - `M` is the `MasterBuilder` associated with the solver.
pub type Result<T, P, M> = std::result::Result<
    T,




    Error<<<M as MasterBuilder>::MasterProblem as MasterProblem>::Err, <P as FirstOrderProblem>::Err>,

>;

impl<MErr, PErr> std::fmt::Display for Error<MErr, PErr>
where
    MErr: std::fmt::Display,
    PErr: std::fmt::Display,
{

    }
}

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

    /// Termination predicate.
    pub terminator: T,

impl<P, T, W, M> Solver<P, T, W, M>
where
    P: FirstOrderProblem,
    P::Err: Send + 'static,
    T: Terminator<SolverData> + Default,
    W: Weighter<SolverData> + Default,
    M: MasterBuilder,
    <M::MasterProblem as MasterProblem>::MinorantIndex: std::hash::Hash,
{
    /// Create a new parallel bundle solver.
    pub fn new(problem: P) -> Self
    where
        M: Default,
    {
        Self::with_master(problem, M::default())

            EvalResult::ObjectiveValue { index, value } => {
                debug!("Receive objective from subproblem {}: {}", index, value);
                if self.data.nxt_ubs[index].is_infinite() {
                    self.data.cnt_remaining_ubs -= 1;
                }
                self.data.nxt_ubs[index] = self.data.nxt_ubs[index].min(value);
            }
            EvalResult::Minorant {
                index,
                mut minorant,
                primal,
            } => {
                debug!("Receive minorant from subproblem {}", index);
                if self.data.nxt_cutvals[index].is_infinite() {
                    self.data.cnt_remaining_mins -= 1;
                }
                // move center of minorant to cur_y
                minorant.move_center(-1.0, &self.data.nxt_d);
                self.data.nxt_cutvals[index] = self.data.nxt_cutvals[index].max(minorant.constant);
                // add minorant to master problem
                master.add_minorant(index, minorant, primal)?;
            }
            EvalResult::Done { .. } => return Ok(false), // nothing to do here
            EvalResult::Error { err, .. } => return Err(Error::Evaluation(err)),
        }

        if self.data.cnt_remaining_ubs > 0 || self.data.cnt_remaining_mins > 0 {
            // Haven't received data from all subproblems, yet.