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; } }