C++ (Cpp) SATSolver::get_model 예제들

예제 #1

파일: multisol_test.cpp 프로젝트: MartinNowack/cryptominisat

int main()
{
    SATSolver solver;
    vector<Lit> clause;

    //We need 3 variables
    solver.new_var();
    solver.new_var();
    solver.new_var();

    //adds "1 0"
    clause.push_back(Lit(0, false));
    solver.add_clause(clause);

    //adds "-1 2 3 0"
    clause.clear();
    clause.push_back(Lit(0, true));
    clause.push_back(Lit(1, false));
    clause.push_back(Lit(2, false));
    solver.add_clause(clause);

    lbool ret = l_True;
    while(ret == l_True) {
        ret = solver.solve();
        if (ret == l_True) {
            std::cout
            << "Solution is: "
            << solver.get_model()[0]
            << ", " << solver.get_model()[1]
            << ", " << solver.get_model()[2]
            << std::endl;

            clause.clear();
            for(size_t i = 0; i < 3; i++) {
                if (solver.get_model()[i] != l_Undef) {
                    clause.push_back(Lit(i, solver.get_model()[i] == l_True));
                }
            }
            solver.add_clause(clause);
        } else if (ret == l_False) {
            std::cout << "No more solutions." << std::endl;
        } else {
            std::cout << "Solver returned that it didn't finish running."
            "maybe you put a limit on its runtime?" << std::endl;
        }
    }

    return 0;
}

예제 #2

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_check_solution_values7)
{
    SATSolver s;
    s.new_var();
    s.new_var();
    s.new_var();
    s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
    vector<Lit> assump = {Lit(0, false), Lit(1, false)};
    lbool ret = s.solve(&assump);
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ(s.get_model()[0], l_True);
    EXPECT_EQ(s.get_model()[1], l_True);
    EXPECT_EQ(s.get_model()[2], l_False);
    EXPECT_EQ( s.nVars(), 3u);
}

예제 #3

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_3_long2)
{
    SATSolver s;
    s.new_var();
    s.new_var();
    s.new_var();
    s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, false);
    s.add_xor_clause(vector<uint32_t>{0U}, true);
    s.add_xor_clause(vector<uint32_t>{1U}, true);
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ(s.get_model()[0], l_True);
    EXPECT_EQ(s.get_model()[1], l_True);
    EXPECT_EQ(s.get_model()[2], l_False);
    EXPECT_EQ( s.nVars(), 3u);
}

예제 #4

파일: stp_test.cpp 프로젝트: msoos/cryptominisat

TEST(stp_test, set_num_threads_true)
{
    SATSolver s;
    s.set_num_threads(5);
    s.new_vars(2);
    s.add_clause(str_to_cl("1,2"));
    s.add_clause(str_to_cl("1,-2"));

    lbool ret = s.solve();
    EXPECT_EQ(ret, l_True);
    EXPECT_EQ(s.get_model()[0], l_True);
}

예제 #5

파일: readme_test.cpp 프로젝트: Darriall/cryptominisat

int main()
{
    SATSolver solver;
    vector<Lit> clause;

    //We need 3 variables
    solver.new_var();
    solver.new_var();
    solver.new_var();

    //adds "1 0"
    clause.push_back(Lit(0, false));
    solver.add_clause(clause);

    //adds "-2 0"
    clause.clear();
    clause.push_back(Lit(1, true));
    solver.add_clause(clause);

    //adds "-1 2 3 0"
    clause.clear();
    clause.push_back(Lit(0, true));
    clause.push_back(Lit(1, false));
    clause.push_back(Lit(2, false));
    solver.add_clause(clause);

    lbool ret = solver.solve();
    assert(ret == l_True);
    assert(solver.get_model()[0] == l_True);
    assert(solver.get_model()[1] == l_False);
    assert(solver.get_model()[2] == l_True);
    std::cout
    << "Solution is: "
    << solver.get_model()[0]
    << ", " << solver.get_model()[1]
    << ", " << solver.get_model()[2]
    << std::endl;

    return 0;
}

예제 #6

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_very_long2)
{
    for(size_t num = 3; num < 30; num++) {
        SATSolver s;
        vector<uint32_t> vars;
        for(unsigned i = 0; i < num; i++) {
            s.new_var();
            vars.push_back(i);
        }
        s.add_xor_clause(vars, true);
        for(unsigned i = 0; i < num-1; i++) {
            s.add_xor_clause(vector<uint32_t>{i}, false);
        }
        lbool ret = s.solve();
        EXPECT_EQ( ret, l_True);
        for(unsigned i = 0; i < num-1; i++) {
            EXPECT_EQ(s.get_model()[i], l_False);
        }
        EXPECT_EQ(s.get_model()[num-1], l_True);
        EXPECT_EQ( s.nVars(), num);
    }
}

예제 #7

파일: stp_test.cpp 프로젝트: msoos/cryptominisat

