void assign(contains_app & x,expr * fml,const rational & v) {
SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned();
uint64 domain_size;
if (is_small_domain(x, eqs, domain_size)) {
SASSERT(v < rational(domain_size, rational::ui64()));
assign_small_domain(x, eqs, uv);
}
else {
assign_large_domain(x, eqs, uv);
}
}
bool is_target_core(expr * n, rational & u) {
if (!is_uninterp_const(n))
return false;
rational l; bool s;
if (m_bm.has_lower(n, l, s) &&
m_bm.has_upper(n, u, s) &&
l.is_zero() &&
!u.is_neg() &&
u.get_num_bits() <= m_max_bits) {
return true;
}
return false;
}
void subst(contains_app & x,const rational & v,expr_ref & fml, expr_ref* def) {
SASSERT(v.is_unsigned());
eq_atoms& eqs = get_eqs(x.x(), fml);
unsigned uv = v.get_unsigned();
uint64 domain_size;
if (is_small_domain(x, eqs, domain_size)) {
SASSERT(uv < domain_size);
subst_small_domain(x, eqs, uv, fml);
}
else {
subst_large_domain(x, eqs, uv, fml);
}
if (def) {
*def = 0; // TBD
}
}
bool is_target(expr * var, rational & val) {
bool strict;
return
is_uninterp_const(var) &&
(!m_normalize_int_only || m_util.is_int(var)) &&
m_bm.has_lower(var, val, strict) &&
!val.is_zero();
}
// **** 1.Add a square root function to the rational class. ****
rational squareRoot(const rational &r)
{
assert(r.numerator()>0);
double top = r.numerator();
double bot = r.denominator();
double topSqrt = sqrt(top);
double botSqrt = sqrt(bot);
// Estimate if not a perfect square
if ((fmod(topSqrt,1)!=0) ||(fmod(botSqrt,1)!=0))
{
topSqrt = sqrt(100*top);
botSqrt = sqrt(100*bot);
}
return rational((int)topSqrt, (int)botSqrt);
}
bool static_features::is_diff_term(expr const * e, rational & r) const {
// lhs can be 'x' or '(+ k x)'
if (!is_arith_expr(e)) {
r.reset();
return true;
}
if (is_numeral(e, r))
return true;
return m_autil.is_add(e) && to_app(e)->get_num_args() == 2 && is_numeral(to_app(e)->get_arg(0), r) && !is_arith_expr(to_app(e)->get_arg(1));
}
void print(rational a){
if(a.get_chisl()==0)std::cout<<"\n 0 ";else{
if(a.get_chisl()==a.get_znam())std::cout<<"\n 1";else{
if(a.get_znam()==1)std::cout<<"\n "<<a.get_chisl();else{
std::cout<<"\n "<<a.get_chisl()<<"/"<<a.get_znam();
}
}
}
}
unsigned context::scoped_state::add(expr* f, rational const& w, symbol const& id) {
if (w.is_neg()) {
throw default_exception("Negative weight supplied. Weight should be positive");
}
if (w.is_zero()) {
throw default_exception("Zero weight supplied. Weight should be positive");
}
if (!m.is_bool(f)) {
throw default_exception("Soft constraint should be Boolean");
}
if (!m_indices.contains(id)) {
m_objectives.push_back(objective(m, id));
m_indices.insert(id, m_objectives.size() - 1);
}
SASSERT(m_indices.contains(id));
unsigned idx = m_indices[id];
m_objectives[idx].m_terms.push_back(f);
m_objectives[idx].m_weights.push_back(w);
m_objectives_term_trail.push_back(idx);
return idx;
}
rational operator - (const rational &left, const rational &right)
{
rational result(
left.numerator() * right.denominator() -
right.numerator() * left.denominator(),
left.denominator() * right.denominator());
return result;
}
int main()
{
int shift = 20;
hashset hset;
hashset::iterator iter;
i64 mup = (1LL<<(2*shift))-1;
i64 mdown = (1LL<<shift)-1;
mup -= mdown;
vector<rational> vr;
for(int di = 2; di <= 35; ++di)
for(int ni = 1; ni < di; ++ni){
int common = gcd(ni, di);
if(common> 1) continue;
vr.push_back(rational(ni, di));
}
sort(vr.begin(), vr.end());
for(unsigned int i = 0; i < vr.size(); ++i){
for(unsigned int j = i; j < vr.size(); ++j){
rational& r1 = vr[i];
rational& r2 = vr[j];
const rational xr = r1 + r2;
//x+y=z
if(xr.pnum() >= xr.pden()) break;
if(xr.pden() <= 35){
rational xr2 = xr + xr;
i64 value = (xr2.pden()<<shift)+(xr2.pnum());
assert(((value & mup)>>shift) == xr2.pden());
assert((value & mdown) == xr2.pnum());
iter = hset.find(value);
if(iter == hset.end()){
hset.insert(value);
//printf("a %lld %lld %lld %lld %lld %lld %lld %lld\n", r1.pnum(), r1.pden(),
// r2.pnum(), r2.pden(), xr.pnum(), xr.pden(), xr2.pnum(), xr2.pden());
}
}
}
}
sym pow(const sym &s,const rational &q) {
if(typeid(*s.expr)==typeid(sym::sym_num))
return sym(pow(((sym::sym_num *)s.expr)->value,q.eval()));
sym snew;
snew.context=s.check_context();
delete snew.expr;
snew.expr=s.expr->clone();
snew.expr=snew.expr->pow(q)->reduce();
return snew;
}
BOOST_CONSTEXPR explicit
rational(rational<NewType> const &r)
: num(r.numerator()), den(is_normalized(int_type(r.numerator()),
int_type(r.denominator())) ? r.denominator() :
(BOOST_THROW_EXCEPTION(bad_rational("bad rational: denormalized conversion")), 0)){}
bool operator==(const rational<T2> &f) const
{
return ((this->_numerator == f.numerator()) &&
(this->_denominator == f.denominator()));
}
sym::sym(const rational &q) {
context=NULL;
expr=new sym::sym_num(q.eval());
}
rational rational::operator /(const rational& second) const {
return rational(getNum() * second.getDenom(), getDenom() * second.getNum());
}
bool rational::operator>(const rational &q) const {
return eval()>q.eval();
}
bool operator == (const rational &left, const rational &right)
{
return (left.numerator() * right.denominator() ==
left.denominator() * right.numerator());
}
// Assignments
void rational::operator = (const rational &right)
{
top = right.numerator();
bottom = right.denominator();
}
inline SPROUT_CONSTEXPR sprout::rational<IntType>
operator-(rational<IntType> const& r) {
return sprout::detail::rational_construct_access<IntType>::raw_construct(
-r.numerator(), r.denominator()
);
}
out << "(" << a.x << ", " << a.y << ")";
return out;
}
std::ostream& tangents::print_tangent_domain(const point &a, const point &b, std::ostream& out) const {
out << "("; print_point(a, out); out << ", "; print_point(b, out); out << ")";
return out;
}
void tangents::generate_simple_tangent_lemma(const rooted_mon* rm) {
if (rm->size() != 2)
return;
TRACE("nla_solver", tout << "rm:"; m_core->print_rooted_monomial_with_vars(*rm, tout) << std::endl;);
m_core->add_empty_lemma();
unsigned i_mon = rm->orig_index();
const monomial & m = c().m_monomials[i_mon];
const rational v = c().product_value(m);
const rational& mv = vvr(m);
SASSERT(mv != v);
SASSERT(!mv.is_zero() && !v.is_zero());
rational sign = rational(nla::rat_sign(mv));
if (sign != nla::rat_sign(v)) {
c().generate_simple_sign_lemma(-sign, m);
return;
}
bool gt = abs(mv) > abs(v);
if (gt) {
for (lpvar j : m) {
const rational & jv = vvr(j);
rational js = rational(nla::rat_sign(jv));
c().mk_ineq(js, j, llc::LT);
c().mk_ineq(js, j, llc::GT, jv);
void reset() {
m_coeff.reset();
g_num_recycled_cells++;
}
// Other functions - not members or friends
rational invert(const rational &r)
{
assert( r.numerator() != 0 );
return rational(r.denominator(), r.numerator());
}
inline rational<IntType> operator- (const rational<IntType>& r)
{
return rational<IntType>(-r.numerator(), r.denominator());
}
rational abs(const rational &q) {
return rational(abs(q.num()),q.den());
}
int main() {
constexpr rational<int> test(4, 2);
constexpr rational<int> normal = normalised(test);
static_assert(normal.numerator() == 2 && normal.denominator() == 1, "...");
}
constexpr rational<Integer> normalised(const rational<Integer>& r) noexcept {
return r.numerator() == 0 ? rational<Integer>{ 0, 1 } :
rational<Integer>{ r.numerator() / gcd(r.numerator(), r.denominator()),
r.denominator() / gcd(r.numerator(), r.denominator()) };
}
bool rational::operator<(const rational &q) const {
return eval()<q.eval();
}
rational rational::operator -(const rational& second) const {
int n1 = getNum(), d1 = getDenom(), n2 = second.getNum(), d2 = second.getDenom();
int denom = d1 * d2 / gcd(d1, d2);
int num = n1 * denom / d1 - n2 * denom / d2;
return rational(num, denom);
}
rational::rational(const rational & value)
{
// use one rational to initialize another
top = value.numerator();
bottom = value.bottom;
}
bool operator<(rational const& a, rational const& b) {
return a.numerator() * b.denominator() < b.numerator() * a.denominator();
}
