Functions and operators

template<class I>
using stp::api::if_integral = std::enable_if_t<std::is_integral_v<I> && !std::is_same_v<I, bool>, int>
template<class F>
using stp::api::if_floating = std::enable_if_t<std::is_floating_point_v<F>, int>
using stp::api::OptionValue = std::variant<bool, std::int64_t, std::uint64_t, std::string, std::vector<std::string>>
using stp::api::BeforeSearch = std::function<bool(SearchPoint&)>

Called at the before-search point; true lets the check search.

using stp::api::StatisticValue = std::variant<std::uint64_t, double, std::string>
const char *stp::api::to_string(Kind)
const char *stp::api::smtlib_name(Kind)

“bvadd”, “fp.add”, “select”, …

const char *stp::api::to_string(SortKind)
const char *stp::api::to_string(RoundingMode)

“RNE” …

const char *stp::api::to_string(UnknownReason)
const char *stp::api::to_string(ErrorCode)
const char *stp::api::to_string(Verdict)
const char *stp::api::to_string(Validity)
const char *stp::api::to_string(Tier)
const char *stp::api::to_string(Settable)
std::ostream &stp::api::operator<<(std::ostream&, Kind)
std::ostream &stp::api::operator<<(std::ostream&, RoundingMode)
std::ostream &stp::api::operator<<(std::ostream&, UnknownReason)
std::ostream &stp::api::operator<<(std::ostream&, Verdict)
std::ostream &stp::api::operator<<(std::ostream&, Validity)
Term stp::api::ite(const Term &a, const Term &b, const Term &c)
Term stp::api::eq(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::eq(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::eq(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::eq(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::eq(F a, const Term &b)
Term stp::api::distinct(const std::vector<Term> &args)
Term stp::api::distinct(std::initializer_list<Term> args)
Term stp::api::distinct(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::distinct(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::distinct(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::distinct(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::distinct(F a, const Term &b)
Term stp::api::apply(const std::vector<Term> &args)
Term stp::api::apply(std::initializer_list<Term> args)
Term stp::api::apply(const Term &a, const Term &b)
Term stp::api::not_(const Term &a)
Term stp::api::and_(const std::vector<Term> &args)
Term stp::api::and_(std::initializer_list<Term> args)
Term stp::api::and_(const Term &a, const Term &b)
Term stp::api::and_(const Term &a)
Term stp::api::or_(const std::vector<Term> &args)
Term stp::api::or_(std::initializer_list<Term> args)
Term stp::api::or_(const Term &a, const Term &b)
Term stp::api::or_(const Term &a)
Term stp::api::xor_(const std::vector<Term> &args)
Term stp::api::xor_(std::initializer_list<Term> args)
Term stp::api::xor_(const Term &a, const Term &b)
Term stp::api::implies(const Term &a, const Term &b)
Term stp::api::bvnot(const Term &a)
Term stp::api::bvand(const std::vector<Term> &args)
Term stp::api::bvand(std::initializer_list<Term> args)
Term stp::api::bvand(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvand(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvand(I a, const Term &b)
Term stp::api::bvor(const std::vector<Term> &args)
Term stp::api::bvor(std::initializer_list<Term> args)
Term stp::api::bvor(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvor(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvor(I a, const Term &b)
Term stp::api::bvxor(const std::vector<Term> &args)
Term stp::api::bvxor(std::initializer_list<Term> args)
Term stp::api::bvxor(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvxor(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvxor(I a, const Term &b)
Term stp::api::bvnand(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvnand(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvnand(I a, const Term &b)
Term stp::api::bvnor(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvnor(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvnor(I a, const Term &b)
Term stp::api::bvxnor(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvxnor(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvxnor(I a, const Term &b)
Term stp::api::bvneg(const Term &a)
Term stp::api::bvadd(const std::vector<Term> &args)
Term stp::api::bvadd(std::initializer_list<Term> args)
Term stp::api::bvadd(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvadd(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvadd(I a, const Term &b)
Term stp::api::bvsub(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsub(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsub(I a, const Term &b)
Term stp::api::bvmul(const std::vector<Term> &args)
Term stp::api::bvmul(std::initializer_list<Term> args)
Term stp::api::bvmul(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvmul(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvmul(I a, const Term &b)
Term stp::api::bvudiv(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvudiv(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvudiv(I a, const Term &b)
Term stp::api::bvurem(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvurem(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvurem(I a, const Term &b)
Term stp::api::bvsdiv(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsdiv(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsdiv(I a, const Term &b)
Term stp::api::bvsrem(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsrem(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsrem(I a, const Term &b)
Term stp::api::bvsmod(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsmod(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsmod(I a, const Term &b)
Term stp::api::bvshl(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvshl(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvshl(I a, const Term &b)
Term stp::api::bvlshr(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvlshr(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvlshr(I a, const Term &b)
Term stp::api::bvashr(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvashr(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvashr(I a, const Term &b)
Term stp::api::concat(const std::vector<Term> &args)
Term stp::api::concat(std::initializer_list<Term> args)
Term stp::api::concat(const Term &a, const Term &b)
Term stp::api::bvcomp(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvcomp(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvcomp(I a, const Term &b)
Term stp::api::bvult(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvult(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvult(I a, const Term &b)
Term stp::api::bvule(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvule(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvule(I a, const Term &b)
Term stp::api::bvugt(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvugt(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvugt(I a, const Term &b)
Term stp::api::bvuge(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvuge(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvuge(I a, const Term &b)
Term stp::api::bvslt(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvslt(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvslt(I a, const Term &b)
Term stp::api::bvsle(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsle(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsle(I a, const Term &b)
Term stp::api::bvsgt(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsgt(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsgt(I a, const Term &b)
Term stp::api::bvsge(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsge(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsge(I a, const Term &b)
Term stp::api::bvuaddo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvuaddo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvuaddo(I a, const Term &b)
Term stp::api::bvsaddo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsaddo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsaddo(I a, const Term &b)
Term stp::api::bvumulo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvumulo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvumulo(I a, const Term &b)
Term stp::api::bvsmulo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsmulo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsmulo(I a, const Term &b)
Term stp::api::bvusubo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvusubo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvusubo(I a, const Term &b)
Term stp::api::bvssubo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvssubo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvssubo(I a, const Term &b)
Term stp::api::bvnego(const Term &a)
Term stp::api::bvsdivo(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsdivo(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::bvsdivo(I a, const Term &b)
Term stp::api::bvredand(const Term &a)
Term stp::api::bvredor(const Term &a)
Term stp::api::select(const Term &a, const Term &b)
Term stp::api::store(const Term &a, const Term &b, const Term &c)
Term stp::api::fp_abs(const Term &a)
Term stp::api::fp_neg(const Term &a)
Term stp::api::fp_add(const Term &rm, const Term &a, const Term &b)
Term stp::api::fp_add(RoundingMode rm, const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_add(const Term &rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_add(const Term &rm, F a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_add(RoundingMode rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_add(RoundingMode rm, F a, const Term &b)
Term stp::api::fp_sub(const Term &rm, const Term &a, const Term &b)
Term stp::api::fp_sub(RoundingMode rm, const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_sub(const Term &rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_sub(const Term &rm, F a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_sub(RoundingMode rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_sub(RoundingMode rm, F a, const Term &b)
Term stp::api::fp_mul(const Term &rm, const Term &a, const Term &b)
Term stp::api::fp_mul(RoundingMode rm, const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_mul(const Term &rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_mul(const Term &rm, F a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_mul(RoundingMode rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_mul(RoundingMode rm, F a, const Term &b)
Term stp::api::fp_div(const Term &rm, const Term &a, const Term &b)
Term stp::api::fp_div(RoundingMode rm, const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_div(const Term &rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_div(const Term &rm, F a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_div(RoundingMode rm, const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_div(RoundingMode rm, F a, const Term &b)
Term stp::api::fp_fma(const Term &rm, const Term &a, const Term &b, const Term &c)
Term stp::api::fp_fma(RoundingMode rm, const Term &a, const Term &b, const Term &c)
Term stp::api::fp_sqrt(const Term &rm, const Term &a)
Term stp::api::fp_sqrt(RoundingMode rm, const Term &a)
Term stp::api::fp_rem(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_rem(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_rem(F a, const Term &b)
Term stp::api::fp_rti(const Term &rm, const Term &a)
Term stp::api::fp_rti(RoundingMode rm, const Term &a)
Term stp::api::fp_min(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_min(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_min(F a, const Term &b)
Term stp::api::fp_max(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_max(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_max(F a, const Term &b)
Term stp::api::fp_eq(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_eq(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_eq(F a, const Term &b)
Term stp::api::fp_lt(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_lt(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_lt(F a, const Term &b)
Term stp::api::fp_leq(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_leq(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_leq(F a, const Term &b)
Term stp::api::fp_gt(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_gt(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_gt(F a, const Term &b)
Term stp::api::fp_geq(const Term &a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_geq(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::fp_geq(F a, const Term &b)
Term stp::api::fp_is_normal(const Term &a)
Term stp::api::fp_is_subnormal(const Term &a)
Term stp::api::fp_is_zero(const Term &a)
Term stp::api::fp_is_inf(const Term &a)
Term stp::api::fp_is_nan(const Term &a)
Term stp::api::fp_is_neg(const Term &a)
Term stp::api::fp_is_pos(const Term &a)
Term stp::api::fp_to_real(const Term &a)
Term stp::api::fp_to_ieee_bv(const Term &a)
Term stp::api::real_add(const std::vector<Term> &args)
Term stp::api::real_add(std::initializer_list<Term> args)
Term stp::api::real_add(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_add(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_add(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_add(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_add(F a, const Term &b)
Term stp::api::real_sub(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_sub(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_sub(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_sub(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_sub(F a, const Term &b)
Term stp::api::real_neg(const Term &a)
Term stp::api::real_mul(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_mul(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_mul(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_mul(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_mul(F a, const Term &b)
Term stp::api::real_div(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_div(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_div(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_div(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_div(F a, const Term &b)
Term stp::api::real_lt(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_lt(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_lt(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_lt(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_lt(F a, const Term &b)
Term stp::api::real_le(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_le(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_le(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_le(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_le(F a, const Term &b)
Term stp::api::real_gt(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_gt(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_gt(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_gt(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_gt(F a, const Term &b)
Term stp::api::real_ge(const Term &a, const Term &b)
template<class I, if_integral<I> = 0>
Term stp::api::real_ge(const Term &a, I b)
template<class I, if_integral<I> = 0>
Term stp::api::real_ge(I a, const Term &b)
template<class F, if_floating<F> = 0>
Term stp::api::real_ge(const Term &a, F b)
template<class F, if_floating<F> = 0>
Term stp::api::real_ge(F a, const Term &b)
Term stp::api::extract(std::uint32_t hi, std::uint32_t lo, const Term&)
Term stp::api::zero_extend(std::uint32_t k, const Term&)
Term stp::api::sign_extend(std::uint32_t k, const Term&)
Term stp::api::repeat(std::uint32_t k, const Term&)
Term stp::api::rotate_left(std::uint32_t k, const Term&)
Term stp::api::rotate_right(std::uint32_t k, const Term&)
Term stp::api::bit(const Term &bv, std::uint32_t i)

(= ((_ extract i i) bv) #b1)

Term stp::api::bool_to_bv1(const Term &b)

(ite b #b1 #b0)

Term stp::api::bv1_to_bool(const Term &bv1)

(= bv1 #b1)

Term stp::api::array_from_bytes(TermManager &tm, const std::vector<std::uint8_t> &bytes, std::uint32_t index_width = 32)

A store chain over (as const … 0) holding bytes at indices [0, n) of an Array BV[index_width] BV8.

Term stp::api::to_fp(const Sort &fp, const Term &rm, const Term &fp_or_real_or_sbv)

The SMT-LIB (_ to_fp e s) family, by argument sort (FP, Real or signed BV).

Term stp::api::to_fp(const Sort &fp, RoundingMode rm, const Term &fp_or_real_or_sbv)
Term stp::api::to_fp_unsigned(const Sort &fp, const Term &rm, const Term &bv)
Term stp::api::to_fp_unsigned(const Sort &fp, RoundingMode rm, const Term &bv)
Term stp::api::to_fp_from_bits(const Sort &fp, const Term &bv)

the reinterpretation

Term stp::api::fp_to_ubv(std::uint32_t m, const Term &rm, const Term&)
Term stp::api::fp_to_sbv(std::uint32_t m, const Term &rm, const Term&)
Term stp::api::fp_to_ubv(std::uint32_t m, RoundingMode rm, const Term&)
Term stp::api::fp_to_sbv(std::uint32_t m, RoundingMode rm, const Term&)
inline Term stp::api::operator+(const Term &a, const Term &b)
inline Term stp::api::operator-(const Term &a, const Term &b)
inline Term stp::api::operator*(const Term &a, const Term &b)
inline Term stp::api::operator/(const Term &a, const Term &b)
inline Term stp::api::operator-(const Term &a)
inline Term stp::api::operator~(const Term &a)
inline Term stp::api::operator&(const Term &a, const Term &b)
inline Term stp::api::operator|(const Term &a, const Term &b)
inline Term stp::api::operator^(const Term &a, const Term &b)
inline Term stp::api::operator<<(const Term &a, const Term &b)
inline Term stp::api::operator!(const Term &a)
inline Term stp::api::operator&&(const Term &a, const Term &b)
inline Term stp::api::operator||(const Term &a, const Term &b)
Version stp::api::version()
std::map<std::string, std::string> stp::api::capabilities()

What this build can do. Keys are stable strings.

bool stp::api::has_sat_backend(std::string_view name)
std::vector<std::string> stp::api::sat_backends()
void stp::api::set_internal_error_policy(InternalErrorPolicy) noexcept

Process-wide by nature: what an INTERNAL or RESOURCE error does. Default POISON; STP_ABORT_ON_INTERNAL_ERROR=1 in the environment selects ABORT.

InternalErrorPolicy stp::api::internal_error_policy() noexcept