Something went wrong. Try again.
This repository has no description
Something went wrong. Try again.
97 kB · 2162 lines
C++
at develop
123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163/* * Main authors: * Kevin Leo <kevin.leo@monash.edu> * Andrea Rendl <andrea.rendl@nicta.com.au> * Guido Tack <guido.tack@monash.edu> */
/* This Source Code Form is subject to the terms of the Mozilla Public * License, v. 2.0. If a copy of the MPL was not distributed with this * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
#include <minizinc/eval_par.hh>#include <minizinc/solvers/gecode/fzn_space.hh>#include <minizinc/solvers/gecode/gecode_constraints.hh>#include <minizinc/solvers/gecode_solverinstance.hh>
using namespace Gecode;
namespace MiniZinc {namespace GecodeConstraints {
void p_mk_intvar(SolverInstanceBase& s, const Variable* var, bool isOutput) { GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); assert(var->timestamp() != -1); if (var->isBounded()) { if (var->lb() >= 0 && var->ub() <= 1) { BoolVar boolVar(*gi._current_space, var->lb().toInt(), var->ub().toInt()); gi._current_space->bv.push_back(boolVar); gi.insertVar(var, GecodeVariable(GecodeVariable::BOOL_TYPE, gi._current_space->bv.size() - 1)); gi._current_space->bv_introduced.push_back(!isOutput); gi._current_space->bv_defined.push_back(!var->definitions().empty()); } else { IntVar intVar(*gi._current_space, gi.arg2intset(Val(var->domain()))); gi._current_space->iv.push_back(intVar); gi.insertVar(var, GecodeVariable(GecodeVariable::INT_TYPE, gi._current_space->iv.size() - 1)); gi._current_space->iv_introduced.push_back(!isOutput); gi._current_space->iv_defined.push_back(!var->definitions().empty()); } } else { IntVar intVar(*gi._current_space, var->lb().isFinite() ? var->lb().toInt() : Gecode::Int::Limits::min, var->ub().isFinite() ? var->ub().toInt() : Gecode::Int::Limits::max); gi._current_space->iv.push_back(intVar); gi.insertVar(var, GecodeVariable(GecodeVariable::INT_TYPE, gi._current_space->iv.size() - 1)); std::cerr << "% GecodeSolverInstance::processFlatZinc: Warning: Unbounded variable " << var->timestamp() << " given maximum integer bounds, this may be incorrect: " << std::endl; gi._current_space->iv_introduced.push_back(!isOutput); gi._current_space->iv_defined.push_back(!var->definitions().empty()); }}
void p_distinct(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs va = gi.arg2intvarargs(call->arg(0)); MZ_IntConLevel icl = gi.ann2icl(call->ann()); unshare(*gi._current_space, va); distinct(*gi._current_space, va, icl == MZ_ICL_DEF ? MZ_ICL_DOM : icl);}
void p_distinctOffset(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs va = gi.arg2intvarargs(call->arg(1)); unshare(*gi._current_space, va); IntArgs oa = gi.arg2intargs(call->arg(0)); MZ_IntConLevel icl = gi.ann2icl(call->ann()); distinct(*gi._current_space, oa, va, icl == MZ_ICL_DEF ? MZ_ICL_DOM : icl);}
void p_all_equal(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs va = gi.arg2intvarargs(call->arg(0)); rel(*gi._current_space, va, IRT_EQ, gi.ann2icl(call->ann()));}
void p_int_CMP(GecodeSolverInstance& s, IntRelType irt, const Constraint* ce) { const Val& ann = ce->ann(); const Val& lhs = ce->arg(0); const Val& rhs = ce->arg(1); if (lhs.isVar()) { if (rhs.isVar()) { rel(*s._current_space, s.arg2intvar(lhs), irt, s.arg2intvar(rhs), s.ann2icl(ann)); } else { rel(*s._current_space, s.arg2intvar(lhs), irt, rhs.toInt(), s.ann2icl(ann)); } } else { rel(*s._current_space, s.arg2intvar(rhs), swap(irt), lhs.toInt(), s.ann2icl(ann)); }}
void p_int_eq(SolverInstanceBase& s, const Constraint* call) { BytecodeProc::Mode m = static_cast<BytecodeProc::Mode>(call->mode()); switch (m) { case BytecodeProc::ROOT: p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_EQ, call); break; case BytecodeProc::ROOT_NEG: p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_NQ, call); break; case BytecodeProc::FUN: p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_EQV, call); break; case BytecodeProc::FUN_NEG: p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_EQV, call); break; case BytecodeProc::IMP: p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_IMP, call); break; case BytecodeProc::IMP_NEG: p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_IMP, call); break; default: assert(false); break; }}void p_int_ne(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_NQ, call);}void p_int_ge(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GQ, call);}void p_int_gt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GR, call);}void p_int_le(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LQ, call);}void p_int_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LE, call);}void p_int_CMP_reif(GecodeSolverInstance& s, IntRelType irt, ReifyMode rm, const Constraint* call) { const Val& ann = call->ann(); if (call->arg(0).isVar()) { if (call->arg(1).isVar()) { rel(*s._current_space, s.arg2intvar(call->arg(0)), irt, s.arg2intvar(call->arg(1)), Reify(s.arg2boolvar(call->arg(0)), rm), s.ann2icl(ann)); } else { rel(*s._current_space, s.arg2intvar(call->arg(0)), irt, call->arg(1).toInt(), Reify(s.arg2boolvar(call->arg(0)), rm), s.ann2icl(ann)); } } else { rel(*s._current_space, s.arg2intvar(call->arg(1)), swap(irt), call->arg(0).toInt(), Reify(s.arg2boolvar(call->arg(0)), rm), s.ann2icl(ann)); }}
///* Comparisons */void p_int_eq_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_EQV, call);}void p_int_ne_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_EQV, call);}void p_int_ge_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_EQV, call);}void p_int_gt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_EQV, call);}void p_int_le_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_EQV, call);}void p_int_lt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_EQV, call);}
void p_int_eq_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_IMP, call);}void p_int_ne_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_IMP, call);}void p_int_ge_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_IMP, call);}void p_int_gt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_IMP, call);}void p_int_le_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_IMP, call);}void p_int_lt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_IMP, call);}
// TODO: int_sum shouldn't occur// These should be int_lin_eq, but binding domains are not yet aggregated.// This is a temporary solution in the meantime.void p_int_sum(SolverInstanceBase& _s, const Constraint* call) { GecodeSolverInstance& s = static_cast<GecodeSolverInstance&>(_s); const Val& ann = call->ann(); const Val& vars = call->arg(0); const Val& res = Val::follow_alias(call->arg(1)); IntArgs ia(vars.size() + 1); for (int i = 0; i < vars.size(); i++) { ia[i] = 1; } ia[vars.size()] = -1; int singleIntVar; bool isBool = s.isBoolArray(vars, singleIntVar); if (res.lb().toInt() < 0 || res.ub().toInt() > 1) { if (singleIntVar == -1) { singleIntVar = vars.size(); } else { isBool = false; } }
if (isBool) { if (singleIntVar != -1) { if (std::abs(ia[singleIntVar]) == 1) { IntVar siv = s.arg2intvar(singleIntVar < vars.size() ? vars[singleIntVar] : res); BoolVarArgs iv = s.arg2boolvarargs(vars, 0, singleIntVar); IntArgs ia_tmp(ia.size() - 1); int count = 0; for (int i = 0; i < ia.size(); i++) { if (i != singleIntVar) ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i]; } IntRelType t = (ia[singleIntVar] == -1 ? IRT_EQ : swap(IRT_EQ)); if (singleIntVar == vars.size()) { linear(*s._current_space, ia_tmp, iv, t, siv, s.ann2icl(ann)); } else { BoolVarArgs iv_new(vars.size()); for (int i = 0; i < vars.size(); i++) { iv_new[i] = iv[i]; } iv_new[vars.size() - 1] = s.arg2boolvar(res); } } else { IntVarArgs iv = s.arg2intvarargs(vars); IntVarArgs iv_new(vars.size() + 1); for (int i = 0; i < vars.size(); i++) { iv_new[i] = iv[i]; } iv_new[vars.size()] = s.arg2intvar(res); linear(*s._current_space, ia, iv_new, IRT_EQ, 0, s.ann2icl(ann)); } } else { BoolVarArgs iv = s.arg2boolvarargs(vars); BoolVarArgs iv_new(vars.size() + 1); for (int i = 0; i < vars.size(); i++) { iv_new[i] = iv[i]; } iv_new[vars.size()] = s.arg2boolvar(res); linear(*s._current_space, ia, iv_new, IRT_EQ, 0, s.ann2icl(ann)); } } else { IntVarArgs iv = s.arg2intvarargs(vars); IntVarArgs iv_new(vars.size() + 1); for (int i = 0; i < vars.size(); i++) { iv_new[i] = iv[i]; } iv_new[vars.size()] = s.arg2intvar(res); linear(*s._current_space, ia, iv_new, IRT_EQ, 0, s.ann2icl(ann)); }}
void p_int_lin_CMP(GecodeSolverInstance& s, IntRelType irt, const Constraint* call) { const Val& ann = call->ann(); IntArgs ia = s.arg2intargs(call->arg(0)); const Val& vars = call->arg(1); int singleIntVar; if (s.isBoolArray(vars, singleIntVar)) { if (singleIntVar != -1) { if (std::abs(ia[singleIntVar]) == 1 && call->arg(2).toInt() == 0) { IntVar siv = s.arg2intvar(vars[singleIntVar]); BoolVarArgs iv = s.arg2boolvarargs(vars, 0, singleIntVar); IntArgs ia_tmp(ia.size() - 1); int count = 0; for (int i = 0; i < ia.size(); i++) { if (i != singleIntVar) ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i]; } IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt)); linear(*s._current_space, ia_tmp, iv, t, siv, s.ann2icl(ann)); } else { IntVarArgs iv = s.arg2intvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), s.ann2icl(ann)); } } else { BoolVarArgs iv = s.arg2boolvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), s.ann2icl(ann)); } } else { IntVarArgs iv = s.arg2intvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), s.ann2icl(ann)); }}void p_int_lin_CMP_reif(GecodeSolverInstance& s, IntRelType irt, ReifyMode rm, const Constraint* call) { const Val& ann = call->ann(); IntArgs ia = s.arg2intargs(call->arg(0)); const Val& vars = call->arg(1); int singleIntVar; auto var = s.arg2boolvar(call->arg(3)); if (s.isBoolArray(vars, singleIntVar)) { if (singleIntVar != -1) { if (std::abs(ia[singleIntVar]) == 1 && call->arg(2).toInt() == 0) { IntVar siv = s.arg2intvar(vars[singleIntVar]); BoolVarArgs iv = s.arg2boolvarargs(vars, 0, singleIntVar); IntArgs ia_tmp(ia.size() - 1); int count = 0; for (int i = 0; i < ia.size(); i++) { if (i != singleIntVar) ia_tmp[count++] = ia[singleIntVar] == -1 ? ia[i] : -ia[i]; } IntRelType t = (ia[singleIntVar] == -1 ? irt : swap(irt)); linear(*s._current_space, ia_tmp, iv, t, siv, Reify(var, rm), s.ann2icl(ann)); } else { IntVarArgs iv = s.arg2intvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), Reify(var, rm), s.ann2icl(ann)); } } else { BoolVarArgs iv = s.arg2boolvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), Reify(var, rm), s.ann2icl(ann)); } } else { IntVarArgs iv = s.arg2intvarargs(vars); linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), Reify(var, rm), s.ann2icl(ann)); }}
void p_int_lin_eq(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_EQ, call);}void p_int_lin_eq_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_EQV, call);}void p_int_lin_eq_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_IMP, call);}void p_int_lin_le(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LQ, call);}void p_int_lin_le_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_EQV, call);}void p_int_lin_le_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_IMP, call);}void p_int_lin_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LE, call);}void p_int_lin_lt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_EQV, call);}void p_int_lin_lt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_IMP, call);}void p_int_lin_ge(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GQ, call);}void p_int_lin_ge_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_EQV, call);}void p_int_lin_ge_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_IMP, call);}void p_int_lin_gt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GR, call);}void p_int_lin_gt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_EQV, call);}void p_int_lin_gt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_int_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_IMP, call);}
void p_bool_lin_CMP(GecodeSolverInstance& s, IntRelType irt, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); IntArgs ia = s.arg2intargs(call->arg(0)); BoolVarArgs iv = s.arg2boolvarargs(call->arg(1)); if (call->arg(2).isVar()) linear(*s._current_space, ia, iv, irt, s.resolveVar(call->arg(2).toVar()).intVar(s._current_space), s.ann2icl(ann)); else linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), s.ann2icl(ann));}void p_bool_lin_CMP_reif(GecodeSolverInstance& s, IntRelType irt, ReifyMode rm, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); if (rm == RM_EQV && call->arg(2).isInt()) { if (call->arg(2).toInt()) { p_bool_lin_CMP(s, irt, call); } else { p_bool_lin_CMP(s, neg(irt), call); } return; } IntArgs ia = s.arg2intargs(call->arg(0)); BoolVarArgs iv = s.arg2boolvarargs(call->arg(1)); if (call->arg(2).isVar()) linear(*s._current_space, ia, iv, irt, s.resolveVar(call->arg(2).toVar()).intVar(s._current_space), Reify(s.arg2boolvar(call->arg(3)), rm), s.ann2icl(ann)); else linear(*s._current_space, ia, iv, irt, call->arg(2).toInt(), Reify(s.arg2boolvar(call->arg(3)), rm), s.ann2icl(ann));}void p_bool_lin_eq(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_EQ, call);}void p_bool_lin_eq_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_EQV, call);}void p_bool_lin_eq_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_IMP, call);}void p_bool_lin_ne(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_NQ, call);}void p_bool_lin_ne_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_EQV, call);}void p_bool_lin_ne_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_IMP, call);}void p_bool_lin_le(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LQ, call);}void p_bool_lin_le_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_EQV, call);}void p_bool_lin_le_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_IMP, call);}void p_bool_lin_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LE, call);}void p_bool_lin_lt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_EQV, call);}void p_bool_lin_lt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_IMP, call);}void p_bool_lin_ge(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GQ, call);}void p_bool_lin_ge_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_EQV, call);}void p_bool_lin_ge_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_IMP, call);}void p_bool_lin_gt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GR, call);}void p_bool_lin_gt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_EQV, call);}void p_bool_lin_gt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_lin_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_IMP, call);}
///* arithmetic constraints */
void p_int_times(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); IntVar x2 = gi.arg2intvar(call->arg(2)); mult(*gi._current_space, x0, x1, x2, gi.ann2icl(call->ann()));}void p_int_div(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); IntVar x2 = gi.arg2intvar(call->arg(2)); div(*gi._current_space, x0, x1, x2, gi.ann2icl(call->ann()));}void p_int_mod(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); IntVar x2 = gi.arg2intvar(call->arg(2)); mod(*gi._current_space, x0, x1, x2, gi.ann2icl(call->ann()));}
void p_int_min(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); IntVar x2 = gi.arg2intvar(call->arg(2)); min(*gi._current_space, x0, x1, x2, gi.ann2icl(call->ann()));}void p_int_max(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); IntVar x2 = gi.arg2intvar(call->arg(2)); max(*gi._current_space, x0, x1, x2, gi.ann2icl(call->ann()));}void p_int_negate(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); rel(*gi._current_space, x0 == -x1, gi.ann2icl(call->ann()));}
///* Boolean constraints */void p_bool_CMP(GecodeSolverInstance& s, IntRelType irt, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); rel(*s._current_space, s.arg2boolvar(call->arg(0)), irt, s.arg2boolvar(call->arg(1)), s.ann2icl(ann));}void p_bool_CMP_reif(GecodeSolverInstance& s, IntRelType irt, ReifyMode rm, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); rel(*s._current_space, s.arg2boolvar(call->arg(0)), irt, s.arg2boolvar(call->arg(1)), Reify(s.arg2boolvar(call->arg(2)), rm), s.ann2icl(ann));}void p_bool_eq(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_EQ, call);}void p_bool_eq_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_EQV, call);}void p_bool_eq_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_EQ, RM_IMP, call);}void p_bool_ne(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_NQ, call);}void p_bool_ne_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_EQV, call);}void p_bool_ne_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_NQ, RM_IMP, call);}void p_bool_ge(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GQ, call);}void p_bool_ge_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_EQV, call);}void p_bool_ge_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GQ, RM_IMP, call);}void p_bool_le(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LQ, call);}void p_bool_le_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_EQV, call);}void p_bool_le_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LQ, RM_IMP, call);}void p_bool_gt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_GR, call);}void p_bool_gt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_EQV, call);}void p_bool_gt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_GR, RM_IMP, call);}void p_bool_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP(static_cast<GecodeSolverInstance&>(s), IRT_LE, call);}void p_bool_lt_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_EQV, call);}void p_bool_lt_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); p_bool_CMP_reif(static_cast<GecodeSolverInstance&>(s), IRT_LE, RM_IMP, call);}
#define BOOL_OP(op) \ BoolVar b0 = gi.arg2boolvar(call->arg(0)); \ BoolVar b1 = gi.arg2boolvar(call->arg(1)); \ if (!call->arg(2).isVar() && call->arg(2).isInt()) { \ rel(*gi._current_space, b0, op, b1, call->arg(2).toInt(), gi.ann2icl(ann)); \ } else { \ rel(*gi._current_space, b0, op, b1, \ gi.resolveVar(call->arg(2).toVar()).boolVar(gi._current_space), gi.ann2icl(ann)); \ }
#define BOOL_ARRAY_OP(op) \ BoolVarArgs bv = gi.arg2boolvarargs(call->arg(0)); \ if (call->size() == 1) { \ rel(*gi._current_space, op, bv, 1, gi.ann2icl(ann)); \ } else { \ rel(*gi._current_space, op, bv, gi.arg2boolvar(call->arg(1)), gi.ann2icl(ann)); \ }
void p_bool_or(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_OP(BoolOpType::BOT_OR);}void p_bool_or_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVar b0 = gi.arg2boolvar(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); BoolVar b2 = gi.arg2boolvar(call->arg(2)); clause(*gi._current_space, BoolOpType::BOT_OR, BoolVarArgs() << b0 << b1, BoolVarArgs() << b2, 1, gi.ann2icl(ann));}void p_bool_and(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_OP(BoolOpType::BOT_AND);}void p_bool_and_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVar b0 = gi.arg2boolvar(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); BoolVar b2 = gi.arg2boolvar(call->arg(2)); rel(*gi._current_space, b2, BoolOpType::BOT_IMP, b0, 1, gi.ann2icl(ann)); rel(*gi._current_space, b2, BoolOpType::BOT_IMP, b1, 1, gi.ann2icl(ann));}void p_array_bool_and(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_ARRAY_OP(Gecode::BoolOpType::BOT_AND);}void p_forall(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT || static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::FUN); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_ARRAY_OP(Gecode::BoolOpType::BOT_AND);}void p_array_bool_and_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bv = gi.arg2boolvarargs(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); for (unsigned int i = bv.size(); i--;) rel(*gi._current_space, b1, Gecode::BoolOpType::BOT_IMP, bv[i], 1, gi.ann2icl(ann));}void p_array_bool_or(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_ARRAY_OP(BoolOpType::BOT_OR);}// void p_exists(SolverInstanceBase& s, const Constraint* call) {// assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::FUN);// const Val& ann =call->ann();// GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s);// BoolVarArgs bvp = gi.arg2boolvarargs(call->arg(0));// BoolVarArgs bvn;// auto var = gi.reifyVar(call);// bvn << var;// clause(*gi._current_space, BoolOpType::BOT_OR, bvp, bvn, 1, gi.ann2icl(ann));// }void p_array_bool_or_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bv = gi.arg2boolvarargs(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); clause(*gi._current_space, BoolOpType::BOT_OR, bv, BoolVarArgs() << b1, 1, gi.ann2icl(ann));}void p_array_bool_xor(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_ARRAY_OP(BoolOpType::BOT_XOR);}void p_array_bool_xor_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bv = gi.arg2boolvarargs(call->arg(0)); BoolVar tmp(*gi._current_space, 0, 1); rel(*gi._current_space, BoolOpType::BOT_XOR, bv, tmp, gi.ann2icl(ann)); rel(*gi._current_space, gi.arg2boolvar(call->arg(1)), BoolOpType::BOT_IMP, tmp, 1);}void p_array_bool_clause(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bvp = gi.arg2boolvarargs(call->arg(0)); BoolVarArgs bvn = gi.arg2boolvarargs(call->arg(1)); clause(*gi._current_space, BoolOpType::BOT_OR, bvp, bvn, 1, gi.ann2icl(ann));}void p_array_bool_clause_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bvp = gi.arg2boolvarargs(call->arg(0)); BoolVarArgs bvn = gi.arg2boolvarargs(call->arg(1)); BoolVar b0 = gi.arg2boolvar(call->arg(2)); clause(*gi._current_space, BoolOpType::BOT_OR, bvp, bvn, b0, gi.ann2icl(ann));}void p_array_bool_clause_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bvp = gi.arg2boolvarargs(call->arg(0)); BoolVarArgs bvn = gi.arg2boolvarargs(call->arg(1)); BoolVar b0 = gi.arg2boolvar(call->arg(2)); clause(*gi._current_space, BoolOpType::BOT_OR, bvp, bvn, b0, gi.ann2icl(ann));}void p_bool_xor(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_OP(BoolOpType::BOT_XOR);}void p_bool_xor_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVar b0 = gi.arg2boolvar(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); BoolVar b2 = gi.arg2boolvar(call->arg(2)); clause(*gi._current_space, BoolOpType::BOT_OR, BoolVarArgs() << b0 << b1, BoolVarArgs() << b2, 1, gi.ann2icl(ann)); clause(*gi._current_space, BoolOpType::BOT_OR, BoolVarArgs(), BoolVarArgs() << b0 << b1 << b2, 1, gi.ann2icl(ann));}void p_bool_l_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVar b0 = gi.arg2boolvar(call->arg(0)); BoolVar b1 = gi.arg2boolvar(call->arg(1)); if (call->arg(2).isInt()) { rel(*gi._current_space, b1, BoolOpType::BOT_IMP, b0, call->arg(2).toInt(), gi.ann2icl(ann)); } else { rel(*gi._current_space, b1, BoolOpType::BOT_IMP, b0, gi.resolveVar(call->arg(2).toVar()).boolVar(gi._current_space), gi.ann2icl(ann)); }}void p_bool_r_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BOOL_OP(BoolOpType::BOT_IMP);}// void p_bool_not(SolverInstanceBase& s, const Constraint* call) {// assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::FUN);// const Val& ann =call->ann();// GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s);// BoolVar x0 = gi.arg2boolvar(call->arg(0));// auto x1 = gi.reifyVar(call);// rel(*gi._current_space, x0, BoolOpType::BOT_XOR, x1, 1, gi.ann2icl(ann));// }
///* element constraints */void p_array_int_element(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar selector = gi.arg2intvar(call->arg(0)); rel(*gi._current_space, selector > 0); if (call->arg(1).containsVar()) { IntVarArgs iv = gi.arg2intvarargs(call->arg(1), 1); element(*gi._current_space, iv, selector, gi.arg2intvar(call->arg(2)), gi.ann2icl(ann)); } else { IntArgs ia = gi.arg2intargs(call->arg(1), 1); element(*gi._current_space, ia, selector, gi.arg2intvar(call->arg(2)), gi.ann2icl(ann)); }}void p_array_bool_element(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar selector = gi.arg2intvar(call->arg(0)); rel(*gi._current_space, selector > 0); if (call->arg(1).isVar()) { BoolVarArgs iv = gi.arg2boolvarargs(call->arg(1), 1); element(*gi._current_space, iv, selector, gi.arg2boolvar(call->arg(2)), gi.ann2icl(ann)); } else { IntArgs ia = gi.arg2boolargs(call->arg(1), 1); element(*gi._current_space, ia, selector, gi.arg2boolvar(call->arg(2)), gi.ann2icl(ann)); }}
///* coercion constraints */void p_bool2int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVar x0 = gi.arg2boolvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); if (call->arg(0).isVar() && call->arg(1).isVar()) { int index = gi.resolveVar(call->arg(0).toVar()).index(); gi.resolveVar(call->arg(1).toVar()).setBoolAliasIndex(index); } channel(*gi._current_space, x0, x1, gi.ann2icl(ann));}
void p_int_in(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntSet d = gi.arg2intset(call->arg(1)); if (call->arg(0).isVar()) { Gecode::IntSetRanges dr(d); Iter::Ranges::Singleton sr(0, 1); Iter::Ranges::Inter<Gecode::IntSetRanges, Iter::Ranges::Singleton> i(dr, sr); IntSet d01(i); if (d01.size() == 0) { gi._current_space->fail(); } else { rel(*gi._current_space, gi.arg2boolvar(call->arg(0)), IRT_GQ, d01.min()); rel(*gi._current_space, gi.arg2boolvar(call->arg(0)), IRT_LQ, d01.max()); } } else { dom(*gi._current_space, gi.arg2intvar(call->arg(0)), d); }}void p_int_in_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntSet d = gi.arg2intset(call->arg(1)); if (call->arg(0).isVar()) { Gecode::IntSetRanges dr(d); Iter::Ranges::Singleton sr(0, 1); Iter::Ranges::Inter<Gecode::IntSetRanges, Iter::Ranges::Singleton> i(dr, sr); IntSet d01(i); if (d01.size() == 0) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) == 0); } else if (d01.max() == 0) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) == !gi.arg2boolvar(call->arg(0))); } else if (d01.min() == 1) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) == gi.arg2boolvar(call->arg(0))); } else { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) == 1); } } else { dom(*gi._current_space, gi.arg2intvar(call->arg(0)), d, gi.arg2boolvar(call->arg(2))); }}void p_int_in_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntSet d = gi.arg2intset(call->arg(1)); if (call->arg(0).isVar()) { Gecode::IntSetRanges dr(d); Iter::Ranges::Singleton sr(0, 1); Iter::Ranges::Inter<Gecode::IntSetRanges, Iter::Ranges::Singleton> i(dr, sr); IntSet d01(i); if (d01.size() == 0) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) == 0); } else if (d01.max() == 0) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) >> !gi.arg2boolvar(call->arg(0))); } else if (d01.min() == 1) { rel(*gi._current_space, gi.arg2boolvar(call->arg(2)) >> gi.arg2boolvar(call->arg(0))); } } else { dom(*gi._current_space, gi.arg2intvar(call->arg(0)), d, Reify(gi.arg2boolvar(call->arg(2)), RM_IMP)); }}
///* constraints from the standard library */
void p_abs(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(call->arg(0)); IntVar x1 = gi.arg2intvar(call->arg(1)); abs(*gi._current_space, x0, x1, gi.ann2icl(ann));}
void p_array_int_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv0 = gi.arg2intvarargs(call->arg(0)); IntVarArgs iv1 = gi.arg2intvarargs(call->arg(1)); rel(*gi._current_space, iv0, IRT_LE, iv1, gi.ann2icl(ann));}
void p_array_int_lq(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv0 = gi.arg2intvarargs(call->arg(0)); IntVarArgs iv1 = gi.arg2intvarargs(call->arg(1)); rel(*gi._current_space, iv0, IRT_LQ, iv1, gi.ann2icl(ann));}
void p_array_bool_lt(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bv0 = gi.arg2boolvarargs(call->arg(0)); BoolVarArgs bv1 = gi.arg2boolvarargs(call->arg(1)); rel(*gi._current_space, bv0, IRT_LE, bv1, gi.ann2icl(ann));}
void p_array_bool_lq(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs bv0 = gi.arg2boolvarargs(call->arg(0)); BoolVarArgs bv1 = gi.arg2boolvarargs(call->arg(1)); rel(*gi._current_space, bv0, IRT_LQ, bv1, gi.ann2icl(ann));}
void p_count(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); if (!call->arg(1).isVar()) { if (!call->arg(2).isVar()) { count(*gi._current_space, iv, call->arg(1).toInt(), IRT_EQ, call->arg(2).toInt(), gi.ann2icl(ann)); } else { count(*gi._current_space, iv, call->arg(1).toInt(), IRT_EQ, gi.arg2intvar(call->arg(2)), gi.ann2icl(ann)); } } else if (!call->arg(2).isVar()) { count(*gi._current_space, iv, gi.arg2intvar(call->arg(1)), IRT_EQ, call->arg(2).toInt(), gi.ann2icl(ann)); } else { count(*gi._current_space, iv, gi.arg2intvar(call->arg(1)), IRT_EQ, gi.arg2intvar(call->arg(2)), gi.ann2icl(ann)); }}
void p_count_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); IntVar x = gi.arg2intvar(call->arg(1)); IntVar y = gi.arg2intvar(call->arg(2)); BoolVar b = gi.arg2boolvar(call->arg(3)); IntVar c(*gi._current_space, 0, Int::Limits::max); count(*gi._current_space, iv, x, IRT_EQ, c, gi.ann2icl(ann)); rel(*gi._current_space, b == (c == y));}void p_count_imp(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); IntVar x = gi.arg2intvar(call->arg(1)); IntVar y = gi.arg2intvar(call->arg(2)); BoolVar b = gi.arg2boolvar(call->arg(3)); IntVar c(*gi._current_space, 0, Int::Limits::max); count(*gi._current_space, iv, x, IRT_EQ, c, gi.ann2icl(ann)); rel(*gi._current_space, b >> (c == y));}
void count_rel(IntRelType irt, SolverInstanceBase& s, const Constraint* call) { const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(1)); count(*gi._current_space, iv, call->arg(2).toInt(), irt, call->arg(0).toInt(), gi.ann2icl(ann));}
void p_at_most(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); count_rel(IRT_LQ, s, call);}
void p_at_least(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); count_rel(IRT_GQ, s, call);}
void p_bin_packing_load(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); int minIdx = call->arg(3).toInt(); IntVarArgs load = gi.arg2intvarargs(call->arg(0)); IntVarArgs l; IntVarArgs bin = gi.arg2intvarargs(call->arg(1)); for (int i = bin.size(); i--;) rel(*gi._current_space, bin[i] >= minIdx); if (minIdx > 0) { for (int i = minIdx; i--;) l << IntVar(*gi._current_space, 0, 0); } else if (minIdx < 0) { IntVarArgs bin2(bin.size()); for (int i = bin.size(); i--;) bin2[i] = expr(*gi._current_space, bin[i] - minIdx, gi.ann2icl(ann)); bin = bin2; } l << load; IntArgs sizes = gi.arg2intargs(call->arg(2));
IntVarArgs allvars = l + bin; unshare(*gi._current_space, allvars); binpacking(*gi._current_space, allvars.slice(0, 1, l.size()), allvars.slice(l.size(), 1, bin.size()), sizes, gi.ann2icl(ann));}
void p_global_cardinality(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv0 = gi.arg2intvarargs(call->arg(0)); IntArgs cover = gi.arg2intargs(call->arg(1)); IntVarArgs iv1 = gi.arg2intvarargs(call->arg(2));
Region re; IntSet cover_s(cover); Gecode::IntSetRanges cover_r(cover_s); Gecode::IntVarRanges* iv0_ri = re.alloc<Gecode::IntVarRanges>(iv0.size()); for (int i = iv0.size(); i--;) iv0_ri[i] = Gecode::IntVarRanges(iv0[i]); Iter::Ranges::NaryUnion iv0_r(re, iv0_ri, iv0.size()); Iter::Ranges::Diff<Iter::Ranges::NaryUnion, Gecode::IntSetRanges> extra_r(iv0_r, cover_r); Iter::Ranges::ToValues<Iter::Ranges::Diff<Iter::Ranges::NaryUnion, Gecode::IntSetRanges> > extra( extra_r); for (; extra(); ++extra) { cover << extra.val(); iv1 << IntVar(*gi._current_space, 0, iv0.size()); }
MZ_IntConLevel icl = gi.ann2icl(ann); if (icl == MZ_ICL_DOM) { IntVarArgs allvars = iv0 + iv1; unshare(*gi._current_space, allvars); count(*gi._current_space, allvars.slice(0, 1, iv0.size()), allvars.slice(iv0.size(), 1, iv1.size()), cover, gi.ann2icl(ann)); } else { unshare(*gi._current_space, iv0); count(*gi._current_space, iv0, iv1, cover, gi.ann2icl(ann)); }}
void p_global_cardinality_closed(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv0 = gi.arg2intvarargs(call->arg(0)); IntArgs cover = gi.arg2intargs(call->arg(1)); IntVarArgs iv1 = gi.arg2intvarargs(call->arg(2)); unshare(*gi._current_space, iv0); count(*gi._current_space, iv0, iv1, cover, gi.ann2icl(ann));}
void p_global_cardinality_low_up(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntArgs cover = gi.arg2intargs(call->arg(1));
IntArgs lbound = gi.arg2intargs(call->arg(2)); IntArgs ubound = gi.arg2intargs(call->arg(3)); IntSetArgs y(cover.size()); for (int i = cover.size(); i--;) y[i] = IntSet(lbound[i], ubound[i]);
IntSet cover_s(cover); Region re; IntVarRanges* xrs = re.alloc<IntVarRanges>(x.size()); for (int i = x.size(); i--;) xrs[i].init(x[i]); Iter::Ranges::NaryUnion u(re, xrs, x.size()); Iter::Ranges::ToValues<Iter::Ranges::NaryUnion> uv(u); for (; uv(); ++uv) { if (!cover_s.in(uv.val())) { cover << uv.val(); y << IntSet(0, x.size()); } }
unshare(*gi._current_space, x); count(*gi._current_space, x, y, cover, gi.ann2icl(ann));}
void p_global_cardinality_low_up_closed(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntArgs cover = gi.arg2intargs(call->arg(1));
IntArgs lbound = gi.arg2intargs(call->arg(2)); IntArgs ubound = gi.arg2intargs(call->arg(3)); IntSetArgs y(cover.size()); for (int i = cover.size(); i--;) y[i] = IntSet(lbound[i], ubound[i]);
unshare(*gi._current_space, x); count(*gi._current_space, x, y, cover, gi.ann2icl(ann));}
void p_minimum(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(1)); min(*gi._current_space, iv, gi.arg2intvar(call->arg(0)), gi.ann2icl(ann));}
void p_maximum(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(1)); max(*gi._current_space, iv, gi.arg2intvar(call->arg(0)), gi.ann2icl(ann));}
void p_maximum_arg(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); argmax(*gi._current_space, iv, gi.arg2intvar(call->arg(1)), true, gi.ann2icl(ann));}
void p_minimum_arg(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); argmin(*gi._current_space, iv, gi.arg2intvar(call->arg(1)), true, gi.ann2icl(ann));}
void p_regular(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs iv = gi.arg2intvarargs(call->arg(0)); int q = call->arg(1).toInt(); int symbols = call->arg(2).toInt(); IntArgs d = gi.arg2intargs(call->arg(3)); int q0 = call->arg(4).toInt();
int noOfTrans = 0; for (int i = 1; i <= q; i++) { for (int j = 1; j <= symbols; j++) { if (d[(i - 1) * symbols + (j - 1)] > 0) noOfTrans++; } }
Region re; DFA::Transition* t = re.alloc<DFA::Transition>(noOfTrans + 1); noOfTrans = 0; for (int i = 1; i <= q; i++) { for (int j = 1; j <= symbols; j++) { if (d[(i - 1) * symbols + (j - 1)] > 0) { t[noOfTrans].i_state = i; t[noOfTrans].symbol = j; t[noOfTrans].o_state = d[(i - 1) * symbols + (j - 1)]; noOfTrans++; } } } t[noOfTrans].i_state = -1;
// Final states assert(false); IntSetVal* isv = nullptr; /* eval_intset(s.env().envi(), call->arg(5)); */ IntSetRanges isr(isv);
int* f = static_cast<int*>(malloc(sizeof(int) * (isv->card().toInt()) + 1)); int i = 0; for (Ranges::ToValues<IntSetRanges> val_iter(isr); val_iter(); ++val_iter, ++i) { f[i] = val_iter.val().toInt(); } f[i] = -1;
DFA dfa(q0, t, f); free(f); unshare(*gi._current_space, iv); extensional(*gi._current_space, iv, dfa, gi.ann2icl(ann));}
void p_sort(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntVarArgs y = gi.arg2intvarargs(call->arg(1)); IntVarArgs xy(x.size() + y.size()); for (int i = x.size(); i--;) xy[i] = x[i]; for (int i = y.size(); i--;) xy[i + x.size()] = y[i]; unshare(*gi._current_space, xy); for (int i = x.size(); i--;) x[i] = xy[i]; for (int i = y.size(); i--;) y[i] = xy[i + x.size()]; sorted(*gi._current_space, x, y, gi.ann2icl(ann));}
void p_inverse_offsets(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); unshare(*gi._current_space, x); int xoff = call->arg(1).toInt(); IntVarArgs y = gi.arg2intvarargs(call->arg(2)); unshare(*gi._current_space, y); int yoff = call->arg(3).toInt(); MZ_IntConLevel icl = gi.ann2icl(call->ann()); channel(*gi._current_space, x, xoff, y, yoff, icl == MZ_ICL_DEF ? MZ_ICL_DOM : icl);}
void p_increasing_int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); rel(*gi._current_space, x, IRT_LQ, gi.ann2icl(ann));}
void p_increasing_bool(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); rel(*gi._current_space, x, IRT_LQ, gi.ann2icl(ann));}
void p_decreasing_int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); rel(*gi._current_space, x, IRT_GQ, gi.ann2icl(ann));}
void p_decreasing_bool(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); rel(*gi._current_space, x, IRT_GQ, gi.ann2icl(ann));}
void p_table_int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntArgs tuples = gi.arg2intargs(call->arg(1)); int noOfVars = x.size(); int noOfTuples = tuples.size() == 0 ? 0 : (tuples.size() / noOfVars); TupleSet ts(noOfVars); for (int i = 0; i < noOfTuples; i++) { IntArgs t(noOfVars); for (int j = 0; j < x.size(); j++) { t[j] = tuples[i * noOfVars + j]; } ts.add(t); } ts.finalize(); extensional(*gi._current_space, x, ts, gi.ann2icl(ann));}void p_table_bool(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); IntArgs tuples = gi.arg2boolargs(call->arg(1)); int noOfVars = x.size(); int noOfTuples = tuples.size() == 0 ? 0 : (tuples.size() / noOfVars); TupleSet ts(noOfVars); for (int i = 0; i < noOfTuples; i++) { IntArgs t(noOfVars); for (int j = 0; j < x.size(); j++) { t[j] = tuples[i * noOfVars + j]; } ts.add(t); } ts.finalize(); extensional(*gi._current_space, x, ts, gi.ann2icl(ann));}
void p_cumulatives(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs start = gi.arg2intvarargs(call->arg(0)); IntVarArgs duration = gi.arg2intvarargs(call->arg(1)); IntVarArgs height = gi.arg2intvarargs(call->arg(2)); int n = start.size(); IntVar bound = gi.arg2intvar(call->arg(3));
int minHeight = INT_MAX; int minHeight2 = INT_MAX; for (int i = n; i--;) if (height[i].min() < minHeight) minHeight = height[i].min(); else if (height[i].min() < minHeight2) minHeight2 = height[i].min(); bool disjunctive = (minHeight > bound.max() / 2) || (minHeight2 > bound.max() / 2 && minHeight + minHeight2 > bound.max()); if (disjunctive) { rel(*gi._current_space, bound >= max(height)); // Unary if (duration.assigned()) { IntArgs durationI(n); for (int i = n; i--;) durationI[i] = duration[i].val(); unshare(*gi._current_space, start); unary(*gi._current_space, start, durationI); } else { IntVarArgs end(n); for (int i = n; i--;) end[i] = expr(*gi._current_space, start[i] + duration[i]); unshare(*gi._current_space, start); unary(*gi._current_space, start, duration, end); } } else if (height.assigned()) { IntArgs heightI(n); for (int i = n; i--;) heightI[i] = height[i].val(); if (duration.assigned()) { IntArgs durationI(n); for (int i = n; i--;) durationI[i] = duration[i].val(); cumulative(*gi._current_space, bound, start, durationI, heightI); } else { IntVarArgs end(n); for (int i = n; i--;) end[i] = expr(*gi._current_space, start[i] + duration[i]); cumulative(*gi._current_space, bound, start, duration, end, heightI); } } else if (bound.assigned()) { IntArgs machine = IntArgs::create(n, 0, 0); IntArgs limit({bound.val()}); IntVarArgs end(n); for (int i = n; i--;) end[i] = expr(*gi._current_space, start[i] + duration[i]); cumulatives(*gi._current_space, machine, start, duration, end, height, limit, true, gi.ann2icl(ann)); } else { int min = Gecode::Int::Limits::max; int max = Gecode::Int::Limits::min; IntVarArgs end(start.size()); for (int i = start.size(); i--;) { min = std::min(min, start[i].min()); max = std::max(max, start[i].max() + duration[i].max()); end[i] = expr(*gi._current_space, start[i] + duration[i]); } for (int time = min; time < max; ++time) { IntVarArgs x(start.size()); for (int i = start.size(); i--;) { IntVar overlaps = channel(*gi._current_space, expr(*gi._current_space, (start[i] <= time) && (time < end[i]))); x[i] = expr(*gi._current_space, overlaps * height[i]); } linear(*gi._current_space, x, IRT_LQ, bound); } }}
void p_among_seq_int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); Gecode::IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntSet S = gi.arg2intset(call->arg(1)); int q = call->arg(2).toInt(); int l = call->arg(3).toInt(); int u = call->arg(4).toInt(); unshare(*gi._current_space, x); sequence(*gi._current_space, x, S, q, l, u, gi.ann2icl(ann));}
void p_among_seq_bool(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); bool val = call->arg(1).toInt(); int q = call->arg(2).toInt(); int l = call->arg(3).toInt(); int u = call->arg(4).toInt(); IntSet S(val, val); unshare(*gi._current_space, x); sequence(*gi._current_space, x, S, q, l, u, gi.ann2icl(ann));}
void p_schedule_unary(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntArgs p = gi.arg2intargs(call->arg(1)); unshare(*gi._current_space, x); unary(*gi._current_space, x, p);}
void p_schedule_unary_optional(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntArgs p = gi.arg2intargs(call->arg(1)); BoolVarArgs m = gi.arg2boolvarargs(call->arg(2)); unshare(*gi._current_space, x); unary(*gi._current_space, x, p, m);}
void p_cumulative_opt(SolverInstanceBase& s, const Constraint* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); const Val& ann = ce->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs start = gi.arg2intvarargs(ce->arg(0)); IntArgs duration = gi.arg2intargs(ce->arg(1)); IntArgs height = gi.arg2intargs(ce->arg(2)); BoolVarArgs opt = gi.arg2boolvarargs(ce->arg(3)); int bound = ce->arg(4).toInt(); unshare(*gi._current_space, start); cumulative(*gi._current_space, bound, start, duration, height, opt, gi.ann2icl(ann));}
void p_circuit(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); int off = call->arg(0).toInt(); IntVarArgs xv = gi.arg2intvarargs(call->arg(1)); unshare(*gi._current_space, xv); circuit(*gi._current_space, off, xv, gi.ann2icl(ann));}void p_circuit_cost_array(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntArgs c = gi.arg2intargs(call->arg(0)); IntVarArgs xv = gi.arg2intvarargs(call->arg(1)); IntVarArgs yv = gi.arg2intvarargs(call->arg(2)); IntVar z = gi.arg2intvar(call->arg(3)); unshare(*gi._current_space, xv); circuit(*gi._current_space, c, xv, yv, z, gi.ann2icl(ann));}void p_circuit_cost(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntArgs c = gi.arg2intargs(call->arg(0)); IntVarArgs xv = gi.arg2intvarargs(call->arg(1)); IntVar z = gi.arg2intvar(call->arg(2)); unshare(*gi._current_space, xv); circuit(*gi._current_space, c, xv, z, gi.ann2icl(ann));}
void p_nooverlap(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x0 = gi.arg2intvarargs(call->arg(0)); IntVarArgs w = gi.arg2intvarargs(call->arg(1)); IntVarArgs y0 = gi.arg2intvarargs(call->arg(2)); IntVarArgs h = gi.arg2intvarargs(call->arg(3)); if (w.assigned() && h.assigned()) { IntArgs iw(w.size()); for (int i = w.size(); i--;) iw[i] = w[i].val(); IntArgs ih(h.size()); for (int i = h.size(); i--;) ih[i] = h[i].val(); nooverlap(*gi._current_space, x0, iw, y0, ih, gi.ann2icl(ann)); } else { IntVarArgs x1(x0.size()), y1(y0.size()); for (int i = x0.size(); i--;) x1[i] = expr(*gi._current_space, x0[i] + w[i]); for (int i = y0.size(); i--;) y1[i] = expr(*gi._current_space, y0[i] + h[i]); nooverlap(*gi._current_space, x0, w, x1, y0, h, y1, gi.ann2icl(ann)); }}
void p_precede(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); int p_s = call->arg(1).toInt(); int p_t = call->arg(2).toInt(); precede(*gi._current_space, x, p_s, p_t, gi.ann2icl(ann));}
void p_nvalue(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(1)); if (call->arg(0).isVar()) { IntVar y = gi.arg2intvar(call->arg(0)); nvalues(*gi._current_space, x, IRT_EQ, y, gi.ann2icl(ann)); } else { nvalues(*gi._current_space, x, IRT_EQ, call->arg(0).toInt(), gi.ann2icl(ann)); }}
void p_among(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(1)); IntSet v = gi.arg2intset(call->arg(2)); if (call->arg(0).isVar()) { IntVar n = gi.arg2intvar(call->arg(0)); unshare(*gi._current_space, x); count(*gi._current_space, x, v, IRT_EQ, n, gi.ann2icl(ann)); } else { unshare(*gi._current_space, x); count(*gi._current_space, x, v, IRT_EQ, call->arg(0).toInt(), gi.ann2icl(ann)); }}
void p_member_int(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntVar y = gi.arg2intvar(call->arg(1)); member(*gi._current_space, x, y, gi.ann2icl(ann));}void p_member_int_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVarArgs x = gi.arg2intvarargs(call->arg(0)); IntVar y = gi.arg2intvar(call->arg(1)); BoolVar b = gi.arg2boolvar(call->arg(2)); member(*gi._current_space, x, y, b, gi.ann2icl(ann));}void p_member_bool(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); BoolVar y = gi.arg2boolvar(call->arg(1)); member(*gi._current_space, x, y, gi.ann2icl(ann));}void p_member_bool_reif(SolverInstanceBase& s, const Constraint* call) { assert(static_cast<BytecodeProc::Mode>(call->mode()) == BytecodeProc::ROOT); const Val& ann = call->ann(); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); BoolVarArgs x = gi.arg2boolvarargs(call->arg(0)); BoolVar y = gi.arg2boolvar(call->arg(1)); member(*gi._current_space, x, y, gi.arg2boolvar(call->arg(2)), gi.ann2icl(ann));}
// FLOAT CONSTRAINTS#ifdef GECODE_HAS_FLOAT_VARS
void p_int2float(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntVar x0 = gi.arg2intvar(ce->arg(0)); FloatVar x1 = gi.arg2floatvar(ce->arg(1)); channel(*gi._current_space, x0, x1);}
void p_float_lin_cmp(GecodeSolverInstance& s, FloatRelType frt, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); FloatValArgs fa = s.arg2floatargs(ce->arg(0)); FloatVarArgs fv = s.arg2floatvarargs(ce->arg(1)); linear(*s._current_space, fa, fv, frt, ce->arg(2)->cast<FloatLit>()->v().toDouble());}void p_float_lin_cmp_reif(GecodeSolverInstance& s, FloatRelType frt, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); FloatValArgs fa = s.arg2floatargs(ce->arg(0)); FloatVarArgs fv = s.arg2floatvarargs(ce->arg(1)); linear(*s._current_space, fa, fv, frt, ce->arg(2)->cast<FloatLit>()->v().toDouble(), s.arg2boolvar(ce->arg(3)));}void p_float_lin_eq(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); p_float_lin_cmp(gi, FRT_EQ, ce);}void p_float_lin_eq_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); p_float_lin_cmp_reif(gi, FRT_EQ, ce);}void p_float_lin_le(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); p_float_lin_cmp(gi, FRT_LQ, ce);}void p_float_lin_le_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); p_float_lin_cmp_reif(gi, FRT_LQ, ce);}
void p_float_times(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); FloatVar z = gi.arg2floatvar(ce->arg(2)); mult(*gi._current_space, x, y, z);}
void p_float_div(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); FloatVar z = gi.arg2floatvar(ce->arg(2)); div(*gi._current_space, x, y, z);}
void p_float_plus(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); FloatVar z = gi.arg2floatvar(ce->arg(2)); rel(*gi._current_space, x + y == z);}
void p_float_sqrt(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); sqrt(*gi._current_space, x, y);}
void p_float_abs(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); abs(*gi._current_space, x, y);}
void p_float_eq(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); rel(*gi._current_space, x, FRT_EQ, y);}void p_float_eq_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); BoolVar b = gi.arg2boolvar(ce->arg(2)); rel(*gi._current_space, x, FRT_EQ, y, b);}void p_float_le(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); rel(*gi._current_space, x, FRT_LQ, y);}void p_float_le_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); BoolVar b = gi.arg2boolvar(ce->arg(2)); rel(*gi._current_space, x, FRT_LQ, y, b);}void p_float_max(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); FloatVar z = gi.arg2floatvar(ce->arg(2)); max(*gi._current_space, x, y, z);}void p_float_min(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); FloatVar z = gi.arg2floatvar(ce->arg(2)); min(*gi._current_space, x, y, z);}void p_float_lt(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); rel(*gi._current_space, x, FRT_LQ, y); rel(*gi._current_space, x, FRT_EQ, y, BoolVar(*gi._current_space, 0, 0));}
void p_float_lt_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); BoolVar b = gi.arg2boolvar(ce->arg(2)); BoolVar b0(*gi._current_space, 0, 1); BoolVar b1(*gi._current_space, 0, 1); rel(*gi._current_space, b == (b0 && !b1)); rel(*gi._current_space, x, FRT_LQ, y, b0); rel(*gi._current_space, x, FRT_EQ, y, b1);}
void p_float_ne(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); rel(*gi._current_space, x, FRT_EQ, y, BoolVar(*gi._current_space, 0, 0));}
#ifdef GECODE_HAS_MPFR#define P_FLOAT_OP(Op) \ void p_float_##Op(SolverInstanceBase& s, const Definition* ce) { \ assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT);GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s);FloatVar x = gi.arg2floatvar(ce->arg(0));FloatVar y = gi.arg2floatvar(ce->arg(1));Op(*gi._current_space, x, y);}P_FLOAT_OP(acos)P_FLOAT_OP(asin)P_FLOAT_OP(atan)P_FLOAT_OP(cos)P_FLOAT_OP(exp)P_FLOAT_OP(sin)P_FLOAT_OP(tan)// P_FLOAT_OP(sinh)// P_FLOAT_OP(tanh)// P_FLOAT_OP(cosh)#undef P_FLOAT_OP
void p_float_ln(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); log(*gi._current_space, x, y);}void p_float_log10(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); log(*gi._current_space, 10.0, x, y);}void p_float_log2(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); FloatVar x = gi.arg2floatvar(ce->arg(0)); FloatVar y = gi.arg2floatvar(ce->arg(1)); log(*gi._current_space, 2.0, x, y);}
#endif#endif
#ifdef GECODE_HAS_SET_VARSvoid p_set_OP(SolverInstanceBase& s, SetOpType op, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); rel(*gi._current_space, gi.arg2setvar(ce->arg(0)), op, gi.arg2setvar(ce->arg(1)), SRT_EQ, gi.arg2setvar(ce->arg(2)));}void p_set_union(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_OP(s, SOT_UNION, ce);}void p_set_intersect(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_OP(s, SOT_INTER, ce);}void p_set_diff(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_OP(s, SOT_MINUS, ce);}
void p_set_symdiff(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVar x = gi.arg2setvar(ce->arg(0)); SetVar y = gi.arg2setvar(ce->arg(1));
SetVarLubRanges xub(x); IntSet xubs(xub); SetVar x_y(*gi._current_space, IntSet::empty, xubs); rel(*gi._current_space, x, SOT_MINUS, y, SRT_EQ, x_y);
SetVarLubRanges yub(y); IntSet yubs(yub); SetVar y_x(*gi._current_space, IntSet::empty, yubs); rel(*gi._current_space, y, SOT_MINUS, x, SRT_EQ, y_x);
rel(*gi._current_space, x_y, SOT_UNION, y_x, SRT_EQ, gi.arg2setvar(ce->arg(2)));}
void p_array_set_OP(SolverInstanceBase& s, SetOpType op, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVarArgs xs = gi.arg2setvarargs(ce->arg(0)); rel(*gi._current_space, op, xs, gi.arg2setvar(ce->arg(1)));}void p_array_set_union(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_array_set_OP(s, SOT_UNION, ce);}void p_array_set_partition(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_array_set_OP(s, SOT_DUNION, ce);}
void p_set_rel(SolverInstanceBase& s, SetRelType srt, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); rel(*gi._current_space, gi.arg2setvar(ce->arg(0)), srt, gi.arg2setvar(ce->arg(1)));}
void p_set_eq(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_EQ, ce);}void p_set_ne(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_NQ, ce);}void p_set_subset(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_SUB, ce);}void p_set_superset(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_SUP, ce);}void p_set_le(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_LQ, ce);}void p_set_lt(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel(s, SRT_LE, ce);}void p_set_card(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); if (!ce->arg(1).isDef()) { IntVal i = ce->arg(1)().toInt(); assert(i < 0 || i > Gecode::Int::Limits::max); unsigned int ui = static_cast<unsigned int>(i.toInt()); cardinality(*gi._current_space, gi.arg2setvar(ce->arg(0)), ui, ui); } else { cardinality(*gi._current_space, gi.arg2setvar(ce->arg(0)), gi.arg2intvar(ce->arg(1))); }}void p_set_in(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); if (!ce->arg(1).isDef()) { IntSet d = gi.arg2intset(ce->arg(1)); if (ce->arg(0).isDef()) { Gecode::IntSetRanges dr(d); Iter::Ranges::Singleton sr(0, 1); Iter::Ranges::Inter<Gecode::IntSetRanges, Iter::Ranges::Singleton> i(dr, sr); IntSet d01(i); if (d01.size() == 0) { gi._current_space->fail(); } else { rel(*gi._current_space, gi.arg2boolvar(ce->arg(0)), IRT_GQ, d01.min()); rel(*gi._current_space, gi.arg2boolvar(ce->arg(0)), IRT_LQ, d01.max()); } } else { dom(*gi._current_space, gi.arg2intvar(ce->arg(0)), d); } } else { if (!ce->arg(0).isDef()) { dom(*gi._current_space, gi.arg2setvar(ce->arg(1)), SRT_SUP, ce->arg(0)().toInt()); } else { rel(*gi._current_space, gi.arg2setvar(ce->arg(1)), SRT_SUP, gi.arg2intvar(ce->arg(0))); } }}void p_set_rel_reif(SolverInstanceBase& s, SetRelType srt, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); rel(*gi._current_space, gi.arg2setvar(ce->arg(0)), srt, gi.arg2setvar(ce->arg(1)), gi.arg2boolvar(ce->arg(2)));}
void p_set_eq_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_EQ, ce);}void p_set_le_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_LQ, ce);}void p_set_lt_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_LE, ce);}void p_set_ne_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_NQ, ce);}void p_set_subset_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_SUB, ce);}void p_set_superset_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_rel_reif(s, SRT_SUP, ce);}void p_set_in_reif(SolverInstanceBase& s, const Definition* ce, ReifyMode rm) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); if (!ce->arg(1).isDef()) { if (rm == RM_EQV) { p_int_in_reif(s, ce); } else { assert(rm == RM_IMP); p_int_in_imp(s, ce); } } else { if (!ce->arg(0).isDef()) { dom(*gi._current_space, gi.arg2setvar(ce->arg(1)), SRT_SUP, ce->arg(0)().toInt(), Reify(gi.arg2boolvar(ce->arg(2)), rm)); } else { rel(*gi._current_space, gi.arg2setvar(ce->arg(1)), SRT_SUP, gi.arg2intvar(ce->arg(0)), Reify(gi.arg2boolvar(ce->arg(2)), rm)); } }}void p_set_in_reif(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_in_reif(s, ce, RM_EQV);}void p_set_in_imp(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_set_in_reif(s, ce, RM_IMP);}void p_set_disjoint(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); rel(*gi._current_space, gi.arg2setvar(ce->arg(0)), SRT_DISJ, gi.arg2setvar(ce->arg(1)));}
void p_link_set_to_booleans(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVar x = gi.arg2setvar(ce->arg(0)); int idx = ce->arg(2)().toInt(); assert(idx >= 0); rel(*gi._current_space, x || IntSet(Set::Limits::min, idx - 1)); BoolVarArgs y = gi.arg2boolvarargs(ce->arg(1), idx); unshare(*gi._current_space, y); channel(*gi._current_space, y, x);}
void p_array_set_element(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); bool isConstant = true; ArrayLit* a = gi.arg2arraylit(ce->arg(1)); for (int i = a->size(); i--;) { if ((*a)[i].isDef()) { isConstant = false; break; } } IntVar selector = gi.arg2intvar(ce->arg(0)); rel(*gi._current_space, selector > 0); if (isConstant) { IntSetArgs sv = gi.arg2intsetargs(gi.env().envi(), ce->arg(1), 1); element(*gi._current_space, sv, selector, gi.arg2setvar(ce->arg(2))); } else { SetVarArgs sv = gi.arg2setvarargs(ce->arg(1), 1); element(*gi._current_space, sv, selector, gi.arg2setvar(ce->arg(2))); }}
void p_array_set_element_op(SolverInstanceBase& s, const Definition* ce, SetOpType op, const IntSet& universe = IntSet(Set::Limits::min, Set::Limits::max)) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); bool isConstant = true; ArrayLit* a = gi.arg2arraylit(ce->arg(1)); for (int i = a->size(); i--;) { if ((*a)[i].isDef()) { isConstant = false; break; } } SetVar selector = gi.arg2setvar(ce->arg(0)); dom(*gi._current_space, selector, SRT_DISJ, 0); if (isConstant) { IntSetArgs sv = gi.arg2intsetargs(gi.env().envi(), ce->arg(1), 1); element(*gi._current_space, op, sv, selector, gi.arg2setvar(ce->arg(2)), universe); } else { SetVarArgs sv = gi.arg2setvarargs(ce->arg(1), 1); element(*gi._current_space, op, sv, selector, gi.arg2setvar(ce->arg(2)), universe); }}
void p_array_set_element_union(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_array_set_element_op(s, ce, SOT_UNION);}
void p_array_set_element_intersect(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_array_set_element_op(s, ce, SOT_INTER);}
void p_array_set_element_intersect_in(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntSet d = gi.arg2intset(gi.env().envi(), ce->arg(3)); p_array_set_element_op(s, ce, SOT_INTER, d);}
void p_array_set_element_partition(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); p_array_set_element_op(s, ce, SOT_DUNION);}
void p_set_convex(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); convex(*gi._current_space, gi.arg2setvar(ce->arg(0)));}
void p_array_set_seq(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVarArgs sv = gi.arg2setvarargs(ce->arg(0)); sequence(*gi._current_space, sv);}
void p_array_set_seq_union(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVarArgs sv = gi.arg2setvarargs(ce->arg(0)); sequence(*gi._current_space, sv, gi.arg2setvar(ce->arg(1)));}
void p_int_set_channel(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); int xoff = ce->arg(1)().toInt(); assert(xoff >= 0); int yoff = ce->arg(3)().toInt(); assert(yoff >= 0); IntVarArgs xv = gi.arg2intvarargs(ce->arg(0), xoff); SetVarArgs yv = gi.arg2setvarargs(ce->arg(2), yoff, 1, IntSet(0, xoff - 1)); IntSet xd(yoff, yv.size() - 1); for (int i = xoff; i < xv.size(); i++) { dom(*gi._current_space, xv[i], xd); } IntSet yd(xoff, xv.size() - 1); for (int i = yoff; i < yv.size(); i++) { dom(*gi._current_space, yv[i], SRT_SUB, yd); } channel(*gi._current_space, xv, yv);}
void p_range(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); int xoff = ce->arg(1)().toInt(); assert(xoff >= 0); IntVarArgs xv = gi.arg2intvarargs(ce->arg(0), xoff); element(*gi._current_space, SOT_UNION, xv, gi.arg2setvar(ce->arg(2)), gi.arg2setvar(ce->arg(3)));}
void p_weights(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); IntArgs e = gi.arg2intargs(ce->arg(0)); IntArgs w = gi.arg2intargs(ce->arg(1)); SetVar x = gi.arg2setvar(ce->arg(2)); IntVar y = gi.arg2intvar(ce->arg(3)); weights(*gi._current_space, e, w, x, y);}
void p_inverse_set(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); int xoff = ce->arg(2)().toInt(); int yoff = ce->arg(3)().toInt(); SetVarArgs x = gi.arg2setvarargs(ce->arg(0), xoff); SetVarArgs y = gi.arg2setvarargs(ce->arg(1), yoff); channel(*gi._current_space, x, y);}
void p_precede_set(SolverInstanceBase& s, const Definition* ce) { assert(static_cast<BytecodeProc::Mode>(ce->mode()) == BytecodeProc::ROOT); GecodeSolverInstance& gi = static_cast<GecodeSolverInstance&>(s); SetVarArgs x = gi.arg2setvarargs(ce->arg(0)); int p_s = ce->arg(1)().toInt(); int p_t = ce->arg(2)().toInt(); precede(*gi._current_space, x, p_s, p_t);}#endif
} // namespace MiniZinc}