Struct pcp::logic::boolean::Boolean

pub struct Boolean<VStore> { /* private fields */ }

Implementations

impl<VStore, Domain, Bound> Boolean<VStore>where
    VStore: VStoreConcept<Item = Domain>,
    Domain: Range + Collection<Item = Bound> + Clone + Debug + 'static,
    Bound: Num,

pub fn new(vstore: &mut VStore) -> Self

Examples found in repository

src/libpcp/propagators/cumulative.rs (line 81)

  pub fn join<CStore>(&mut self, vstore: &mut VStore, cstore: &mut CStore) where
    CStore: IntCStore<VStore> + 'static
  {
    let tasks = self.starts.len();
    // Special case where only one task needs to be scheduled.
    if tasks == 1 {
      // c >= r[j]
      cstore.alloc(Box::new(x_geq_y(self.capacity_var(), self.resource_at(0))));
    }
    else {
      // forall( j in tasks ) (...)
      for j in 0..tasks {
        let mut resource_vars = vec![];
        self.intermediate.push(vec![]);
        for i in 0..tasks {
          if i != j {
            // conj <-> s[i] <= s[j] /\ s[j] < s[i] + d[i]
            let conj = Box::new(Conjunction::new(vec![
              // s[i] <= s[j]
              Box::new(x_leq_y(self.start_at(i), self.start_at(j))),
              // s[j] < s[i] + d[i]
              Box::new(XLessYPlusZ::new(self.start_at(j), self.start_at(i), self.duration_at(i)))]));

            // bi <-> conj
            let bi = Boolean::new(vstore);
            let equiv = equivalence(Box::new(bi.clone()), conj);
            cstore.alloc(equiv);

            // r = bi * r[i]
            let ri = self.resource_at(i);
            let ri_ub = ri.read(vstore).upper();
            let r_dom = Domain::new(Bound::zero(), ri_ub);
            // let hole = Domain::new(Bound::one(), ri_ub.clone() - Bound::one());
            let r = vstore.alloc(r_dom);
            self.intermediate.last_mut().unwrap().push(r.index());
            let r = Box::new(r) as Var<VStore>;
            cstore.alloc(Box::new(XEqYMulZ::new(r.bclone(), Box::new(bi), ri)));
            resource_vars.push(r);
          }
        }
        //  sum( i in tasks where i != j )(...)
        let sum = Box::new(Sum::new(resource_vars));
        // c >= r[j] + sum
        cstore.alloc(Box::new(x_geq_y_plus_z(self.capacity_var(), self.resource_at(j), sum)));
      }
    }
  }

Trait Implementations

impl<VStore> Clone for Boolean<VStore>where
    VStore: Collection,

fn clone(&self) -> Self

Returns a copy of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl<VStore> Debug for Boolean<VStore>

fn fmt(&self, fmt: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl<VStore> DisplayStateful<Model> for Boolean<VStore>

fn display(&self, model: &Model)

impl<VStore, Domain, Bound> NotFormula<VStore> for Boolean<VStore>where
    VStore: VStoreConcept<Item = Domain> + 'static,
    Domain: IntDomain<Item = Bound> + 'static,
    Bound: IntBound + 'static,

fn not(&self) -> Formula<VStore>

impl<VStore, Dom, Bound> Propagator<VStore> for Boolean<VStore>where
    VStore: VStoreConcept<Item = Dom>,
    Dom: Collection<Item = Bound> + Singleton,
    Bound: Num,

fn propagate(&mut self, vstore: &mut VStore) -> bool

Returns false if it failed to propagate (a variable has an empty domain after propagation).

impl<VStore> PropagatorDependencies<FDEvent> for Boolean<VStore>

fn dependencies(&self) -> Vec<(usize, FDEvent)>

Each event on a variable that can change the result of the is_subsumed method should be listed here.

impl<VStore> StoreMonotonicUpdate<VStore> for Boolean<VStore>where
    VStore: VStoreConcept,

fn update(&mut self, store: &mut VStore, value: VStore::Item) -> bool

impl<VStore> StoreRead<VStore> for Boolean<VStore>where
    VStore: VStoreConcept,

fn read(&self, store: &VStore) -> VStore::Item

impl<VStore, Dom, Bound> Subsumption<VStore> for Boolean<VStore>where
    VStore: Collection<Item = Dom>,
    Dom: Bounded<Item = Bound> + IsSingleton,
    Bound: Num,

fn is_subsumed(&self, store: &VStore) -> SKleene

impl<VStore> ViewDependencies<FDEvent> for Boolean<VStore>

fn dependencies(&self, event: FDEvent) -> Vec<(usize, FDEvent)>