Struct pcp::term::sum::Sum

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

Implementations

impl<VStore> Sum<VStore>

pub fn new(vars: Vec<Var<VStore>>) -> Self

Examples found in repository

src/libpcp/term/sum.rs (line 40)

  fn clone(&self) -> Self {
    Sum::new(self.vars.iter().map(|v| v.bclone()).collect())
  }

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

  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 Sum<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> Debug for Sum<VStore>

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

Formats the value using the given formatter.

impl<VStore> DisplayStateful<Model> for Sum<VStore>

fn display(&self, model: &Model)

impl<VStore, Domain, Bound> StoreMonotonicUpdate<VStore> for Sum<VStore>where
    VStore: VStoreConcept<Item = Domain>,
    Domain: IntDomain<Item = Bound>,
    Bound: IntBound,

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

impl<VStore, Domain, Bound> StoreRead<VStore> for Sum<VStore>where
    VStore: VStoreConcept<Item = Domain>,
    Domain: IntDomain<Item = Bound>,
    Bound: IntBound,

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

impl<VStore> ViewDependencies<FDEvent> for Sum<VStore>

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