RsBundle  Check-in [5221a3331a]

        }).unwrap();
        solver.terminator = Box::new(StandardTerminator{
            termination_precision: 1e-6
        });
        solver.solve().unwrap();

        let costs : f64 = (0..solver.problem().num_subproblems()).map(|i| {
            let (coeffs, primals) : (Vec<_>, Vec<_>) = solver.aggregated_primals(i).into_iter().unzip();
            let aggr_primals = solver.problem().aggregate_primals_ref(&coeffs, &primals);
            solver.problem().get_primal_costs(i, &aggr_primals)
        }).sum();
        info!("Primal costs: {}", costs);
    } else {
        panic!("Usage: {} FILENAME", program);
    }
}

    /// Aggregate primal information.
    ///
    /// This function is called from the solver when minorants are
    /// aggregated. The problem can use this information to aggregate
    /// the corresponding primal information.
    ///

    /// - `coeffs` are the coefficient for the convex combination
    /// - `primals` are the corresponding primals to be aggregated
    ///
    /// The function must return the new aggregated primal.
    ///
    /// The default implementation does nothing and simply returns the
    /// last primal. This should work if the implementing problem does
    /// not provide primal information, e.g. if `Self::Primal = ()`.
    #[allow(unused_variables)]
    fn aggregate_primals(&mut self, coeffs: &[Real], primals: Vec<Self::Primal>) -> Self::Primal {
        let mut primals = primals;
        primals.pop().unwrap()
    }

    /// Return updates of the problem.
    ///
    /// The default implementation returns no updates.
    fn update(&mut self, _state: &UpdateState<Self::Primal>) -> Result<Vec<Update>, Self::Error> {
        Ok(vec![])

                }
            }
            sum
        }
    }

    /// Aggregate primal vectors.
    pub fn aggregate_primals_ref(&self, coeffs: &[Real], primals: &[&Vec<DVector>]) -> Vec<DVector> {
        let mut aggr = primals[0].iter().map(|x| {
            let mut r = dvec![];
            r.scal(coeffs[0], x);
            r
        }).collect::<Vec<_>>();

        for i in 1..primals.len() {
            for (j,x) in primals[i].iter().enumerate() {
                aggr[j].add_scaled(coeffs[i], x);
            }
        }

        aggr
    }
}

            Ok(SimpleEvaluation {
                objective: objective,
                minorants: vec![(Minorant { constant: objective, linear: subg }, sols)],
            })
        }
    }

    fn aggregate_primals(&mut self, coeffs: &[Real], primals: Vec<Vec<DVector>>) -> Vec<DVector> {
        self.aggregate_primals_ref(coeffs, &primals.iter().map(|x| x).collect::<Vec<_>>())
    }
}

                let aggr = self.minorants[i].split_off(self.params.max_bundle_size-2);
                let aggr_sum = aggr.iter().map(|m| m.multiplier).sum();
                let (aggr_mins, aggr_primals) : (Vec<_>, Vec<_>) = aggr.into_iter().map(|m| {
                    (m.index, m.primal.unwrap())
                }).unzip();
                let (aggr_min, aggr_coeffs) = try!(self.master.aggregate(i, &aggr_mins));
                // append aggregated minorant
                debug_assert_eq!(aggr_coeffs.len(), aggr_primals.len());
                self.minorants[i].push(MinorantInfo{
                    index: aggr_min,
                    multiplier: aggr_sum,
                    primal: Some(self.problem.aggregate_primals(&aggr_coeffs, aggr_primals)),

                });
            }
        }
        Ok(())
    }

    /// Perform a descent step.