z3-z3-4.13.0.src.test.rational.cpp Maven / Gradle / Ivy
The newest version!
/*++
Copyright (c) 2006 Microsoft Corporation
Module Name:
tst_rational.cpp
Abstract:
Test rationals
Author:
Leonardo de Moura (leonardo) 2006-09-26.
Revision History:
--*/
#include
#include "util/vector.h"
#include "util/rational.h"
#include "util/trace.h"
#include "util/ext_gcd.h"
#include "util/timeit.h"
static void tst1() {
rational r1(1);
rational r2(1,2);
rational r3(2,4);
ENSURE(r2 == r3);
ENSURE(r1 != r2);
ENSURE(r2 + r3 == r1);
ENSURE(r1.is_pos());
ENSURE((r2 - r1).is_neg());
ENSURE((r2 - r3).is_zero());
ENSURE(floor(r2).is_zero());
ENSURE(ceil(r2).is_one());
// std::cout << "-r2: " << (-r2) << ", floor(-r2):" << floor(-r2) << "\n";
ENSURE(floor(-r2).is_minus_one());
ENSURE(ceil(-r2).is_zero());
ENSURE(floor(r1) == r1);
ENSURE(ceil(r1) == r1);
rational r4(3,5);
ENSURE(r3 * r4 == rational(3, 10));
ENSURE(r3 / r4 == rational(5, 6));
rational r5(2,3);
ENSURE(r4 * r5 == rational(2, 5));
--r2;
ENSURE(r2 == -r3);
r2.neg();
ENSURE(r2 == r3);
--r2;
r2 = abs(r2);
ENSURE(r2 == r3);
--r2;
++r2;
ENSURE(r2 == r3);
ENSURE(r2 == abs(r2));
ENSURE(r4 * rational(1) == r4);
ENSURE((r4 * rational(0)).is_zero());
ENSURE(r4 * rational(-1) == -r4);
ENSURE(rational(1) * r4 == r4);
ENSURE((rational(0) * r4).is_zero());
ENSURE(rational(-1) * r4 == -r4);
ENSURE(r4 + rational(0) == r4);
ENSURE(ceil(r4).is_one());
// std::cout << "r3: " << r3 << ", r4: " << r4 << ", -r4: " << -r4 << ", r3 / (-r4): " << (r3 / (-r4)) << "\n";
ENSURE(r3 / (-r4) == rational(5,-6));
ENSURE(div(rational(7), rational(2)) == rational(3));
ENSURE(rational(7) % rational(4) == rational(3));
ENSURE(div(rational(7), rational(-2)) == rational(-3));
ENSURE(rational(3) + rational(5) == rational(8));
ENSURE(rational("13/10") + rational("7/10") == rational(2));
ENSURE(rational("100/20") == rational(5));
ENSURE(gcd(rational(12), rational(8)) == rational(4));
ENSURE(ceil(rational(-3,2)) == rational(-1));
ENSURE(floor(rational(-3,2)) == rational(-2));
ENSURE(ceil(rational(3,2)) == rational(2));
ENSURE(floor(rational(3,2)) == rational(1));
ENSURE(rational(3).is_pos());
ENSURE(rational(0).is_nonneg());
ENSURE(rational(3).is_pos());
ENSURE(rational(3).is_nonneg());
ENSURE(rational(0).is_nonneg());
ENSURE(!rational(3).is_zero());
ENSURE(!rational(-3).is_zero());
ENSURE(rational(0).is_zero());
ENSURE(rational(1).is_one());
ENSURE(!rational(2).is_one());
ENSURE(rational(3,4) >= rational(2,8));
ENSURE(rational(3,4) <= rational(7,8));
ENSURE(rational(3,4) <= rational(3,4));
ENSURE(rational(3,4) >= rational(3,4));
ENSURE(rational(3,4) > rational(2,8));
ENSURE(rational(3,4) < rational(7,8));
TRACE("rational", tout << rational(3,4) << "\n";);
TRACE("rational", tout << rational(7,9) << "\n";);
TRACE("rational", tout << rational(-3,7) << "\n";);
TRACE("rational", tout << rational(5,8) << "\n";);
TRACE("rational", tout << rational(4,2) << "\n";);
ENSURE(rational(3) + rational(2) == rational(5));
ENSURE(rational(3) - rational(2) == rational(1));
ENSURE(rational(3) * rational(2) == rational(6));
ENSURE(rational(6) / rational(2) == rational(3));
ENSURE(rational(6) % rational(4) == rational(2));
ENSURE(power(rational(2),0) == rational(1));
ENSURE(power(rational(2),1) == rational(2));
ENSURE(power(rational(2),3) == rational(8));
}
static void tst2() {
rational r1("10000000000000000000000000000000000");
rational r2("10000000000000000000000000000000000/3");
rational r3("20000000000000000000000000000000000/6");
TRACE("rational", tout << r1 << std::endl;);
TRACE("rational", tout << r2 << std::endl;);
TRACE("rational", tout << r3 << std::endl;);
ENSURE(r2 == r3);
ENSURE(r1 != r2);
ENSURE(rational(2)*r2 + r3 == r1);
ENSURE(r1.is_pos());
ENSURE((r2 - r1).is_neg());
ENSURE((r2 - r3).is_zero());
// std::cout << "===> " << floor(r2) << "\n";
{
rational r0("1/3000000000000000000000000");
ENSURE(ceil(r0).is_one());
ENSURE(floor(-r0).is_minus_one());
ENSURE(ceil(-r0).is_zero());
}
ENSURE(floor(r1) == r1);
ENSURE(ceil(r1) == r1);
rational r4("300000000/5");
ENSURE(rational(1,2) * r4 == rational("300000000/10"));
ENSURE(rational(1,2) / r4 == rational("5/600000000"));
rational r5(2,3);
ENSURE(r4 * r5 == rational("200000000/5"));
rational r6("10000000000000000000000000000000003/3");
--r6;
ENSURE(r6 == r2);
r6.neg();
ENSURE(r6 != r2);
ENSURE(abs(r6) == r2);
--r2;
++r2;
r2.neg();
ENSURE(r2 == r6);
ENSURE(r6 * rational(1) == r6);
ENSURE((r6 * rational(0)).is_zero());
ENSURE(r6 * rational(-1) == -r6);
ENSURE(rational(1) * r6 == r6);
ENSURE((rational(0) * r6).is_zero());
ENSURE(rational(-1) * r6 == -r6);
ENSURE(r6 + rational(0) == r6);
ENSURE(rational("300000000000000").is_pos());
ENSURE(rational("0000000000000000000").is_nonneg());
ENSURE(rational("0000000000000000000").is_nonpos());
ENSURE(rational("3000000000000000000/2").is_pos());
ENSURE(rational("3000000000000000000/2").is_nonneg());
ENSURE((-rational("3000000000000000000/2")).is_neg());
ENSURE(!rational("3000000000000000000/2").is_neg());
ENSURE(!rational("3000000000000000000/2").is_zero());
ENSURE(!rational("3000000000000000000/2").is_one());
ENSURE(rational("99999999999/2") >= rational("23/2"));
ENSURE(rational("99999999999/2") > rational("23/2"));
ENSURE(rational("23/2") <= rational("99999999999/2"));
ENSURE(rational("23/2") < rational("99999999999/2"));
ENSURE(!(rational("99999999999/2") < rational("23/2")));
rational int64_max("9223372036854775807");
rational int64_min((-int64_max) - rational(1));
// is_int64
ENSURE(int64_max.is_int64());
ENSURE(int64_min.is_int64());
ENSURE(rational(0).is_int64());
ENSURE(rational(1).is_int64());
ENSURE(rational(-1).is_int64());
ENSURE(!(int64_max + rational(1)).is_int64());
ENSURE(!(int64_min - rational(1)).is_int64());
// is_uint64
ENSURE(int64_max.is_uint64());
ENSURE(!int64_min.is_uint64());
ENSURE(rational(0).is_uint64());
ENSURE(rational(1).is_uint64());
ENSURE(!rational(-1).is_uint64());
ENSURE((int64_max + rational(1)).is_uint64());
ENSURE(!(int64_min - rational(1)).is_uint64());
rational uint64_max(rational(1) + (rational(2) * int64_max));
ENSURE(uint64_max.is_uint64());
// get_int64, get_uint64
uint64_t u1 = uint64_max.get_uint64();
uint64_t u2 = UINT64_MAX;
VERIFY(u1 == u2);
std::cout << "int64_max: " << int64_max << ", INT64_MAX: " << INT64_MAX << ", int64_max.get_int64(): " << int64_max.get_int64() << ", int64_max.get_uint64(): " << int64_max.get_uint64() << "\n";
ENSURE(int64_max.get_int64() == INT64_MAX);
ENSURE(int64_min.get_int64() == INT64_MIN);
// extended Euclid:
}
void tst3() {
rational n1 = power(rational(2), 32);
TRACE("rational", tout << "n1: " << n1 << "\n";);
rational n2 = div(n1, rational(2));
rational n3 = div(rational(2), n2);
TRACE("rational",
tout << "n1: " << n1 << "\n";
tout << "n2: " << n2 << "\n";
tout << "n3: " << n3 << "\n";);
rational n4 = n1 - rational(3);
rational n5 = div(n4, rational(2));
TRACE("rational",
tout << "n4: " << n4 << "\n";
tout << "n5: " << n5 << "\n";);
ENSURE(n5 == rational("2147483646"));
}
void tst4() {
rational n1("4294967293");
TRACE("rational", tout << "n1: " << n1 << "\n";);
rational n2 = div(n1, rational(2));
}
void tst5() {
rational n1(1);
n1.neg();
rational n2("4294967295");
n1 /= n2;
TRACE("rational", tout << n1 << " " << n2 << " " << n1.is_big() << " " << n2.is_big() << "\n";);
n1 *= n2;
TRACE("rational", tout << "after: " << n1 << " " << n2 << "\n";);
ENSURE(n1.is_minus_one());
}
void tst6() {
rational t1(5);
rational t2(3);
rational a, b, g;
g = gcd(t1, t2, a, b);
t1 = rational(15);
t2 = rational(25);
g = gcd(t1, t2, a, b);
t1.neg();
g = gcd(t1, t2, a, b);
t2.neg();
g = gcd(t1, t2, a, b);
t1.neg();
g = gcd(t1, t2, a, b);
std::swap(t1, t2);
g = gcd(t1, t2, a, b);
t1.neg();
g = gcd(t1, t2, a, b);
t2.neg();
g = gcd(t1, t2, a, b);
t1.neg();
g = gcd(t1, t2, a, b);
}
class rational_tester {
public:
static void tst1() {
rational n1(-1);
rational n2(8);
ENSURE((n1 % n2).is_minus_one());
ENSURE(mod(n1, n2) == rational(7));
}
static void tst_hash(int val) {
rational n1(val);
rational n2("10203939394995449949494394932929");
rational n3(val);
n2 = n3;
ENSURE(n1.hash() == n2.hash());
}
static void tst2() {
tst_hash(0);
for (int i = 0; i <= 10000; i++) {
int r = rand() % INT_MAX;
if (rand()%2 == 1) r = -r;
tst_hash(r);
}
}
};
static void tst7() {
rational p;
p = power(rational(2), 32);
for (unsigned i = 1; i < 1000; i++) {
rational n(i);
rational x;
rational y;
rational gcd;
extended_gcd(n, p, gcd, x, y);
TRACE("gcd", tout << n << " " << p << ": " << gcd << " " << x << " " << y << "\n";);
ENSURE(!mod(n, rational(2)).is_one() || mod(n * x, p).is_one());
}
}
static void tst8() {
rational r;
ENSURE(!rational(-4).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-3).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-2).is_int_perfect_square(r) && r.is_zero());
ENSURE(!rational(-1).is_int_perfect_square(r) && r.is_zero());
ENSURE(rational(0).is_int_perfect_square(r) && r.is_zero());
ENSURE(rational(1).is_int_perfect_square(r) && r.is_one());
ENSURE(!rational(2).is_int_perfect_square(r) && r == rational(2));
ENSURE(!rational(3).is_int_perfect_square(r) && r == rational(2));
ENSURE(rational(4).is_int_perfect_square(r) && r == rational(2));
ENSURE(!rational(5).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(6).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(7).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(8).is_int_perfect_square(r) && r == rational(3));
ENSURE(rational(9).is_int_perfect_square(r) && r == rational(3));
ENSURE(!rational(10).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(11).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(12).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(13).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(14).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(15).is_int_perfect_square(r) && r == rational(4));
ENSURE(rational(16).is_int_perfect_square(r) && r == rational(4));
ENSURE(!rational(17).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(18).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(19).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(20).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(21).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(22).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(23).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(24).is_int_perfect_square(r) && r == rational(5));
ENSURE(rational(25).is_int_perfect_square(r) && r == rational(5));
ENSURE(!rational(26).is_int_perfect_square(r) && r == rational(6));
ENSURE(rational(36).is_int_perfect_square(r) && r == rational(6));
ENSURE(rational(1,9).is_perfect_square(r) && r == rational(1,3));
ENSURE(rational(4,9).is_perfect_square(r) && r == rational(2,3));
}
static void tstmod(rational const& m, rational const& n) {
//
// (=> (distinct n 0)
// (let ((q (div m n)) (r (mod m n)))
// (and (= m (+ (* n q) r))
// (<= 0 r (- (abs n) 1))))))
//
rational q = div(m,n);
rational r = mod(m,n);
std::cout << m << " " << n << " " << q << " " << r << "\n";
std::cout << m << " == " << n*q+r << "\n";
ENSURE(m == (n * q) + r);
ENSURE(rational::zero() <= r);
ENSURE(r < abs(n));
}
static void tst9() {
// record semantics of rational div/mod.
tstmod(rational("41000000000000"),rational("-7000000000000"));
tstmod(rational("-41000000000000"),rational("-7000000000000"));
tstmod(rational("-41000000000000"),rational("7000000000000"));
tstmod(rational("41000000000000"),rational("7000000000000"));
tstmod(rational(41),rational(-7));
tstmod(rational(-41),rational(-7));
tstmod(rational(-41),rational(7));
tstmod(rational(41),rational(7));
}
#define NUM_RATIONALS 1000000
#define MAGNITUDE 10000
static void tst10(bool use_ints) {
if (use_ints)
std::cout << "Testing multiplication performance using small ints\n";
else
std::cout << "Testing multiplication performance using small rationals\n";
vector vals;
vector vals2;
vector fvals;
vals.resize(NUM_RATIONALS);
vals2.resize(NUM_RATIONALS);
fvals.resize(NUM_RATIONALS);
for (unsigned i = 0; i < NUM_RATIONALS; i++) {
int r1 = rand() % MAGNITUDE;
int r2 = use_ints ? 1 : rand() % MAGNITUDE;
if (r2 == 0) r2 = 1;
if (rand() % 2 == 0) r1 = -r1;
vals[i] = rational(r1, r2);
vals2[i] = rational(r1, r2);
fvals[i] = ((float)r1) / ((float)r2);
}
{
timeit t(true, "multiplication with rationals");
for (unsigned i = 0; i < NUM_RATIONALS - 1; i++) {
vals[i] *= vals[i+1];
}
}
{
timeit t(true, "multiplication with floats: ");
for (unsigned i = 0; i < NUM_RATIONALS - 1; i++) {
fvals[i] *= fvals[i+1];
}
}
std::cout << "\n";
}
#define NUM_RATIONALS2 10000
#define MAGNITUDE2 100000000
static void tst11(bool use_ints) {
vector vals;
vector fvals;
vals.resize(NUM_RATIONALS2);
fvals.resize(NUM_RATIONALS2);
for (unsigned i = 0; i < NUM_RATIONALS2; i++) {
int r1 = rand() % MAGNITUDE2;
int r2 = use_ints ? 1 : rand() % MAGNITUDE2;
if (r2 == 0) r2 = 1;
if (rand() % 2 == 0) r1 = -r1;
vals[i] = rational(r1, r2);
fvals[i] = ((float)r1) / ((float)r2);
}
{
timeit t(true, "multiplication with big rationals");
for (unsigned j = 0; j < 10; j++)
for (unsigned i = 0; i < NUM_RATIONALS2-1; i++) {
vals[i] *= vals[i+1];
}
}
{
timeit t(true, "multiplication with floats: ");
for (unsigned j = 0; j < 10; j++)
for (unsigned i = 0; i < NUM_RATIONALS2-1; i++) {
fvals[i] *= fvals[i+1];
}
}
std::cout << "\n";
}
static void tst12() {
std::cout << "test12\n";
rational r;
r = 5;
SASSERT(r.get_bit(0));
SASSERT(!r.get_bit(1));
SASSERT(r.get_bit(2));
SASSERT(!r.get_bit(3));
r = rational("10000000000000000000000000000000001");
for (unsigned i = 0; i < r.get_num_bits(); ++i)
std::cout << i << ": " << r.get_bit(i) << "\n";
}
static void tst13() {
std::cout << "test13\n";
rational const step = rational(1) / rational(3);
for (rational r; r < 5000; r += step) {
{
unsigned k = r.prev_power_of_two();
if (r >= 1) {
VERIFY(rational::power_of_two(k) <= r);
VERIFY(r < rational::power_of_two(k + 1));
}
else {
VERIFY_EQ(k, 0);
}
}
{
unsigned k = r.next_power_of_two();
VERIFY(r <= rational::power_of_two(k));
VERIFY(k == 0 || rational::power_of_two(k - 1) < r);
}
}
}
void tst_rational() {
TRACE("rational", tout << "starting rational test...\n";);
std::cout << "sizeof(rational): " << sizeof(rational) << "\n";
rational r1("10000000000000000000000000000000001");
r1.hash();
tst1();
tst2();
tst3();
tst4();
tst5();
std::cout << "running tst6" << std::endl;
tst6();
std::cout << "running tst7" << std::endl;
tst7();
std::cout << "running tst8" << std::endl;
tst8();
std::cout << "running tst9" << std::endl;
tst9();
std::cout << "running rational_tester::tst1" << std::endl;
rational_tester::tst1();
rational_tester::tst2();
tst11(true);
tst10(true);
tst10(false);
tst12();
tst13();
}