contractor mk_contractor_gsl(box const & box, shared_ptr<ode_constraint> const ctr, contractor const & eval_ctc, ode_direction const dir, bool const use_cache, double const timeout) {
    if (!use_cache) {
        return contractor(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
    }
    if (dir == ode_direction::FWD) {
        static unordered_map<shared_ptr<ode_constraint>, contractor> gsl_fwd_ctc_cache;
        auto it = gsl_fwd_ctc_cache.find(ctr);
        if (it == gsl_fwd_ctc_cache.end()) {
            contractor ctc(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
            gsl_fwd_ctc_cache.emplace(ctr, ctc);
            return ctc;
        } else {
            return it->second;
        }
    } else {
        static unordered_map<shared_ptr<ode_constraint>, contractor> gsl_bwd_ctc_cache;
        auto it = gsl_bwd_ctc_cache.find(ctr);
        if (it == gsl_bwd_ctc_cache.end()) {
            contractor ctc(make_shared<contractor_gsl>(box, ctr, eval_ctc, dir, timeout));
            gsl_bwd_ctc_cache.emplace(ctr, ctc);
            return ctc;
        } else {
            return it->second;
        }
    }
}
contractor mk_contractor_eval(shared_ptr<nonlinear_constraint> const ctr, bool const use_cache) {
    if (!use_cache) {
        return contractor(make_shared<contractor_eval>(ctr));
    }
    static unordered_map<shared_ptr<nonlinear_constraint>, contractor> eval_ctc_cache;
    auto const it = eval_ctc_cache.find(ctr);
    if (it == eval_ctc_cache.end()) {
        contractor ctc(make_shared<contractor_eval>(ctr));
        eval_ctc_cache.emplace(ctr, ctc);
        return ctc;
    } else {
        return it->second;
    }
}
contractor mk_contractor_empty() {
    return contractor(make_shared<contractor_empty>());
}
Exemple #4
0
contractor mk_contractor_sample(unsigned const n, vector<constraint *> const & ctrs) {
    return contractor(make_shared<contractor_sample>(n, ctrs));
}
contractor mk_contractor_aggressive(unsigned const n, vector<shared_ptr<constraint>> const & ctrs) {
    return contractor(make_shared<contractor_aggressive>(n, ctrs));
}
contractor mk_contractor_cache(contractor const & ctc) {
    return contractor(make_shared<contractor_cache>(ctc));
}
contractor mk_contractor_int(box const & b) {
    return contractor(make_shared<contractor_int>(b));
}
contractor mk_contractor_fixpoint(function<bool(box const &, box const &)> guard, vector<contractor> const & cvec) {
    return contractor(make_shared<contractor_fixpoint>(guard, cvec));
}
contractor mk_contractor_join(contractor const & c1, contractor const & c2) {
    return contractor(make_shared<contractor_join>(c1, c2));
}
contractor mk_contractor_id() {
    return contractor(make_shared<contractor_id>());
}
contractor mk_contractor_parallel_all(contractor const & c1, contractor const & c2) {
    return contractor(make_shared<contractor_parallel_all>(c1, c2));
}
contractor mk_contractor_parallel_all(vector<contractor> const & v) {
    return contractor(make_shared<contractor_parallel_all>(v));
}
contractor mk_contractor_parallel_all(initializer_list<contractor> const & l) {
    return contractor(make_shared<contractor_parallel_all>(l));
}
Exemple #14
0
contractor mk_contractor_pseq(vector<contractor> const & v) {
    return contractor(make_shared<contractor_pseq>(v));
}
Exemple #15
0
contractor mk_contractor_pseq(initializer_list<contractor> const & l) {
    return contractor(make_shared<contractor_pseq>(l));
}
contractor mk_contractor_throw() {
    return contractor(make_shared<contractor_throw>());
}
contractor mk_contractor_throw_if_empty(contractor const & c) {
    return contractor(make_shared<contractor_throw_if_empty>(c));
}
contractor mk_contractor_debug(string const & s) {
    return contractor(make_shared<contractor_debug>(s));
}
contractor mk_contractor_ite(function<bool(box const &)> guard, contractor const & c_then, contractor const & c_else) {
    return contractor(make_shared<contractor_ite>(guard, c_then, c_else));
}
contractor mk_contractor_seq(initializer_list<contractor> const & l) {
    if (l.size() == 0) {
        return mk_contractor_id();
    }
    return contractor(make_shared<contractor_seq>(l));
}
contractor mk_contractor_fixpoint(function<bool(box const &, box const &)> guard, initializer_list<vector<contractor>> const & cvec_list) {
    return contractor(make_shared<contractor_fixpoint>(guard, cvec_list));
}
contractor mk_contractor_seq(vector<contractor> const & v) {
    if (v.size() == 0) {
        return mk_contractor_id();
    }
    return contractor(make_shared<contractor_seq>(v));
}
contractor mk_contractor_seq(contractor const & c1, contractor const & c2) {
    return contractor(make_shared<contractor_seq>(c1, c2));
}
contractor mk_contractor_try(contractor const & c) {
    return contractor(make_shared<contractor_try>(c));
}
contractor mk_contractor_sample(box const & b, unsigned const n, vector<shared_ptr<constraint>> const & ctrs) {
    return contractor(make_shared<contractor_sample>(b, n, ctrs));
}
contractor mk_contractor_try_or(contractor const & c1, contractor const & c2) {
    return contractor(make_shared<contractor_try_or>(c1, c2));
}
contractor mk_contractor_generic_forall(box const & b, shared_ptr<generic_forall_constraint> const ctr) {
    return contractor(make_shared<contractor_generic_forall>(b, ctr));
}
Exemple #28
0
contractor mk_contractor_int() {
    return contractor(make_shared<contractor_int>());
}