Z3_bool Z3_API Z3_get_numeral_rational_int64(Z3_context c, Z3_ast v, int64_t* num, int64_t* den) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_rational_int64(c, v, num, den); RESET_ERROR_CODE(); CHECK_IS_EXPR(v, Z3_FALSE); if (!num || !den) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return Z3_FALSE; } rational r; Z3_bool ok = Z3_get_numeral_rational(c, v, r); if (ok != Z3_TRUE) { return ok; } rational n = numerator(r); rational d = denominator(r); if (n.is_int64() && d.is_int64()) { *num = n.get_int64(); *den = d.get_int64(); return ok; } return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }
Z3_string Z3_API Z3_get_numeral_decimal_string(Z3_context c, Z3_ast a, unsigned precision) { Z3_TRY; LOG_Z3_get_numeral_decimal_string(c, a, precision); RESET_ERROR_CODE(); CHECK_IS_EXPR(a, ""); expr* e = to_expr(a); rational r; arith_util & u = mk_c(c)->autil(); if (u.is_numeral(e, r) && !r.is_int()) { std::ostringstream buffer; r.display_decimal(buffer, precision); return mk_c(c)->mk_external_string(buffer.str()); } if (u.is_irrational_algebraic_numeral(e)) { algebraic_numbers::anum const & n = u.to_irrational_algebraic_numeral(e); algebraic_numbers::manager & am = u.am(); std::ostringstream buffer; am.display_decimal(buffer, n, precision); return mk_c(c)->mk_external_string(buffer.str()); } Z3_bool ok = Z3_get_numeral_rational(c, a, r); if (ok == Z3_TRUE) { return mk_c(c)->mk_external_string(r.to_string()); } else { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return ""; } Z3_CATCH_RETURN(""); }
Z3_bool Z3_API Z3_is_numeral_ast(Z3_context c, Z3_ast a) { Z3_TRY; LOG_Z3_is_numeral_ast(c, a); RESET_ERROR_CODE(); CHECK_IS_EXPR(a, Z3_FALSE); expr* e = to_expr(a); return mk_c(c)->autil().is_numeral(e) || mk_c(c)->bvutil().is_numeral(e) || mk_c(c)->fpautil().is_numeral(e) || mk_c(c)->fpautil().is_rm_numeral(e) || mk_c(c)->datalog_util().is_numeral_ext(e); Z3_CATCH_RETURN(Z3_FALSE); }
Z3_bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, Z3_bool model_completion, Z3_ast * v) { Z3_TRY; LOG_Z3_model_eval(c, m, t, model_completion, v); if (v) *v = nullptr; RESET_ERROR_CODE(); CHECK_NON_NULL(m, Z3_FALSE); CHECK_IS_EXPR(t, Z3_FALSE); model * _m = to_model_ref(m); expr_ref result(mk_c(c)->m()); _m->eval(to_expr(t), result, model_completion == Z3_TRUE); mk_c(c)->save_ast_trail(result.get()); *v = of_ast(result.get()); RETURN_Z3_model_eval Z3_TRUE; Z3_CATCH_RETURN(0); }
Z3_string Z3_API Z3_get_numeral_string(Z3_context c, Z3_ast a) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_string(c, a); RESET_ERROR_CODE(); CHECK_IS_EXPR(a, ""); rational r; Z3_bool ok = Z3_get_numeral_rational(c, a, r); if (ok == Z3_TRUE) { return mk_c(c)->mk_external_string(r.to_string()); } else { // floats are separated from all others to avoid huge rationals. fpa_util & fu = mk_c(c)->fpautil(); scoped_mpf tmp(fu.fm()); mpf_rounding_mode rm; if (mk_c(c)->fpautil().is_rm_numeral(to_expr(a), rm)) { switch (rm) { case OP_FPA_RM_NEAREST_TIES_TO_EVEN: return mk_c(c)->mk_external_string("roundNearestTiesToEven"); break; case OP_FPA_RM_NEAREST_TIES_TO_AWAY: return mk_c(c)->mk_external_string("roundNearestTiesToAway"); break; case OP_FPA_RM_TOWARD_POSITIVE: return mk_c(c)->mk_external_string("roundTowardPositive"); break; case OP_FPA_RM_TOWARD_NEGATIVE: return mk_c(c)->mk_external_string("roundTowardNegative"); break; case OP_FPA_RM_TOWARD_ZERO: default: return mk_c(c)->mk_external_string("roundTowardZero"); break; } } else if (mk_c(c)->fpautil().is_numeral(to_expr(a), tmp)) { return mk_c(c)->mk_external_string(fu.fm().to_string(tmp)); } else { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return ""; } } Z3_CATCH_RETURN(""); }
Z3_bool Z3_API Z3_get_numeral_uint(Z3_context c, Z3_ast v, unsigned* u) { Z3_TRY; // This function invokes Z3_get_numeral_uint64, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_uint(c, v, u); RESET_ERROR_CODE(); CHECK_IS_EXPR(v, Z3_FALSE); if (!u) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return Z3_FALSE; } uint64_t l; if (Z3_get_numeral_uint64(c, v, &l) && (l <= 0xFFFFFFFF)) { *u = static_cast<unsigned>(l); return Z3_TRUE; } return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }
Z3_bool Z3_API Z3_get_numeral_int(Z3_context c, Z3_ast v, int* i) { Z3_TRY; // This function invokes Z3_get_numeral_int64, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_int(c, v, i); RESET_ERROR_CODE(); CHECK_IS_EXPR(v, Z3_FALSE); if (!i) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return Z3_FALSE; } int64_t l; if (Z3_get_numeral_int64(c, v, &l) && l >= INT_MIN && l <= INT_MAX) { *i = static_cast<int>(l); return Z3_TRUE; } return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }
bool Z3_API Z3_model_eval(Z3_context c, Z3_model m, Z3_ast t, bool model_completion, Z3_ast * v) { Z3_TRY; LOG_Z3_model_eval(c, m, t, model_completion, v); if (v) *v = nullptr; RESET_ERROR_CODE(); CHECK_NON_NULL(m, false); CHECK_IS_EXPR(t, false); model * _m = to_model_ref(m); params_ref p; ast_manager& mgr = mk_c(c)->m(); _m->set_solver(alloc(api::seq_expr_solver, mgr, p)); expr_ref result(mgr); model::scoped_model_completion _scm(*_m, model_completion); result = (*_m)(to_expr(t)); mk_c(c)->save_ast_trail(result.get()); *v = of_ast(result.get()); RETURN_Z3_model_eval true; Z3_CATCH_RETURN(0); }
Z3_bool Z3_API Z3_get_numeral_int64(Z3_context c, Z3_ast v, int64_t* i) { Z3_TRY; // This function invokes Z3_get_numeral_rational, but it is still ok to add LOG command here because it does not return a Z3 object. LOG_Z3_get_numeral_int64(c, v, i); RESET_ERROR_CODE(); CHECK_IS_EXPR(v, Z3_FALSE); if (!i) { SET_ERROR_CODE(Z3_INVALID_ARG, nullptr); return Z3_FALSE; } rational r; Z3_bool ok = Z3_get_numeral_rational(c, v, r); if (ok == Z3_TRUE && r.is_int64()) { *i = r.get_int64(); return ok; } return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }
Z3_bool Z3_API Z3_get_numeral_rational(Z3_context c, Z3_ast a, rational& r) { Z3_TRY; // This function is not part of the public API RESET_ERROR_CODE(); CHECK_IS_EXPR(a, Z3_FALSE); expr* e = to_expr(a); if (mk_c(c)->autil().is_numeral(e, r)) { return Z3_TRUE; } unsigned bv_size; if (mk_c(c)->bvutil().is_numeral(e, r, bv_size)) { return Z3_TRUE; } uint64_t v; if (mk_c(c)->datalog_util().is_numeral(e, v)) { r = rational(v, rational::ui64()); return Z3_TRUE; } return Z3_FALSE; Z3_CATCH_RETURN(Z3_FALSE); }