Beispiel #1
0
void VACExtension::enforcePass1()
{
    //  VACVariable* xi;
    VACVariable *xj;
    VACBinaryConstraint *cij;
    //if (ToulBar2::verbose > 1) cout << "VAC Enforce Pass 1" << endl;

    while (!VAC.empty()) {
        xj = (VACVariable *) VAC.pop_first();
        //list<Constraint*> l;
        for (ConstraintList::iterator itc = xj->getConstrs()->begin();
                itc != xj->getConstrs()->end(); ++itc) {
            Constraint *c = (*itc).constr;
            if (c->arity() == 2 && !c->isSep()) {
                cij = (VACBinaryConstraint *) c;
                //        xi = (VACVariable *)cij->getVarDiffFrom(xj);
                //if(xj->getMaxK(nbIterations) > 2) l.push_back(cij); else
                if (enforcePass1(xj, cij))
                    return;
            }
        }

        /*for (list<Constraint*>::iterator itl = l.begin(); itl != l.end(); ++itl) {
		   cij = (VACConstraint *) *itl;
		   if(enforcePass1(xj,cij)) return;
		   } */
    }
    inconsistentVariable = -1;
}
void Mistral::ConsolidateListener::notify_add_con(Constraint c) {

  //std::cout << "ADD CON " << c << std::endl;

  Variable *scope = c.get_scope();
  int arity = c.arity();
  for(int i=0; i<arity; ++i) {
    constraints[scope[i].id()].add(c);
    constraints[scope[i].id()].back().set_index(i);
  }
}
Beispiel #3
0
bool VACExtension::checkPass1() const
{
    VACBinaryConstraint *cij;
    VACVariable *xi, *xj;
    bool supportFound;
    TreeDecomposition *td = wcsp->getTreeDec();

    for (unsigned int i = 0; i < wcsp->numberOfVariables(); i++) {
        xi = (VACVariable *) wcsp->getVar(i);
        if (td
                && !td->isActiveAndInCurrentClusterSubTree(xi->
                        getCluster()))
            continue;
        for (ConstraintList::iterator iter = xi->getConstrs()->begin();
                iter != xj->getConstrs()->end(); ++iter) {
            Constraint *c = (*iter).constr;
            if (c->arity() == 2 && !c->isSep()) {
                cij = (VACBinaryConstraint *) c;
                xj = (VACVariable *) cij->getVarDiffFrom(xi);
                for (EnumeratedVariable::iterator iti =
                        xi->begin(); iti != xi->end(); ++iti) {
                    Value v = *iti;
                    supportFound = false;
                    for (EnumeratedVariable::iterator itj =
                            xj->begin(); itj != xj->end();
                            ++itj) {
                        Value w = *itj;
                        if ((xi->getVACCost(v) ==
                                MIN_COST)
                                && (xj->getVACCost(w) ==
                                        MIN_COST)
                                        && (cij->
                                                getVACCost(xi, xj, v,
                                                        w) ==
                                                                MIN_COST)) {
                            supportFound = true;
                            break;
                        }
                    }
                    if (!supportFound) {
                        return false;
                    }
                }
            }
        }
    }
    return true;
}
    set<Constraint *> subConstraint(){
    	set <Constraint *> subcstr;
    	set<int> scope;
    	for(int k=0; k < arity(); k++) {
    		scope.insert(getVar(k)->wcspIndex);
    	}
    	for(set<int>::iterator itx = scope.begin(); itx != scope.end(); ++itx){
    		ConstraintList* xctrs = (wcsp->getVar(*itx))->getConstrs();
    		for (ConstraintList::iterator it=xctrs->begin(); it != xctrs->end(); ++it){
    			Constraint * ctr = (*it).constr;
    			if(ctr->arity() < arity() && scopeIncluded(ctr)) subcstr.insert(ctr);
    		}
    	}

    	return subcstr;
    }
