commit c6a967f23a254ec85f50a83266826f74c7f77ef5 · dekker.one/on-restart-benchmarks

+1 -1

lib/interpreter.cpp

···

       1555
       1555
        
             assert(var->definitions().back() == con);

     

       1556
       1556
        
             var->_definitions.pop_back();

     

       1557
       1557
        
           } else {

     

       1558
       1558
       -
             assert(false);

     

       1558
       1558
       +
             var->_definitions.push_back(con);

     

       1559
       1559
        
           }

     

       1560
       1560
        
           def_trail.pop_back();

     

       1561
       1561
        
         }

+1 -1

lib/interpreter/variable.cpp

···

       346
       346
        
         _subscriptions.clear();

     

       347
       347
        
       

     

       348
       348
        
         // Set Alias

     

       349
       349
       -
         interpreter->trail.trail_alias(interpreter, this);

     

       350
       349
        
         _aliased = true;

     

       351
       350
        
         _domain = v;

     

       352
       351
        
         v.addRef(interpreter);

     

       352
       352
       +
         interpreter->trail.trail_alias(interpreter, this);

     

       353
       353
        
       }

     

       354
       354
        
       

     

       355
       355
        
       void Variable::unalias(Interpreter* interpreter, Val dom) {

+1 -1

lib/solver.cpp

···

       817
       817
        
         }

     

       818
       818
        
         flatten_time = tm01.s();

     

       819
       819
        
         // FIXME: Global registers should not be removed, merely hidden

     

       820
       820
       -
         interpreter->clear_globals();

     

       820
       820
       +
         // interpreter->clear_globals();

     

       821
       821
        
         if (verbose) {

     

       822
       822
        
           std::cerr << "Status: " << Interpreter::status_to_string[interpreter->status()] << std::endl;

     

       823
       823
        
           if (interpreter->status() == Interpreter::ROGER) {

+3 -1

solvers/gecode/gecode_constraints.cpp

···

       38
       38
        
             gi._current_space->iv_defined.push_back(!var->definitions().empty());

     

       39
       39
        
           }

     

       40
       40
        
         } else {

     

       41
       41
       -
           IntVar intVar(*gi._current_space, Gecode::Int::Limits::min, Gecode::Int::Limits::max);

     

       41
       41
       +
           IntVar intVar(*gi._current_space,

     

       42
       42
       +
                         var->lb().isFinite() ? var->lb().toInt() : Gecode::Int::Limits::min,

     

       43
       43
       +
                         var->ub().isFinite() ? var->ub().toInt() : Gecode::Int::Limits::max);

     

       42
       44
        
           gi._current_space->iv.push_back(intVar);

     

       43
       45
        
           gi.insertVar(var, GecodeVariable(GecodeVariable::INT_TYPE, gi._current_space->iv.size() - 1));

     

       44
       46
        
           std::cerr << "% GecodeSolverInstance::processFlatZinc: Warning: Unbounded variable "

+1 -1

solvers/gecode/gecode_solverinstance.cpp

···

       1152
       1152
        
           if (val.isInt() && val >= 0 && val <= 1) {

     

       1153
       1153
        
             continue;

     

       1154
       1154
        
           } else if (val.isVar()) {

     

       1155
       1155
       -
             if (val.lb().toInt() >= 0 && val.ub().toInt() <= 1) {

     

       1155
       1155
       +
             if (val.lb() >= Val(int(0)) && val.ub() <= Val(int(1))) {

     

       1156
       1156
        
               continue;

     

       1157
       1157
        
             }

     

       1158
       1158
        
             return false;