Пример #1
0
 Z3_ast Z3_API Z3_algebraic_root(Z3_context c, Z3_ast a, unsigned k) {
     Z3_TRY;
     LOG_Z3_algebraic_root(c, a, k);
     RESET_ERROR_CODE();
     CHECK_IS_ALGEBRAIC_X(a, 0);
     if (k % 2 == 0) {
         if ((is_rational(c, a) && get_rational(c, a).is_neg()) ||
             (!is_rational(c, a) && am(c).is_neg(get_irrational(c, a)))) {
             SET_ERROR_CODE(Z3_INVALID_ARG);
             RETURN_Z3(0);
         }
     }
     algebraic_numbers::manager & _am = am(c);
     scoped_anum _r(_am);
     if (is_rational(c, a)) {
         scoped_anum av(_am);                                     
         _am.set(av, get_rational(c, a).to_mpq());   
         _am.root(av, k, _r);
     }
     else {
         algebraic_numbers::anum const & av = get_irrational(c, a);
         _am.root(av, k, _r);
     }
     expr * r = au(c).mk_numeral(_r, false);
     mk_c(c)->save_ast_trail(r);
     RETURN_Z3(of_ast(r));
     Z3_CATCH_RETURN(0);
 }
Пример #2
0
 Z3_ast Z3_API Z3_algebraic_div(Z3_context c, Z3_ast a, Z3_ast b) {
     Z3_TRY;
     LOG_Z3_algebraic_div(c, a, b);
     RESET_ERROR_CODE();
     CHECK_IS_ALGEBRAIC_X(a, 0);
     CHECK_IS_ALGEBRAIC_X(b, 0);
     if ((is_rational(c, b) && get_rational(c, b).is_zero()) ||
         (!is_rational(c, b) && am(c).is_zero(get_irrational(c, b)))) {
         SET_ERROR_CODE(Z3_INVALID_ARG);
         RETURN_Z3(0);
     }
     BIN_OP(/,div);
     Z3_CATCH_RETURN(0);
 }
Пример #3
0
renf_elem_class::operator mpq_class() const noexcept
{
    mpq_class z;

    if (nf == nullptr)
        fmpq_get_mpq(z.__get_mp(), b);
    else if (is_rational())
    {
        assert(is_rational() && "renf_elem_class not a rational");
        ::fmpq_t q;
        fmpq_init(q);
        nf_elem_get_fmpq(q, a->elem, parent().renf_t()->nf);
        fmpq_get_mpq(z.__get_mp(), q);
        fmpq_clear(q);
    }

    return z;
}
Пример #4
0
 static bool to_anum_vector(Z3_context c, unsigned n, Z3_ast a[], scoped_anum_vector & as) {
     algebraic_numbers::manager & _am = am(c);
     scoped_anum tmp(_am);
     for (unsigned i = 0; i < n; i++) {
         if (is_rational(c, a[i])) {
             _am.set(tmp, get_rational(c, a[i]).to_mpq());       
             as.push_back(tmp);
         }
         else if (is_irrational(c, a[i])) {
             as.push_back(get_irrational(c, a[i]));
         }
         else {
             return false;
         }
     }
     return true;
 }
Пример #5
0
 int Z3_API Z3_algebraic_sign(Z3_context c, Z3_ast a) {
     Z3_TRY;
     LOG_Z3_algebraic_sign(c, a);
     RESET_ERROR_CODE();
     CHECK_IS_ALGEBRAIC(a, 0);
     if (is_rational(c, a)) {
         rational v = get_rational(c, a);
         if (v.is_pos()) return 1;
         else if (v.is_neg()) return -1;
         else return 0;
     }
     else {
         algebraic_numbers::anum const & v = get_irrational(c, a);
         if (am(c).is_pos(v)) return 1;
         else if (am(c).is_neg(v)) return -1;
         else return 0;
     }
     Z3_CATCH_RETURN(0);
 }
Пример #6
0
// ---------------------------------------------------------------------------
// do_wait: Command interface to wait_que
//
void do_wait
(
    dbref executor,
    dbref caller,
    dbref enactor,
    int   eval,
    int key,
    char *event,
    char *cmd,
    char *cargs[],
    int ncargs
)
{
    CLinearTimeAbsolute ltaWhen;
    CLinearTimeDelta    ltd;

    // If arg1 is all numeric, do simple (non-sem) timed wait.
    //
    if (is_rational(event))
    {
        if (key & WAIT_UNTIL)
        {
            ltaWhen.SetSecondsString(event);
        }
        else
        {
            ltaWhen.GetUTC();
            ltd.SetSecondsString(event);
            ltaWhen += ltd;
        }
        wait_que(executor, caller, enactor, eval, true, ltaWhen, NOTHING, 0,
            cmd,
            ncargs, cargs,
            mudstate.global_regs);
        return;
    }

    // Semaphore wait with optional timeout.
    //
    char *what = parse_to(&event, '/', 0);
    init_match(executor, what, NOTYPE);
    match_everything(0);

    dbref thing = noisy_match_result();
    if (!Good_obj(thing))
    {
        return;
    }
    else if (!Controls(executor, thing) && !Link_ok(thing))
    {
        notify(executor, NOPERM_MESSAGE);
    }
    else
    {
        // Get timeout, default 0.
        //
        int atr = A_SEMAPHORE;
        bool bTimed = false;
        if (event && *event)
        {
            if (is_rational(event))
            {
                if (key & WAIT_UNTIL)
                {
                    ltaWhen.SetSecondsString(event);
                }
                else
                {
                    ltaWhen.GetUTC();
                    ltd.SetSecondsString(event);
                    ltaWhen += ltd;
                }
                bTimed = true;
            }
            else
            {
                ATTR *ap = atr_str(event);
                if (!ap)
                {
                    atr = mkattr(executor, event);
                    if (atr <= 0)
                    {
                        notify_quiet(executor, "Invalid attribute.");
                        return;
                    }
                    ap = atr_num(atr);
                }
                else
                {
                    atr = ap->number;
                }
                if (!bCanSetAttr(executor, thing, ap))
                {
                    notify_quiet(executor, NOPERM_MESSAGE);
                    return;
                }
            }
        }

        int num = add_to(thing, 1, atr);
        if (num <= 0)
        {
            // Thing over-notified, run the command immediately.
            //
            thing = NOTHING;
            bTimed = false;
        }
        wait_que(executor, caller, enactor, eval, bTimed, ltaWhen, thing, atr,
            cmd,
            ncargs, cargs,
            mudstate.global_regs);
    }
}
Пример #7
0
static rational get_rational(Z3_context c, Z3_ast a) {
    SASSERT(is_rational(c, a));
    rational r;
    VERIFY(au(c).is_numeral(to_expr(a), r));
    return r;
}