Beispiel #5
0
void VACExtension::afterPreprocessing()
{
    int discarded = 0;
    for (unsigned int i = 0; i < wcsp->numberOfConstraints(); i++) {
        Constraint *c = wcsp->getCtr(i);
        if (c->connected() && (c->arity() <= 3) && !c->isSep()) {
            if (c->getTightness() <
                    to_double(ToulBar2::relaxThreshold)) {
                c->deconnect();
                discarded++;
            }
        }
    }
    if (discarded)
        cout << "WARNING num of discarded ctrs: " << discarded << endl;
}
Mistral::ConsolidateListener::ConsolidateListener(Mistral::Solver *s) 
  : VariableListener(), ConstraintListener(), solver(s)
{
  sequence = &(solver->sequence);
  constraints.initialise(solver->variables.size);


  // int n = solver->variables.size;
  // for(int i=0; i<n; ++i) {
  //   Vector< Constraint > neighborhood;
  //   neighborhood.initialise(solver->variables[i].get_degree());
  //   for(int k=0; k<3; ++k) {
  //     for(int j=solver->constraint_graph[i].on[k].size-1; j>=0; --j)
  //    	neighborhood.add(solver->constraint_graph[i].on[k][j]);
  //   }
  //   constraints.add(neighborhood);
  // }

  //std::cout << "Variables size: " << solver->variables.size << std::endl;

  Constraint c;
  Variable *scope;
  int i, j, arity, n=solver->variables.size;

  for(i=0; i<n; ++i) {
    constraints[i].initialise(solver->variables[i].get_degree());
  }

  n = solver->constraints.size;
  for(i=0; i<n; ++i) {
    c = solver->constraints[i];
    scope = c.get_scope();
    arity = c.arity();
    for(j=0; j<arity; ++j) {
      if(!scope[j].is_ground()) {
	//std::cout << " " << scope[j] << std::endl;
	c.set_index(j);
	constraints[scope[j].id()].add(c);
      }
    }
  }

  //std::cout << constraints[66] << std::endl;

  solver->add((VariableListener*)this);
  solver->add((ConstraintListener*)this);
}
bool VACVariable::averaging()
{
	Cost Top = wcsp->getUb();
	bool change = false;
	EnumeratedVariable* x;
	EnumeratedVariable* y;
	Constraint* ctr = NULL;
	ConstraintList::iterator itc = getConstrs()->begin();
	if(itc != getConstrs()->end())	ctr = (*itc).constr;
	while(ctr) {
		if(ctr->arity() == 2 && !ctr->isSep()) {
			BinaryConstraint* bctr = (BinaryConstraint*) ctr;
			x = (EnumeratedVariable*) bctr->getVarDiffFrom( (Variable*) this );
			for (iterator it = begin(); it != end(); ++it) {
				Cost cu = getCost(*it);
				Cost cmin = Top;
				for (iterator itx = x->begin(); itx != x->end(); ++itx) {
					Cost cbin = bctr->getCost(this,x,*it,*itx);
					if(cbin < cmin) cmin = cbin;
				}
				assert(cmin < Top);
				Double mean = to_double(cmin + cu) / 2.;	
				Double extc = to_double(cu) - mean;					 
				if(abs(extc) >= 1) {
				  Cost costi = (Long) extc;
				  for (iterator itx = x->begin(); itx != x->end(); ++itx) {
					bctr->addcost(this,x,*it,*itx,costi);				
				  }
				  if(mean > to_double(cu)) project(*it, -costi); 
				  else extend(*it, costi);
				  change = true;
				}
			}
		} else if(ctr->arity() == 3 && !ctr->isSep()) {
			TernaryConstraint* tctr = (TernaryConstraint*) ctr;
			x = (EnumeratedVariable*) tctr->getVar( 0 );
			if(x == this) x = (EnumeratedVariable*) tctr->getVar( 1 );
		    y = (EnumeratedVariable*) tctr->getVarDiffFrom((Variable*) this, (Variable*)x);
			for (iterator it = begin(); it != end(); ++it) {
				Cost cu = getCost(*it);
				Cost cmin = Top;
				for (iterator itx = x->begin(); itx != x->end(); ++itx) {
				for (iterator ity = y->begin(); ity != y->end(); ++ity) {
					Cost ctern = tctr->getCost(this,x,y,*it,*itx,*ity);
					if(ctern < cmin) cmin = ctern;
				}}
				assert(cmin < Top);
				Double mean = to_double(cmin + cu) / 2.;
				Double extc = to_double(cu) - mean;				 
				if(abs(extc) >= 1) {
					Cost costi = (Long) extc;
					for (iterator itx = x->begin(); itx != x->end(); ++itx) {
					for (iterator ity = y->begin(); ity != y->end(); ++ity) {
						tctr->addCost(this,x,y,*it,*itx,*ity,costi);				
					}}
					if(mean > to_double(cu)) project(*it, -costi); 
					else extend(*it, costi);
					change = true;
				}
			}
		} else if(ctr->arity() >= 4 && ctr->extension() && !ctr->isSep()) {
			NaryConstraint* nctr = (NaryConstraint*) ctr;
			for (iterator it = begin(); it != end(); ++it) {
				Cost cu = getCost(*it);
				Cost cmin = Top;
				int tindex = nctr->getIndex(this);
				String tuple;
				Cost cost;
				Long nbtuples = 0;
				nctr->first();
				while (nctr->next(tuple,cost)) {
				  nbtuples++;
				  if (toValue(tuple[tindex] - CHAR_FIRST)==(*it) && cost < cmin) cmin = cost;
				}
				if (nctr->getDefCost() < cmin && nbtuples < nctr->getDomainSizeProduct()) cmin = nctr->getDefCost();
				//				assert(cmin < Top);
				Double mean = to_double(cmin + cu) / 2.;
				Double extc = to_double(cu) - mean;				 
				if(abs(extc) >= 1) {
					Cost costi = (Cost) extc;
					if(nctr->getDefCost() < Top) {
					  nctr->firstlex();
					  while( nctr->nextlex(tuple,cost) ) {
						if (toValue(tuple[tindex] - CHAR_FIRST)==(*it)) {
						  if(cost + costi < Top) nctr->setTuple(tuple, cost + costi);
						  else nctr->setTuple(tuple, Top);
						}
					  }
					  nctr->setDefCost(Top);
					} else {
					  nctr->first();
					  while( nctr->next(tuple,cost) ) {
						if (toValue(tuple[tindex] - CHAR_FIRST)==(*it)) {
						  if(cost + costi < Top) nctr->addtoTuple(tuple, costi);
						  else nctr->setTuple(tuple, Top);
						}
					  }
					}
					if(mean > to_double(cu)) project(*it, -costi); 
					else extend(*it, costi);
					change = true;
				}
			}
		}
		++itc;
		if(itc != getConstrs()->end()) ctr = (*itc).constr;
		else ctr = NULL;
	}
	return change;
}