diff --git a/.gitignore b/.gitignore index 28833e3..cb4dc65 100644 --- a/.gitignore +++ b/.gitignore @@ -2,6 +2,16 @@ main/cosoco main/cosoco.* +# the clangd cache +.cache +# the build folder +build +# the default cmake makefile +Makefile + +.vscode +Testing + # instances @@ -12,6 +22,8 @@ cmake_install.cmake cmake-build-debug CMakeFiles CMakeCache.txt +cosoco-test*_include.cmake +CTestTestfile.cmake # lib diff --git a/CMakeLists.txt b/CMakeLists.txt index 52556d2..ed7dbb6 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,21 +1,31 @@ -cmake_minimum_required(VERSION 3.3) +cmake_minimum_required(VERSION 3.12) #set(CMAKE_C_COMPILER "gcc-7") #set(CMAKE_CXX_COMPILER "g++-7") project(cosoco) +# Check if the 'no-xcsp3' option is enabled +option(NO_XCSP3 "Disable XCSP3 support" OFF) -set(CMAKE_RUNTIME_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/main") -set(CMAKE_LIBRARY_OUTPUT_DIRECTORY "${CMAKE_CURRENT_SOURCE_DIR}/lib") -set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${CMAKE_CURRENT_SOURCE_DIR}/lib) +# define some c++ flags +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Wno-parentheses -Wall -O3 -Wno-unused-label") +if(NO_XCSP3) + #turn warning into errors only when we are not using XCSP3 parser + #as the errors might come from the dependencies (libxml2 or XCSP3-Parser) + set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -Werror -Wnon-virtual-dtor") +endif() +# GoogleTest requires at least C++14 +set(CMAKE_CXX_STANDARD 14) +set(CMAKE_CXX_STANDARD_REQUIRED ON) -set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -std=c++14 -Wno-parentheses -Wall -O3 -Wno-unused-label") -include_directories(/usr/local/opt/libxml2/include/libxml2/) include_directories(${CMAKE_CURRENT_SOURCE_DIR}) - -find_package(LibXml2 REQUIRED) -include_directories(${LIBXML2_INCLUDE_DIRS}) +if(NOT NO_XCSP3) + #if we're not using xcsp, don't include libxml2 + include_directories(/usr/local/opt/libxml2/include/libxml2/) + find_package(LibXml2 REQUIRED) + include_directories(${LIBXML2_INCLUDE_DIRS}) +endif() file(GLOB_RECURSE Cosoco_SOURCES ${PROJECT_SOURCE_DIR}/constraints/*.cc @@ -27,52 +37,65 @@ file(GLOB_RECURSE Cosoco_SOURCES ${PROJECT_SOURCE_DIR}/utils/*.cc ) -file(GLOB_RECURSE Cosoco_HEADERS - ${PROJECT_SOURCE_DIR}/constraints/*.h - ${PROJECT_SOURCE_DIR}/core/*.h - ${PROJECT_SOURCE_DIR}/mtl/*.h - ${PROJECT_SOURCE_DIR}/main/*.h - ${PROJECT_SOURCE_DIR}/optimizer/*.h - ${PROJECT_SOURCE_DIR}/problems/*.h - ${PROJECT_SOURCE_DIR}/solver/*.h - ${PROJECT_SOURCE_DIR}/utils/*.h -) - set(LIBRARY_NAME libcosoco) - -file(GLOB_RECURSE Cosoco_HEADERS "./*.h") - set(Cosoco_INCLUDE_DIRS "") -foreach (_headerFile ${Cosoco_HEADERS}) - get_filename_component(_dir ${_headerFile} PATH) - list(APPEND Cosoco_INCLUDE_DIRS ${_dir}) -endforeach () - -list(REMOVE_DUPLICATES Cosoco_INCLUDE_DIRS) - include_directories( ${Cosoco_INCLUDE_DIRS} - ${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/include/ ) - add_library(${LIBRARY_NAME} STATIC ${Cosoco_SOURCES} solver/utils/Profiling.cc) +if(NOT NO_XCSP3) + include_directories( + ${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/include/ + ) -link_directories(${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/lib) + link_directories(${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/lib) + target_compile_definitions(${LIBRARY_NAME} PRIVATE USE_XCSP3) +endif() set_target_properties(${LIBRARY_NAME} PROPERTIES OUTPUT_NAME "cosoco") - -link_libraries(xcsp3parser) -add_executable(cosoco main/Main.cc - mtl/Matrix.h) -target_link_libraries(cosoco ${LIBRARY_NAME}) -target_link_libraries(cosoco ${LIBXML2_LIBRARIES}) - - -target_include_directories(${LIBRARY_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) - +#define the executable +if(NOT NO_XCSP3) + link_libraries(xcsp3parser) + add_executable(cosoco main/Main.cc + mtl/Matrix.h) + target_compile_definitions(cosoco PRIVATE USE_XCSP3) + target_link_libraries(cosoco ${LIBRARY_NAME}) + target_link_libraries(cosoco ${LIBXML2_LIBRARIES}) + + + target_include_directories(${LIBRARY_NAME} PUBLIC ${CMAKE_CURRENT_SOURCE_DIR}/include) +endif() + + +#tests +# Find Google Test (if not present, tests will not be compiled) +find_package(GTest) + +if(GTEST_FOUND) + # Add test source files + file(GLOB_RECURSE Cosoco_TESTS + ${PROJECT_SOURCE_DIR}/test/*.cc + ) + #define the test executable and its dependencies + add_executable(cosoco-test ${Cosoco_TESTS}) + target_link_libraries(cosoco-test GTest::gtest_main) + target_link_libraries(cosoco-test ${LIBRARY_NAME}) + if(NOT NO_XCSP3) + target_include_directories(cosoco-test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/include/) + target_include_directories(cosoco-test PRIVATE ${LIBXML2_INCLUDE_DIRS}) + target_link_libraries(cosoco-test ${LIBXML2_LIBRARIES}) + target_link_libraries(cosoco-test xcsp3parser) + target_link_directories(cosoco-test PRIVATE ${CMAKE_CURRENT_SOURCE_DIR}/../XCSP3-CPP-Parser/lib) + endif() + + enable_testing() + # Add a test target + include(GoogleTest) + gtest_discover_tests(cosoco-test) +endif() \ No newline at end of file diff --git a/build-lib.sh b/build-lib.sh new file mode 100755 index 0000000..9ade255 --- /dev/null +++ b/build-lib.sh @@ -0,0 +1,3 @@ +cmake -DNO_XCSP3=ON -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" . +#cmake -DCMAKE_BUILD_TYPE=Debug -G "Unix Makefiles" . +cmake --build . --target libcosoco -- -j 8 diff --git a/build.sh b/build.sh index fb35a5d..a661b87 100755 --- a/build.sh +++ b/build.sh @@ -1,6 +1,6 @@ cd ../XCSP3-CPP-Parser ./build.sh cd ../cosoco/ -cmake -DCMAKE_BUILD_TYPE=Release -G "Unix Makefiles" . +cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_RUNTIME_OUTPUT_DIRECTORY="`pwd`/main" -DCMAKE_LIBRARY_OUTPUT_DIRECTORY="`pwd`/lib" -DCMAKE_ARCHIVE_OUTPUT_DIRECTORY="`pwd`/lib" -G "Unix Makefiles" . #cmake -DCMAKE_BUILD_TYPE=Debug -G "Unix Makefiles" . cmake --build . --target cosoco -- -j 8 diff --git a/constraints/Constraint.cc b/constraints/Constraint.cc index 8514531..7c9c499 100644 --- a/constraints/Constraint.cc +++ b/constraints/Constraint.cc @@ -4,11 +4,15 @@ #include +#ifdef USE_XCSP3 #include "XCSP3Tree.h" -#include "mtl/Map.h" #include "solver/utils/FactoryConstraints.h" #include "utils/Utils.h" +#else +#include "utils/Options.h" +#endif /* #ifdef USE_XCSP3 */ +#include "core/Problem.h" using namespace std; using namespace Cosoco; @@ -154,6 +158,7 @@ void Constraint::extractConstraintTupleFromInterpretation(const vec &interp } } +#ifdef USE_XCSP3 void createTuples(int posx, vec &scope, XCSP3Core::Tree *tree, vec> &conflicts, vec> &supports, std::map &tuple) { @@ -162,8 +167,8 @@ void createTuples(int posx, vec &scope, XCSP3Core::Tree *tree, vecdomain.maxSize(); i++) { tuple[x->_name] = x->domain.toVal(i); - if(posx == scope.size() - 2 && tree->root->type == OEQ && tree->root->parameters[1]->type == OVAR) { - auto *nv = dynamic_cast(tree->root->parameters[1]); + if(posx == scope.size() - 2 && tree->root->type == XCSP3Core::OEQ && tree->root->parameters[1]->type == XCSP3Core::OVAR) { + auto *nv = dynamic_cast(tree->root->parameters[1]); if(nodeContainsVar(tree->root->parameters[0], nv->var) == false) { // we have expr = var // we evaluate the expression and put the value in support @@ -171,7 +176,7 @@ void createTuples(int posx, vec &scope, XCSP3Core::Tree *tree, veccontainsValue(eval)) { supports.push(); tuple[scope.last()->_name] = eval; - assert(tuple.size() == scope.size()); + assert(tuple.size() == (size_t)scope.size()); for(auto &x : scope) supports.last().push(tuple[x->_name]); } continue; @@ -207,6 +212,7 @@ void Constraint::toExtensionConstraint(XCSP3Core::Tree *tree, vec &s } } +#endif /* USE_XCSP3 */ // Display void Constraint::display(bool allDetails) { diff --git a/constraints/Constraint.h b/constraints/Constraint.h index 5fd9388..c6ad5a9 100644 --- a/constraints/Constraint.h +++ b/constraints/Constraint.h @@ -1,11 +1,8 @@ #ifndef CONSTRAINT_H #define CONSTRAINT_H -#include #include -#include "XCSP3Tree.h" -#include "core/Problem.h" #include "core/Variable.h" #include "mtl/SparseSet.h" #include "mtl/SparseSetOfVariables.h" @@ -13,6 +10,14 @@ #define NOTINSCOPE -1 + +#ifdef USE_XCSP3 +#include +namespace XCSP3Core { +class Tree; +} +#endif + namespace Cosoco { enum State { CONSISTENT, INCONSISTENT, UNDEF }; @@ -49,8 +54,9 @@ class Constraint { // Constructors and delayed initialisation Constraint(Problem &p, std::string n, vec &vars); Constraint(Problem &p, std::string n); // For global constraints, the scope is managed by themselves - bool scopeIsOk(); // is the scope is correctly defined? - virtual bool isCorrectlyDefined(); // is the constraint is correctly defined? + virtual ~Constraint() = default; + bool scopeIsOk(); // is the scope is correctly defined? + virtual bool isCorrectlyDefined(); // is the constraint is correctly defined? void addToScope(vec &vars); void addToScope(Variable *x); @@ -88,8 +94,10 @@ class Constraint { // Display virtual void display(bool allDetails = false); virtual void attachSolver(Solver *s); - static void toExtensionConstraint(XCSP3Core::Tree *tree, vec &scope, std::vector > &tuples, - bool &isSupport); // Extract Extensional . Return nullptr if too many tuples +#ifdef USE_XCSP3 + static void toExtensionConstraint(XCSP3Core::Tree *tree, vec &scope, std::vector > &tuples, + bool &isSupport); // Extract Extensional . Return nullptr if too many tuples +#endif protected: // All this part simplify scope initialisation diff --git a/constraints/extensions/CompactTable.h b/constraints/extensions/CompactTable.h index bc61fe3..3ff9dda 100644 --- a/constraints/extensions/CompactTable.h +++ b/constraints/extensions/CompactTable.h @@ -6,9 +6,9 @@ #define COSOCO_COMPACTTABLE_H -#include "Extension.h" -#include "ObserverDecision.h" -#include "SparseSetMultiLevel.h" +#include "constraints/extensions/Extension.h" +#include "mtl/SparseSetMultiLevel.h" +#include "solver/observers/ObserverDecision.h" #define BITSET unsigned long long #define SIZEW (8 * sizeof(BITSET)) #define BIT_ALL_ONE 0xFFFFFFFFFFFFFFFF diff --git a/constraints/extensions/Extension.h b/constraints/extensions/Extension.h index c75d15a..2a27df5 100644 --- a/constraints/extensions/Extension.h +++ b/constraints/extensions/Extension.h @@ -9,9 +9,9 @@ #define EXTENSION_H -#include "Matrix.h" -#include "XCSP3Constants.h" #include "constraints/Constraint.h" +#include "mtl/Matrix.h" +#include "utils/Constants.h" namespace Cosoco { class Extension : public Constraint { diff --git a/constraints/extensions/MDDExtension.cc b/constraints/extensions/MDDExtension.cc index b64c069..c3ba481 100644 --- a/constraints/extensions/MDDExtension.cc +++ b/constraints/extensions/MDDExtension.cc @@ -1,5 +1,7 @@ #include "MDDExtension.h" +#ifdef USE_XCSP3 + #include "constraints/extensions/structures/MDD.h" #include "solver/Solver.h" @@ -148,3 +150,5 @@ void MDDExtension::attachSolver(Solver *s) { void MDDExtension::notifyDeleteDecision(Variable *x, int v, Solver &s) { falseTimestamp++; } + +#endif /* USE_XCSP3 */ diff --git a/constraints/extensions/MDDExtension.h b/constraints/extensions/MDDExtension.h index e77b025..101122c 100644 --- a/constraints/extensions/MDDExtension.h +++ b/constraints/extensions/MDDExtension.h @@ -1,6 +1,8 @@ +#pragma once #ifndef COSOCO_MDDEXTENSION_H #define COSOCO_MDDEXTENSION_H +#ifdef USE_XCSP3 #include "Extension.h" #include "solver/observers/ObserverDecision.h" @@ -37,4 +39,6 @@ class MDDExtension : public Extension, ObserverDeleteDecision { }; } // namespace Cosoco +#endif /* USE_XCSP3 */ + #endif // COSOCO_MDDEXTENSION_H diff --git a/constraints/extensions/ShortSTR2.cc b/constraints/extensions/ShortSTR2.cc index 0701111..98d6991 100644 --- a/constraints/extensions/ShortSTR2.cc +++ b/constraints/extensions/ShortSTR2.cc @@ -1,8 +1,8 @@ #include "ShortSTR2.h" -#include "XCSP3Constants.h" #include "mtl/Matrix.h" #include "solver/Solver.h" +#include "utils/Constants.h" // TODO restore lastsize when backtracking using namespace Cosoco; diff --git a/constraints/extensions/structures/MDD.cc b/constraints/extensions/structures/MDD.cc index ee152d1..cc40224 100644 --- a/constraints/extensions/structures/MDD.cc +++ b/constraints/extensions/structures/MDD.cc @@ -1,10 +1,11 @@ #include "MDD.h" +#ifdef USE_XCSP3 + #include #include #include -#include "MDD.h" using namespace Cosoco; @@ -170,3 +171,5 @@ bool MDDNode::isRoot() const { return level == 0; } MDDNode::MDDNode(std::string n, int _id, int lvl, int maxNbChilds) : id(_id), level(lvl), name(n) { childs.growTo(maxNbChilds, nullptr); } + +#endif /* USE_XCSP3 */ diff --git a/constraints/extensions/structures/MDD.h b/constraints/extensions/structures/MDD.h index 5591c8a..73c362c 100644 --- a/constraints/extensions/structures/MDD.h +++ b/constraints/extensions/structures/MDD.h @@ -1,6 +1,8 @@ +#pragma once #ifndef COSOCO_MDD_H #define COSOCO_MDD_H +#ifdef USE_XCSP3 #include #include @@ -47,5 +49,6 @@ class MDD { }; } // namespace Cosoco +#endif /* USE_XCSP3 */ #endif // COSOCO_MDD_H diff --git a/constraints/genericFiltering/AC3rm.cc b/constraints/genericFiltering/AC3rm.cc index aefaf64..1d675c7 100644 --- a/constraints/genericFiltering/AC3rm.cc +++ b/constraints/genericFiltering/AC3rm.cc @@ -1,7 +1,7 @@ -#include "AC3rm.h" +#include "constraints/genericFiltering/AC3rm.h" -#include "Options.h" #include "solver/Solver.h" +#include "solver/utils/Options.h" using namespace Cosoco; using namespace std; @@ -35,7 +35,7 @@ bool AdapterAC3rm::isItTimeToStartFiltering() { for(Variable *x : scope) { assert(x->size() > 0); nb *= x->size(); - if(nb > maxSize) + if(nb > (unsigned long long)maxSize) return false; } assert(nb > 0); diff --git a/constraints/genericFiltering/AC3rm.h b/constraints/genericFiltering/AC3rm.h index 8942b36..6e71607 100644 --- a/constraints/genericFiltering/AC3rm.h +++ b/constraints/genericFiltering/AC3rm.h @@ -1,13 +1,13 @@ -#include "TupleIteratorWithoutOrder.h" -#include "constraints/Constraint.h" -#include "mtl/Map.h" - #ifndef AdapterAC3RM_H #define AdapterAC3RM_H +#include "constraints/Constraint.h" +#include "constraints/genericFiltering/TupleIteratorWithoutOrder.h" +#include "mtl/Vec.h" +#include "optimizer/ObjectiveConstraint.h" /** - * A class adapter to perform AC3rm on each type of constraint + * A class adapter to perform AC3rm on each type of constraint * See IJCAI'07 : Lecoutre, Hemery. A Study of Residual Supports in Arc Consistency. */ diff --git a/constraints/genericFiltering/TupleIterator.h b/constraints/genericFiltering/TupleIterator.h index 79e0449..f40c5db 100644 --- a/constraints/genericFiltering/TupleIterator.h +++ b/constraints/genericFiltering/TupleIterator.h @@ -30,6 +30,7 @@ class TupleIterator { toReturn.growTo(arity); fixedPositions.growTo(arity); } + virtual ~TupleIterator() = default; virtual void setFirstTuple(vec &first) = 0; diff --git a/constraints/genericFiltering/TupleIteratorWithoutOrder.h b/constraints/genericFiltering/TupleIteratorWithoutOrder.h index b91ec70..7f69b6e 100644 --- a/constraints/genericFiltering/TupleIteratorWithoutOrder.h +++ b/constraints/genericFiltering/TupleIteratorWithoutOrder.h @@ -19,6 +19,7 @@ class TupleIteratorWithoutOrder : public TupleIterator { public: explicit TupleIteratorWithoutOrder(vec &sc) : TupleIterator(sc) { positions.growTo(arity); } + virtual ~TupleIteratorWithoutOrder() = default; void setFirstTuple(vec &first) override; diff --git a/constraints/globals/comparison/DistinctVectors.cc b/constraints/globals/comparison/DistinctVectors.cc index 38457c9..b18ec1c 100644 --- a/constraints/globals/comparison/DistinctVectors.cc +++ b/constraints/globals/comparison/DistinctVectors.cc @@ -1,6 +1,5 @@ -#include "DistinctVectors.h" +#include "constraints/globals/comparison/DistinctVectors.h" -#include "DomainRange.h" #include "solver/Solver.h" using namespace Cosoco; diff --git a/constraints/globals/connection/Precedence.h b/constraints/globals/connection/Precedence.h index e994b25..4fa8373 100644 --- a/constraints/globals/connection/Precedence.h +++ b/constraints/globals/connection/Precedence.h @@ -5,9 +5,9 @@ #ifndef COSOCO_PRECEDENCECONSTRAINT_H #define COSOCO_PRECEDENCECONSTRAINT_H -#include "ObserverDecision.h" #include "constraints/globals/GlobalConstraint.h" #include "mtl/Vec.h" +#include "solver/observers/ObserverDecision.h" namespace Cosoco { diff --git a/constraints/globals/connection/element/ElementVariable.cc b/constraints/globals/connection/element/ElementVariable.cc index 00d19a5..13166bf 100644 --- a/constraints/globals/connection/element/ElementVariable.cc +++ b/constraints/globals/connection/element/ElementVariable.cc @@ -1,8 +1,7 @@ #include "ElementVariable.h" -#include - #include "solver/Solver.h" +#include "utils/Constants.h" using namespace Cosoco; diff --git a/constraints/globals/connection/minimum/MinimumConstant.h b/constraints/globals/connection/minimum/MinimumConstant.h index 659f942..12e988f 100644 --- a/constraints/globals/connection/minimum/MinimumConstant.h +++ b/constraints/globals/connection/minimum/MinimumConstant.h @@ -3,6 +3,7 @@ #include "constraints/globals/GlobalConstraint.h" #include "mtl/Vec.h" +#include "optimizer/ObjectiveConstraint.h" namespace Cosoco { class MinimumConstant : public GlobalConstraint, public ObjectiveConstraint { diff --git a/constraints/globals/connection/minimum/MinimumVariableEQ.h b/constraints/globals/connection/minimum/MinimumVariableEQ.h index 40c35f5..9c8f29c 100644 --- a/constraints/globals/connection/minimum/MinimumVariableEQ.h +++ b/constraints/globals/connection/minimum/MinimumVariableEQ.h @@ -1,8 +1,8 @@ -#include "Constraint.h" #ifndef MINIMUMVARIABLEEQ_H #define MINIMUMVARIABLEEQ_H +#include "constraints/Constraint.h" #include "constraints/globals/GlobalConstraint.h" #include "mtl/Vec.h" diff --git a/constraints/globals/counting/CardinalityWeak.h b/constraints/globals/counting/CardinalityWeak.h index 7632187..b74f715 100644 --- a/constraints/globals/counting/CardinalityWeak.h +++ b/constraints/globals/counting/CardinalityWeak.h @@ -1,5 +1,8 @@ #ifndef COSOCO_CARDINALITYWEAK_H #define COSOCO_CARDINALITYWEAK_H + +#include + #include "constraints/globals/GlobalConstraint.h" diff --git a/constraints/globals/counting/NValuesLEK.cc b/constraints/globals/counting/NValuesLEK.cc index 433bdb8..9a65c87 100644 --- a/constraints/globals/counting/NValuesLEK.cc +++ b/constraints/globals/counting/NValuesLEK.cc @@ -2,7 +2,7 @@ // Created by audemard on 26/04/2018. // -#include "NValuesLEK.h" +#include "constraints/globals/counting/NValuesLEK.h" #include @@ -37,7 +37,7 @@ bool NValuesLEK::filter(Variable *x) { if(y->size() == 1) myset.insert(y->value()); // set.add(map.get(y.dom.firstValue())); - if(myset.size() > k) + if((int)myset.size() > k) return false; if((int)myset.size() == k) { diff --git a/constraints/globals/counting/NValuesLEK.h b/constraints/globals/counting/NValuesLEK.h index 0bd909d..527514c 100644 --- a/constraints/globals/counting/NValuesLEK.h +++ b/constraints/globals/counting/NValuesLEK.h @@ -4,11 +4,10 @@ #ifndef COSOCO_NVALUESLEK_H #define COSOCO_NVALUESLEK_H - - -#include - #include + +#include "constraints/globals/GlobalConstraint.h" +#include "optimizer/ObjectiveConstraint.h" namespace Cosoco { class NValuesLEK : public GlobalConstraint, public ObjectiveConstraint { public: diff --git a/constraints/globals/packing/BinPacking.cc b/constraints/globals/packing/BinPacking.cc index 8a8f4a1..fc1e386 100644 --- a/constraints/globals/packing/BinPacking.cc +++ b/constraints/globals/packing/BinPacking.cc @@ -2,9 +2,8 @@ // Created by audemard on 08/02/2022. // -#include "BinPacking.h" +#include "constraints/globals/packing/BinPacking.h" -#include "Sort.h" #include "solver/Solver.h" using namespace Cosoco; diff --git a/constraints/globals/packing/BinPacking.h b/constraints/globals/packing/BinPacking.h index 77c8a56..d8f28dc 100644 --- a/constraints/globals/packing/BinPacking.h +++ b/constraints/globals/packing/BinPacking.h @@ -5,9 +5,9 @@ #ifndef COSOCO_BINPACKING_H #define COSOCO_BINPACKING_H -#include "ObserverDecision.h" #include "constraints/globals/GlobalConstraint.h" #include "mtl/SparseSetMultiLevel.h" +#include "solver/observers/ObserverDecision.h" namespace Cosoco { diff --git a/constraints/globals/packing/CumulativeVariablesC.cc b/constraints/globals/packing/CumulativeVariablesC.cc index ba126e3..1d70c80 100644 --- a/constraints/globals/packing/CumulativeVariablesC.cc +++ b/constraints/globals/packing/CumulativeVariablesC.cc @@ -2,10 +2,9 @@ // Created by audemard on 21/12/2022. // -#include "CumulativeVariablesC.h" +#include "constraints/globals/packing/CumulativeVariablesC.h" -#include "Constraint.h" -#include "solver/Solver.h" +#include "constraints/Constraint.h" using namespace Cosoco; diff --git a/constraints/globals/summing/SumGE.h b/constraints/globals/summing/SumGE.h index df69f34..41c2223 100644 --- a/constraints/globals/summing/SumGE.h +++ b/constraints/globals/summing/SumGE.h @@ -1,7 +1,8 @@ #ifndef SUMGE_H #define SUMGE_H -#include "Sum.h" +#include "constraints/globals/summing/Sum.h" +#include "optimizer/ObjectiveConstraint.h" namespace Cosoco { class SumGE : public Sum, public ObjectiveConstraint { diff --git a/constraints/intension/Intension.cc b/constraints/intension/Intension.cc index 65f7fe7..c898c59 100644 --- a/constraints/intension/Intension.cc +++ b/constraints/intension/Intension.cc @@ -1,6 +1,8 @@ #include "constraints/intension/Intension.h" -#include +#ifdef USE_XCSP3 +#include "XCSP3Tree.h" + using namespace Cosoco; @@ -36,8 +38,8 @@ bool Intension::filter(Variable *dummy) { void Intension::updateBound(long bound) { - auto *nodeB = dynamic_cast(evaluator->root); - auto *nodeC = dynamic_cast(nodeB->parameters[1]); + auto *nodeB = dynamic_cast(evaluator->root); + auto *nodeC = dynamic_cast(nodeB->parameters[1]); nodeC->val = bound; } @@ -51,9 +53,11 @@ long Intension::minLowerBound() { return INT_MIN + 10; } long Intension::computeScore(vec &solution) { assert(solution.size() == scope.size()); for(int i = 0; i < scope.size(); i++) tuple[scope[i]->_name] = solution[i]; - auto *nodeB = dynamic_cast(evaluator->root); + auto *nodeB = dynamic_cast(evaluator->root); return nodeB->parameters[0]->evaluate(tuple); } -void Intension::display(bool d) { std::cout << evaluator->toString() << std::endl; } \ No newline at end of file +void Intension::display(bool d) { std::cout << evaluator->toString() << std::endl; } + +#endif /* USE_XCSP3 */ \ No newline at end of file diff --git a/constraints/intension/Intension.h b/constraints/intension/Intension.h index c96d92a..98ce5c2 100644 --- a/constraints/intension/Intension.h +++ b/constraints/intension/Intension.h @@ -1,18 +1,28 @@ #ifndef INTENSION_H #define INTENSION_H -#include "XCSP3Tree.h" +#ifdef USE_XCSP3 +#include + #include "constraints/Constraint.h" -using namespace XCSP3Core; +#include "optimizer/ObjectiveConstraint.h" + + +namespace XCSP3Core { +class Tree; +} + + namespace Cosoco { class Intension : public Constraint, public ObjectiveConstraint { protected: - Tree * evaluator; + XCSP3Core::Tree *evaluator; std::map tuple; public: // Constructors - Intension(Problem &p, std::string n, Tree *tree, vec &scope) : Constraint(p, n, scope), evaluator(tree) { + Intension(Problem &p, std::string n, XCSP3Core::Tree *tree, vec &scope) + : Constraint(p, n, scope), evaluator(tree) { type = "Intension"; } @@ -39,5 +49,5 @@ class Intension : public Constraint, public ObjectiveConstraint { }; } // namespace Cosoco - +#endif /* USE_XCSP3 */ #endif /* INTENSION_H */ diff --git a/constraints/primitives/DisjunctiveVars.h b/constraints/primitives/DisjunctiveVars.h index 93be0bc..607a73d 100644 --- a/constraints/primitives/DisjunctiveVars.h +++ b/constraints/primitives/DisjunctiveVars.h @@ -5,8 +5,8 @@ #ifndef COSOCO_DISJUNCTIVEVARS_H #define COSOCO_DISJUNCTIVEVARS_H -#include "Constraint.h" -#include "GlobalConstraint.h" +#include "constraints/Constraint.h" +#include "constraints/globals/GlobalConstraint.h" namespace Cosoco { class DisjunctiveVars : public GlobalConstraint { public: diff --git a/constraints/primitives/DistNE.cc b/constraints/primitives/DistNE.cc index b2d2c1f..57c89d0 100644 --- a/constraints/primitives/DistNE.cc +++ b/constraints/primitives/DistNE.cc @@ -1,6 +1,6 @@ -#include "DistNE.h" +#include "constraints/primitives/DistNE.h" -#include "Binary.h" +#include "constraints/Binary.h" #include "core/Variable.h" #include "solver/Solver.h" diff --git a/constraints/primitives/GEUnary.h b/constraints/primitives/GEUnary.h index 80451f9..123a97d 100644 --- a/constraints/primitives/GEUnary.h +++ b/constraints/primitives/GEUnary.h @@ -5,16 +5,16 @@ #ifndef COSOCO_GEUNARY_H #define COSOCO_GEUNARY_H #include "constraints/Constraint.h" - +#include "optimizer/ObjectiveConstraint.h" namespace Cosoco { -class GEUnary : public Constraint, public ObjectiveConstraint { +class GEUnary : public Constraint, public ObjectiveConstraint { public: int k; // Constructors - GEUnary(Problem &p, std::string n, Variable *x, int k); + GEUnary(Problem &p, std::string n, Variable *x, int k); // filtering bool filter(Variable *x) override; @@ -29,6 +29,4 @@ class GEUnary : public Constraint, public ObjectiveConstraint { } // namespace Cosoco - - #endif // COSOCO_GEUNARY_H diff --git a/constraints/primitives/LEUnary.h b/constraints/primitives/LEUnary.h index f56aa71..833826b 100644 --- a/constraints/primitives/LEUnary.h +++ b/constraints/primitives/LEUnary.h @@ -5,16 +5,16 @@ #ifndef COSOCO_LEUNARY_H #define COSOCO_LEUNARY_H #include "constraints/Constraint.h" - +#include "optimizer/ObjectiveConstraint.h" namespace Cosoco { -class LEUnary : public Constraint, public ObjectiveConstraint { +class LEUnary : public Constraint, public ObjectiveConstraint { public: int k; // Constructors - LEUnary(Problem &p, std::string n, Variable *x, int k); + LEUnary(Problem &p, std::string n, Variable *x, int k); // filtering bool filter(Variable *x) override; @@ -29,6 +29,4 @@ class LEUnary : public Constraint, public ObjectiveConstraint { } // namespace Cosoco - - #endif // COSOCO_LEUNARY_H diff --git a/constraints/primitives/Reification.h b/constraints/primitives/Reification.h index 2659c84..50897e5 100644 --- a/constraints/primitives/Reification.h +++ b/constraints/primitives/Reification.h @@ -6,7 +6,7 @@ #define COSOCO_REIFICATION_H -#include "Binary.h" +#include "constraints/Binary.h" #include "constraints/Ternary.h" namespace Cosoco { diff --git a/core/OptimizationProblem.cc b/core/OptimizationProblem.cc index c645849..5f94d4b 100644 --- a/core/OptimizationProblem.cc +++ b/core/OptimizationProblem.cc @@ -5,23 +5,18 @@ using namespace Cosoco; OptimizationProblem::OptimizationProblem(const std::string &n) : Problem(n), objectiveLB(nullptr), objectiveUB(nullptr) { } -void OptimizationProblem::addObjectiveLB(ObjectiveConstraint *o, bool alreadyAdded) { +void OptimizationProblem::addObjectiveLB(ObjectiveConstraint *o) { if(objectiveLB != nullptr) throw std::logic_error("Lower Bound Objective is already specified"); if(isConstructionDone) throw std::logic_error("Construction of the problem is already done! You can not add objective\n"); objectiveLB = o; - if(alreadyAdded == false) - addConstraint(dynamic_cast(o)); } - -void OptimizationProblem::addObjectiveUB(ObjectiveConstraint *o, bool alreadyAdded) { +void OptimizationProblem::addObjectiveUB(ObjectiveConstraint *o) { if(objectiveUB != nullptr) throw std::logic_error("Upper Bound Objective is already specified"); if(isConstructionDone) throw std::logic_error("Construction of the problem is already done! You can not add objective\n"); objectiveUB = o; - if(alreadyAdded == false) - addConstraint(dynamic_cast(o)); } diff --git a/core/OptimizationProblem.h b/core/OptimizationProblem.h index 80dd7b7..01d4e01 100644 --- a/core/OptimizationProblem.h +++ b/core/OptimizationProblem.h @@ -16,8 +16,8 @@ class OptimizationProblem : public Problem { // An optimosation problem is a p ObjectiveConstraint *objectiveUB; // ctr <= ct OptimisationType type; // Minimize or Maximize? - void addObjectiveLB(ObjectiveConstraint *o, bool alreadyAdded = false); // Add the LB constraint - void addObjectiveUB(ObjectiveConstraint *o, bool alreadyAdded = false); // Add the UB constraint + void addObjectiveLB(ObjectiveConstraint *o); // Add the already added LB constraint + void addObjectiveUB(ObjectiveConstraint *o); // Add the already added UB constraint }; } // namespace Cosoco diff --git a/core/Problem.cc b/core/Problem.cc index 9377aeb..191f85e 100644 --- a/core/Problem.cc +++ b/core/Problem.cc @@ -17,14 +17,14 @@ void Problem::delayedConstruction() { isConstructionDone = true; int idx = 0; - for(Variable *v : variables) v->delayedConstruction(idx++, variables.size()); + for(auto &v : variables) v->delayedConstruction(idx++, variables.size()); int idc = 0; - for(Constraint *c : constraints) c->delayedConstruction(idc++); + for(auto &c : constraints) c->delayedConstruction(idc++); bool error = false; try { - for(Constraint *c : constraints) { + for(auto &c : constraints) { c->scopeIsOk(); c->isCorrectlyDefined(); } @@ -36,7 +36,7 @@ void Problem::delayedConstruction() { throw std::logic_error("Some constraints are badly defined"); isBinary = maximumArity() == 2; - for(Variable *x : variables) { + for(auto &x : variables) { if(x->constraints.size() == 0) x->useless = true; } @@ -45,22 +45,23 @@ void Problem::delayedConstruction() { void Problem::attachSolver(Solver *s) { solver = s; - for(Constraint *c : constraints) c->attachSolver(solver); + for(auto &c : constraints) c->attachSolver(solver); } -void Problem::addConstraint(Constraint *c) { +void Problem::addConstraint(std::unique_ptr &&c) { if(isConstructionDone) throw std::logic_error("Construction of the problem is already done! You can not add constraints"); - constraints.push(c); + constraints.emplace_back(std::move(c)); } Variable *Problem::createVariable(std::string n, Domain &d, int array) { if(isConstructionDone) throw std::logic_error("Construction of the problem is already done! You can not add variables"); - auto *v = new Variable(*this, n, d, nbVariables(), array); - variables.push(v); + + variables.emplace_back(std::make_unique(*this, n, d, nbVariables(), array)); + auto *v = variables.back().get(); mapping[v->name()] = v; return v; } @@ -70,13 +71,13 @@ Variable *Problem::createVariable(std::string n, Domain &d, int array) { bool Problem::checkSolution() { vec tuple; // All variables must be assigned - for(Variable *v : variables) + for(auto &v : variables) if(v->size() != 1 && v->useless == false) { fprintf(stderr, "Solution Error : var %s has domain of size %d\n", v->name(), v->size()); return false; } - for(Constraint *c : constraints) { + for(auto &c : constraints) { tuple.clear(); for(Variable *x : c->scope) tuple.push(x->domain.toVal(x->domain[0])); @@ -102,9 +103,9 @@ int Problem::nbConstraints() const { return constraints.size(); } int Problem::maximumTuplesInExtension() { unsigned int tmp = 0; - for(Constraint *c : constraints) { + for(auto &c : constraints) { Extension *ext; - if((ext = dynamic_cast(c)) == nullptr) + if((ext = dynamic_cast(c.get())) == nullptr) continue; if(tmp < ext->nbTuples()) tmp = ext->nbTuples(); @@ -115,9 +116,9 @@ int Problem::maximumTuplesInExtension() { int Problem::minimumTuplesInExtension() { unsigned int tmp = INT_MAX; - for(Constraint *c : constraints) { + for(auto &c : constraints) { Extension *ext; - if((ext = dynamic_cast(c)) == nullptr) + if((ext = dynamic_cast(c.get())) == nullptr) continue; if(tmp > ext->nbTuples()) tmp = ext->nbTuples(); @@ -128,7 +129,7 @@ int Problem::minimumTuplesInExtension() { int Problem::nbConstraintsOfSize(int size) { int nb = 0; - for(Constraint *c : constraints) + for(auto &c : constraints) if(c->scope.size() == size) nb++; return nb; @@ -136,13 +137,13 @@ int Problem::nbConstraintsOfSize(int size) { long Problem::nbValues() { long tmp = 0; - for(Variable *x : variables) tmp += x->size(); + for(auto &x : variables) tmp += x->size(); return tmp; } int Problem::minimumArity() { int tmp = constraints[0]->scope.size(); - for(Constraint *c : constraints) + for(auto &c : constraints) if(c->scope.size() < tmp) tmp = c->scope.size(); return tmp; @@ -151,7 +152,7 @@ int Problem::minimumArity() { int Problem::maximumArity() { int tmp = 0; - for(Constraint *c : constraints) + for(auto &c : constraints) if(c->scope.size() > tmp) tmp = c->scope.size(); return tmp; @@ -160,7 +161,7 @@ int Problem::maximumArity() { int Problem::maximumDomainSize() { int nb = variables[0]->size(); - for(Variable *v : variables) + for(auto &v : variables) if(nb < v->size()) nb = v->size(); return nb; @@ -169,7 +170,7 @@ int Problem::maximumDomainSize() { int Problem::minimumDomainSize() { int nb = variables[0]->size(); - for(Variable *v : variables) + for(auto &v : variables) if(nb > v->size()) nb = v->size(); return nb; @@ -177,20 +178,20 @@ int Problem::minimumDomainSize() { void Problem::nbTypeOfConstraints(std::map &tmp) { - for(Constraint *c : constraints) tmp[c->type]++; + for(auto &c : constraints) tmp[c->type]++; } // displayCurrentBranch void Problem::display(bool alldetails) { printf("Variables : \n"); - for(Variable *v : variables) { + for(auto &v : variables) { printf(" "); v->display(true); printf("\n"); } printf("Constraint : \n"); - for(Constraint *c : constraints) { + for(auto &c : constraints) { printf(" "); c->display(true); printf("\n"); diff --git a/core/Problem.h b/core/Problem.h index 95146c3..6522dd6 100644 --- a/core/Problem.h +++ b/core/Problem.h @@ -2,7 +2,9 @@ #define PROBLEM_H #include +#include #include +#include #include "constraints/Constraint.h" #include "core/Variable.h" @@ -17,15 +19,15 @@ class Solver; class Problem { public: - const std::string name; // The name of the problem - Solver *solver; // The attached solver (initialized to nullptr) - vec constraints; // The set of constraints - vec variables; // The set of variables - vec > variablesArray; // The different arrays of Variables - bool isConstructionDone; // true if the construction of the problem is done - bool isBinary; // Not currently used - int nbExtensionsSharded; // nb extension constraints shared - int nbOriginalVars; // The number of original vars in the model + const std::string name; // The name of the problem + Solver *solver; // The attached solver (initialized to nullptr) + std::vector> constraints; // The set of constraints + std::vector> variables; // The set of variables + vec> variablesArray; // The different arrays of Variables + bool isConstructionDone; // true if the construction of the problem is done + bool isBinary; // Not currently used + int nbExtensionsSharded; // nb extension constraints shared + int nbOriginalVars; // The number of original vars in the model std::map mapping; // The mapping between the name of the variables and the Variable itself. Useful for parsing @@ -37,7 +39,7 @@ class Problem { Variable *createVariable(std::string n, Domain &d, int array = -1); // Add a new variable - void addConstraint(Constraint *c); // Add a new constraint + void addConstraint(std::unique_ptr &&c); // Add a new constraint // Problem Statistics diff --git a/core/domain/Domain.h b/core/domain/Domain.h index d4a27b4..8fef13a 100644 --- a/core/domain/Domain.h +++ b/core/domain/Domain.h @@ -5,7 +5,6 @@ #include "mtl/LinkedSet.h" #include "mtl/LinkedSetIterator.h" #include "mtl/Vec.h" -#include "utils/Verbose.h" namespace Cosoco { @@ -26,6 +25,7 @@ class Domain { // Constructors and initialisation Domain(int sz) : idvs(sz, true) { } + virtual ~Domain() = default; void delayedConstruction(int nbVars) { } diff --git a/core/domain/DomainRange.h b/core/domain/DomainRange.h index a69b5af..aecc88d 100644 --- a/core/domain/DomainRange.h +++ b/core/domain/DomainRange.h @@ -1,7 +1,7 @@ #ifndef DOMAINRANGE_H #define DOMAINRANGE_H -#include "Domain.h" +#include "core/domain/Domain.h" namespace Cosoco { diff --git a/main/Main.cc b/main/Main.cc index 4717bd3..e31d688 100644 --- a/main/Main.cc +++ b/main/Main.cc @@ -1,12 +1,11 @@ -#include #include #include -#include #include "XCSP3CoreParser.h" +#include "optimizer/Optimizer.h" #include "solver/Solver.h" -#include "utils/CosocoCallbacks.h" +#include "solver/utils/CosocoCallbacks.h" #include "utils/Options.h" #include "utils/System.h" @@ -221,7 +220,7 @@ void displayProblemStatistics(Problem *solvingProblem, double initial_time) { solvingProblem->nbTypeOfConstraints(typeOfConstraints); std::set bigConstraints; - for(Constraint *c : solvingProblem->constraints) + for(auto &c : solvingProblem->constraints) if(c->scope.size() > 100) bigConstraints.insert(c->type); diff --git a/mtl/IntTypes.h b/mtl/IntTypes.h index 6f3da71..63dd41e 100644 --- a/mtl/IntTypes.h +++ b/mtl/IntTypes.h @@ -30,7 +30,6 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #else -#include #include #endif diff --git a/mtl/Map.h b/mtl/Map.h index 718e357..70f65af 100644 --- a/mtl/Map.h +++ b/mtl/Map.h @@ -21,9 +21,7 @@ OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWA #define Cosoco_Map_h #include -#include -#include "mtl/IntTypes.h" #include "mtl/Vec.h" namespace Cosoco { @@ -192,8 +190,7 @@ class Map { assert(table != NULL); vec& ps = table[index(k)]; int j = 0; - for(; j < ps.size() && !equals(ps[j].key, k); j++) - ; + for(; j < ps.size() && !equals(ps[j].key, k); j++); assert(j < ps.size()); ps[j] = ps.last(); ps.pop(); diff --git a/mtl/Matrix.h b/mtl/Matrix.h index c0c8c36..02a7df9 100644 --- a/mtl/Matrix.h +++ b/mtl/Matrix.h @@ -9,7 +9,8 @@ #include #include "Vec.h" -#include "XCSP3Constants.h" +#include "utils/Constants.h" + namespace Cosoco { template class Matrix { diff --git a/mtl/SparseSetOfVariables.h b/mtl/SparseSetOfVariables.h index f16293e..2df7295 100644 --- a/mtl/SparseSetOfVariables.h +++ b/mtl/SparseSetOfVariables.h @@ -5,6 +5,8 @@ #include #include +#include +#include #include "core/Constants.h" #include "core/Variable.h" @@ -31,14 +33,14 @@ class SparseSetOfVariables { public: // Constructor - SparseSetOfVariables(int size, vec &vars, bool full = false) : maxsz(size) { + SparseSetOfVariables(int size, const std::vector> &vars, bool full = false) : maxsz(size) { positions.growTo(size); elements.growTo(size); - assert(vars.size() == size); + assert(vars.size() == (size_t)size); for(int i = 0; i < size; i++) { assert(vars[i]->idx == i); // Be careful positions[i] = i; - elements[i] = vars[i]; + elements[i] = vars[i].get(); } limit = full ? size : 0; } diff --git a/optimizer/ObjectiveConstraint.h b/optimizer/ObjectiveConstraint.h index cd5f317..71e085c 100644 --- a/optimizer/ObjectiveConstraint.h +++ b/optimizer/ObjectiveConstraint.h @@ -6,6 +6,8 @@ namespace Cosoco { class ObjectiveConstraint { // This constraint can be used as an objective public: + virtual ~ObjectiveConstraint() = default; + virtual void updateBound(long bound) = 0; // Update the current bound virtual long maxUpperBound() = 0; // Bounds are included virtual long minLowerBound() = 0; // Bounds are included diff --git a/optimizer/Optimizer.cc b/optimizer/Optimizer.cc index a3efa37..2976ec2 100644 --- a/optimizer/Optimizer.cc +++ b/optimizer/Optimizer.cc @@ -1,10 +1,8 @@ #include "Optimizer.h" -#include - -#include "Options.h" #include "core/OptimizationProblem.h" -#include "utils/System.h" +#include "solver/restarts/Restart.h" +#include "solver/utils/Options.h" using namespace Cosoco; @@ -89,8 +87,10 @@ int Optimizer::solveInOneDirection(vec &assumps) { if(progressSaving) { vec idvalues; idvalues.growTo(solver->problem.nbVariables()); - for(Variable *x : solver->problem.variables) idvalues[x->idx] = solver->problem.variables[x->idx]->domain[0]; - ((ForceIdvs *)solver->heuristicVal)->setIdValues(idvalues); + for(auto &x : solver->problem.variables) { + idvalues[x->idx] = solver->problem.variables[x->idx]->domain[0]; + } + ((ForceIdvs *)solver->heuristicVal.get())->setIdValues(idvalues); } } diff --git a/optimizer/Optimizer.h b/optimizer/Optimizer.h index e808054..84c1c71 100644 --- a/optimizer/Optimizer.h +++ b/optimizer/Optimizer.h @@ -4,11 +4,12 @@ #include #include "ObjectiveConstraint.h" -#include "Solution.h" #include "core/OptimizationProblem.h" #include "core/Problem.h" +#include "optimizer/Solution.h" #include "solver/AbstractSolver.h" #include "solver/Solver.h" +#include "solver/heuristics/values/HeuristicVal.h" namespace Cosoco { @@ -53,7 +54,7 @@ class Optimizer : public AbstractSolver, ObserverConflict { void addProgressSaving() { assert(solver != nullptr); progressSaving = true; - solver->heuristicVal = new ForceIdvs(*solver, solver->heuristicVal, false); + solver->heuristicVal = std::make_unique(*solver, std::move(solver->heuristicVal), false); } diff --git a/optimizer/Solution.h b/optimizer/Solution.h index 69b6dbd..7f4f24e 100644 --- a/optimizer/Solution.h +++ b/optimizer/Solution.h @@ -1,16 +1,14 @@ #ifndef COSOCO_SOLUTION_H #define COSOCO_SOLUTION_H -#include -#include -#include - #include -#include #include +#include -#include "Termcolor.h" -#include "mtl/Vec.h" +#include "core/OptimizationProblem.h" +#include "utils/Constants.h" +#include "utils/System.h" +#include "utils/Termcolor.h" namespace Cosoco { diff --git a/solver/AbstractSolver.h b/solver/AbstractSolver.h index 86b2b08..70c81e1 100644 --- a/solver/AbstractSolver.h +++ b/solver/AbstractSolver.h @@ -41,6 +41,7 @@ class AbstractSolver { virtual void displayCurrentSolution() = 0; // displayCurrentBranch the current solution AbstractSolver(Problem &pp) : problem(pp), core(0), status(RUNNING), nbSolutions(0), random_seed(91648253) { } + virtual ~AbstractSolver() = default; void setVerbosity(int vv) { diff --git a/solver/Solver.cc b/solver/Solver.cc index 3e8713e..0e99261 100644 --- a/solver/Solver.cc +++ b/solver/Solver.cc @@ -1,32 +1,32 @@ -#include "./Solver.h" - -#include -#include -#include -#include -#include -#include -#include -#include - -#include +#include "solver/Solver.h" + #include +#include -#include "HeuristicValASGS.h" -#include "HeuristicValOccs.h" -#include "HeuristicValRoundRobin.h" -#include "HeuristicVarFRBA.h" -#include "HeuristicVarRoundRobin.h" -#include "Options.h" -#include "PickOnDom.h" -#include "PoolOfHeuristicsValues.h" #include "constraints/Constraint.h" +#include "core/Problem.h" #include "core/Variable.h" +#include "heuristics/values/HeuristicValASGS.h" #include "heuristics/values/HeuristicValFirst.h" +#include "heuristics/values/HeuristicValOccs.h" +#include "heuristics/values/HeuristicValRoundRobin.h" #include "heuristics/values/HeuristicValStickingValue.h" #include "heuristics/variables/HeuristicVarDomWdeg.h" +#include "heuristics/variables/HeuristicVarFRBA.h" +#include "heuristics/variables/HeuristicVarRoundRobin.h" #include "heuristics/variables/LastConflictReasoning.h" #include "heuristics/variables/RandomizeFirstDescent.h" +#include "solver/heuristics/values/HeuristicValLast.h" +#include "solver/heuristics/values/HeuristicValRandom.h" +#include "solver/heuristics/values/PoolOfHeuristicsValues.h" +#include "solver/heuristics/variables/HeuristicVarCACD.h" +#include "solver/heuristics/variables/PickOnDom.h" +#include "solver/restarts/GeometricRestart.h" +#include "solver/restarts/InnerOuter.h" +#include "solver/restarts/LubyRestart.h" +#include "solver/utils/Options.h" +#include "solver/utils/Profiling.h" +#include "utils/System.h" using namespace Cosoco; using namespace std; //---------------------------------------------- @@ -57,36 +57,36 @@ Solver::Solver(Problem &p) doProfiling = options::boolOptions["profile"].value; if(options::stringOptions["val"].value == "first") - heuristicVal = new HeuristicValFirst(*this); + heuristicVal = std::make_unique(*this); if(options::stringOptions["val"].value == "rand") - heuristicVal = new HeuristicValRandom(*this); + heuristicVal = std::make_unique(*this); if(options::stringOptions["val"].value == "last") - heuristicVal = new HeuristicValLast(*this); + heuristicVal = std::make_unique(*this); if(options::stringOptions["val"].value == "robin") - heuristicVal = new HeuristicValRoundRobin(*this, options::stringOptions["robin"].value); + heuristicVal = std::make_unique(*this, options::stringOptions["robin"].value); if(options::stringOptions["val"].value == "occs") - heuristicVal = new HeuristicValOccs(*this); + heuristicVal = std::make_unique(*this); if(options::stringOptions["val"].value == "asgs") - heuristicVal = new HeuristicValASGS(*this); + heuristicVal = std::make_unique(*this); if(options::stringOptions["val"].value == "pool") - heuristicVal = new PoolOfHeuristicsValues(*this); - if(heuristicVal == nullptr) { + heuristicVal = std::make_unique(*this); + if(heuristicVal.get() == nullptr) { std::cerr << "unknown heuristic value " << options::stringOptions["val"].value << "\n"; exit(1); } if(options::stringOptions["var"].value == "wdeg") - heuristicVar = new HeuristicVarDomWdeg(*this); + heuristicVar = std::make_unique(*this); if(options::stringOptions["var"].value == "cacd") - heuristicVar = new HeuristicVarCACD(*this); + heuristicVar = std::make_unique(*this); if(options::stringOptions["var"].value == "pick") - heuristicVar = new PickOnDom(*this); + heuristicVar = std::make_unique(*this); if(options::stringOptions["var"].value == "frba") - heuristicVar = new HeuristicVarFRBA(*this); + heuristicVar = std::make_unique(*this); if(options::stringOptions["var"].value == "robin") - heuristicVar = new HeuristicVarRoundRobin(*this); - if(heuristicVar == nullptr) { + heuristicVar = std::make_unique(*this); + if(heuristicVar.get() == nullptr) { std::cerr << "unknown heuristic variable " << options::stringOptions["var"].value << "\n"; exit(1); } @@ -120,11 +120,11 @@ Solver::Solver(Problem &p) if(options::boolOptions["stick"].value) addStickingValue(); if(options::stringOptions["restarts"].value == "geo") - restart = new GeometricRestart(this); + restart = std::make_unique(this); if(options::stringOptions["restarts"].value == "luby") - restart = new LubyRestart(this); + restart = std::make_unique(this); if(options::stringOptions["restarts"].value == "io") - restart = new InnerOuterRestart(this); + restart = std::make_unique(this); if(restart == nullptr && options::stringOptions["restarts"].value != "no") { std::cerr << "unknown heuristic restart " << options::stringOptions["restart"].value << "\n"; exit(1); @@ -150,18 +150,20 @@ Solver::Solver(Problem &p) void Solver::addNoGoodsFromRestarts() { nogoodsFromRestarts = true; - noGoodsEngine = new NoGoodsEngine(*this); + noGoodsEngine = std::make_unique(*this); } void Solver::addLastConflictReasoning() { - heuristicVar = new LastConflictReasoning(*this, heuristicVar, options::intOptions["lc"].value); + heuristicVar = std::make_unique(*this, std::move(heuristicVar), options::intOptions["lc"].value); } -void Solver::addRandomizationFirstDescent() { heuristicVar = new RandomizeFirstDescent(*this, heuristicVar); } +void Solver::addRandomizationFirstDescent() { + heuristicVar = std::make_unique(*this, std::move(heuristicVar)); +} -void Solver::addStickingValue() { heuristicVal = new HeuristicValStickingValue(*this, heuristicVal); } +void Solver::addStickingValue() { heuristicVal = std::make_unique(*this, std::move(heuristicVal)); } void Solver::setDecisionVariables(vec &vars) { @@ -210,10 +212,10 @@ int Solver::solve(vec &assumps) { } // Remove useless variables: - for(Variable *x : problem.variables) + for(auto &x : problem.variables) if(x->useless) { - unassignedVariables.del(x); - decisionVariables.del(x); + unassignedVariables.del(x.get()); + decisionVariables.del(x.get()); } return search(assumps); @@ -250,7 +252,7 @@ int Solver::search(vec &assumptions) { RootPropagation &assumption = assumptions[decisionLevel()]; // printf("x=%d equal=%d idv=%d\n", assumption.idx,assumption.equal, assumption.idv); // assert(assumption.equal); // We deal only with positive assumptions - Variable *tmp = problem.variables[assumption.idx]; + auto *tmp = problem.variables[assumption.idx].get(); if(tmp->containsIdv(assumption.idv) == false) { // UNSAT WRT Assumptions fullBacktrack(); @@ -305,7 +307,7 @@ bool Solver::manageSolution() { problem.checkSolution(); lastSolution.clear(); // Store the last solution - for(Variable *x : problem.variables) lastSolution.push(x->useless ? 0 : x->value()); + for(auto &x : problem.variables) lastSolution.push(x->useless ? 0 : x->value()); if(displaySolution) displayCurrentSolution(); @@ -363,7 +365,7 @@ bool Solver::isAssigned(Variable *x) const { return unassignedVariables.contains //---------------------------------------------- void Solver::reinitializeConstraints() { - for(Constraint *c : problem.constraints) { // Reinitialisze status for all constraints + for(auto &c : problem.constraints) { // Reinitialisze status for all constraints c->reinitialize(); assert(c->status() == UNDEF); } @@ -382,7 +384,7 @@ void Solver::fullBacktrack(bool all) { queue.clear(); // Useless ? trail_lim.clear(); decisionVariablesId.clear(); - for(Variable *x : problem.variables) // Reinitialize all domain variables. + for(auto &x : problem.variables) // Reinitialize all domain variables. x->domain.reinitialize(); } notifyFullBactrack(); @@ -566,7 +568,7 @@ Constraint *Solver::propagateComplete() { assert(decisionLevel() == 0); queue.fill(); - for(Variable *x : problem.variables) x->timestamp = ++timestamp; + for(auto &x : problem.variables) x->timestamp = ++timestamp; return propagate(); } @@ -795,12 +797,12 @@ void Solver::displayCurrentSolution() { printf("c solution %d\n", nbSolutions); printf("\nv \n"); printf("v "); - for(Variable *x : problem.variables) + for(auto &x : problem.variables) if(x->_name.rfind("__av", 0) != 0) printf("%s ", x->name()); printf("\n"); printf("v "); - for(Variable *x : problem.variables) + for(auto &x : problem.variables) if(x->_name.rfind("__av", 0) != 0) { if(x->useless) printf("* "); diff --git a/solver/Solver.h b/solver/Solver.h index bdaa769..8d65c6d 100644 --- a/solver/Solver.h +++ b/solver/Solver.h @@ -1,24 +1,20 @@ #ifndef SOLVER_H #define SOLVER_H -#include -#include - +#include #include -#include "AbstractSolver.h" -#include "Profiling.h" #include "core/Problem.h" #include "heuristics/values/HeuristicVal.h" #include "heuristics/variables/HeuristicVar.h" -#include "mtl/SparseSetCounter.h" #include "mtl/SparseSetMultiLevel.h" #include "mtl/SparseSetOfVariables.h" #include "mtl/Vec.h" -#include "nogoods/NoGoodsEngine.h" #include "observers/ObserverConflict.h" #include "observers/ObserverDecision.h" -#include "restarts/Restart.h" +#include "solver/AbstractSolver.h" +#include "solver/nogoods/NoGoodsEngine.h" +#include "solver/observers/ObserverDomainReduction.h" namespace Cosoco { #define NBSTATS 3 @@ -72,9 +68,9 @@ class Solver : public AbstractSolver { bool stopSearch = false; // Stop the search usefull, in // with the optimizer bool warmStart; // -- Heuristics ------------------------------------------------------------------------ - HeuristicVar *heuristicVar; // The heuristic to choose variables - HeuristicVal *heuristicVal; // The heuristic to choose values - Restart *restart = nullptr; // The restart strategy + std::unique_ptr heuristicVar; // The heuristic to choose variables + std::unique_ptr heuristicVal; // The heuristic to choose values + std::unique_ptr restart; // The restart strategy // -- Propagations ---------------------------------------------------------------------- SparseSetOfVariables queue; // Propagation queue Constraint *currentFilteredConstraint; // The constraint that is filtered @@ -88,7 +84,7 @@ class Solver : public AbstractSolver { unsigned long timestamp = 0; // Current timestamp // -- Nogoods from Restarts ----------------------------------------------------------- - NoGoodsEngine *noGoodsEngine; + std::unique_ptr noGoodsEngine; bool nogoodsFromRestarts = false; void addNoGoodsFromRestarts(); diff --git a/solver/heuristics/values/ForceIdv.cc b/solver/heuristics/values/ForceIdv.cc index 511b557..86cce75 100644 --- a/solver/heuristics/values/ForceIdv.cc +++ b/solver/heuristics/values/ForceIdv.cc @@ -6,7 +6,8 @@ using namespace Cosoco; -ForceIdvs::ForceIdvs(Solver &s, HeuristicVal *h, bool oo, vec *values) : HeuristicVal(s), hv(h), conflictAlreadySeen(false), onlyOnce(oo) { +ForceIdvs::ForceIdvs(Solver &s, std::unique_ptr &&h, bool oo, vec *values) + : HeuristicVal(s), hv(std::move(h)), conflictAlreadySeen(false), onlyOnce(oo) { s.addObserverConflict(this); idvs.growTo(solver.problem.nbVariables(), -1); if(values != nullptr) { diff --git a/solver/heuristics/values/ForceIdv.h b/solver/heuristics/values/ForceIdv.h index 83c71b7..9d0aebe 100644 --- a/solver/heuristics/values/ForceIdv.h +++ b/solver/heuristics/values/ForceIdv.h @@ -2,6 +2,8 @@ #define COSOCO_FORCEVALUE_H #include +#include + #include "HeuristicVal.h" @@ -9,13 +11,13 @@ namespace Cosoco { // Try to assign value class ForceIdvs : public HeuristicVal, ObserverConflict { protected: - vec idvs; - HeuristicVal *hv; - bool conflictAlreadySeen; - bool onlyOnce; + vec idvs; + std::unique_ptr hv; + bool conflictAlreadySeen; + bool onlyOnce; public: - ForceIdvs(Solver &s, HeuristicVal *h, bool oo = true, vec *values = nullptr); + ForceIdvs(Solver &s, std::unique_ptr &&h, bool oo = true, vec *values = nullptr); int select(Variable *x) override; void notifyConflict(Constraint *c, int level) override; diff --git a/solver/heuristics/values/HeuristicVal.h b/solver/heuristics/values/HeuristicVal.h index be99bf6..2f6164e 100644 --- a/solver/heuristics/values/HeuristicVal.h +++ b/solver/heuristics/values/HeuristicVal.h @@ -8,6 +8,7 @@ class HeuristicVal { public: Solver &solver; HeuristicVal(Solver &s) : solver(s) { } + virtual ~HeuristicVal() = default; virtual int select(Variable *x) = 0; // How to select a variable }; diff --git a/solver/heuristics/values/HeuristicValASGS.h b/solver/heuristics/values/HeuristicValASGS.h index 4829c2d..0a192b5 100644 --- a/solver/heuristics/values/HeuristicValASGS.h +++ b/solver/heuristics/values/HeuristicValASGS.h @@ -7,12 +7,12 @@ #include "HeuristicVal.h" -using namespace Cosoco; +namespace Cosoco { class HeuristicValASGS : public HeuristicVal { public: explicit HeuristicValASGS(Solver &s); - + int select(Variable *x) override; }; - +} // namespace Cosoco #endif // COSOCO_HEURISTICVALASGS_H diff --git a/solver/heuristics/values/HeuristicValOccs.cc b/solver/heuristics/values/HeuristicValOccs.cc index a75d311..5c4eacc 100644 --- a/solver/heuristics/values/HeuristicValOccs.cc +++ b/solver/heuristics/values/HeuristicValOccs.cc @@ -2,9 +2,9 @@ // Created by audemard on 16/11/22. // -#include "HeuristicValOccs.h" +#include "solver/heuristics/values/HeuristicValOccs.h" -#include "Map.h" +#include "mtl/Map.h" #include "solver/Solver.h" using namespace Cosoco; @@ -14,7 +14,6 @@ HeuristicValOccs::HeuristicValOccs(Solver &s) : HeuristicVal(s) { nbOccurrences.push(); elements.push(); // Put all elements in Map. - bool first = true; for(Variable *x : solver.problem.variablesArray[i]) { for(int idv : x->domain) { int v = x->domain.toVal(idv); diff --git a/solver/heuristics/values/HeuristicValOccs.h b/solver/heuristics/values/HeuristicValOccs.h index 53f4a3a..bb23176 100644 --- a/solver/heuristics/values/HeuristicValOccs.h +++ b/solver/heuristics/values/HeuristicValOccs.h @@ -5,8 +5,8 @@ #ifndef COSOCO_HEURISTICVALOCCS_H #define COSOCO_HEURISTICVALOCCS_H -#include "HeuristicVal.h" -#include "Map.h" +#include "mtl/Map.h" +#include "solver/heuristics/values/HeuristicVal.h" namespace Cosoco { struct IntHash { diff --git a/solver/heuristics/values/HeuristicValStickingValue.cc b/solver/heuristics/values/HeuristicValStickingValue.cc index 1957bbc..28935bd 100644 --- a/solver/heuristics/values/HeuristicValStickingValue.cc +++ b/solver/heuristics/values/HeuristicValStickingValue.cc @@ -4,7 +4,8 @@ using namespace Cosoco; -HeuristicValStickingValue::HeuristicValStickingValue(Solver &s, HeuristicVal *h) : HeuristicVal(s), hv(h) { +HeuristicValStickingValue::HeuristicValStickingValue(Solver &s, std::unique_ptr &&h) + : HeuristicVal(s), hv(std::move(h)) { lastValue.growTo(solver.problem.nbVariables(), -1); } diff --git a/solver/heuristics/values/HeuristicValStickingValue.h b/solver/heuristics/values/HeuristicValStickingValue.h index 52478f0..5db18ce 100644 --- a/solver/heuristics/values/HeuristicValStickingValue.h +++ b/solver/heuristics/values/HeuristicValStickingValue.h @@ -1,16 +1,18 @@ #ifndef COSOCO_HEURISTICVALSTICKINGVALUE_H #define COSOCO_HEURISTICVALSTICKINGVALUE_H +#include + #include "HeuristicVal.h" namespace Cosoco { class HeuristicValStickingValue : public HeuristicVal { protected: - vec lastValue; - HeuristicVal *hv; + vec lastValue; + std::unique_ptr hv; public: - HeuristicValStickingValue(Solver &s, HeuristicVal *h); + HeuristicValStickingValue(Solver &s, std::unique_ptr &&h); virtual int select(Variable *x) override; }; } // namespace Cosoco diff --git a/solver/heuristics/values/PoolOfHeuristicsValues.cc b/solver/heuristics/values/PoolOfHeuristicsValues.cc index a42cff1..eef0189 100644 --- a/solver/heuristics/values/PoolOfHeuristicsValues.cc +++ b/solver/heuristics/values/PoolOfHeuristicsValues.cc @@ -2,11 +2,11 @@ // Created by audemard on 16/02/23. // -#include "PoolOfHeuristicsValues.h" +#include "solver/heuristics/values/PoolOfHeuristicsValues.h" -#include "Optimizer.h" -#include "Solver.h" -#include "Sum.h" +#include "constraints/globals/summing/Sum.h" +#include "core/OptimizationProblem.h" +#include "solver/Solver.h" using namespace Cosoco; PoolOfHeuristicsValues::PoolOfHeuristicsValues(Solver &s) : HeuristicVal(s) { diff --git a/solver/heuristics/variables/HeuristicVar.h b/solver/heuristics/variables/HeuristicVar.h index d0eebce..2607bb4 100644 --- a/solver/heuristics/variables/HeuristicVar.h +++ b/solver/heuristics/variables/HeuristicVar.h @@ -11,6 +11,7 @@ class HeuristicVar { public: Solver &solver; explicit HeuristicVar(Solver &s) : freezed(false), solver(s) { } + virtual ~HeuristicVar() = default; virtual Variable *select() = 0; // How to select a variable, return nullptr if none exist virtual bool stop() { // Stop the search with this heuristic diff --git a/solver/heuristics/variables/HeuristicVarCACD.cc b/solver/heuristics/variables/HeuristicVarCACD.cc index b53562e..14dfb0c 100644 --- a/solver/heuristics/variables/HeuristicVarCACD.cc +++ b/solver/heuristics/variables/HeuristicVarCACD.cc @@ -33,7 +33,7 @@ Variable *HeuristicVarCACD::select() { } if(solver.warmStart == false && solver.statistics[restarts] < 1 && solver.nbSolutions == 0) { - Constraint *c = solver.problem.constraints.last(); + auto &c = solver.problem.constraints.back(); for(Variable *x : c->scope) if(x->size() > 1) return x; diff --git a/solver/heuristics/variables/HeuristicVarDomWdeg.cc b/solver/heuristics/variables/HeuristicVarDomWdeg.cc index fea7fe7..550b5a7 100644 --- a/solver/heuristics/variables/HeuristicVarDomWdeg.cc +++ b/solver/heuristics/variables/HeuristicVarDomWdeg.cc @@ -23,7 +23,7 @@ Variable *HeuristicVarDomWdeg::select() { } if(solver.warmStart == false && solver.statistics[restarts] < 1 && solver.nbSolutions == 0) { - Constraint *c = solver.problem.constraints.last(); + auto &c = solver.problem.constraints.back(); for(Variable *x : c->scope) if(x->size() > 1) return x; @@ -133,8 +133,8 @@ void HeuristicVarDomWdeg::notifyFullBacktrack() { if(solver.statistics[GlobalStats::restarts] > 0 && ((solver.statistics[GlobalStats::restarts] + 1) - solver.lastSolutionRun) % 30 == 0) { printf("erer\n"); - for(Constraint *c : solver.problem.constraints) c->wdeg.fill(0); - for(Variable *x : solver.problem.variables) x->wdeg = 0; + for(auto &c : solver.problem.constraints) c->wdeg.fill(0); + for(auto &x : solver.problem.variables) x->wdeg = 0; } } diff --git a/solver/heuristics/variables/HeuristicVarRoundRobin.h b/solver/heuristics/variables/HeuristicVarRoundRobin.h index 11d6e1b..c23b5c1 100644 --- a/solver/heuristics/variables/HeuristicVarRoundRobin.h +++ b/solver/heuristics/variables/HeuristicVarRoundRobin.h @@ -5,8 +5,8 @@ #ifndef COSOCO_HEURISTICVARROUNDROBIN_H #define COSOCO_HEURISTICVARROUNDROBIN_H -#include "HeuristicVar.h" -#include "ObserverDecision.h" +#include "solver/heuristics/variables/HeuristicVar.h" +#include "solver/observers/ObserverDecision.h" namespace Cosoco { class HeuristicVarRoundRobin : public HeuristicVar, ObserverDeleteDecision { diff --git a/solver/heuristics/variables/LastConflictReasoning.cc b/solver/heuristics/variables/LastConflictReasoning.cc index cecebb5..be7acf4 100644 --- a/solver/heuristics/variables/LastConflictReasoning.cc +++ b/solver/heuristics/variables/LastConflictReasoning.cc @@ -3,8 +3,8 @@ using namespace Cosoco; -LastConflictReasoning::LastConflictReasoning(Solver &s, HeuristicVar *hv, int n) - : HeuristicVar(s), hvar(hv), nVariables(n), lastAssigned(nullptr), candidate(nullptr) { +LastConflictReasoning::LastConflictReasoning(Solver &s, std::unique_ptr &&hv, int n) + : HeuristicVar(s), hvar(std::move(hv)), nVariables(n), lastAssigned(nullptr), candidate(nullptr) { s.addObserverNewDecision(this); s.addObserverDeleteDecision(this); } diff --git a/solver/heuristics/variables/LastConflictReasoning.h b/solver/heuristics/variables/LastConflictReasoning.h index e939070..c41c4ee 100644 --- a/solver/heuristics/variables/LastConflictReasoning.h +++ b/solver/heuristics/variables/LastConflictReasoning.h @@ -7,13 +7,13 @@ #include "solver/observers/ObserverConflict.h" namespace Cosoco { class LastConflictReasoning : public HeuristicVar, ObserverNewDecision, ObserverDeleteDecision { - HeuristicVar *hvar; // The main heuristic - vec lcs; // The last conflict variable - int nVariables; - Variable *lastAssigned, *candidate; + std::unique_ptr hvar; // The main heuristic + vec lcs; // The last conflict variable + int nVariables; + Variable *lastAssigned, *candidate; public: - LastConflictReasoning(Solver &s, HeuristicVar *hv, int _nbVariables = 2); + LastConflictReasoning(Solver &s, std::unique_ptr &&hv, int _nbVariables = 2); Variable *select() override; diff --git a/solver/heuristics/variables/PickOnDom.cc b/solver/heuristics/variables/PickOnDom.cc index c40eb87..14a304b 100644 --- a/solver/heuristics/variables/PickOnDom.cc +++ b/solver/heuristics/variables/PickOnDom.cc @@ -55,8 +55,8 @@ void PickOnDom::notifyFullBacktrack() { if(solver.statistics[GlobalStats::restarts] > 0 && ((solver.statistics[GlobalStats::restarts] + 1) - solver.lastSolutionRun) % 30 == 0) { printf("erer\n"); - for(Constraint *c : solver.problem.constraints) c->wdeg.fill(0); - for(Variable *x : solver.problem.variables) x->wdeg = 0; + for(auto &c : solver.problem.constraints) c->wdeg.fill(0); + for(auto &x : solver.problem.variables) x->wdeg = 0; } } diff --git a/solver/heuristics/variables/RandomizeFirstDescent.cc b/solver/heuristics/variables/RandomizeFirstDescent.cc index 99f9040..f7ed36b 100644 --- a/solver/heuristics/variables/RandomizeFirstDescent.cc +++ b/solver/heuristics/variables/RandomizeFirstDescent.cc @@ -3,7 +3,8 @@ using namespace Cosoco; -RandomizeFirstDescent::RandomizeFirstDescent(Solver &s, HeuristicVar *hv) : HeuristicVar(s), firstDescent(true), hvar(hv) { +RandomizeFirstDescent::RandomizeFirstDescent(Solver &s, std::unique_ptr &&hv) + : HeuristicVar(s), firstDescent(true), hvar(std::move(hv)) { s.addObserverConflict(this); } @@ -13,7 +14,7 @@ Variable *RandomizeFirstDescent::select() { int pos = irand(solver.seed, solver.problem.variables.size()); if(solver.problem.variables[pos]->isAssigned() == false) - return solver.problem.variables[pos]; + return solver.problem.variables[pos].get(); } return hvar->select(); } diff --git a/solver/heuristics/variables/RandomizeFirstDescent.h b/solver/heuristics/variables/RandomizeFirstDescent.h index 35da273..ef3dbeb 100644 --- a/solver/heuristics/variables/RandomizeFirstDescent.h +++ b/solver/heuristics/variables/RandomizeFirstDescent.h @@ -6,6 +6,8 @@ #define COSOCO_RANDOMIZEFIRSTDESCENT_H +#include + #include "HeuristicVar.h" #include "solver/Solver.h" #include "solver/observers/ObserverConflict.h" @@ -14,10 +16,10 @@ namespace Cosoco { class RandomizeFirstDescent : public HeuristicVar, ObserverConflict { - bool firstDescent; - HeuristicVar *hvar; // The main heuristic + bool firstDescent; + std::unique_ptr hvar; // The main heuristic public: - RandomizeFirstDescent(Solver &s, HeuristicVar *hv); + RandomizeFirstDescent(Solver &s, std::unique_ptr &&hv); // Returns a random float 0 <= x < 1. Seed must never be 0. inline double drand(double &seed) { diff --git a/solver/learning/IPSLearner.cc b/solver/learning/IPSLearner.cc index 3c701dc..ec9360a 100644 --- a/solver/learning/IPSLearner.cc +++ b/solver/learning/IPSLearner.cc @@ -106,9 +106,9 @@ void IPSLearner::extract() { } } } else { - for(Variable *x : problem.variables) - if(canEliminateVariable(x) == false) { - extracted.push(x); + for(auto &x : problem.variables) + if(canEliminateVariable(x.get()) == false) { + extracted.push(x.get()); selectedVariables[x->idx] = true; } } diff --git a/solver/nogoods/NoGoodsEngine.cc b/solver/nogoods/NoGoodsEngine.cc index a3ef8fc..3b8390a 100644 --- a/solver/nogoods/NoGoodsEngine.cc +++ b/solver/nogoods/NoGoodsEngine.cc @@ -2,9 +2,12 @@ // Created by audemard on 20/02/23. // -#include "NoGoodsEngine.h" +#include "solver/nogoods/NoGoodsEngine.h" -#include "System.h" +#include + +#include "solver/Solver.h" +#include "utils/System.h" using namespace Cosoco; Constraint *NoGoodsEngine::fake = (Constraint *)0x1; @@ -31,6 +34,13 @@ NoGoodsEngine::NoGoodsEngine(Solver &s) : solver(s), maxArity(1000), capacity(0) enlargeNogoodStructure(1024 * 1024); } +NoGoodsEngine::~NoGoodsEngine() { + if(nogoods) { + free(nogoods); + nogoods = nullptr; + } +} + std::ostream &operator<<(std::ostream &stream, Tuple const &tuple) { stream << tuple.x->_name << (tuple.eq ? "=" : "!=") << tuple.idv << " "; return stream; @@ -41,9 +51,9 @@ std::ostream &operator<<(std::ostream &stream, Tuple const &tuple) { void NoGoodsEngine::generateNogoodFromSolution() { vec nogood; - for(Variable *x : solver.problem.variables) + for(auto &x : solver.problem.variables) if(x->useless == false) - nogood.push(getNegativeDecisionFor(x, x->domain.toIdv(x->value()))); + nogood.push(getNegativeDecisionFor(x.get(), x->domain.toIdv(x->value()))); addNoGood(nogood); } @@ -215,7 +225,7 @@ void NoGoodsEngine::notifyFullBacktrack() { currentBranch.clear(); } // -- From x=idv to int and vice-versa //----------------------------------------------------------------------- -Variable *NoGoodsEngine::getVariableIn(int number) { return solver.problem.variables[abs(number) / OFFSET]; } +Variable *NoGoodsEngine::getVariableIn(int number) { return solver.problem.variables[abs(number) / OFFSET].get(); } inline int NoGoodsEngine::getIndexIn(int number) const { return abs(number) % OFFSET - 1; } diff --git a/solver/nogoods/NoGoodsEngine.h b/solver/nogoods/NoGoodsEngine.h index c74405f..845ec0d 100644 --- a/solver/nogoods/NoGoodsEngine.h +++ b/solver/nogoods/NoGoodsEngine.h @@ -5,16 +5,17 @@ #ifndef COSOCO_NOGOODSENGINE_H #define COSOCO_NOGOODSENGINE_H -#include "ObserverDecision.h" -#include "Solver.h" -#include "Tuple.h" +#include + +#include "solver/nogoods/Tuple.h" +#include "solver/observers/ObserverDecision.h" #define NOGOODSSTATS 7 enum NoGoodStats { nbnogoods, size1, size2, sumsize, maxsize, cfl, props }; namespace Cosoco { typedef long long Lit; - +class Solver; class NoGoodsEngine : public ObserverNewDecision, ObserverDeleteDecision { Solver &solver; @@ -37,6 +38,7 @@ class NoGoodsEngine : public ObserverNewDecision, ObserverDeleteDecision { static Constraint *fake; vec statistics; explicit NoGoodsEngine(Solver &s); + virtual ~NoGoodsEngine(); bool generateNogoodsFromRestarts(); // Generate different nogoods void addNoGood(vec &nogood); // Add a no good to the database diff --git a/solver/nogoods/Tuple.h b/solver/nogoods/Tuple.h index b2329ae..223e65c 100644 --- a/solver/nogoods/Tuple.h +++ b/solver/nogoods/Tuple.h @@ -4,7 +4,8 @@ #ifndef COSOCO_TUPLE_H #define COSOCO_TUPLE_H -#include "solver/Solver.h" + +#include "core/Variable.h" namespace Cosoco { class Tuple { public: diff --git a/solver/observers/ObserverConflict.h b/solver/observers/ObserverConflict.h index 2bf77ca..576d83c 100644 --- a/solver/observers/ObserverConflict.h +++ b/solver/observers/ObserverConflict.h @@ -6,6 +6,7 @@ namespace Cosoco { class ObserverConflict { public: + virtual ~ObserverConflict() = default; virtual void notifyConflict(Constraint *c, int level) = 0; }; } // namespace Cosoco diff --git a/solver/observers/ObserverDecision.h b/solver/observers/ObserverDecision.h index 4005e8b..c6d7c5d 100644 --- a/solver/observers/ObserverDecision.h +++ b/solver/observers/ObserverDecision.h @@ -6,12 +6,14 @@ class Solver; class ObserverNewDecision { public: - virtual void notifyNewDecision(Variable *x, Solver &s) { }; // Notify, when everything is done + virtual ~ObserverNewDecision() = default; + virtual void notifyNewDecision(Variable *x, Solver &s) {}; // Notify, when everything is done }; class ObserverDeleteDecision { public: - virtual void notifyDeleteDecision(Variable *x, int v, Solver &s) { }; // Notify, when everything is done + virtual ~ObserverDeleteDecision() = default; + virtual void notifyDeleteDecision(Variable *x, int v, Solver &s) {}; // Notify, when everything is done virtual void notifyFullBacktrack() { } }; diff --git a/solver/observers/ObserverDomainReduction.h b/solver/observers/ObserverDomainReduction.h index 0e5d651..e6c17b2 100644 --- a/solver/observers/ObserverDomainReduction.h +++ b/solver/observers/ObserverDomainReduction.h @@ -7,6 +7,7 @@ class Solver; class Variable; class ObserverDomainReduction { public: + virtual ~ObserverDomainReduction() = default; virtual void notifyDomainReduction(Variable *x, int idv, Solver &s) = 0; // event is sent before the value is removed virtual void notifyDomainAssignment(Variable *x, int idv, Solver &s) = 0; // event is sent before the value is assigned }; diff --git a/solver/restarts/Restart.h b/solver/restarts/Restart.h index 4dcb38a..73565f6 100644 --- a/solver/restarts/Restart.h +++ b/solver/restarts/Restart.h @@ -9,6 +9,7 @@ class Restart { public: Solver *solver; Restart(Solver *s) : solver(s) { } + virtual ~Restart() = default; virtual bool isItTimeToRestart() = 0; // Return true if the solver has to restart virtual void initialize() = 0; // Start from scratch policy }; diff --git a/solver/utils/CosocoCallbacks.cc b/solver/utils/CosocoCallbacks.cc index 3334937..fb5eb8a 100644 --- a/solver/utils/CosocoCallbacks.cc +++ b/solver/utils/CosocoCallbacks.cc @@ -1,8 +1,15 @@ #include "CosocoCallbacks.h" + +#ifdef USE_XCSP3 +#include + +#include "core/OptimizationProblem.h" +#include "core/domain/DomainValues.h" + using namespace Cosoco; -void CosocoCallbacks::beginInstance(InstanceType type) { +void XCSP3Core::CosocoCallbacks::beginInstance(InstanceType type) { problem = type == CSP ? new Problem("") : new OptimizationProblem(""); problems.push(problem); decisionVariables.growTo(nbcores); @@ -18,14 +25,14 @@ void CosocoCallbacks::beginInstance(InstanceType type) { recognizeSpecialIntensionCases = false; } -void CosocoCallbacks::endInstance() { +void XCSP3Core::CosocoCallbacks::endInstance() { if(auxiliaryIdx > 0) std::cout << "c " << auxiliaryIdx << " auxiliary variables\n"; problem->delayedConstruction(); printf("c nb Intensions -> Extensions : %d (shared: %d)\n", nbIntension2Extention, nbSharedIntension2Extension); } -void CosocoCallbacks::buildVariableInteger(string id, int minValue, int maxValue) { +void XCSP3Core::CosocoCallbacks::buildVariableInteger(string id, int minValue, int maxValue) { Variable *x = problem->createVariable(id, *(new DomainRange(minValue, maxValue)), inArray ? problem->variablesArray.size() - 1 : -1); if(inArray) @@ -33,7 +40,7 @@ void CosocoCallbacks::buildVariableInteger(string id, int minValue, int maxValue mappingXV[id] = new XVariable(id, nullptr); } -void CosocoCallbacks::buildVariableInteger(string id, vector &values) { +void XCSP3Core::CosocoCallbacks::buildVariableInteger(string id, vector &values) { Variable *x = problem->createVariable(id, *(new DomainValue(vector2vec(values))), inArray ? problem->variablesArray.size() - 1 : -1); if(inArray) @@ -41,50 +48,50 @@ void CosocoCallbacks::buildVariableInteger(string id, vector &values) { mappingXV[id] = new XVariable(id, nullptr); } -void CosocoCallbacks::beginVariableArray(string id) { +void XCSP3Core::CosocoCallbacks::beginVariableArray(string id) { for(int core = 0; core < nbcores; core++) problem->variablesArray.push(); inArray = true; } -void CosocoCallbacks::endVariableArray() { inArray = false; } +void XCSP3Core::CosocoCallbacks::endVariableArray() { inArray = false; } -void CosocoCallbacks::endVariables() { +void XCSP3Core::CosocoCallbacks::endVariables() { nbInitialsVariables = problem->nbVariables(); problem->nbOriginalVars = problem->nbVariables(); } -void CosocoCallbacks::initGroups() { +void XCSP3Core::CosocoCallbacks::initGroups() { insideGroup = true; nbMDD = 0; nbIntension = -1; } -void CosocoCallbacks::beginGroup(string name) { initGroups(); } +void XCSP3Core::CosocoCallbacks::beginGroup(string name) { initGroups(); } -void CosocoCallbacks::endGroup() { insideGroup = false; } +void XCSP3Core::CosocoCallbacks::endGroup() { insideGroup = false; } -void CosocoCallbacks::beginSlide(string id, bool circular) { initGroups(); } +void XCSP3Core::CosocoCallbacks::beginSlide(string id, bool circular) { initGroups(); } -void CosocoCallbacks::endSlide() { +void XCSP3Core::CosocoCallbacks::endSlide() { insideGroup = false; initGroups(); } -void CosocoCallbacks::beginBlock(string classes) { initGroups(); } +void XCSP3Core::CosocoCallbacks::beginBlock(string classes) { initGroups(); } -void CosocoCallbacks::endBlock() { +void XCSP3Core::CosocoCallbacks::endBlock() { initGroups(); insideGroup = false; } -void CosocoCallbacks::beginObjectives() { startToParseObjective = true; } +void XCSP3Core::CosocoCallbacks::beginObjectives() { startToParseObjective = true; } //-------------------------------------------------------------------------------------- @@ -92,20 +99,21 @@ void CosocoCallbacks::beginObjectives() { startToParseObjective = true; } //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildConstraintExtension(string id, vector list, vector> &origTuples, bool support, - bool hasStar) { +void XCSP3Core::CosocoCallbacks::buildConstraintExtension(string id, vector list, vector> &origTuples, + bool support, bool hasStar) { if(hasStar && !support) throw runtime_error("Extension constraint with star and conflict tuples is not yet supported"); toMyVariables(list); buildConstraintExtension2(id, vars, origTuples, support, hasStar); } -void CosocoCallbacks::buildConstraintExtensionAs(string id, vector list, bool support, bool hasStar) { - FactoryConstraints::createConstraintExtensionAs(problem, id, toMyVariables(list), problem->constraints.last()); +void XCSP3Core::CosocoCallbacks::buildConstraintExtensionAs(string id, vector list, bool support, bool hasStar) { + FactoryConstraints::createConstraintExtensionAs(problem, id, toMyVariables(list), problem->constraints.back().get()); } -void CosocoCallbacks::buildConstraintExtension2(const string &id, vec &scope, const vector> &origTuples, - bool support, bool hasStar) const { +void XCSP3Core::CosocoCallbacks::buildConstraintExtension2(const string &id, vec &scope, + const vector> &origTuples, bool support, + bool hasStar) const { vec> tuples; tuples.growTo(origTuples.size()); @@ -119,7 +127,8 @@ void CosocoCallbacks::buildConstraintExtension2(const string &id, vec &tuples, bool support, bool hasStar) { +void XCSP3Core::CosocoCallbacks::buildConstraintExtension(string id, XVariable *variable, vector &tuples, bool support, + bool hasStar) { if(hasStar) throw runtime_error("Extension constraint with star is not yet supported"); @@ -127,9 +136,10 @@ void CosocoCallbacks::buildConstraintExtension(string id, XVariable *variable, v } -void CosocoCallbacks::buildConstraintIntension(string id, Tree *tree) { manageIntension->intension(id, tree); } +void XCSP3Core::CosocoCallbacks::buildConstraintIntension(string id, Tree *tree) { manageIntension->intension(id, tree); } -void CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariable *x, int k, XVariable *y) { // x + k op y +void XCSP3Core::CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariable *x, int k, + XVariable *y) { // x + k op y assert(op == LE || op == LT || op == EQ || op == NE); @@ -161,7 +171,8 @@ void CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariabl buildConstraintIntension(id, new Tree(tmp)); // TODO } -void CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariable *xx, int k) { // x op k op is <= or >= +void XCSP3Core::CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariable *xx, + int k) { // x op k op is <= or >= Variable *x = problem->mapping[xx->id]; vec values; for(int idv : x->domain) { @@ -172,8 +183,8 @@ void CosocoCallbacks::buildConstraintPrimitive(string id, OrderType op, XVariabl FactoryConstraints::createConstraintUnary(problem, id, x, values, true); } -void CosocoCallbacks::buildConstraintPrimitive(string id, XVariable *xx, bool in, int min, - int max) { // x in/notin [min,max] +void XCSP3Core::CosocoCallbacks::buildConstraintPrimitive(string id, XVariable *xx, bool in, int min, + int max) { // x in/notin [min,max] Variable *x = problem->mapping[xx->id]; vec values; for(int idv : x->domain) { @@ -185,7 +196,7 @@ void CosocoCallbacks::buildConstraintPrimitive(string id, XVariable *xx, bool in } -void CosocoCallbacks::buildConstraintMult(string id, XVariable *x, XVariable *y, XVariable *z) { +void XCSP3Core::CosocoCallbacks::buildConstraintMult(string id, XVariable *x, XVariable *y, XVariable *z) { if(x == y || x == z || y == z) { cout << "eq(" + z->id + ",mul(" + x->id + "," + y->id + "))\n"; buildConstraintIntension(id, new Tree("eq(" + z->id + ",mul(" + x->id + "," + y->id + "))")); @@ -201,9 +212,9 @@ void CosocoCallbacks::buildConstraintMult(string id, XVariable *x, XVariable *y, // Language constraints //-------------------------------------------------------------------------------------- -Cosoco::MDD *CosocoCallbacks::sameMDDAsPrevious(vec &list) { +Cosoco::MDD *XCSP3Core::CosocoCallbacks::sameMDDAsPrevious(vec &list) { if(insideGroup && nbMDD) { // Check is the MDD is the same - auto *ext = dynamic_cast(problem->constraints.last()); + auto *ext = dynamic_cast(problem->constraints.back().get()); assert(ext != nullptr); assert(list.size() == ext->scope.size()); int same = true; @@ -220,7 +231,7 @@ Cosoco::MDD *CosocoCallbacks::sameMDDAsPrevious(vec &list) { } -void CosocoCallbacks::buildConstraintMDD(string id, vector &list, vector &transitions) { +void XCSP3Core::CosocoCallbacks::buildConstraintMDD(string id, vector &list, vector &transitions) { toMyVariables(list, vars); Cosoco::MDD *mdd = nullptr; if((mdd = sameMDDAsPrevious(vars)) != nullptr) @@ -234,8 +245,8 @@ void CosocoCallbacks::buildConstraintMDD(string id, vector &list, v } -void CosocoCallbacks::buildConstraintRegular(string id, vector &list, string start, vector &final, - vector &transitions) { +void XCSP3Core::CosocoCallbacks::buildConstraintRegular(string id, vector &list, string start, vector &final, + vector &transitions) { toMyVariables(list, vars); // Some variables can appear multiple times.... We replace by a new variable and an allequal @@ -255,9 +266,9 @@ void CosocoCallbacks::buildConstraintRegular(string id, vector &lis } vec tmp; tmp.push(vars[i]); - tmp.push(problem->variables.last()); + tmp.push(problem->variables.back().get()); FactoryConstraints::createConstraintAllEqual(problem, id, tmp); - vars[i] = problem->variables.last(); + vars[i] = problem->variables.back().get(); } vars[i]->fake = 1; } @@ -276,7 +287,7 @@ void CosocoCallbacks::buildConstraintRegular(string id, vector &lis // Graph constraints //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildConstraintCircuit(string id, vector &list, int startIndex) { +void XCSP3Core::CosocoCallbacks::buildConstraintCircuit(string id, vector &list, int startIndex) { if(startIndex != 0) throw runtime_error("Circuit with startIndex != 0 is not yet supported"); @@ -289,16 +300,16 @@ void CosocoCallbacks::buildConstraintCircuit(string id, vector &lis // Comparison constraints //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildConstraintAlldifferent(string id, vector &list) { +void XCSP3Core::CosocoCallbacks::buildConstraintAlldifferent(string id, vector &list) { FactoryConstraints::createConstraintAllDiff(problem, id, toMyVariables(list)); } -void CosocoCallbacks::buildConstraintAlldifferentExcept(string id, vector &list, vector &except) { +void XCSP3Core::CosocoCallbacks::buildConstraintAlldifferentExcept(string id, vector &list, vector &except) { FactoryConstraints::createConstraintAllDiffExcept(problem, id, toMyVariables(list), except); } -void CosocoCallbacks::buildConstraintAlldifferent(string id, vector &trees) { +void XCSP3Core::CosocoCallbacks::buildConstraintAlldifferent(string id, vector &trees) { vector auxiliaryVariables; insideGroup = false; createAuxiliaryVariablesAndExpressions(trees, auxiliaryVariables); @@ -326,7 +337,7 @@ void CosocoCallbacks::buildConstraintAlldifferent(string id, vector &tre } -void CosocoCallbacks::buildConstraintAlldifferentList(string id, vector> &origlists) { +void XCSP3Core::CosocoCallbacks::buildConstraintAlldifferentList(string id, vector> &origlists) { vec> lists; for(auto &origlist : origlists) { lists.push(); @@ -336,7 +347,7 @@ void CosocoCallbacks::buildConstraintAlldifferentList(string id, vector> &matrix) { +void XCSP3Core::CosocoCallbacks::buildConstraintAlldifferentMatrix(string id, vector> &matrix) { // lines for(auto &list : matrix) buildConstraintAlldifferent(id, list); @@ -349,28 +360,29 @@ void CosocoCallbacks::buildConstraintAlldifferentMatrix(string id, vector &list) { +void XCSP3Core::CosocoCallbacks::buildConstraintAllEqual(string id, vector &list) { FactoryConstraints::createConstraintAllEqual(problem, id, toMyVariables(list)); } -void CosocoCallbacks::buildConstraintNotAllEqual(string id, vector &list) { +void XCSP3Core::CosocoCallbacks::buildConstraintNotAllEqual(string id, vector &list) { FactoryConstraints::createConstraintNotAllEqual(problem, id, toMyVariables(list)); } -void CosocoCallbacks::buildConstraintOrdered(string id, vector &list, OrderType order) { +void XCSP3Core::CosocoCallbacks::buildConstraintOrdered(string id, vector &list, OrderType order) { vector lengths; FactoryConstraints::createConstraintOrdered(problem, id, toMyVariables(list), lengths, order); } -void CosocoCallbacks::buildConstraintOrdered(string id, vector &list, vector &lengths, OrderType order) { +void XCSP3Core::CosocoCallbacks::buildConstraintOrdered(string id, vector &list, vector &lengths, + OrderType order) { FactoryConstraints::createConstraintOrdered(problem, id, toMyVariables(list), lengths, order); } -void CosocoCallbacks::buildConstraintLex(string id, vector> &lists, OrderType order) { +void XCSP3Core::CosocoCallbacks::buildConstraintLex(string id, vector> &lists, OrderType order) { vec list1, list2; for(unsigned int i = 0; i < lists.size() - 1; i++) { toMyVariables(lists[i], list1); @@ -380,7 +392,7 @@ void CosocoCallbacks::buildConstraintLex(string id, vector> } -void CosocoCallbacks::buildConstraintLexMatrix(string id, vector> &matrix, OrderType order) { +void XCSP3Core::CosocoCallbacks::buildConstraintLexMatrix(string id, vector> &matrix, OrderType order) { // lines buildConstraintLex(id, matrix, order); @@ -399,21 +411,22 @@ void CosocoCallbacks::buildConstraintLexMatrix(string id, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vector &list, XCondition &xc) { vector coeffs; coeffs.assign(list.size(), 1); buildConstraintSum(id, list, coeffs, xc); } -void CosocoCallbacks::buildConstraintSum(string id, vector &list, vector &origcoeffs, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vector &list, vector &origcoeffs, + XCondition &xc) { vars.clear(); toMyVariables(list, vars); buildConstraintSum(id, vars, origcoeffs, xc); } -void CosocoCallbacks::buildConstraintSum(string id, vec &variables, vector &coeffs, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vec &variables, vector &coeffs, XCondition &xc) { string xcvar = xc.var; bool varCondition = xc.operandType == VARIABLE; vector2vec(coeffs); @@ -436,7 +449,8 @@ void CosocoCallbacks::buildConstraintSum(string id, vec &variables, } -void CosocoCallbacks::buildConstraintSum(string id, vector &list, vector &coeffs, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vector &list, vector &coeffs, + XCondition &xc) { bool scalar = true; for(unsigned int i = 0; i < list.size(); i++) { if(list[i]->domain->minimum() != 0 || list[i]->domain->maximum() != 1) { @@ -505,14 +519,14 @@ void CosocoCallbacks::buildConstraintSum(string id, vector &list, v } -void CosocoCallbacks::buildConstraintSum(string id, vector &trees, XCondition &cond) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vector &trees, XCondition &cond) { vector coeffs; coeffs.assign(trees.size(), 1); buildConstraintSum(id, trees, coeffs, cond); } -void CosocoCallbacks::buildConstraintSum(string id, vector &trees, vector &coefs, XCondition &cond) { +void XCSP3Core::CosocoCallbacks::buildConstraintSum(string id, vector &trees, vector &coefs, XCondition &cond) { vector auxiliaryVariables; insideGroup = false; createAuxiliaryVariablesAndExpressions(trees, auxiliaryVariables); @@ -524,27 +538,27 @@ void CosocoCallbacks::buildConstraintSum(string id, vector &trees, vecto } -void CosocoCallbacks::buildConstraintAtMost(string id, vector &list, int value, int k) { +void XCSP3Core::CosocoCallbacks::buildConstraintAtMost(string id, vector &list, int value, int k) { FactoryConstraints::createConstraintAtMost(problem, id, toMyVariables(list), value, k); } -void CosocoCallbacks::buildConstraintAtLeast(string id, vector &list, int value, int k) { +void XCSP3Core::CosocoCallbacks::buildConstraintAtLeast(string id, vector &list, int value, int k) { FactoryConstraints::createConstraintAtLeast(problem, id, toMyVariables(list), value, k); } -void CosocoCallbacks::buildConstraintExactlyK(string id, vector &list, int value, int k) { +void XCSP3Core::CosocoCallbacks::buildConstraintExactlyK(string id, vector &list, int value, int k) { FactoryConstraints::createConstraintExactly(problem, id, toMyVariables(list), value, k); } -void CosocoCallbacks::buildConstraintExactlyVariable(string id, vector &list, int value, XVariable *x) { +void XCSP3Core::CosocoCallbacks::buildConstraintExactlyVariable(string id, vector &list, int value, XVariable *x) { FactoryConstraints::createConstraintExactlyVariable(problem, id, toMyVariables(list), value, problem->mapping[x->id]); } -void CosocoCallbacks::buildConstraintNValues(string id, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintNValues(string id, vector &list, XCondition &xc) { if(!(xc.operandType == VARIABLE && xc.op == EQ)) throw runtime_error("c Such nValues constraint Not yes supported"); @@ -552,7 +566,8 @@ void CosocoCallbacks::buildConstraintNValues(string id, vector &lis } -void CosocoCallbacks::buildConstraintCount(string id, vector &list, vector &values, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCount(string id, vector &list, vector &values, + XCondition &xc) { if(values.size() == 1) { vector trees; for(auto &xv : list) { @@ -566,7 +581,7 @@ void CosocoCallbacks::buildConstraintCount(string id, vector &list, } -void CosocoCallbacks::buildConstraintCount(string id, vector &trees, vector &values, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCount(string id, vector &trees, vector &values, XCondition &xc) { if(values.size() == 1) { vector newtrees; for(auto &tree : trees) { @@ -580,7 +595,8 @@ void CosocoCallbacks::buildConstraintCount(string id, vector &trees, vec } -void CosocoCallbacks::buildConstraintCount(string id, vector &trees, vector &values, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCount(string id, vector &trees, vector &values, + XCondition &xc) { // TODO WARNING if(values.size() == 1) { vector newtrees; @@ -595,8 +611,8 @@ void CosocoCallbacks::buildConstraintCount(string id, vector &trees, vec } -void CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, vector &intOccurs, - bool closed) { +void XCSP3Core::CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, + vector &intOccurs, bool closed) { vec occurs; for(int o : intOccurs) { occurs.push(); @@ -607,8 +623,8 @@ void CosocoCallbacks::buildConstraintCardinality(string id, vector } -void CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, - vector &varOccurs, bool closed) { +void XCSP3Core::CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, + vector &varOccurs, bool closed) { vec occurs; for(XVariable *xv : varOccurs) { occurs.push(); @@ -619,8 +635,8 @@ void CosocoCallbacks::buildConstraintCardinality(string id, vector } -void CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, - vector &intervalOccurs, bool closed) { +void XCSP3Core::CosocoCallbacks::buildConstraintCardinality(string id, vector &list, vector values, + vector &intervalOccurs, bool closed) { vec occurs; for(XInterval &xi : intervalOccurs) { occurs.push(); @@ -636,7 +652,7 @@ void CosocoCallbacks::buildConstraintCardinality(string id, vector // Connection constraints //-------------------------------------------------------------------------------------- -string CosocoCallbacks::createExpression(string minmax, OrderType op, vector &list, string value) { +string XCSP3Core::CosocoCallbacks::createExpression(string minmax, OrderType op, vector &list, string value) { string o; if(op == LE) @@ -661,7 +677,7 @@ string CosocoCallbacks::createExpression(string minmax, OrderType op, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintMaximum(string id, vector &list, XCondition &xc) { if(xc.operandType == VARIABLE) { if(xc.op == EQ) { vector auxiliaryVariables; @@ -676,7 +692,7 @@ void CosocoCallbacks::buildConstraintMaximum(string id, vector &list, XC throw runtime_error("Maximum over set is not yet supported"); } -void CosocoCallbacks::buildConstraintMinimum(string id, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintMinimum(string id, vector &list, XCondition &xc) { if(xc.operandType == VARIABLE) { if(xc.op == EQ) { vector auxiliaryVariables; @@ -691,7 +707,7 @@ void CosocoCallbacks::buildConstraintMinimum(string id, vector &list, XC throw runtime_error("minimum over set is not yet supported"); } -void CosocoCallbacks::buildConstraintMaximum(string id, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintMaximum(string id, vector &list, XCondition &xc) { if(xc.operandType == VARIABLE) { if(xc.op == EQ) { toMyVariables(list, vars); @@ -722,7 +738,7 @@ void CosocoCallbacks::buildConstraintMaximum(string id, vector &lis } -void CosocoCallbacks::buildConstraintMinimum(string id, vector &list, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintMinimum(string id, vector &list, XCondition &xc) { if(xc.operandType == VARIABLE) { if(xc.op == EQ) { toMyVariables(list, vars); @@ -753,15 +769,15 @@ void CosocoCallbacks::buildConstraintMinimum(string id, vector &lis } -void CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, - RankType rank, int value) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, + RankType rank, int value) { Variable *idx = problem->mapping[index->id]; FactoryConstraints::createConstraintElementConstant(problem, id, toMyVariables(list), idx, startIndex, value); } -void CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, - RankType rank, XVariable *value) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, + RankType rank, XVariable *value) { if(value->id == index->id) { for(XVariable *x : list) if(x == value) @@ -790,8 +806,8 @@ void CosocoCallbacks::buildConstraintElement(string id, vector &lis } -void CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, RankType rank, - XVariable *value) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex, XVariable *index, + RankType rank, XVariable *value) { vec tmp; vec> tuples; Variable *idx = problem->mapping[index->id]; @@ -809,7 +825,8 @@ void CosocoCallbacks::buildConstraintElement(string id, vector &list, int s FactoryConstraints::createConstraintExtension(problem, id, tmp, tuples, true, false); } -void CosocoCallbacks::buildConstraintElement(string id, vector &list, XVariable *index, int startIndex, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector &list, XVariable *index, int startIndex, + XCondition &xc) { vector aux; for(int value : list) { string auxVar = "__av" + std::to_string(auxiliaryIdx++) + "__"; @@ -820,8 +837,8 @@ void CosocoCallbacks::buildConstraintElement(string id, vector &list, XVari buildConstraintElement(id, aux, index, startIndex, xc); } -void CosocoCallbacks::buildConstraintElement(string id, vector &list, XVariable *index, int startIndex, - XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector &list, XVariable *index, int startIndex, + XCondition &xc) { if(xc.op == EQ) { if(xc.operandType == INTEGER) { buildConstraintElement(id, list, startIndex, index, ANY, xc.val); @@ -874,8 +891,9 @@ void CosocoCallbacks::buildConstraintElement(string id, vector &lis buildConstraintElement(id, list, startIndex, index, ANY, x); } -void CosocoCallbacks::buildConstraintElement(string id, vector> &matrix, int startRowIndex, XVariable *rowIndex, - int startColIndex, XVariable *colIndex, XVariable *value) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector> &matrix, int startRowIndex, + XVariable *rowIndex, int startColIndex, XVariable *colIndex, + XVariable *value) { if(startRowIndex != 0 || startColIndex != 0) throw runtime_error("Element int matrix with startRowIndex or StartColIndex !=0 not yet supported"); @@ -907,8 +925,8 @@ void CosocoCallbacks::buildConstraintElement(string id, vector> &mat } -void CosocoCallbacks::buildConstraintElement(string id, vector> &matrix, int startRowIndex, - XVariable *rowIndex, int startColIndex, XVariable *colIndex, int value) { +void XCSP3Core::CosocoCallbacks::buildConstraintElement(string id, vector> &matrix, int startRowIndex, + XVariable *rowIndex, int startColIndex, XVariable *colIndex, int value) { if(rowIndex == colIndex) { if(matrix.size() != matrix[0].size()) throw runtime_error("Problem in element matrix"); @@ -932,15 +950,15 @@ void CosocoCallbacks::buildConstraintElement(string id, vector &list, int startIndex) { +void XCSP3Core::CosocoCallbacks::buildConstraintChannel(string id, vector &list, int startIndex) { if(startIndex != 0) throw runtime_error("Channel is not implemented with index != 0"); toMyVariables(list); FactoryConstraints::createConstraintChannel(problem, id, vars, 0); } -void CosocoCallbacks::buildConstraintChannel(string id, vector &list1, int startIndex1, vector &list2, - int startIndex2) { +void XCSP3Core::CosocoCallbacks::buildConstraintChannel(string id, vector &list1, int startIndex1, + vector &list2, int startIndex2) { vec X; vec Y; toMyVariables(list1, X); @@ -949,7 +967,7 @@ void CosocoCallbacks::buildConstraintChannel(string id, vector &lis } -void CosocoCallbacks::buildConstraintChannel(string id, vector &list, int startIndex, XVariable *value) { +void XCSP3Core::CosocoCallbacks::buildConstraintChannel(string id, vector &list, int startIndex, XVariable *value) { // return forall(range(list.length), i -> intension(iff(list[i], eq(value, i)))); int i = 0; for(XVariable *x : list) { @@ -965,7 +983,8 @@ void CosocoCallbacks::buildConstraintChannel(string id, vector &lis //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildConstraintNoOverlap(string id, vector &origins, vector &lengths, bool zeroIgnored) { +void XCSP3Core::CosocoCallbacks::buildConstraintNoOverlap(string id, vector &origins, vector &lengths, + bool zeroIgnored) { if(!zeroIgnored) throw runtime_error("Nooverlap with zeroIgnored not yet supported"); @@ -975,8 +994,8 @@ void CosocoCallbacks::buildConstraintNoOverlap(string id, vector &o FactoryConstraints::createConstraintNoOverlap(problem, id, vars[i], vars[j], lengths[i], lengths[j]); } -void CosocoCallbacks::buildConstraintNoOverlap(string id, vector &origins, vector &lengths, - bool zeroIgnored) { +void XCSP3Core::CosocoCallbacks::buildConstraintNoOverlap(string id, vector &origins, vector &lengths, + bool zeroIgnored) { if(!zeroIgnored) throw runtime_error("K dim Nooverlap with zeroIgnored not yet supported"); for(unsigned int i = 0; i < origins.size(); i++) @@ -989,8 +1008,8 @@ void CosocoCallbacks::buildConstraintNoOverlap(string id, vector &o } } -void CosocoCallbacks::buildConstraintNoOverlap(string id, vector> &origins, - vector> &lengths, bool zeroIgnored) { +void XCSP3Core::CosocoCallbacks::buildConstraintNoOverlap(string id, vector> &origins, + vector> &lengths, bool zeroIgnored) { if(!zeroIgnored) throw runtime_error("K dim Nooverlap with zeroIgnored not yet supported"); @@ -1012,8 +1031,8 @@ void CosocoCallbacks::buildConstraintNoOverlap(string id, vector> &origins, vector> &lengths, - bool zeroIgnored) { +void XCSP3Core::CosocoCallbacks::buildConstraintNoOverlap(string id, vector> &origins, + vector> &lengths, bool zeroIgnored) { if(!zeroIgnored) throw runtime_error("K dim Nooverlap with zeroIgnored not yet supported"); assert(origins.size() == lengths.size() && origins[0].size() == 2); @@ -1081,8 +1100,8 @@ void CosocoCallbacks::buildConstraintNoOverlap(string id, vector &origins, vector &lengths, - vector &heights, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, vector &lengths, + vector &heights, XCondition &xc) { vars.clear(); vec h, l; vector2vec(lengths); @@ -1097,8 +1116,8 @@ void CosocoCallbacks::buildConstraintCumulative(string id, vector & } -void CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, vector &lengths, - vector &varHeights, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, vector &lengths, + vector &varHeights, XCondition &xc) { vars.clear(); vec l; vec myvarHeights; @@ -1115,8 +1134,8 @@ void CosocoCallbacks::buildConstraintCumulative(string id, vector & } -void CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, vector &varlengths, - vector &h, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, + vector &varlengths, vector &h, XCondition &xc) { vars.clear(); vec heights; vec myvarwidths; @@ -1132,8 +1151,9 @@ void CosocoCallbacks::buildConstraintCumulative(string id, vector & } -void CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, vector &varwidths, - vector &varheights, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintCumulative(string id, vector &origins, + vector &varwidths, vector &varheights, + XCondition &xc) { vars.clear(); vec myvarwidths, myvarheights; @@ -1149,7 +1169,8 @@ void CosocoCallbacks::buildConstraintCumulative(string id, vector & } -void CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, XCondition &cond) { +void XCSP3Core::CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, + XCondition &cond) { vars.clear(); toMyVariables(list, vars); if(Variable::haveSameDomainType(vars) == false) { @@ -1170,8 +1191,8 @@ void CosocoCallbacks::buildConstraintBinPacking(string id, vector & } -void CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, vector &capacities, - bool load) { +void XCSP3Core::CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, + vector &capacities, bool load) { vec s, c; vector2vec(sizes); vals.copyTo(s); @@ -1187,15 +1208,15 @@ void CosocoCallbacks::buildConstraintBinPacking(string id, vector & for(int cap : capacities) { string auxVar = "__av" + std::to_string(auxiliaryIdx++) + "__"; buildVariableInteger(auxVar, cap, cap); - loads.push(problem->variables.last()); + loads.push(problem->variables.back().get()); } FactoryConstraints::createConstraintBinPacking(problem, id, vars, s, loads); } else FactoryConstraints::createConstraintBinPacking(problem, id, vars, s, c); } -void CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, - vector &capacities, bool load) { +void XCSP3Core::CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, + vector &capacities, bool load) { vec s; vector2vec(sizes); vals.copyTo(s); @@ -1223,8 +1244,8 @@ void CosocoCallbacks::buildConstraintBinPacking(string id, vector & } } -void CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, - vector &conditions, int startindex) { +void XCSP3Core::CosocoCallbacks::buildConstraintBinPacking(string id, vector &list, vector &sizes, + vector &conditions, int startindex) { for(XCondition &xc : conditions) { if(xc.operandType != VARIABLE && xc.op != EQ) throw std::runtime_error("Bin packing with all condiions not EQ=VAR is not yet implemented"); @@ -1243,7 +1264,7 @@ void CosocoCallbacks::buildConstraintBinPacking(string id, vector & // Instantiation constraint //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildConstraintInstantiation(string id, vector &list, vector &values) { +void XCSP3Core::CosocoCallbacks::buildConstraintInstantiation(string id, vector &list, vector &values) { for(unsigned int i = 0; i < list.size(); i++) { vec value; if(values[i] == STAR) @@ -1254,12 +1275,13 @@ void CosocoCallbacks::buildConstraintInstantiation(string id, vector &list, vector values, bool covered) { +void XCSP3Core::CosocoCallbacks::buildConstraintPrecedence(string id, vector &list, vector values, + bool covered) { toMyVariables(list); FactoryConstraints::createConstraintPrecedence(problem, id, vars, vector2vec(values), covered); } -void CosocoCallbacks::buildConstraintPrecedence(string id, vector &list, bool covered) { +void XCSP3Core::CosocoCallbacks::buildConstraintPrecedence(string id, vector &list, bool covered) { toMyVariables(list); std::set values; for(Variable *x : vars) { @@ -1270,15 +1292,16 @@ void CosocoCallbacks::buildConstraintPrecedence(string id, vector & FactoryConstraints::createConstraintPrecedence(problem, id, vars, tmp, covered); } -void CosocoCallbacks::buildConstraintKnapsack(string id, vector &list, vector &weights, vector &profits, - XCondition weightsCondition, XCondition &profitCondition) { +void XCSP3Core::CosocoCallbacks::buildConstraintKnapsack(string id, vector &list, vector &weights, + vector &profits, XCondition weightsCondition, + XCondition &profitCondition) { buildConstraintSum(id, list, weights, weightsCondition); buildConstraintSum(id, list, profits, profitCondition); } -void CosocoCallbacks::buildConstraintFlow(string id, vector &list, vector &balance, vector &weights, - vector> &arcs, XCondition &xc) { +void XCSP3Core::CosocoCallbacks::buildConstraintFlow(string id, vector &list, vector &balance, + vector &weights, vector> &arcs, XCondition &xc) { std::set set; toMyVariables(list); for(auto &arc : arcs) { @@ -1315,59 +1338,60 @@ void CosocoCallbacks::buildConstraintFlow(string id, vector &list, // Objectives //-------------------------------------------------------------------------------------- -void CosocoCallbacks::buildObjectiveMinimizeExpression(string expr) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimizeExpression(string expr) { string tmp = "le(" + expr + ",0)"; buildConstraintIntension("objective", new XCSP3Core::Tree(tmp)); auto *po = static_cast(problem); po->type = OptimisationType::Minimize; - auto *oc = dynamic_cast(problem->constraints.last()); - po->addObjectiveUB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveUB(oc); } -void CosocoCallbacks::buildObjectiveMaximizeExpression(string expr) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximizeExpression(string expr) { string tmp = "ge(" + expr + ",0)"; // Fake value buildConstraintIntension("objective", new XCSP3Core::Tree(tmp)); auto *po = static_cast(problem); po->type = OptimisationType::Maximize; - auto *oc = dynamic_cast(problem->constraints.last()); + auto *oc = dynamic_cast(problem->constraints.back().get()); assert(oc != nullptr); - po->addObjectiveLB(oc, true); + po->addObjectiveLB(oc); } -void CosocoCallbacks::buildObjectiveMinimizeVariable(XVariable *x) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimizeVariable(XVariable *x) { FactoryConstraints::createConstraintUnaryLE(problem, "", problem->mapping[x->id], 0); auto *po = static_cast(problem); po->type = OptimisationType::Minimize; - auto *oc = dynamic_cast(problem->constraints.last()); - po->addObjectiveUB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveUB(oc); } -void CosocoCallbacks::buildObjectiveMaximizeVariable(XVariable *x) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximizeVariable(XVariable *x) { FactoryConstraints::createConstraintUnaryGE(problem, "", problem->mapping[x->id], 0); auto *po = static_cast(problem); po->type = OptimisationType::Maximize; - auto *oc = dynamic_cast(problem->constraints.last()); - po->addObjectiveLB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveLB(oc); } -void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &list) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &list) { vector coeffs; coeffs.assign(list.size(), 1); buildObjectiveMinimize(type, list, coeffs); } -void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list) { vector coeffs; coeffs.assign(list.size(), 1); buildObjectiveMaximize(type, list, coeffs); } -void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vec &variables, vector &origcoeffs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vec &variables, + vector &origcoeffs) { auto *po = static_cast(problem); po->type = OptimisationType::Minimize; @@ -1380,8 +1404,8 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vec(problem->constraints.last()); - po->addObjectiveLB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveLB(oc); break; } case PRODUCT_O: @@ -1389,20 +1413,20 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vec(problem->constraints.last()); - po->addObjectiveUB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveUB(oc); break; } case MAXIMUM_O: { FactoryConstraints::createConstraintMaximumLE(problem, "objective", variables, INT_MAX); - auto *oc = dynamic_cast(problem->constraints.last()); - po->addObjectiveUB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveUB(oc); break; } case NVALUES_O: { FactoryConstraints::createConstraintNValuesLE(problem, "objective", variables, variables.size() + 1); - auto *oc = dynamic_cast(problem->constraints.last()); - po->addObjectiveUB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveUB(oc); break; } case LEX_O: @@ -1412,7 +1436,8 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vec &list, vector &origcoeffs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &list, + vector &origcoeffs) { for(int core = 0; core < nbcores; core++) { toMyVariables(list, vars); buildObjectiveMinimize(type, vars, origcoeffs); @@ -1420,7 +1445,8 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &variables, vector &origcoeffs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vec &variables, + vector &origcoeffs) { auto *po = static_cast(problem); po->type = OptimisationType::Maximize; @@ -1447,18 +1473,20 @@ void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vec(problem->constraints.last()); - po->addObjectiveLB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveLB(oc); } -void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list, vector &origcoeffs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list, + vector &origcoeffs) { toMyVariables(list, vars); buildObjectiveMaximize(type, vars, origcoeffs); } -void CosocoCallbacks::createAuxiliaryVariablesAndExpressions(vector &trees, vector &auxiliaryVariables) { +void XCSP3Core::CosocoCallbacks::createAuxiliaryVariablesAndExpressions(vector &trees, + vector &auxiliaryVariables) { set values; std::map tuple; @@ -1505,7 +1533,7 @@ void CosocoCallbacks::createAuxiliaryVariablesAndExpressions(vector &tre } -void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &trees, vector &coefs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &trees, vector &coefs) { vector auxiliaryVariables; startToParseObjective = false; createAuxiliaryVariablesAndExpressions(trees, auxiliaryVariables); @@ -1518,7 +1546,7 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &trees, vector &coefs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &trees, vector &coefs) { vector auxiliaryVariables; startToParseObjective = false; @@ -1532,7 +1560,8 @@ void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list, vector &coefs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &list, + vector &coefs) { auto *po = static_cast(problem); po->type = OptimisationType::Minimize; switch(type) { @@ -1549,9 +1578,9 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector(problem->constraints.last()); - std::cout << problem->constraints.last()->type << std::endl; - po->addObjectiveLB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + std::cout << problem->constraints.back()->type << std::endl; + po->addObjectiveLB(oc); break; } default: @@ -1560,7 +1589,8 @@ void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &list, vector &coefs) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &list, + vector &coefs) { auto *po = static_cast(problem); po->type = OptimisationType::Maximize; toMyVariables(list); @@ -1578,23 +1608,25 @@ void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector(problem->constraints.last()); - po->addObjectiveLB(oc, true); + auto *oc = dynamic_cast(problem->constraints.back().get()); + po->addObjectiveLB(oc); } -void CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &trees) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMinimize(ExpressionObjective type, vector &trees) { vector coeffs; coeffs.assign(trees.size(), 1); buildObjectiveMinimize(type, trees, coeffs); } -void CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &trees) { +void XCSP3Core::CosocoCallbacks::buildObjectiveMaximize(ExpressionObjective type, vector &trees) { vector coeffs; coeffs.assign(trees.size(), 1); buildObjectiveMaximize(type, trees, coeffs); } -void CosocoCallbacks::buildAnnotationDecision(vector &list) { toMyVariables(list, decisionVariables[0]); } +void XCSP3Core::CosocoCallbacks::buildAnnotationDecision(vector &list) { toMyVariables(list, decisionVariables[0]); } + +#endif /* USE_XCSP3 */ \ No newline at end of file diff --git a/solver/utils/CosocoCallbacks.h b/solver/utils/CosocoCallbacks.h index 7e09edd..2ecdf0b 100644 --- a/solver/utils/CosocoCallbacks.h +++ b/solver/utils/CosocoCallbacks.h @@ -1,7 +1,8 @@ #ifndef COSOCO_COSOCOCALLBACKS_H #define COSOCO_COSOCOCALLBACKS_H -#include +#ifdef USE_XCSP3 + #include #include "FactoryConstraints.h" @@ -17,8 +18,6 @@ #include "utils/Utils.h" -using namespace Cosoco; -using namespace std; namespace XCSP3Core { class CosocoCallbacks; @@ -35,7 +34,8 @@ class Primitive { std::string id; - Primitive(XCSP3Core::CosocoCallbacks &m, string expr, int a) : pattern(new Tree(std::move(expr))), callbacks(m), arity(a) { } + Primitive(XCSP3Core::CosocoCallbacks &m, std::string expr, int a) + : pattern(new Tree(std::move(expr))), callbacks(m), arity(a) { } Primitive(XCSP3Core::CosocoCallbacks &m) : pattern(nullptr), callbacks(m), arity(0) { } virtual ~Primitive() { } @@ -62,18 +62,18 @@ class Primitive { class ManageIntension { public: - vec patterns; - CosocoCallbacks &callbacks; - map cachedExtensions; + Cosoco::vec patterns; + CosocoCallbacks &callbacks; + map cachedExtensions; explicit ManageIntension(CosocoCallbacks &callbacks); void createPrimitives(); void intension(std::string id, Tree *tree); bool recognizePrimitives(std::string id, Tree *tree); - bool toExtension(std::string id, Tree *tree, vec &scope); - bool existInCacheExtension(string &expr, vec &scope); + bool toExtension(std::string id, Tree *tree, Cosoco::vec &scope); + bool existInCacheExtension(string &expr, Cosoco::vec &scope); bool decompose(std::string id, Tree *tree); bool decompose(Node *node); - void extractVariables(Node *node, vector &listOfVariables); + void extractVariables(Node *node, vector &listOfVariables); }; @@ -81,7 +81,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { friend class ManageIntension; protected: - vec &vector2vec(vector &src) { + Cosoco::vec &vector2vec(vector &src) { vals.clear(); vals.growTo(src.size()); for(unsigned int i = 0; i < src.size(); i++) vals[i] = src[i]; @@ -89,23 +89,23 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { } - vec &toMyVariables(vector &src, vec &dest) { + Cosoco::vec &toMyVariables(std::vector &src, Cosoco::vec &dest) { dest.clear(); for(unsigned int i = 0; i < src.size(); i++) dest.push(problem->mapping[src[i]->id]); return dest; } - vec &toMyVariables(vector &src) { return toMyVariables(src, vars); } + Cosoco::vec &toMyVariables(std::vector &src) { return toMyVariables(src, vars); } - Range possibleValuesForExpressionInRange(Node *node) { + Cosoco::Range possibleValuesForExpressionInRange(Node *node) { if(XCSP3Core::isPredicateOperator(node->type)) return {0, 1}; if(node->type == OVAR) { - auto *nx = dynamic_cast(node); - Variable *x = problem->mapping[nx->var]; + auto *nx = dynamic_cast(node); + auto *x = problem->mapping[nx->var]; return {x->minimum(), x->maximum()}; } if(node->type == ODECIMAL) { @@ -115,7 +115,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { assert(node->parameters.size() > 0); // To be sure assert(node->parameters.size() > 0); // To be sure - vec ranges; + Cosoco::vec ranges; for(Node *n : node->parameters) ranges.push(possibleValuesForExpressionInRange(n)); @@ -152,7 +152,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { if(node->type == OADD) { int mn = 0, mx = 0; - for(Range r : ranges) { + for(Cosoco::Range r : ranges) { mn += r.min; mx += r.max; } @@ -178,7 +178,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { if(node->type == OMIN) { int mn = ranges[0].min, mx = ranges[0].max; - for(Range &r : ranges) { + for(Cosoco::Range &r : ranges) { mn = mn > r.min ? r.min : mn; mx = mx > r.max ? r.max : mx; } @@ -187,7 +187,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { if(node->type == OMAX) { int mn = ranges[0].min, mx = ranges[0].max; - for(Range &r : ranges) { + for(Cosoco::Range &r : ranges) { mn = mn < r.min ? r.min : mn; mx = mx < r.max ? r.max : mx; } @@ -200,7 +200,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { } assert(false); - return Range(0, 0); // Avoid warning + return Cosoco::Range(0, 0); // Avoid warning } @@ -209,7 +209,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { values.insert(tree->evaluate(tuple)); return; } - Variable *x = problem->mapping[tree->listOfVariables[idx]]; // Take core 0 is ok + auto *x = problem->mapping[tree->listOfVariables[idx]]; // Take core 0 is ok for(int idv : x->domain) { tuple[tree->listOfVariables[idx]] = x->domain.toVal(idv); possibleValuesForExpression(tree, tuple, values, idx + 1); @@ -221,31 +221,31 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { int nbIntension; bool inArray; - int nbMDD; - vec vars; // Not so beautiful, but efficient... - vec vals; // Avoid std::move and save lines... - bool startToParseObjective; - int auxiliaryIdx; - map expressionsToAuxiliaryVariables; - vector previousArgument; - int nbIntension2Extention; + int nbMDD; + Cosoco::vec vars; // Not so beautiful, but efficient... + Cosoco::vec vals; // Avoid std::move and save lines... + bool startToParseObjective; + int auxiliaryIdx; + map expressionsToAuxiliaryVariables; + vector previousArgument; + int nbIntension2Extention; public: - int nbcores; - unsigned long long intension2extensionLimit; - vec problems; - Cosoco::Problem *problem; - bool optimizationProblem; + int nbcores; + unsigned long long intension2extensionLimit; + Cosoco::vec problems; + Cosoco::Problem *problem; + bool optimizationProblem; bool invertOptimization; // See Sum objective. If minimize -> Maximize and change sum (only sumGE is supported) - vec> decisionVariables; - int nbInitialsVariables; - std::map mappingXV; - ManageIntension *manageIntension; + Cosoco::vec> decisionVariables; + int nbInitialsVariables; + std::map mappingXV; + ManageIntension *manageIntension; CosocoCallbacks(int ncores) : startToParseObjective(false), nbcores(ncores) { recognizeSpecialIntensionCases = false; manageIntension = new ManageIntension(*this); - if(options::stringOptions["removeclasses"].value != "") { - std::vector classes = split1(std::string(options::stringOptions["removeclasses"].value), ','); + if(Cosoco::options::stringOptions["removeclasses"].value != "") { + std::vector classes = split1(std::string(Cosoco::options::stringOptions["removeclasses"].value), ','); for(const std::string &c : classes) addClassToDiscard(c); } } @@ -292,8 +292,8 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { void buildConstraintExtensionAs(string id, vector list, bool support, bool hasStar); - void buildConstraintExtension2(const string &id, vec &scope, const vector> &origTuples, bool support, - bool hasStar) const; + void buildConstraintExtension2(const string &id, Cosoco::vec &scope, + const std::vector> &origTuples, bool support, bool hasStar) const; void buildConstraintExtension(string id, XVariable *variable, vector &tuples, bool support, bool hasStar) override; @@ -313,12 +313,12 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { // Language constraints //-------------------------------------------------------------------------------------- - Cosoco::MDD *sameMDDAsPrevious(vec &list); + Cosoco::MDD *sameMDDAsPrevious(Cosoco::vec &list); - void buildConstraintMDD(string id, vector &list, vector &transitions) override; + void buildConstraintMDD(std::string id, std::vector &list, std::vector &transitions) override; - void buildConstraintRegular(string id, vector &list, string start, vector &final, - vector &transitions) override; + void buildConstraintRegular(std::string id, std::vector &list, std::string start, + std::vector &final, std::vector &transitions) override; //-------------------------------------------------------------------------------------- // Graph constraints @@ -361,7 +361,7 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { void buildConstraintSum(string id, vector &list, vector &origcoeffs, XCondition &xc) override; - void buildConstraintSum(string id, vec &variables, vector &coeffs, XCondition &xc); + void buildConstraintSum(string id, Cosoco::vec &variables, std::vector &coeffs, XCondition &xc); void buildConstraintSum(string id, vector &list, vector &coeffs, XCondition &xc) override; @@ -501,11 +501,11 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { void buildObjectiveMaximize(ExpressionObjective type, vector &list) override; - void buildObjectiveMinimize(ExpressionObjective type, vec &variables, vector &origcoeffs); + void buildObjectiveMinimize(ExpressionObjective type, Cosoco::vec &variables, vector &origcoeffs); void buildObjectiveMinimize(ExpressionObjective type, vector &list, vector &origcoeffs) override; - void buildObjectiveMaximize(ExpressionObjective type, vec &variables, vector &origcoeffs); + void buildObjectiveMaximize(ExpressionObjective type, Cosoco::vec &variables, vector &origcoeffs); void buildObjectiveMaximize(ExpressionObjective type, vector &list, vector &origcoeffs) override; @@ -534,4 +534,8 @@ class CosocoCallbacks : public XCSP3CoreCallbacks { } // namespace XCSP3Core + + +#endif /* USE_XCSP3 */ + #endif // COSOCO_COSOCOCALLBACKS_H diff --git a/solver/utils/FactoryConstraints.h b/solver/utils/FactoryConstraints.h index 8931496..851c830 100644 --- a/solver/utils/FactoryConstraints.h +++ b/solver/utils/FactoryConstraints.h @@ -1,74 +1,73 @@ #ifndef FACTORYCONSTRAINTS_H #define FACTORYCONSTRAINTS_H -#include -#include - -#include "BinPacking.h" -#include "BinPackingLoad.h" -#include "CardinalityWeak.h" -#include "CompactTable.h" -#include "Constraint.h" -#include "CumulativeVariablesC.h" -#include "CumulativeVariablesH.h" -#include "CumulativeVariablesHW.h" -#include "CumulativeVariablesHWC.h" -#include "CumulativeVariablesW.h" -#include "DisjunctiveVars.h" -#include "Options.h" -#include "Precedence.h" -#include "Reification.h" +#ifdef USE_XCSP3 + #include "XCSP3Constants.h" +#include "XCSP3Tree.h" +#include "constraints/Constraint.h" +#include "constraints/extensions/BinaryExtension.h" +#include "constraints/extensions/CompactTable.h" +#include "constraints/extensions/MDDExtension.h" +#include "constraints/extensions/STRNeg.h" +#include "constraints/extensions/ShortSTR2.h" +#include "constraints/extensions/Unary.h" +#include "constraints/genericFiltering/AC3rm.h" +#include "constraints/globals/comparison/AllDifferent.h" +#include "constraints/globals/comparison/DistinctVectors.h" +#include "constraints/globals/comparison/Lexicographic.h" +#include "constraints/globals/comparison/NotAllEqual.h" +#include "constraints/globals/connection/Precedence.h" +#include "constraints/globals/connection/element/ElementConstant.h" #include "constraints/globals/connection/element/ElementMatrix.h" +#include "constraints/globals/connection/element/ElementVariable.h" +#include "constraints/globals/connection/maximum/MaximumConstantGE.h" +#include "constraints/globals/connection/maximum/MaximumConstantLE.h" #include "constraints/globals/connection/maximum/MaximumVariableEQ.h" +#include "constraints/globals/connection/minimum/MinimumConstantGE.h" +#include "constraints/globals/connection/minimum/MinimumConstantLE.h" +#include "constraints/globals/connection/minimum/MinimumVariableEQ.h" +#include "constraints/globals/counting/AtLeastK.h" +#include "constraints/globals/counting/AtMostK.h" +#include "constraints/globals/counting/CardinalityWeak.h" +#include "constraints/globals/counting/ExactlyK.h" +#include "constraints/globals/counting/ExactlyKVariable.h" #include "constraints/globals/counting/NValuesEQVar.h" +#include "constraints/globals/counting/NValuesLEK.h" #include "constraints/globals/graph/Circuit.h" +#include "constraints/globals/packing/BinPacking.h" +#include "constraints/globals/packing/BinPackingLoad.h" #include "constraints/globals/packing/Cumulative.h" +#include "constraints/globals/packing/CumulativeVariablesC.h" +#include "constraints/globals/packing/CumulativeVariablesH.h" +#include "constraints/globals/packing/CumulativeVariablesHW.h" +#include "constraints/globals/packing/CumulativeVariablesHWC.h" +#include "constraints/globals/packing/CumulativeVariablesW.h" #include "constraints/globals/packing/NoOverlap.h" +#include "constraints/globals/summing/Sum.h" +#include "constraints/globals/summing/SumEQ.h" +#include "constraints/globals/summing/SumGE.h" +#include "constraints/globals/summing/SumNE.h" #include "constraints/globals/summing/SumScalarLEK.h" #include "constraints/globals/summing/SumScalarLEVar.h" +#include "constraints/intension/Intension.h" +#include "constraints/primitives/DiffXY.h" +#include "constraints/primitives/Disjunctive.h" +#include "constraints/primitives/DisjunctiveVars.h" +#include "constraints/primitives/DistXYeqZ.h" +#include "constraints/primitives/EQ.h" +#include "constraints/primitives/GEUnary.h" +#include "constraints/primitives/LE.h" +#include "constraints/primitives/LEUnary.h" +#include "constraints/primitives/LT.h" +#include "constraints/primitives/Reification.h" +#include "constraints/primitives/xEqOryk.h" #include "constraints/primitives/xTimesyEQz.h" -#include "extensions/BinaryExtension.h" -#include "extensions/MDDExtension.h" -#include "extensions/STRNeg.h" -#include "extensions/ShortSTR2.h" -#include "extensions/Unary.h" -#include "genericFiltering/AC3rm.h" -#include "globals/comparison/AllDifferent.h" -#include "globals/comparison/DistinctVectors.h" -#include "globals/comparison/Lexicographic.h" -#include "globals/comparison/NotAllEqual.h" -#include "globals/connection/element/ElementConstant.h" -#include "globals/connection/element/ElementVariable.h" -#include "globals/connection/maximum/MaximumConstantGE.h" -#include "globals/connection/maximum/MaximumConstantLE.h" -#include "globals/connection/minimum/MinimumConstantGE.h" -#include "globals/connection/minimum/MinimumConstantLE.h" -#include "globals/connection/minimum/MinimumVariableEQ.h" -#include "globals/counting/AtLeastK.h" -#include "globals/counting/AtMostK.h" -#include "globals/counting/ExactlyK.h" -#include "globals/counting/ExactlyKVariable.h" -#include "globals/counting/NValuesLEK.h" -#include "globals/summing/Sum.h" -#include "globals/summing/SumEQ.h" -#include "globals/summing/SumGE.h" -#include "globals/summing/SumNE.h" -#include "intension/Intension.h" #include "mtl/Vec.h" -#include "primitives/DiffXY.h" -#include "primitives/Disjunctive.h" -#include "primitives/DistXYeqZ.h" -#include "primitives/EQ.h" -#include "primitives/GEUnary.h" -#include "primitives/LE.h" -#include "primitives/LEUnary.h" -#include "primitives/LT.h" -#include "primitives/xEqOryk.h" +#include "solver/utils/Options.h" #include "utils/Verbose.h" namespace Cosoco { -using namespace XCSP3Core; typedef struct Occurs Occurs; struct Occurs { @@ -90,67 +89,68 @@ class FactoryConstraints { static void createConstraintXeqAndY(Problem *p, std::string name, Variable *x, vec &l) { l.push(x); - p->addConstraint(new XeqAndY(*p, name, l)); + p->addConstraint(std::make_unique(*p, name, l)); } static void createConstraintXeqOrYeqK(Problem *p, std::string name, Variable *res, vec &cl, vec &vals) { - p->addConstraint(new xEqOryk(*p, name, res, cl, vals)); + p->addConstraint(std::make_unique(*p, name, res, cl, vals)); } static void createConstraintIntension(Problem *p, std::string name, XCSP3Core::Tree *tree, vec &scope) { - p->addConstraint(new AdapterAC3rm(new Intension(*p, name, tree, scope))); + p->addConstraint(std::make_unique(new Intension(*p, name, tree, scope))); } static void createConstraintLessThan(Problem *p, std::string name, Variable *x, int k, Variable *y, bool strict) { if(strict) - p->addConstraint(new Lt(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); else - p->addConstraint(new Le(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } static void createConstraintXeqYplusk(Problem *p, std::string name, Variable *x, Variable *y, int k) { - p->addConstraint(new EQ(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } static void createConstraintDistXYeqZ(Problem *p, std::string name, Variable *x, Variable *y, Variable *z) { - p->addConstraint(new DistXYeqZ(*p, name, x, y, z)); + p->addConstraint(std::make_unique(*p, name, x, y, z)); } static void createConstraintXeqYeqK(Problem *p, std::string name, Variable *x, Variable *y, int k) { - p->addConstraint(new XeqYeqK(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } static void createConstraintXeqYneK(Problem *p, std::string name, Variable *x, Variable *y, int k) { - p->addConstraint(new XeqYneK(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } static void createConstraintXeqKleY(Problem *p, std::string name, Variable *x, Variable *y, int k) { - p->addConstraint(new XeqKleY(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } static void createConstraintXeqYleK(Problem *p, std::string name, Variable *x, Variable *y, int k) { - p->addConstraint(new XeqYleK(*p, name, x, y, k)); + p->addConstraint(std::make_unique(*p, name, x, y, k)); } - static void createReification(Problem *p, std::string name, Variable *x, Variable *y, Variable *z, ExpressionType op) { + static void createReification(Problem *p, std::string name, Variable *x, Variable *y, Variable *z, + XCSP3Core::ExpressionType op) { assert(x != y && x != z && y != z); - if(op == OLE) { - p->addConstraint(new ReifLE(*p, name, x, y, z)); + if(op == XCSP3Core::OLE) { + p->addConstraint(std::make_unique(*p, name, x, y, z)); return; } - if(op == OLT) { - p->addConstraint(new ReifLT(*p, name, x, y, z)); + if(op == XCSP3Core::OLT) { + p->addConstraint(std::make_unique(*p, name, x, y, z)); return; } - if(op == OEQ) { - p->addConstraint(new ReifEQ(*p, name, x, y, z)); + if(op == XCSP3Core::OEQ) { + p->addConstraint(std::make_unique(*p, name, x, y, z)); return; } - if(op == ONE) { - p->addConstraint(new ReifNE(*p, name, x, y, z)); + if(op == XCSP3Core::ONE) { + p->addConstraint(std::make_unique(*p, name, x, y, z)); return; } assert(false); @@ -210,28 +210,29 @@ class FactoryConstraints { scp.push(y); if(x != z && y != z) scp.push(z); - createConstraintIntension(p, name, new Tree("eq(" + z->_name + ",mul(" + x->_name + "," + y->_name + "))"), scp); + createConstraintIntension(p, name, new XCSP3Core::Tree("eq(" + z->_name + ",mul(" + x->_name + "," + y->_name + "))"), + scp); } else - p->addConstraint(new xTimesyEQz(*p, name, x, y, z)); + p->addConstraint(std::make_unique(*p, name, x, y, z)); } - static Constraint *newExtensionConstraint(Problem *p, std::string name, vec &vars, vec> &tuples, - bool isSupport, bool hasStar = false) { - Extension *ctr = nullptr; + static std::unique_ptr newExtensionConstraint(Problem *p, std::string name, vec &vars, + vec> &tuples, bool isSupport, bool hasStar = false) { + std::unique_ptr ctr; if(vars.size() == 2) { if(isSupport) - ctr = new BinaryExtension(*p, name, isSupport, vars[0], vars[1]); + ctr = std::make_unique(*p, name, isSupport, vars[0], vars[1]); else - ctr = new STRNeg(*p, name, vars, tuples.size()); + ctr = std::make_unique(*p, name, vars, tuples.size()); } else { if(isSupport) { if(options::boolOptions["ct"].value) - ctr = new CompactTable(*p, name, vars, tuples.size()); + ctr = std::make_unique(*p, name, vars, tuples.size()); else - ctr = new ShortSTR2(*p, name, vars, tuples.size()); + ctr = std::make_unique(*p, name, vars, tuples.size()); } else { assert(hasStar == false); // TODO - ctr = new STRNeg(*p, name, vars, tuples.size()); + ctr = std::make_unique(*p, name, vars, tuples.size()); } } @@ -247,67 +248,69 @@ class FactoryConstraints { static void createConstraintExtensionAs(Problem *p, std::string name, vec &vars, Constraint *c) { - Extension *ctr = nullptr; - auto *sameConstraint = (Extension *)c; + std::unique_ptr ctr; + auto *sameConstraint = (Extension *)c; assert(sameConstraint->scope.size() == vars.size()); p->nbExtensionsSharded++; if(vars.size() == 1) { - p->addConstraint(new Unary(*p, name, vars[0], ((Unary *)p->constraints.last())->values, - ((Unary *)p->constraints.last())->areSupports)); + p->addConstraint(std::make_unique(*p, name, vars[0], ((Unary *)p->constraints.back().get())->values, + ((Unary *)p->constraints.back().get())->areSupports)); return; } if(vars.size() == 2) { if(sameConstraint->isSupport) - ctr = - new BinaryExtension(*p, name, sameConstraint->isSupport, vars[0], vars[1], (BinaryExtension *)sameConstraint); + ctr = std::make_unique(*p, name, sameConstraint->isSupport, vars[0], vars[1], + (BinaryExtension *)sameConstraint); else - ctr = new STRNeg(*p, name, vars, sameConstraint->tuples); + ctr = std::make_unique(*p, name, vars, sameConstraint->tuples); } if(vars.size() > 2) { if(sameConstraint->isSupport) { // ctr = new ShortSTR2(*p, name, vars, sameConstraint->tuples); if(options::boolOptions["ct"].value) - ctr = new CompactTable(*p, name, vars, sameConstraint->tuples); + ctr = std::make_unique(*p, name, vars, sameConstraint->tuples); else - ctr = new ShortSTR2(*p, name, vars, sameConstraint->tuples); + ctr = std::make_unique(*p, name, vars, sameConstraint->tuples); } else - ctr = new STRNeg(*p, name, vars, sameConstraint->tuples); + ctr = std::make_unique(*p, name, vars, sameConstraint->tuples); } - p->addConstraint(ctr); + p->addConstraint(std::move(ctr)); } static void createConstraintUnary(Problem *p, std::string name, Variable *x, vec &values, bool isSupport) { - p->addConstraint(new Unary(*p, name, x, values, isSupport)); + p->addConstraint(std::make_unique(*p, name, x, values, isSupport)); } static void createConstraintUnaryGE(Problem *p, std::string name, Variable *x, int k) { - p->addConstraint(new GEUnary(*p, name, x, k)); + p->addConstraint(std::make_unique(*p, name, x, k)); } static void createConstraintUnaryLE(Problem *p, std::string name, Variable *x, int k) { - p->addConstraint(new LEUnary(*p, name, x, k)); + p->addConstraint(std::make_unique(*p, name, x, k)); } //-------------------------------------------------------------------------------------- // Language constraints //-------------------------------------------------------------------------------------- - static void createConstraintMDD(Problem *p, std::string name, vec &vars, vec &transitions) { - p->addConstraint(new MDDExtension(*p, name, vars, transitions)); + static void createConstraintMDD(Problem *p, std::string name, vec &vars, + vec &transitions) { + p->addConstraint(std::make_unique(*p, name, vars, transitions)); } static void createConstraintMDD(Problem *p, std::string name, vec &vars, MDD *mdd) { - p->addConstraint(new MDDExtension(*p, name, vars, mdd)); + p->addConstraint(std::make_unique(*p, name, vars, mdd)); } static void createConstraintRegular(Problem *p, std::string name, vec &vars, string start, - std::vector &final, vec &transitions) { - p->addConstraint(new MDDExtension(*p, name, vars, MDD::buildFromAutomata(name, vars, start, final, transitions))); + std::vector &final, vec &transitions) { + p->addConstraint( + std::make_unique(*p, name, vars, MDD::buildFromAutomata(name, vars, start, final, transitions))); } //-------------------------------------------------------------------------------------- @@ -315,7 +318,7 @@ class FactoryConstraints { //-------------------------------------------------------------------------------------- static void createConstraintCircuit(Problem *p, std::string name, vec &vars) { - p->addConstraint(new Circuit(*p, name, vars)); + p->addConstraint(std::make_unique(*p, name, vars)); } @@ -325,9 +328,9 @@ class FactoryConstraints { static void createConstraintAllDiff(Problem *p, std::string name, vec &vars) { if(vars.size() == 2) - p->addConstraint(new DiffXY(*p, name, vars[0], vars[1])); + p->addConstraint(std::make_unique(*p, name, vars[0], vars[1])); else - p->addConstraint(new AllDifferent(*p, name, vars)); + p->addConstraint(std::make_unique(*p, name, vars)); } @@ -411,7 +414,8 @@ class FactoryConstraints { lists.size() * (lists.size() - 1) / 2); for(int i = 0; i < lists.size(); i++) - for(int j = i + 1; j < lists.size(); j++) p->addConstraint(new DistinctVectors(*p, name, lists[i], lists[j])); + for(int j = i + 1; j < lists.size(); j++) + p->addConstraint(std::make_unique(*p, name, lists[i], lists[j])); } else { verbose.log(NORMAL, "c AllDiff List constraint using extension constraint\n", lists.size() * (lists.size() - 1) / 2); for(int i = 0; i < lists.size(); i++) @@ -424,12 +428,12 @@ class FactoryConstraints { static void createConstraintAllEqual(Problem *p, std::string name, vec &vars) { - for(int i = 0; i < vars.size() - 1; i++) p->addConstraint(new EQ(*p, name, vars[i], vars[i + 1])); + for(int i = 0; i < vars.size() - 1; i++) p->addConstraint(std::make_unique(*p, name, vars[i], vars[i + 1])); } static void createConstraintNotAllEqual(Problem *p, std::string name, vec &vars) { - p->addConstraint(new NotAllEqual(*p, name, vars)); + p->addConstraint(std::make_unique(*p, name, vars)); } @@ -447,7 +451,7 @@ class FactoryConstraints { coeffs.push(-1); coeffs.push(1); coeffs.push(1); - p->addConstraint(new SumEQ(*p, name, vars, coeffs, 0)); + p->addConstraint(std::make_unique(*p, name, vars, coeffs, 0)); } static void createConstraintSum(Problem *p, std::string name, Variable *x, Variable *y, Variable *z) { // x+y=z @@ -459,34 +463,34 @@ class FactoryConstraints { coeffs.push(-1); coeffs.push(1); coeffs.push(1); - p->addConstraint(new SumEQ(*p, name, vars, coeffs, 0)); + p->addConstraint(std::make_unique(*p, name, vars, coeffs, 0)); } static void createConstraintSum(Problem *p, std::string name, vec &vars, vec &coeffs, long l, - OrderType order) { - if(order == LE) { - p->addConstraint(new SumScalarLEK(*p, name, vars, coeffs, l)); + XCSP3Core::OrderType order) { + if(order == XCSP3Core::LE) { + p->addConstraint(std::make_unique(*p, name, vars, coeffs, l)); return; } throw runtime_error("Not yet implemented scalar"); } static void createConstraintSum(Problem *p, std::string name, vec &vars, vec &coeffs, Variable *z, - OrderType order) { - if(order == LE) { - p->addConstraint(new SumScalarLEVar(*p, name, vars, coeffs, z)); + XCSP3Core::OrderType order) { + if(order == XCSP3Core::LE) { + p->addConstraint(std::make_unique(*p, name, vars, coeffs, z)); return; } throw runtime_error("Not yet implemented scalar"); } static void createConstraintSum(Problem *p, std::string name, vec &vars, vec &coeffs, long l, - OrderType order) { - Sum *ctr = nullptr; + XCSP3Core::OrderType order) { + std::unique_ptr ctr; // Rearrange coeffs. - if(order == OrderType::LE || order == OrderType::LT) { + if(order == XCSP3Core::OrderType::LE || order == XCSP3Core::OrderType::LT) { for(int i = 0; i < coeffs.size(); i++) coeffs[i] = -coeffs[i]; l = -l; } @@ -534,62 +538,62 @@ class FactoryConstraints { vars.shrink(i - j); switch(order) { - case OrderType::LE: - ctr = new SumGE(*p, name, vars, coeffs, l); + case XCSP3Core::OrderType::LE: + ctr = std::make_unique(*p, name, vars, coeffs, l); break; - case OrderType::LT: - ctr = new SumGE(*p, name, vars, coeffs, l + 1); + case XCSP3Core::OrderType::LT: + ctr = std::make_unique(*p, name, vars, coeffs, l + 1); break; - case OrderType::GE: - ctr = new SumGE(*p, name, vars, coeffs, l); + case XCSP3Core::OrderType::GE: + ctr = std::make_unique(*p, name, vars, coeffs, l); break; - case OrderType::GT: - ctr = new SumGE(*p, name, vars, coeffs, l + 1); // TODO + case XCSP3Core::OrderType::GT: + ctr = std::make_unique(*p, name, vars, coeffs, l + 1); // TODO break; - case OrderType::IN: + case XCSP3Core::OrderType::IN: throw runtime_error("This is forbidden to construct a sum with IN operator"); break; - case OrderType::EQ: - ctr = new SumEQ(*p, name, vars, coeffs, l); + case XCSP3Core::OrderType::EQ: + ctr = std::make_unique(*p, name, vars, coeffs, l); break; - case OrderType::NE: - ctr = new SumNE(*p, name, vars, coeffs, l); + case XCSP3Core::OrderType::NE: + ctr = std::make_unique(*p, name, vars, coeffs, l); break; } - assert(ctr != nullptr); - p->addConstraint(ctr); + assert(ctr.get() != nullptr); + p->addConstraint(std::move(ctr)); } static void createConstraintAtLeast(Problem *p, std::string name, vec &vars, int value, int k) { if(k == 0) return; - p->addConstraint(new AtLeastK(*p, name, vars, k, value)); + p->addConstraint(std::make_unique(*p, name, vars, k, value)); } static void createConstraintAtMost(Problem *p, std::string name, vec &vars, int value, int k) { - p->addConstraint(new AtMostK(*p, name, vars, k, value)); + p->addConstraint(std::make_unique(*p, name, vars, k, value)); } static void createConstraintExactly(Problem *p, std::string name, vec &vars, int value, int k) { - p->addConstraint(new ExactlyK(*p, name, vars, k, value)); + p->addConstraint(std::make_unique(*p, name, vars, k, value)); } static void createConstraintExactlyVariable(Problem *p, std::string name, vec &vars, int value, Variable *k) { - p->addConstraint(new ExactlyKVariable(*p, name, vars, k, value)); + p->addConstraint(std::make_unique(*p, name, vars, k, value)); } static void createConstraintNValuesLE(Problem *p, std::string name, vec &vars, int k) { - p->addConstraint(new NValuesLEK(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } static void createConstraintNValuesEQV(Problem *p, std::string name, vec &vars, Variable *k) { - p->addConstraint(new NValuesEQVar(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } @@ -598,19 +602,19 @@ class FactoryConstraints { //-------------------------------------------------------------------------------------- static void createConstraintElementConstant(Problem *p, std::string name, vec &vars, Variable *index, int startIndex, int v) { - p->addConstraint(new ElementConstant(*p, name, vars, index, v, startIndex == 1)); + p->addConstraint(std::make_unique(*p, name, vars, index, v, startIndex == 1)); } static void createConstraintElementVariable(Problem *p, std::string name, vec &vars, Variable *index, int startIndex, Variable *v) { - p->addConstraint(new ElementVariable(*p, name, vars, index, v, startIndex == 1)); + p->addConstraint(std::make_unique(*p, name, vars, index, v, startIndex == 1)); } static void createConstraintElementMatrix(Problem *p, std::string name, vec> &matrix, Variable *rindex, Variable *cindex, int value) { - p->addConstraint(new ElementMatrix(*p, name, matrix, rindex, cindex, value)); + p->addConstraint(std::make_unique(*p, name, matrix, rindex, cindex, value)); } @@ -625,7 +629,7 @@ class FactoryConstraints { if(occurs[0].type == OCCURS_INTEGER && vars.size() > 1000) { vec occs; for(Occurs &o : occurs) occs.push(o.value); - p->addConstraint(new CardinalityWeak(*p, name, vars, values, occs)); + p->addConstraint(std::make_unique(*p, name, vars, values, occs)); return; } @@ -643,36 +647,38 @@ class FactoryConstraints { } - static void createConstraintOrdered(Problem *p, std::string name, vec &vars, vector &lengths, OrderType op) { + static void createConstraintOrdered(Problem *p, std::string name, vec &vars, vector &lengths, + XCSP3Core::OrderType op) { for(int i = 0; i < vars.size() - 1; i++) { int k = lengths.size() == 0 ? 0 : lengths[i]; - if(op == OrderType::LE) - p->addConstraint( - new Le(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i], vars[i + 1], k)); - if(op == OrderType::LT) - p->addConstraint( - new Lt(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i], vars[i + 1], k)); - - if(op == OrderType::GE) - p->addConstraint( - new Le(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i + 1], vars[i], -k)); - if(op == OrderType::GT) - p->addConstraint( - new Lt(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i + 1], vars[i], -k)); + if(op == XCSP3Core::OrderType::LE) + p->addConstraint(std::make_unique(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i], + vars[i + 1], k)); + if(op == XCSP3Core::OrderType::LT) + p->addConstraint(std::make_unique(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), vars[i], + vars[i + 1], k)); + + if(op == XCSP3Core::OrderType::GE) + p->addConstraint(std::make_unique(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), + vars[i + 1], vars[i], -k)); + if(op == XCSP3Core::OrderType::GT) + p->addConstraint(std::make_unique(*p, name + vars[i]->name() + " op " + name + vars[i + 1]->name(), + vars[i + 1], vars[i], -k)); } } - static void createConstraintLex(Problem *p, std::string name, vec &vars1, vec &vars2, OrderType op) { - if(op == OrderType::LE) - p->addConstraint(new Lexicographic(*p, name, vars1, vars2, false)); - if(op == OrderType::LT) - p->addConstraint(new Lexicographic(*p, name, vars1, vars2, true)); + static void createConstraintLex(Problem *p, std::string name, vec &vars1, vec &vars2, + XCSP3Core::OrderType op) { + if(op == XCSP3Core::OrderType::LE) + p->addConstraint(std::make_unique(*p, name, vars1, vars2, false)); + if(op == XCSP3Core::OrderType::LT) + p->addConstraint(std::make_unique(*p, name, vars1, vars2, true)); - if(op == OrderType::GE) - p->addConstraint(new Lexicographic(*p, name, vars2, vars1, false)); - if(op == OrderType::GT) - p->addConstraint(new Lexicographic(*p, name, vars2, vars1, true)); + if(op == XCSP3Core::OrderType::GE) + p->addConstraint(std::make_unique(*p, name, vars2, vars1, false)); + if(op == XCSP3Core::OrderType::GT) + p->addConstraint(std::make_unique(*p, name, vars2, vars1, true)); } @@ -693,39 +699,39 @@ class FactoryConstraints { //----------------------------------------------------------------------- static void createConstraintNoOverlap(Problem *p, std::string name, Variable *x1, Variable *x2, int w1, int w2) { - p->addConstraint(new Disjunctive(*p, name, x1, x2, w1, w2)); + p->addConstraint(std::make_unique(*p, name, x1, x2, w1, w2)); // string tmp = "or(le(add(" + x1->_name + "," + to_string(w1) + ")," + x2->_name + "),le(add(" + x2->_name + "," + // to_string(w2) + ")," + x1->_name + "))"; createConstraintIntension(p, "no overlap", tmp); } static void createConstraintDisjunctiveVars(Problem *p, std::string name, Variable *x1, Variable *x2, Variable *w1, Variable *w2) { - p->addConstraint(new DisjunctiveVars(*p, name, x1, x2, w1, w2)); + p->addConstraint(std::make_unique(*p, name, x1, x2, w1, w2)); } static void createConstraintDisjunctive2D(Problem *p, std::string name, Variable *x1, Variable *x2, Variable *y1, Variable *y2, int w1, int w2, int h1, int h2) { - p->addConstraint(new Disjunctive2D(*p, name, x1, x2, y1, y2, w1, w2, h1, h2)); + p->addConstraint(std::make_unique(*p, name, x1, x2, y1, y2, w1, w2, h1, h2)); } //----------------------------------------------------------------------- static void createConstraintMaximumLE(Problem *p, std::string name, vec &vars, int k) { - p->addConstraint(new MaximumConstantLE(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } static void createConstraintMaximumGE(Problem *p, std::string name, vec &vars, int k) { - p->addConstraint(new MaximumConstantGE(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } static void createConstraintMinimumLE(Problem *p, std::string name, vec &vars, int k) { - p->addConstraint(new MinimumConstantLE(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } static void createConstraintMinimumGE(Problem *p, std::string name, vec &vars, int k) { - p->addConstraint(new MinimumConstantGE(*p, name, vars, k)); + p->addConstraint(std::make_unique(*p, name, vars, k)); } @@ -734,10 +740,10 @@ class FactoryConstraints { verbose.log(NORMAL, "c min(x...)=x -> use inequalities\n"); for(Variable *x : vars) { if(x != value) - p->addConstraint(new Le(*p, name, value, x, 0)); + p->addConstraint(std::make_unique(*p, name, value, x, 0)); } } else - p->addConstraint(new MinimumVariableEQ(*p, name, vars, value)); + p->addConstraint(std::make_unique(*p, name, vars, value)); } @@ -746,10 +752,10 @@ class FactoryConstraints { verbose.log(NORMAL, "c max(x...)=x -> use inequalities\n"); for(Variable *x : vars) { if(x != value) - p->addConstraint(new Le(*p, name, x, value, 0)); + p->addConstraint(std::make_unique(*p, name, x, value, 0)); } } else - p->addConstraint(new MaximumVariableEQ(*p, name, vars, value)); + p->addConstraint(std::make_unique(*p, name, vars, value)); } @@ -758,62 +764,64 @@ class FactoryConstraints { //-------------------------------------------------------------------------------------- static void createConstraintCumulative(Problem *p, std::string name, vec &vars, vec &lengths, vec &heights, Variable *limit) { - p->addConstraint(new CumulativeVariablesC(*p, name, vars, lengths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, lengths, heights, limit)); } static void createConstraintCumulative(Problem *p, std::string name, vec &vars, vec &lengths, vec &heights, int limit) { - p->addConstraint(new Cumulative(*p, name, vars, vars, lengths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, vars, lengths, heights, limit)); } static void createConstraintCumulativeHeightVariable(Problem *p, std::string name, vec &vars, vec &lengths, vec &heights, int limit) { - p->addConstraint(new CumulativeVariablesH(*p, name, vars, lengths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, lengths, heights, limit)); } static void createConstraintCumulativeHeightVariableLV(Problem *p, std::string name, vec &vars, vec &lengths, vec &heights, Variable *limit) { - p->addConstraint(new CumulativeVariablesHLimitV(*p, name, vars, lengths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, lengths, heights, limit)); } static void createConstraintCumulativeWidthVariables(Problem *p, std::string name, vec &vars, vec &lengths, vec &heights, int limit) { - p->addConstraint(new CumulativeVariablesW(*p, name, vars, lengths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, lengths, heights, limit)); } static void createConstraintCumulativeHeightAndWidthVariables(Problem *p, std::string name, vec &vars, vec &widths, vec &heights, int limit) { - p->addConstraint(new CumulativeVariablesHW(*p, name, vars, widths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, widths, heights, limit)); } static void createConstraintCumulativeHeightAndWidthAndConditionVariables(Problem *p, std::string name, vec &vars, vec &widths, vec &heights, Variable *limit) { - p->addConstraint(new CumulativeVariablesHWC(*p, name, vars, widths, heights, limit)); + p->addConstraint(std::make_unique(*p, name, vars, widths, heights, limit)); } static void createConstraintNoOverlap(Problem *p, std::string name, vec &X, vec &width, vec &Y, vec &heights) { - p->addConstraint(new NoOverlap(*p, name, X, width, Y, heights)); + p->addConstraint(std::make_unique(*p, name, X, width, Y, heights)); } static void createConstraintPrecedence(Problem *p, std::string name, vec &vars, vec &values, bool covered) { - p->addConstraint(new Precedence(*p, name, vars, values, covered)); + p->addConstraint(std::make_unique(*p, name, vars, values, covered)); } static void createConstraintBinPacking(Problem *p, std::string name, vec &vars, vec &sizes, vec &limits) { - p->addConstraint(new BinPacking(*p, name, vars, sizes, limits)); + p->addConstraint(std::make_unique(*p, name, vars, sizes, limits)); } static void createConstraintBinPacking(Problem *p, std::string name, vec &vars, vec &sizes, vec &loads) { - p->addConstraint(new BinPackingLoad(*p, name, vars, sizes, loads)); + p->addConstraint(std::make_unique(*p, name, vars, sizes, loads)); } }; } // namespace Cosoco +#endif /* USE_XCSP3 */ + #endif /* FACTORYCONSTRAINTS_H */ diff --git a/solver/utils/ManageIntension.cc b/solver/utils/ManageIntension.cc index e01abcf..44963b1 100644 --- a/solver/utils/ManageIntension.cc +++ b/solver/utils/ManageIntension.cc @@ -1,11 +1,12 @@ // // Created by audemard on 30/03/24. // - +#ifdef USE_XCSP3 #include #include "CosocoCallbacks.h" using namespace XCSP3Core; +using namespace Cosoco; void replace_all_occurrences(std::string &input, const std::string &replace_word, const std::string &replace_by) { size_t pos = input.find(replace_word); @@ -212,7 +213,7 @@ bool ManageIntension::toExtension(std::string id, XCSP3Core::Tree *tree, vec varsCore; for(Variable *tmp : scope) varsCore.push(callbacks.problem->mapping[tmp->_name]); callbacks.buildConstraintExtension2(id, varsCore, tuples, isSupport, false); - cachedExtensions[expr] = callbacks.problem->constraints.last(); + cachedExtensions[expr] = callbacks.problem->constraints.back().get(); return true; } @@ -402,7 +403,7 @@ class PBinary7 : public Primitive { // x= mul(y,y) tuples.push_back({v, v * v}); } callbacks.buildConstraintExtension2(id, scope, tuples, true, false); - callbacks.manageIntension->cachedExtensions[expr] = callbacks.problem->constraints.last(); + callbacks.manageIntension->cachedExtensions[expr] = callbacks.problem->constraints.back().get(); return true; } }; @@ -721,3 +722,5 @@ void ManageIntension::createPrimitives() { patterns.push(new PNary4(callbacks)); // patterns.push(new PNary5(callbacks)); } + +#endif /* USE_XCSP3 */ diff --git a/solver/utils/Profiling.cc b/solver/utils/Profiling.cc index 658b4ca..ca52c4b 100644 --- a/solver/utils/Profiling.cc +++ b/solver/utils/Profiling.cc @@ -10,7 +10,7 @@ using namespace Cosoco; Profiling::Profiling(Solver *s) : solver(s) { } void Profiling::initialize() { - for(Constraint *c : solver->problem.constraints) + for(auto &c : solver->problem.constraints) if(constraintsData.find(c->type) == constraintsData.end()) constraintsData.insert(make_pair(c->type, ConstraintData())); } diff --git a/test/Integration.cc b/test/Integration.cc new file mode 100644 index 0000000..10c74fd --- /dev/null +++ b/test/Integration.cc @@ -0,0 +1,46 @@ +#include + +#include "constraints/primitives/GEUnary.h" +#include "core/Problem.h" +#include "core/Variable.h" +#include "core/domain/DomainRange.h" +#include "solver/Solver.h" +#include "solver/restarts/Restart.h" +#include "test/Utils.h" + +TEST(IntegrationTest, oneVarNoConstraint) { + Cosoco::OptionDefaultAndCleaner _defaultOptions; + + Cosoco::Problem p("oneVarNoConstraint"); + Cosoco::DomainRange domain(0, 4); + p.createVariable(std::string("MyOnlyVariable"), domain); + Cosoco::Solver solver(p); + Cosoco::vec assumps; + p.delayedConstruction(); + try { + auto result = solver.solve(assumps); + EXPECT_EQ(result, R_SAT); + } catch(std::exception &e) { + printf("%s", e.what()); + FAIL(); + } +} + +TEST(IntegrationTest, oneVarOneConstraint) { + Cosoco::OptionDefaultAndCleaner _defaultOptions; + + Cosoco::Problem p("oneVarNoConstraint"); + Cosoco::DomainRange domain(0, 4); + auto *var = p.createVariable(std::string("MyOnlyVariable"), domain); + p.addConstraint(std::make_unique(p, "MyOnlyConstraint", var, 3)); + Cosoco::Solver solver(p); + Cosoco::vec assumps; + p.delayedConstruction(); + try { + auto result = solver.solve(assumps); + EXPECT_EQ(result, R_SAT); + } catch(std::exception &e) { + printf("%s", e.what()); + FAIL(); + } +} \ No newline at end of file diff --git a/test/Utils.h b/test/Utils.h new file mode 100644 index 0000000..597a289 --- /dev/null +++ b/test/Utils.h @@ -0,0 +1,27 @@ +#pragma once +#ifndef COSOCO_TEST_UTILS +#define COSOCO_TEST_UTILS + +#include "solver/utils/Options.h" + +namespace Cosoco { + +/** + * The purpose of this class it to have solver options initialized with + * their default values and having all options automatically cleared when + * the object gets deleted + */ +class OptionDefaultAndCleaner { + public: + OptionDefaultAndCleaner() { options::createOptions(); } + ~OptionDefaultAndCleaner() { + options::stringOptions.clear(); + options::boolOptions.clear(); + options::intOptions.clear(); + options::doubleOptions.clear(); + } +}; + +} // namespace Cosoco + +#endif \ No newline at end of file diff --git a/test/main.cc b/test/main.cc new file mode 100644 index 0000000..23f41c2 --- /dev/null +++ b/test/main.cc @@ -0,0 +1,6 @@ +#include + +int main(int argc, char **argv) { + testing::InitGoogleTest(&argc, argv); + return RUN_ALL_TESTS(); +} \ No newline at end of file diff --git a/utils/Constants.h b/utils/Constants.h new file mode 100644 index 0000000..7c9660b --- /dev/null +++ b/utils/Constants.h @@ -0,0 +1,12 @@ +#pragma once +#ifndef COSOCO_CONSTANTS +#define COSOCO_CONSTANTS + +#ifdef USE_XCSP3 +#include "XCSP3Constants.h" +#else +#include +#define STAR INT_MAX +#endif + +#endif \ No newline at end of file diff --git a/utils/Utils.cc b/utils/Utils.cc index 42c0b73..445b5ad 100644 --- a/utils/Utils.cc +++ b/utils/Utils.cc @@ -1,9 +1,9 @@ // // Created by audemard on 16/04/24. // +#include "Utils.h" #include -#include std::vector &split1(const std::string &s, char delim, std::vector &elems) { std::stringstream ss(s); diff --git a/utils/Utils.h b/utils/Utils.h index 9db2fd1..b1942cf 100644 --- a/utils/Utils.h +++ b/utils/Utils.h @@ -1,11 +1,13 @@ // // Created by audemard on 10/11/2015. // -#include +#pragma once #ifndef COSOCO_UTILS_H #define COSOCO_UTILS_H +#include +#include template const T &max(const T &a, const T &b) { @@ -25,6 +27,11 @@ inline double drand(double &seed) { // Returns a random integer 0 <= x < size. Seed must never be 0. inline int irand(double &seed, int size) { return (int)(drand(seed) * size); } +std::vector &split1(const std::string &s, char delim, std::vector &elems); +std::vector split1(const std::string &s, char delim); + +#ifdef USE_XCSP3 +#include "XCSP3TreeNode.h" inline bool nodeContainsVar(XCSP3Core::Node *n, std::string name) { if(n->type == XCSP3Core::OVAR) { auto *nv = dynamic_cast(n); @@ -38,8 +45,8 @@ inline bool nodeContainsVar(XCSP3Core::Node *n, std::string name) { return true; return false; } -std::vector &split1(const std::string &s, char delim, std::vector &elems); -std::vector split1(const std::string &s, char delim); + +#endif /* USE_XCSP3 */ #endif // COSOCO_UTILS_H