RsBundle  Check-in [d67ab3a0b0]

        /// Some parameter has an invalid value.
        Parameter(msg: String) {
            description("Parameter error")
            display("Parameter error: {}", msg)
        }

        /// The lower bound of a variable is larger than the upper bound.
        InvalidBounds(lower: Real, upper: Real) {
            description("invalid bounds")
            display("Invalid bounds, lower:{} upper:{}", lower, upper)
        }

        /// The value of a variable is outside its bounds.
        ViolatedBounds(lower: Real, upper: Real, value: Real) {
            description("violated bounds")
            display("Violated bounds, lower:{} upper:{} value:{}", lower, upper, value)
        }
    }
}


/// Result type for solvers.
pub type Result<T> = result::Result<T, Error>;

        }

        let lb = self.problem.lower_bounds().map(|x| x.to_dense());
        let ub = self.problem.upper_bounds().map(|x| x.to_dense());
        for i in 0..self.cur_y.len() {
            let lb_i = lb.as_ref().map(|x| x[i]).unwrap_or(NEG_INFINITY);
            let ub_i = ub.as_ref().map(|x| x[i]).unwrap_or(INFINITY);
            if lb_i > ub_i { return Err(Error::InvalidBounds(lb_i, ub_i)); }
            if self.cur_y[i] < lb_i {
                self.cur_valid = false;
                self.cur_y[i] = lb_i;
            } else if self.cur_y[i] > ub_i {
                self.cur_valid = false;
                self.cur_y[i] = ub_i;
            }

            }
        };

        let mut newvars = Vec::with_capacity(updates.len());
        for u in updates {
            match u {
                Update::AddVariable{lower, upper} => {
                    if lower > upper {
                        return Err(Error::InvalidBounds(lower, upper))
                    }
                    let value = if lower > 0.0 { lower }
                    else if upper < 0.0 { upper }
                    else { 0.0 };
                    newvars.push((lower, upper));
                    newvars.push((lower - value, upper - value));
                },
            }
        }

        if !newvars.is_empty() {
            let mut problem = &mut self.problem;
            let minorants = &self.minorants;