int main(void) {
uint32_t n;
init_rationals();
init_poly_table(&poly_table, 100, 20);
build_poly_table(&poly_table, 100, 1000);
printf("==== ALL POLYS ====\n");
print_poly_table(&poly_table);
printf("====\n");
base_test();
random_test(1000, 40);
n = 1000;
while (n > 0) {
random_test(4000, 200);
n --;
}
n = 1000;
while (n > 0) {
random_test(4000, 100);
n --;
}
delete_poly_table(&poly_table);
cleanup_rationals();
return 0;
}
int main(void) {
xrational_t *a;
init_rationals();
a = (xrational_t *) safe_malloc(150 * sizeof(xrational_t));
init_test_array(a, 150);
printf("Init: size 1\n");
init_xq_hmap(&map, 1);
print_hmap(&map);
test1(&map, a, 150);
printf("Reset\n");
reset_xq_hmap(&map);
print_hmap(&map);
test1(&map, a, 150);
delete_xq_hmap(&map);
free_test_array(a, 150);
cleanup_rationals();
return 0;
}
int main() {
init_rationals();
test1();
test2();
test3();
test4();
cleanup_rationals();
return 0;
}
int main(void) {
init_rationals();
test_small_small();
test_big_small();
test_small_big();
test_big_big();
cleanup_rationals();
return 0;
}
int main(void) {
init_rationals();
init_vartable();
show_all_vars(stdout);
test_constraint();
delete_vartable();
cleanup_rationals();
return 0;
}
int main(void) {
init_rationals();
init_pprod_table(&ptable, 0);
init_rba_buffer(&buffer, &ptable);
run_tests(&buffer);
delete_rba_buffer(&buffer);
delete_pprod_table(&ptable);
cleanup_rationals();
return 0;
}
// Used assert_true instead of assert to prevent compiler warnings
int main(void) {
uint32_t i;
bool ok;
init_rationals();
build_polys();
show_polys();
init_offset_manager(&mngr, NULL, notify_equality);
/*
* FIRST TESTS
*/
for (i=0; i<NPOLYS; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
printf("\n*** Initial state ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_increase_decision_level(&mngr);
test_equality(var[3], var[4], 0, 123);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_backtrack(&mngr, 0);
printf("\n*** After backtracking to level 0 ***\n");
print_ptable(&mngr);
print_vtable(&mngr);
offset_manager_increase_decision_level(&mngr);
test_equality(var[3], -1, 1, 234);
test_equality(var[3], var[4], 0, 123);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_backtrack(&mngr, 0);
ok = offset_manager_propagate(&mngr);
printf("\n*** After backtracking to level 0 ***\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
/*
* SECOND TEST
*/
reset_offset_manager(&mngr);
printf("\n*** After reset ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
for (i=0; i<NPOLYS/2; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
offset_manager_push(&mngr);
printf("\n*** After push ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
while (i < NPOLYS) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
i ++;
}
printf("\n*** After adding all polys ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[5], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_pop(&mngr);
printf("\n*** After pop ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[4], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
/*
* THIRD TEST
*/
reset_offset_manager(&mngr);
printf("\n*** After reset ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
for (i=0; i<6; i++) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
}
test_equality(var[5], var[3], 10, 111);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_push(&mngr);
printf("\n*** After push ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
while (i < NPOLYS) {
record_offset_poly(&mngr, term[i], var[i], poly[i]);
i ++;
}
printf("\n*** After adding all polys ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
test_equality(var[4], var[3], 10, 111);
test_equality(-1, var[3], 56, 122);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
offset_manager_pop(&mngr);
printf("\n*** After pop ****\n");
print_var2poly(&mngr);
print_var2offset_var(&mngr);
print_ptable(&mngr);
print_vtable(&mngr);
ok = offset_manager_propagate(&mngr);
printf("\n*** After propagate ****\n");
print_ptable(&mngr);
print_vtable(&mngr);
assert_true(ok);
delete_offset_manager(&mngr);
delete_polys();
cleanup_rationals();
return 0;
}
int main() {
uint32_t i;
init_rationals();
init_dl_vartable(&table);
printf("Initial table\n");
print_dl_vartable(&table);
for (i=0; i<10; i++) {
test_random_triple(&table);
}
printf("After 10 additions\n");
print_dl_vartable(&table);
test_add_diff(&table);
printf("Push\n");
dl_vartable_push(&table);
for (i=0; i<10; i++) {
test_random_triple(&table);
}
printf("After 10 additions\n");
print_dl_vartable(&table);
test_add_diff(&table);
printf("Push\n");
dl_vartable_push(&table);
printf("Pop\n");
dl_vartable_pop(&table);
print_dl_vartable(&table);
printf("Pop\n");
dl_vartable_pop(&table);
print_dl_vartable(&table);
printf("Reset\n");
reset_dl_vartable(&table);
print_dl_vartable(&table);
printf("Push\n");
dl_vartable_push(&table);
for (i=0; i<100; i++) {
test_random_triple(&table);
}
printf("After 100 additions\n");
print_dl_vartable(&table);
test_add_diff(&table);
printf("Pop\n");
dl_vartable_pop(&table);
print_dl_vartable(&table);
printf("Reset\n");
reset_dl_vartable(&table);
print_dl_vartable(&table);
delete_dl_vartable(&table);
cleanup_rationals();
return 0;
}
/*
* Tests
*/
int main(void) {
rational_t alpha;
uint32_t n;
int32_t v;
init_rationals();
q_init(&alpha);
init_poly_buffer(&buffer);
printf("--- Init ---\n");
print_poly_buffer_details(&buffer);
reset_poly_buffer(&buffer);
printf("--- Reset ---\n");
print_poly_buffer_details(&buffer);
normalize_poly_buffer(&buffer);
printf("--- Normalize ---\n");
print_poly_buffer_details(&buffer);
reset_poly_buffer(&buffer);
printf("--- Reset ---\n");
print_poly_buffer_details(&buffer);
random_rational(&alpha);
poly_buffer_add_monomial(&buffer, 2, &alpha);
printf("--- Add monomial x!2 * alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_add_const(&buffer, &alpha);
printf("--- Add constant alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_add_monomial(&buffer, 1, &alpha);
printf("--- Add monomial x!1 * alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_sub_monomial(&buffer, 2, &alpha);
printf("--- Sub monomial x!2 * alpha ---\n");
print_poly_buffer_details(&buffer);
normalize_poly_buffer(&buffer);
printf("--- Normalize ---\n");
print_poly_buffer_details(&buffer);
reset_poly_buffer(&buffer);
printf("--- Reset ---\n");
print_poly_buffer_details(&buffer);
random_rational(&alpha);
poly_buffer_sub_monomial(&buffer, 2, &alpha);
printf("--- Sub monomial x!2 * alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_sub_const(&buffer, &alpha);
printf("--- Sub constant alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_add_monomial(&buffer, 1, &alpha);
printf("--- Add monomial x!1 * alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_sub_monomial(&buffer, 2, &alpha);
printf("--- Sub monomial x!2 * alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_add_const(&buffer, &alpha);
printf("--- Add constant alpha ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_add_var(&buffer, 3);
printf("--- Add var x!3 ---\n");
print_poly_buffer_details(&buffer);
poly_buffer_sub_var(&buffer, 3);
printf("--- Sub var x!3 ---\n");
print_poly_buffer_details(&buffer);
normalize_poly_buffer(&buffer);
printf("--- Normalize ---\n");
print_poly_buffer_details(&buffer);
reset_poly_buffer(&buffer);
for (n=0; n<400; n++) {
v = random() % 200;
random_rational(&alpha);
poly_buffer_add_monomial(&buffer, v, &alpha);
}
printf("--- 400 random monomials ---\n");
print_poly_buffer_details(&buffer);
normalize_poly_buffer(&buffer);
printf("--- Normalize ---\n");
print_poly_buffer_details(&buffer);
delete_poly_buffer(&buffer);
q_clear(&alpha);
cleanup_rationals();
return 0;
}
int main() {
int32_t x, y;
uint32_t a, b, n;
char c;
string_buffer_t *s;
s = &buffer;
init_string_buffer(s, 0);
show_test("empty buffer", s);
string_buffer_reset(s);
for (c = 'a'; c <= 'z'; c++) {
string_buffer_append_char(s, c);
}
show_test("alphabet", s);
string_buffer_reset(s);
for (c = 'a'; c <= 'z'; c++) {
string_buffer_append_char(s, c);
}
string_buffer_append_string(s, "au898ue2bcc90219");
show_test("alphabet+au898ue2bcc90219", s);
x = INT32_MIN;
for (;;){
sprintf(aux, "signed number: %" PRId32, x);
string_buffer_reset(s);
string_buffer_append_int32(s, x);
show_test(aux, s);
y = x >> 1;
if (y == x) break;
x = y;
}
x = INT32_MAX;
for (;;) {
sprintf(aux, "signed number: %" PRId32, x);
string_buffer_reset(s);
string_buffer_append_int32(s, x);
show_test(aux, s);
y = x>>1;
if (y == x) break;
x = y;
}
a = UINT32_MAX;
for (;;){
sprintf(aux, "unsigned number: %" PRIu32, a);
string_buffer_reset(s);
string_buffer_append_uint32(s, a);
show_test(aux, s);
b = a >> 1;
if (b == a) break;
a = b;
}
mpz_init(z0);
mpz_init(z1);
mpq_init(q0);
mpz_set_str(z0, "111102222033330123456789", 10);
string_buffer_reset(s);
string_buffer_append_mpz(s, z0);
show_test("mpz: 111102222033330123456789", s);
mpz_set_str(z0, "-111102222033330123456789", 10);
string_buffer_reset(s);
string_buffer_append_mpz(s, z0);
show_test("mpz: -111102222033330123456789", s);
string_buffer_reset(s);
string_buffer_append_mpz(s, z1);
show_test("mpz: 0", s);
mpq_set_str(q0, "-98765432109876543210", 10);
string_buffer_reset(s);
string_buffer_append_mpq(s, q0);
show_test("mpq: -98765432109876543210", s);
mpq_set_str(q0, "-98765432109876543210/38192839777", 10);
string_buffer_reset(s);
string_buffer_append_mpq(s, q0);
show_test("mpq: -98765432109876543210/38192839777", s);
init_rationals();
rational_t r0;
q_init(&r0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: 0", s);
q_set_int32(&r0, -12, 73);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -12/73", s);
q_set_mpq(&r0, q0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -98765432109876543210/38192839777", s);
q_set_mpz(&r0, z0);
string_buffer_reset(s);
string_buffer_append_rational(s, &r0);
show_test("rational: -111102222033330123456789", s);
printf("\nBit Vectors\n");
init_bvconstants();
bv0 = bvconst_alloc(1);
bvconst_clear(bv0, 1);
for (n=1; n<= 32; n++) {
string_buffer_reset(s);
string_buffer_append_bvconst(s, bv0, n);
sprintf(aux, "bv[%" PRIu32"]: 0b000...", n);
show_test(aux, s);
}
for (n=1; n <= 32; n++) {
bvconst_clear(bv0, 1);
bvconst_set_bit(bv0, n-1);
string_buffer_reset(s);
string_buffer_append_bvconst(s, bv0, n);
sprintf(aux, "bv[%" PRIu32"]: 0b100...", n);
show_test(aux, s);
}
bvconst_free(bv0, 1);
cleanup_bvconstants();
cleanup_rationals();
mpz_clear(z0);
mpz_clear(z1);
mpq_clear(q0);
delete_string_buffer(s);
return 0;
}
/*
* Delete table
*/
static void delete_globals(void) {
delete_pprod_table(&prod_table);
cleanup_rationals();
}
