/*
* Copy t's value into buffer b
* - t must be defined in table and be a bitvector term
* - b->ptbl must be the same as table->pprods
*/
void bvarith_buffer_set_term(bvarith_buffer_t *b, term_table_t *table, term_t t) {
pprod_t **v;
bvpoly_t *p;
uint32_t n;
int32_t i;
assert(b->ptbl == table->pprods);
assert(pos_term(t) && good_term(table, t) && is_bitvector_term(table, t));
i = index_of(t);
n = bitsize_for_idx(table, i);
bvarith_buffer_prepare(b, n); // reset b
switch (table->kind[i]) {
case POWER_PRODUCT:
bvarith_buffer_add_pp(b, pprod_for_idx(table, i));
break;
case BV_CONSTANT:
bvarith_buffer_add_const(b, bvconst_for_idx(table, i)->data);
break;
case BV_POLY:
p = bvpoly_for_idx(table, i);
v = pprods_for_bvpoly(table, p);
bvarith_buffer_add_bvpoly(b, p, v);
term_table_reset_pbuffer(table);
break;
default:
bvarith_buffer_add_var(b, t);
break;
}
}
void expand_bvpprod(bvexp_table_t *table, bvarith_buffer_t *buffer, pp_buffer_t *p, uint32_t n, uint32_t *c) {
bv_vartable_t *vtbl;
bvmlist_t *q;
pp_buffer_t *aux;
pprod_t *r;
uint32_t *a;
uint32_t i, m, d, e, k;
thvar_t x;
assert(buffer->store == &table->store && buffer->ptbl == &table->pprods);
bvarith_buffer_prepare(buffer, n);
bvarith_buffer_set_one(buffer);
aux = p;
vtbl = table->vtbl;
if (total_degree_test(table, vtbl, p)) {
aux = &table->pp;
pp_buffer_reset(aux);
// make a copy of c in the internal bvconst buffer
bvconstant_copy(&table->bvconst, n, c);
c = table->bvconst.data;
k = (n + 31) >> 5;
m = p->len;
for (i=0; i<m; i++) {
x = p->prod[i].var;
d = p->prod[i].exp;
if (bvvar_is_const(vtbl, x)) {
a = bvvar_val(vtbl, x);
bvconst_mulpower(c, k, a, d);
} else {
q = bvexp_def(table, x);
if (q != NULL && mlist_is_short(q, &e) && d * e <= BVEXP_DEGREE_LIMIT) {
bvarith_buffer_mul_mlist_power(buffer, q, d, &table->aux);
} else {
pp_buffer_mul_varexp(aux, x, d);
}
}
}
// normalize
bvconst_normalize(c, n);
pp_buffer_normalize(aux);
}
/*
* The result is c * aux * buffer
*/
r = pprod_from_buffer(&table->pprods, aux);
bvarith_buffer_mul_mono(buffer, c, r);
bvarith_buffer_normalize(buffer);
}
void expand_bvpoly(bvexp_table_t *table, bvarith_buffer_t *buffer, bvpoly_buffer_t *p) {
bv_vartable_t *vtbl;
bvmlist_t *q;
uint32_t *c;
uint32_t i, n;
thvar_t x;
assert(buffer->store == &table->store && buffer->ptbl == &table->pprods);
bvarith_buffer_prepare(buffer, bvpoly_buffer_bitsize(p));
n = bvpoly_buffer_num_terms(p);
if (n > 0) {
vtbl = table->vtbl;
i = 0;
// constant term of p
if (bvpoly_buffer_var(p, 0) == const_idx) {
bvarith_buffer_add_const(buffer, bvpoly_buffer_coeff(p, 0));
i ++;
}
// non-constant terms
while (i < n) {
x = bvpoly_buffer_var(p, i);
c = bvpoly_buffer_coeff(p, i);
i ++;
if (bvvar_is_const(vtbl, x)) {
bvarith_buffer_add_const_times_const(buffer, c, bvvar_val(vtbl, x));
} else {
q = bvexp_def(table, x);
if (q != NULL) {
bvarith_buffer_add_const_times_mlist(buffer, q, c);
} else {
bvarith_buffer_add_varmono(buffer, c, x);
}
}
}
bvarith_buffer_normalize(buffer);
}
}
/*
* Initialize the buffers:
* - n = bitsize
*/
static void init_test2(uint32_t n) {
uint32_t q0[4];
uint32_t i;
assert(0 < n && n <= 128);
for (i=0; i<8; i++) {
init_bvarith_buffer(aux + i, &prod_table, &store);
bvarith_buffer_prepare(aux + i, n);
}
bvarith_buffer_add_var(&aux[0], 3); // x_3
bvconst_set32(q0, 4, 2);
bvarith_buffer_add_const(&aux[1], q0); // 2
bvarith_buffer_add_var(&aux[2], 1);
bvarith_buffer_sub_var(&aux[2], 2); // x_1 - x_2
bvarith_buffer_add_var(&aux[3], 0);
bvarith_buffer_sub_const(&aux[3], q0); // x_0 - 2
bvarith_buffer_add_pp(&aux[4], pprod_mul(&prod_table, var_pp(1), var_pp(1))); // x_1^2
bvarith_buffer_add_var(&aux[5], 0);
bvarith_buffer_mul_const(&aux[5], q0); // 2 * x_0
bvarith_buffer_add_varmono(&aux[6], q0, 1); // 2 * x_1
bvarith_buffer_sub_var(&aux[7], 3);
bvarith_buffer_sub_var(&aux[7], 3);
bvarith_buffer_add_var(&aux[7], 4);
for (i=0; i<8; i++) {
bvarith_buffer_normalize(aux + i);
}
}
/*
* Test binary operations with b1 and b2
*/
static void test_ops(bvarith_buffer_t *b1, bvarith_buffer_t *b2) {
bvarith_buffer_t b;
uint32_t n;
assert(b1->bitsize == b2->bitsize);
printf("b1: ");
print_bvarith_buffer(stdout, b1);
printf("\nb2: ");
print_bvarith_buffer(stdout, b2);
printf("\n");
printf("Equality test: ");
if (bvarith_buffer_equal(b1, b2)) {
printf("yes\n");
} else {
printf("no\n");
}
n = b1->bitsize;
init_bvarith_buffer(&b, &prod_table, &store);
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 + b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_sub_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 - b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_sub_buffer(&b, b1);
bvarith_buffer_normalize(&b);
printf(" b2 - b1: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b1);
bvarith_buffer_mul_buffer(&b, b2);
bvarith_buffer_normalize(&b);
printf(" b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer(&b, b2);
bvarith_buffer_mul_buffer(&b, b1);
bvarith_buffer_normalize(&b);
printf(" b2 * b1: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_add_buffer_times_buffer(&b, b1, b2);
bvarith_buffer_normalize(&b);
printf(" b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
bvarith_buffer_prepare(&b, n);
bvarith_buffer_sub_buffer_times_buffer(&b, b1, b2);
bvarith_buffer_normalize(&b);
printf("- b1 * b2: ");
print_bvarith_buffer(stdout, &b);
printf("\n");
delete_bvarith_buffer(&b);
printf("----\n");
}
/*
* Tests: one buffer
* - n = bitsize
*/
static void test1(uint32_t n) {
bvarith_buffer_t buffer;
uint32_t q0[4];
assert(0 < n && n <= 128);
init_bvarith_buffer(&buffer, &prod_table, &store);
bvarith_buffer_prepare(&buffer, n);
printf("Empty buffer\n");
test_buffer(&buffer);
printf("x_0 + x_1\n");
bvarith_buffer_add_var(&buffer, 0);
bvarith_buffer_add_var(&buffer, 1);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("After reset\n");
bvarith_buffer_prepare(&buffer, n);
test_buffer(&buffer);
printf("x_2 - x_0\n");
bvarith_buffer_add_var(&buffer, 2);
bvarith_buffer_sub_var(&buffer, 0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("x_2 - x_0 + x_1 + x_0\n");
bvarith_buffer_prepare(&buffer, n);
bvarith_buffer_add_var(&buffer, 2);
bvarith_buffer_sub_var(&buffer, 0);
bvarith_buffer_add_var(&buffer, 1);
bvarith_buffer_add_var(&buffer, 0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Adding 3\n");
bvconst_set32(q0, 4, 3);
bvarith_buffer_add_const(&buffer, q0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Negating\n");
bvarith_buffer_negate(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Negating again\n");
bvarith_buffer_negate(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by 2 x_4\n");
bvconst_set32(q0, 4, 2);
bvarith_buffer_mul_varmono(&buffer, q0, 4);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by x_1^2\n");
bvarith_buffer_mul_var(&buffer, 1);
bvarith_buffer_mul_var(&buffer, 1);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Multiplying by 0\n");
bvconst_clear(q0, 4);
bvarith_buffer_mul_const(&buffer, q0);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("x_1 + 1 - x_2\n");
bvarith_buffer_prepare(&buffer, n);
bvarith_buffer_add_var(&buffer, 1);
bvconst_set32(q0, 4, 1);
bvarith_buffer_add_const(&buffer, q0);
bvarith_buffer_sub_var(&buffer, 2);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
printf("Squaring\n");
bvarith_buffer_square(&buffer);
bvarith_buffer_normalize(&buffer);
test_buffer(&buffer);
delete_bvarith_buffer(&buffer);
}
int main(void) {
thvar_t x, y, z;
init_bvconstants();
init_bv_vartable(&vtbl);
init_bvexp_table(&table, &vtbl);
bvexp_init_buffer64(&table, &b1);
bvexp_init_buffer64(&table, &b2);
bvexp_init_buffer(&table, &c1);
bvexp_init_buffer(&table, &c2);
printf("=== Initial table ===\n");
print_bvexp_table(stdout, &table);
printf("\n");
x = make_bvvar(&vtbl, 10);
y = make_bvvar(&vtbl, 10);
z = make_bvvar(&vtbl, 10);
// 2 + x + y
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_const(&b1, 2);
bvarith64_buffer_add_var(&b1, x);
bvarith64_buffer_add_var(&b1, y);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_const(&b1, 2);
bvarith64_buffer_add_var(&b1, x);
bvarith64_buffer_add_var(&b1, y);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
// (x + z) * (y - z)
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_var(&b1, x);
bvarith64_buffer_add_var(&b1, z);
bvarith64_buffer_prepare(&b2, 10);
bvarith64_buffer_add_var(&b2, y);
bvarith64_buffer_sub_var(&b2, z);
bvarith64_buffer_mul_buffer(&b1, &b2);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_var(&b1, x);
bvarith64_buffer_add_var(&b1, z);
bvarith64_buffer_prepare(&b2, 10);
bvarith64_buffer_add_var(&b2, y);
bvarith64_buffer_sub_var(&b2, z);
bvarith64_buffer_mul_buffer(&b1, &b2);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
// x * y * z^2
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_var(&b1, z);
bvarith64_buffer_square(&b1);
bvarith64_buffer_mul_var(&b1, y);
bvarith64_buffer_mul_var(&b1, x);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
bvarith64_buffer_prepare(&b1, 10);
bvarith64_buffer_add_var(&b1, z);
bvarith64_buffer_square(&b1);
bvarith64_buffer_mul_var(&b1, y);
bvarith64_buffer_mul_var(&b1, x);
bvarith64_buffer_normalize(&b1);
test_buffer64(&table, &b1);
// Large coefficients
x = make_bvvar(&vtbl, 100);
y = make_bvvar(&vtbl, 100);
z = make_bvvar(&vtbl, 100);
// 1 + x + y
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_set_one(&c1);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, y);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_set_one(&c1);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, y);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
// (x + z) * (y - z)
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_prepare(&c2, 100);
bvarith_buffer_add_var(&c2, y);
bvarith_buffer_sub_var(&c2, z);
bvarith_buffer_mul_buffer(&c1, &c2);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_prepare(&c2, 100);
bvarith_buffer_add_var(&c2, y);
bvarith_buffer_sub_var(&c2, z);
bvarith_buffer_mul_buffer(&c1, &c2);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
// x * y * z^2
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_square(&c1);
bvarith_buffer_mul_var(&c1, y);
bvarith_buffer_mul_var(&c1, x);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_square(&c1);
bvarith_buffer_mul_var(&c1, y);
bvarith_buffer_mul_var(&c1, x);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
printf("=== Final table ===\n");
print_bvexp_table(stdout, &table);
printf("\n");
// remove two variables
bvexp_table_remove_vars(&table, 11);
printf("=== After removing two variables ===\n");
print_bvexp_table(stdout, &table);
printf("\n");
// recheck: 1 + x + y
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_set_one(&c1);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, y);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
// recheck: (x + z) * (y - z)
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_prepare(&c2, 100);
bvarith_buffer_add_var(&c2, y);
bvarith_buffer_sub_var(&c2, z);
bvarith_buffer_mul_buffer(&c1, &c2);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
bvarith_buffer_prepare(&c1, 100);
bvarith_buffer_add_var(&c1, x);
bvarith_buffer_add_var(&c1, z);
bvarith_buffer_prepare(&c2, 100);
bvarith_buffer_add_var(&c2, y);
bvarith_buffer_sub_var(&c2, z);
bvarith_buffer_mul_buffer(&c1, &c2);
bvarith_buffer_normalize(&c1);
test_buffer(&table, &c1);
printf("=== Final table ===\n");
print_bvexp_table(stdout, &table);
printf("\n");
// cleanup
delete_bvarith64_buffer(&b1);
delete_bvarith64_buffer(&b2);
delete_bvarith_buffer(&c1);
delete_bvarith_buffer(&c2);
delete_bvexp_table(&table);
delete_bv_vartable(&vtbl);
cleanup_bvconstants();
return 0;
}
