LinExpr
operator -(int c, const IntVar& x) {
if (x.assigned() && Int::Limits::valid(static_cast<double>(c)-x.val()))
return LinExpr(static_cast<double>(c)-x.val());
else
return LinExpr(x,LinExpr::NT_SUB,c);
}
LinExpr
operator +(const LinExpr& e, const IntVar& x) {
if (x.assigned())
return e + x.val();
else
return LinExpr(e,LinExpr::NT_ADD,x);
}
LinExpr
operator -(const IntVar& x, int c) {
if (x.assigned() && Int::Limits::valid(x.val()-static_cast<double>(c)))
return LinExpr(x.val()-static_cast<double>(c));
else
return LinExpr(x,LinExpr::NT_ADD,-c);
}
LinExpr
operator +(const IntVar& x, const LinExpr& e) {
if (x.assigned())
return x.val() + e;
else
return LinExpr(x,LinExpr::NT_ADD,e);
}
LinExpr
operator -(const IntVar& x) {
if (x.assigned())
return LinExpr(-x.val());
else
return LinExpr(x,LinExpr::NT_SUB,0);
}
// Constructor for cloning s
Pandigital(bool share, Pandigital& s) : Script(share,s),
base(s.base) {
x.update(*this, share, s.x);
num1.update(*this, share, s.num1);
num2.update(*this, share, s.num2);
res.update(*this, share, s.res);
}
// Constructor for cloning s
Investments(bool share, Investments& s) : MaximizeScript(share,s) {
x.update(*this, share, s.x);
total_persons.update(*this, share, s.total_persons);
total_budget.update(*this, share, s.total_budget);
total_projects.update(*this, share, s.total_projects);
total_values.update(*this, share, s.total_values);
}
TEST(frontend_Solver, Basic2) {
Solver slv( new Naxos() );
IntVar a(slv, 0, 30);
IntVar b = a + 3;
IntVar c = a*2 + b;
slv.add( a > 10 );
slv.add( b <= 20 );
slv.add( c != 48 );
IntVarArray arr(slv);
arr.push_back(a);
arr.push_back(b);
arr.push_back(c);
slv.addGoal(Labeling(arr));
Int nsolutions = 0;
while( slv.nextSolution() ) {
nsolutions++;
ASSERT_TRUE(a.value() > 10);
ASSERT_TRUE(b.value() <= 20);
ASSERT_TRUE(c.value() != 48);
}
ASSERT_EQ(nsolutions, 6);
}
virtual void print(std::ostream& os) const {
char output[s.val()+1][s.val()+1];
memset(output, 0, sizeof(output));
for (int i = 0; i < N-1; ++i) {
for (int j = 0; j < size(i); ++j) {
for (int k = 0; k < size(i); ++k) {
output[x[i].val()+j][y[i].val()+k] = size(i);
}
}
}
bool one = false;
for (int i = 0; i < s.val(); ++i) {
for (int j = 0; j < s.val(); ++j) {
if (output[i][j] == 0) {
if (!one) {
one = true;
printf(" 1");
} else {
printf(" ");
}
} else {
printf("%2d", output[i][j]);
}
}
printf("\n");
}
}
LinExpr
operator -(const LinExpr& e, const IntVar& x) {
if (x.assigned())
return e - x.val();
else
return LinExpr(e,LinExpr::NT_SUB,x);
}
LinExpr
operator -(const IntVar& x, const LinExpr& e) {
if (x.assigned())
return x.val() - e;
else
return LinExpr(x,LinExpr::NT_SUB,e);
}
int Square::gfb(string name)
{
IntVar *v;
lib=ConnectToSharedMemory();
lib->Load();
v=(IntVar*)lib->Find(name);
return v->getValue();
}
int DoubleDigit::gfbi(string name)
{
IntVar *v;
lib=ConnectToSharedMemory();
//lib->Load();
v=(IntVar*)lib->Find(name);
return v->getValue();
}
void
cumulative(Home home, IntVar c, const IntVarArgs& s, const IntArgs& p,
const IntArgs& u, const BoolVarArgs& m, IntConLevel icl) {
if (c.assigned())
cumulative(home,c.val(),s,p,u,m,icl);
else
cumulative(home,Int::IntView(c),s,p,u,m,icl);
}
void Engine::init() {
signal(SIGINT,SIGINT_handler);
// signal(SIGHUP,SIGINT_handler);
if (so.parallel) master.initMPI();
// Get the vars ready
for (int i = 0; i < vars.size(); i++) {
IntVar *v = vars[i];
if (v->pinfo.size() == 0) v->in_queue = true;
else v->pushInQueue();
}
if (so.lazy) {
for (int i = 0; i < vars.size(); i++) {
if (vars[i]->getMax() - vars[i]->getMin() <= so.eager_limit) {
vars[i]->specialiseToEL();
} else {
std::cerr << "using lazy literal\n";
vars[i]->specialiseToLL();
}
}
} else {
for (int i = 0; i < vars.size(); i++) vars[i]->initVals(true);
}
// Get the propagators ready
process_ircs();
// Get well founded propagators ready
wf_init();
// Get MIP propagator ready
if (so.mip) mip->init();
// Get SAT propagator ready
sat.init();
// Set lits allowed to be in learnt clauses
problem->restrict_learnable();
// Get LDSB ready
if (so.ldsb) ldsb.init();
// Do MIP presolve
if (so.mip) mip->presolve();
// Ready
finished_init = true;
}
void
cumulative(Home home, IntVar c, const TaskTypeArgs& t,
const IntVarArgs& s, const IntArgs& p, const IntArgs& u,
IntConLevel icl) {
if (c.assigned())
cumulative(home,c.val(),t,s,p,u,icl);
else
cumulative(home,Int::IntView(c),t,s,p,u,icl);
}
LinExpr
operator +(const BoolVar& x, const IntVar& y) {
if (x.assigned())
return x.val() + y;
else if (y.assigned())
return x + y.val();
else
return LinExpr(x,LinExpr::NT_ADD,y);
}
LinExpr
operator -(const BoolVar& x, const IntVar& y) {
if (x.assigned())
return x.val() - y;
else if (y.assigned())
return x - y.val();
else
return LinExpr(x,LinExpr::NT_SUB,y);
}
LinExpr
operator *(const IntVar& x, int a) {
if (a == 0)
return LinExpr(0.0);
else if (x.assigned() &&
Int::Limits::valid(static_cast<double>(a)*x.val()))
return LinExpr(static_cast<double>(a)*x.val());
else
return LinExpr(x,a);
}
bool propagate() {
for (int i = 0; i < new_fixed.size(); i++) {
int r = new_fixed[i]/p.m;
int c = new_fixed[i]%p.m;
if (TEST && r != row) {
row = r;
printf("Processing %dth row\n", (int) row);
}
if (r != row) {
printf("r = %d, c = %d\n", r, c);
for (int i = 0; i < p.n; i++) {
for (int j = 0; j < p.m; j++) {
if (p.x[i][j]->isFixed()) printf("%d, ", p.x[i][j]->getVal());
else printf("?, ");
}
printf("\n");
}
printf("\n");
}
assert(r == row);
IntVar *v = p.x[r][c];
for (int j = 0; j < p.m; j++) {
if (!fixed[row][j]) continue;
if (p.x[row][j]->getVal() != v->getVal()) continue;
int s, b;
if (j < c) { s = j; b = c; }
else { s = c; b = j; }
int size1 = (1<<s), size2 = (1<<(b-s-1)), size3 = (1<<(p.m-b-1));
for (int v3 = 0; v3 < size3; v3++) {
for (int v2 = 0; v2 < size2; v2++) {
for (int v1 = 0; v1 < size1; v1++) {
int z = v1 + (1<<s) + (v2<<(s+1)) + (1<<b) + (v3<<(b+1));
counts[z] = counts[z] + 1;
if (counts[z] > limits[row+1][set_sizes[z]]) {
printf("z = %d %x, counts[z] = %d\n", z, z, (int) counts[z]);
printf("row+1 = %d, set_sizes[z] = %d, limit = %d\n", row+1, set_sizes[z], limits[row+1][set_sizes[z]]);
return false;
}
}
}
}
}
fixed[r][c] = 1;
}
bool finished_row = true;
for (int j = 0; j < p.m; j++) {
if (!p.x[row][j]->isFixed()) { finished_row = false; break; }
}
if (finished_row) row = row + 1;
return true;
}
Digit::Digit(string name)
{
Library l;
IntVar *v;
l.Load();
if((v=(IntVar*)l.Find(name))==0)
{
l.Create(name, 69);
l.Save();
v=(IntVar*)l.Find(name);
}
setDigit(v->getValue());
}
int Square::getVarFromBase(string name, int newval)
{
IntVar *v;
lib=MkSM();
lib->Load();
if((v=(IntVar*)lib->Find(name))==0)
{
lib->Create(name, newval);
lib->Save();
v=(IntVar*)lib->Find(name);
}
return (v->getValue());
}
void FlatZincSpace::parseSolveAnn(AST::Array* ann) {
bool hadSearchAnnotation = false;
if (ann) {
std::vector<AST::Node*> flatAnn;
flattenAnnotations(ann, flatAnn);
for (unsigned int i=0; i<flatAnn.size(); i++) {
try {
AST::Call *call = flatAnn[i]->getCall("int_search");
AST::Array *args = call->getArgs(4);
AST::Array *vars = args->a[0]->getArray();
vec<Branching*> va;
for (unsigned int i = 0; i < vars->a.size(); i++) {
if (vars->a[i]->isInt()) continue;
IntVar* v = iv[vars->a[i]->getIntVar()];
if (v->isFixed()) continue;
va.push(v);
}
branch(va, ann2ivarsel(args->a[1]), ann2ivalsel(args->a[2]));
if (AST::String* s = dynamic_cast<AST::String*>(args->a[3])) {
if (s->s == "all") so.nof_solutions = 0;
}
hadSearchAnnotation = true;
} catch (AST::TypeError& e) {
(void) e;
try {
AST::Call *call = flatAnn[i]->getCall("bool_search");
AST::Array *args = call->getArgs(4);
AST::Array *vars = args->a[0]->getArray();
vec<Branching*> va(vars->a.size());
for (int i=vars->a.size(); i--; )
va[i] = new BoolView(bv[vars->a[i]->getBoolVar()]);
branch(va, ann2ivarsel(args->a[1]), ann2ivalsel(args->a[2]));
if (AST::String* s = dynamic_cast<AST::String*>(args->a[3])) {
if (s->s == "all") so.nof_solutions = 0;
}
hadSearchAnnotation = true;
} catch (AST::TypeError& e) {
(void) e;
fprintf(stderr, "% Type error in search annotation. Ignoring!\n");
}
}
}
}
if (!hadSearchAnnotation) {
fprintf(stderr, "% No search annotation given. Defaulting to VSIDS!\n");
if (!so.vsids) {
so.vsids = true;
engine.branching->add(&sat);
}
}
}
void print() {
for (int i = 0; i < n_names; i++) {
printf("%d, ", x[i]->getVal());
}
printf("\n");
printf("SAT = %d\n", sat->getVal());
}
/// Constructor for cloning
QueenArmies(bool share, QueenArmies& s)
: MaximizeScript(share,s), n(s.n) {
U.update(*this, share, s.U);
W.update(*this, share, s.W);
w.update(*this, share, s.w);
b.update(*this, share, s.b);
q.update(*this, share, s.q);
}
void print() {
for (int i = 0; i < n; i++) {
int m = e[i]->getVal();
printf("e_%d = %d, ", i, m);
}
printf("\n");
printf("Stacks = %d\n\n", stacks->getVal());
}
void SAT::convertToClause(SClause& sc) {
out_learnt.clear();
int *pt = sc.data;
for (int i = 0; i < sc.size; i++) {
if (0x8000000 & *pt) {
int index = 0x7ffffff & *pt;
int var_index = (0x7ffffff & *pt) >> 2;
assert(index >= 0);
assert(var_index < engine.vars.size() && "Index is too high!");
int constraint_type = *pt & 0x3;
IntVar *v = engine.vars[var_index];
assert(v->getType() == INT_VAR_LL);
int value = pt[1];
Lit p = ((IntVarLL*) v)->getLit((constraint_type == 2 ? (value + 1) : value), constraint_type);
out_learnt.push(p);
pt += 2;
} else {
void PropagatorFactory::add(const IntVarRange& obj) {
notifyMonitorsOfAdding(obj);
if (getEngine().modes().usegecode) {
addCP(obj);
} else {
if (intvars.find(obj.varID) != intvars.cend()) {
stringstream ss;
ss << "Integer variable " << toString(obj.varID, getEngine()) << " was declared twice.\n";
throw idpexception(ss.str());
}
IntVar* intvar = NULL;
if (not isNegInfinity(obj.minvalue) && not isPosInfinity(obj.maxvalue) && abs(obj.maxvalue - obj.minvalue) < 100) {
intvar = new RangeIntVar(obj.getID(), getEnginep(), obj.varID, obj.minvalue, obj.maxvalue, obj.partial?obj.possiblynondenoting:getEngine().getFalseLit());
} else {
intvar = new LazyIntVar(obj.getID(), getEnginep(), obj.varID, obj.minvalue, obj.maxvalue, obj.partial?obj.possiblynondenoting:getEngine().getFalseLit()); // TODO also for enum variables
}
intvars.insert({ obj.varID, new IntView(intvar, intvar->getVarID(), Weight(0)) });
intvar->finish();
}
}
void print() {
#if 1
for(int act = 0; act < acts; act++)
{
printf("[");
for(int ss = 0; ss < shifts; ss++)
{
printf("%d",demand[ss][act]);
}
printf("]\n");
}
#endif
printf("Hours worked: %f\n",1.0*cost->getVal()/4);
for(int ww = 0; ww < xv.size(); ww++)
{
printf("[");
for (int ii = 0; ii < shifts; ii++ )
{
// if(ii)
// printf(", ");
int val(xv[ww][ii]->getVal());
if(val < acts)
{
printf("%d",val);
} else {
switch(val - acts)
{
#ifdef DISTINCT_REST
case G_R:
printf("R");
break;
case G_B:
printf("B");
break;
case G_L:
printf("L");
break;
#else
case G_R:
printf("R");
break;
default:
assert(0);
break;
#endif
}
}
}
printf("]\n");
}
}
TEST(frontend_Solver, Basic) {
Solver slv( new Naxos() );
IntVar a(slv, 0, 10);
IntVar b = a - 3;
IntVar c = a + 3;
IntVarArray arr(slv);
arr.push_back(a);
arr.push_back(b);
arr.push_back(c);
IntVarArray::iterator iter = arr.begin();
ASSERT_TRUE( (*iter).equals(a) );
++iter;
ASSERT_TRUE( (*iter).equals(b) );
++iter;
ASSERT_TRUE( (*iter).equals(c) );
++iter;
ASSERT_THROW(*iter, FeatherException);
ASSERT_TRUE( arr[0].equals(a) );
ASSERT_TRUE( arr[1].equals(b) );
ASSERT_TRUE( arr[2].equals(c) );
ASSERT_EQ( arr.size(), 3);
ASSERT_FALSE( arr.empty() );
slv.addGoal(Labeling(arr));
Int nsolutions = 0;
while( slv.nextSolution() ) {
nsolutions++;
std::cout << "solution" << std::endl;
std::cout << a.value() << std::endl;
std::cout << b.value() << std::endl;
std::cout << c.value() << std::endl;
}
}