TEST(stp_test, default_polar_false)
{
    SATSolver s;
    s.set_no_simplify_at_startup();
    s.set_default_polarity(false);
    s.new_vars(4);
    s.add_clause(str_to_cl("-1, -2, -3, -4"));
    lbool ret = s.solve();
    EXPECT_EQ(ret, l_True);
    for(size_t i = 0; i < 4; i++) {
        EXPECT_EQ(s.get_model()[0], l_False);
    }
}

예제 #8

파일: incremental-cryptominisat.cpp 프로젝트: slavam2605/EFSM-tools

int main(int argc, const char* argv[]) {
    if (argc < 2) {
        std::cout << "Run: incremental-cryptominisat <varNumber> <timeLimit in seconds>" << std::endl;
        return 1;
    }
    
    int var_number = atoi(argv[1]);
    int time_limit = atoi(argv[2]);
    SolverConf conf;
    conf.maxTime = time_limit;
    SATSolver solver (conf, NULL);
    solver.new_vars(var_number);

    while (true) {
        std::string line;
        std::getline(std::cin, line);
        if (line == "solve") {
            lbool res = solver.solve();
            if (res == l_True) {
                std::cout << "SAT" << std::endl;
                std::vector<lbool> model = solver.get_model();
                std::cout << "v ";
                for (int i = 0; i < model.size(); i++) {
                    std::cout << (model[i] == l_True ? "" : "-") << (i + 1) << " ";
                }
                std::cout << std::endl;
            } else if (res == l_False) {
                std::cout << "UNSAT" << std::endl;
            } else {
                std::cout << "UNKNOWN" << std::endl;
            }
        } else if (line == "halt") {
            break;
        } else {
            std::vector<Lit> lits;
            std::istringstream iss(line);
            do {
                std::string sub;
                iss >> sub;
                int literal = atoi(sub.c_str());
                if (literal == 0) {
                    break;
                }
                lits.push_back(Lit(abs(literal) - 1, literal < 0));
            } while (iss);
            solver.add_clause(lits);
        }
    }
    
    return 0;
}

예제 #9

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(normal_interface, solve_multi_thread)
{
    SATSolver s;
    s.set_num_threads(2);
    s.new_vars(2);
    s.add_clause(vector<Lit>{Lit(0, false), Lit(1, false)});
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);

    s.add_clause(vector<Lit>{Lit(0, true)});
    ret = s.solve();
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ(s.get_model()[0], l_False);
    EXPECT_EQ(s.get_model()[1], l_True);
}

예제 #10

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_check_unsat_multi_solve_multi_thread)
{
    SATSolver s;
    s.set_num_threads(3);
    s.new_vars(3);
    s.add_xor_clause(vector<uint32_t>{0U, 1U}, false);
    s.add_xor_clause(vector<uint32_t>{0U, 1U, 2U}, true);
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ( s.nVars(), 3u);

    s.add_xor_clause(vector<uint32_t>{0U}, false);
    ret = s.solve();
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ( s.get_model()[0], l_False);
    EXPECT_EQ( s.get_model()[1], l_False);
    EXPECT_EQ( s.get_model()[2], l_True);
    EXPECT_EQ( s.nVars(), 3u);

    s.add_xor_clause(vector<uint32_t>{1U}, true);
    ret = s.solve();
    EXPECT_EQ( ret, l_False);
    EXPECT_EQ( s.nVars(), 3u);
}

예제 #11

파일: basic_test.cpp 프로젝트: msoos/cryptominisat

TEST(normal_interface, solve_multi_thread)
{
    SATSolver s;
    s.set_num_threads(2);
    s.new_vars(2);
    s.add_clause(str_to_cl("1, 2"));
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);

    s.add_clause(str_to_cl("-1"));
    ret = s.solve();
    EXPECT_EQ( ret, l_True);
    EXPECT_EQ(s.get_model()[0], l_False);
    EXPECT_EQ(s.get_model()[1], l_True);
}

예제 #12

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_check_solution_values2)
{
    SATSolver s;
    s.new_var();
    s.new_var();
    s.add_xor_clause(vector<uint32_t>{0U}, true);
    s.add_xor_clause(vector<uint32_t>{1U}, true);
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);
    for(size_t i = 0;i < 10; i++) {
        ret = s.solve();
        EXPECT_EQ( ret, l_True);
        EXPECT_EQ(s.get_model()[0], l_True);
        EXPECT_EQ(s.get_model()[1], l_True);
    }
    EXPECT_EQ( s.nVars(), 2u);
}

예제 #13

파일: basic_test.cpp 프로젝트: kuldeepmeel/cryptominisat

TEST(xor_interface, xor_very_long)
{
    SATSolver s;
    vector<uint32_t> vars;
    for(unsigned i = 0; i < 30; i++) {
        s.new_var();
        vars.push_back(i);
    }
    s.add_xor_clause(vars, false);
    for(unsigned i = 0; i < 29; i++) {
        s.add_xor_clause(vector<uint32_t>{i}, false);
    }
    lbool ret = s.solve();
    EXPECT_EQ( ret, l_True);
    for(unsigned i = 0; i < 30; i++) {
        EXPECT_EQ(s.get_model()[i], l_False);
    }
    EXPECT_EQ( s.nVars(), 30u);
}