fn queue_constraint_by_counter(&mut self, constraint: usize) -> Result<Change, LinearProgramType<OF>> {
        match self.counters.constraint[constraint] {
            0 => {
                let right_hand_side = self.updates.b(constraint);
                let constraint_type = self.updates.constraint_type(constraint);
                if is_empty_constraint_feasible(right_hand_side, constraint_type) {
                    self.remove_constraint(constraint);
                    Ok(Change::Meaningful)
                } else {
                    Err(LinearProgramType::Infeasible)
                }
            }
            1 => {
                self.queues.bound.push(constraint);
                Ok(Change::None)
            },
            _ => Ok(Change::None),
        }
    }
/// If the number of elements in a constraint drops below a certain number, something might need
/// to happen.
///
/// We try to remove elements from the constraint matrix the entire time; the number of elements
/// in each row is counted such that we don't need to search for the rows where we might apply
/// some of the most powerful rules, the ones that work with certainty and make the problem
/// smaller.
///
/// Empty rows are handled directly in this function.
///
/// # Arguments
///
/// * `constraint`: The constraint whos counter might have becomes sufficiently low to activate
/// a rule.
///
/// # Returns
///
/// Whether a meaningful change was made in the function (such as when the constraint is empty).
If the number of elements in a constraint drops below a certain number, something might need
to happen.

We try to remove elements from the constraint matrix the entire time; the number of elements
in each row is counted such that we don't need to search for the rows where we might apply
some of the most powerful rules, the ones that work with certainty and make the problem
smaller.

Empty rows are handled directly in this function.
If the number of elements in a constraint drops below a certain number something might need to happen . We try to remove elements from the constraint matrix the entire time ; the number of elements in each row is counted such that we don ' t need to search for the rows where we might apply some of the most powerful rules the ones that work with certainty and make the problem smaller . Empty rows are handled directly in this function .
fn queue_constraint_by_counter(&mut self, constraint: usize) -> Result<Change, LinearProgramType<OF>> {
        match self.counters.constraint[constraint] {
            0 => {
                let right_hand_side = self.updates.b(constraint);
                let constraint_type = self.updates.constraint_type(constraint);
                if is_empty_constraint_feasible(right_hand_side, constraint_type) {
                    self.remove_constraint(constraint);
                    Ok(Change::Meaningful)
                } else {
                    Err(LinearProgramType::Infeasible)
                }
            }
            1 => {
                self.queues.bound.push(constraint);
                Ok(Change::None)
            },
            _ => Ok(Change::None),
        }
    }
fn queue_constraint_by_counter ( & mut self , constraint : usize ) -> Result < Change , LinearProgramType < OF > > { match self . counters . constraint [ constraint ] { 0 => { let right_hand_side = self . updates . b ( constraint ) ; let constraint_type = self . updates . constraint_type ( constraint ) ; if is_empty_constraint_feasible ( right_hand_side , constraint_type ) { self . remove_constraint ( constraint ) ; Ok ( Change :: Meaningful ) } else { Err ( LinearProgramType :: Infeasible ) } } 1 => { self . queues . bound . push ( constraint ) ; Ok ( Change :: None ) } , _ => Ok ( Change :: None ) , } }
If the number of elements in a constraint drops below a certain number, something might need
to happen.
If the number of elements in a constraint drops below a certain number something might need to happen .
&mut self
constraint
usize
Whether a meaningful change was made in the function (such as when the constraint is empty).
Whether a meaningful change was made in the function ( such as when the constraint is empty ) .
&mut self
constraint
usize