/*
* Add a * r * b1 to b
*/
void arith_buffer_add_mono_times_buffer(arith_buffer_t *b, arith_buffer_t *b1, rational_t *a, pprod_t *r) {
mlist_t *p, *aux, *p1;
mlist_t **q;
pprod_t *r1;
q = &b->list;
p = *q;
p1 = b1->list;
while (p1->next != NULL) {
r1 = pprod_mul(b->ptbl, p1->prod, r);
while (pprod_precedes(p->prod, r1)) {
q = &p->next;
p = *q;
}
if (p->prod == r1) {
q_addmul(&p->coeff, &p1->coeff, a);
q = &p->next;
p = *q;
} else {
assert(pprod_precedes(r1, p->prod));
aux = alloc_list_elem(b->store);
aux->next = p;
q_addmul(&aux->coeff, &p1->coeff, a); // since aux->coeff is 0 initially
aux->prod = r1;
*q = aux;
q = &aux->next;
b->nterms ++;
}
p1 = p1->next;
}
}
/*
* Initialize the buffers
*/
static void init_test2(void) {
rational_t q0;
uint32_t i;
q_init(&q0);
for (i=0; i<8; i++) {
init_rba_buffer(aux + i, &prod_table);
}
rba_buffer_add_var(&aux[0], 3); // x_3
q_set32(&q0, 2);
rba_buffer_add_const(&aux[1], &q0); // 2
rba_buffer_add_var(&aux[2], 1);
rba_buffer_sub_var(&aux[2], 2); // x_1 - x_2
rba_buffer_add_var(&aux[3], 0);
rba_buffer_sub_const(&aux[3], &q0); // x_0 - 2
rba_buffer_add_pp(&aux[4], pprod_mul(&prod_table, var_pp(1), var_pp(1))); // x_1^2
rba_buffer_add_var(&aux[5], 0);
rba_buffer_mul_const(&aux[5], &q0); // 2 * x_0
rba_buffer_add_varmono(&aux[6], &q0, 1); // 2 * x_1
rba_buffer_sub_var(&aux[7], 3);
rba_buffer_sub_var(&aux[7], 3);
rba_buffer_add_var(&aux[7], 4);
q_clear(&q0);
}
/*
* Add - r * b1 to b
*/
void arith_buffer_sub_pp_times_buffer(arith_buffer_t *b, arith_buffer_t *b1, pprod_t *r) {
mlist_t *p, *aux, *p1;
mlist_t **q;
pprod_t *r1;
q = &b->list;
p = *q;
p1 = b1->list;
while (p1->next != NULL) {
r1 = pprod_mul(b->ptbl, p1->prod, r);
while (pprod_precedes(p->prod, r1)) {
q = &p->next;
p = *q;
}
if (p->prod == r1) {
q_sub(&p->coeff, &p1->coeff);
q = &p->next;
p = *q;
} else {
assert(pprod_precedes(r1, p->prod));
aux = alloc_list_elem(b->store);
aux->next = p;
q_set_neg(&aux->coeff, &p1->coeff);
aux->prod = r1;
*q = aux;
q = &aux->next;
b->nterms ++;
}
p1 = p1->next;
}
}
/*
* Multiply b by (- r)
*/
void arith_buffer_mul_negpp(arith_buffer_t *b, pprod_t *r) {
pprod_table_t *tbl;
mlist_t *p;
tbl = b->ptbl;
p = b->list;
while (p->next != NULL) {
assert(p->prod != end_pp);
p->prod = pprod_mul(tbl, p->prod, r);
q_neg(&p->coeff);
p = p->next;
}
}
/*
* Multiply b by a * r
*/
void arith_buffer_mul_mono(arith_buffer_t *b, rational_t *a, pprod_t *r) {
pprod_table_t *tbl;
mlist_t *p;
tbl = b->ptbl;
p = b->list;
while (p->next != NULL) {
assert(p->prod != end_pp);
p->prod = pprod_mul(tbl, p->prod, r);
q_mul(&p->coeff, a);
p = p->next;
}
}
/*
* Multiply b by power product r
*/
void arith_buffer_mul_pp(arith_buffer_t *b, pprod_t *r) {
pprod_table_t *tbl;
mlist_t *p;
/*
* We use the fact that the monomial ordering
* is compatible with multiplication, that is
* r1 < r2 => r * r1 < r * r2
*/
tbl = b->ptbl;
p = b->list;
while (p->next != NULL) {
assert(p->prod != end_pp);
p->prod = pprod_mul(tbl, p->prod, r);
p = p->next;
}
}
/*
* Subtract a * poly from b
*/
void arith_buffer_sub_mono_times_monarray(arith_buffer_t *b, monomial_t *poly, pprod_t **pp, rational_t *a, pprod_t *r) {
mlist_t *p, *aux;
mlist_t **q;
pprod_t *r1;
assert(good_pprod_array(poly, pp));
q = &b->list;
p = *q;
while (poly->var < max_idx) {
// poly points to a pair (coeff, x_i)
// r1 = r * power product for x_i
r1 = pprod_mul(b->ptbl, *pp, r);
while (pprod_precedes(p->prod, r1)) {
q = &p->next;
p = *q;
}
// p points to monomial whose prod is >= r1 in the deg-lex order
// q points to the predecessor of p in the list
if (p->prod == r1) {
q_submul(&p->coeff, &poly->coeff, a);
q = &p->next;
p = *q;
} else {
assert(pprod_precedes(r1, p->prod));
aux = alloc_list_elem(b->store);
aux->next = p;
q_submul(&aux->coeff, &poly->coeff, a); // aux->coeff is initialized to 0 in alloc_list_elem
aux->prod = r1;
*q = aux;
q = &aux->next;
b->nterms ++;
}
// move to the next monomial of poly
poly ++;
pp ++;
}
}
/*
* 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);
}
}
int main(void) {
uint32_t i, j, n;
pprod_t *q;
init_pprod_table(&ptbl, 10);
init_pp_buffer(&buffer, 10);
p[0] = empty_pp;
p[1] = var_pp(0);
p[2] = var_pp(1);
p[3] = var_pp(2);
p[4] = var_pp(3);
num_prods = 5;
for (i=0; i<5; i++) {
for (j=0; j<5; j++) {
q = pprod_mul(&ptbl, p[i], p[j]);
print_pprod0(stdout, p[i]);
printf(" * ");
print_pprod0(stdout, p[j]);
printf(" = ");
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
}
}
n = num_prods;
for (i=0; i<n; i++) {
for (j=0; j<n; j++) {
q = pprod_mul(&ptbl, p[i], p[j]);
print_pprod0(stdout, p[i]);
printf(" * ");
print_pprod0(stdout, p[j]);
printf(" = ");
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
}
}
for (i=0; i<num_prods; i++) {
pp_buffer_set_pprod(&buffer, p[i]);
printf("p[%"PRIu32"] = %p = ", i, p[i]);
print_pprod0(stdout, p[i]);
printf("\n");
printf("buffer: ");
print_pp_buffer0(stdout, &buffer);
printf("\n");
q = pprod_from_buffer(&ptbl, &buffer);
printf("prod from buffer = %p = ", q);
print_pprod0(stdout, q);
if (q != p[i]) {
printf("BUG: HASH CONSING FAILED\n");
fflush(stdout);
abort();
}
printf("\n\n");
}
// delete the non-trivial products
for (i=5; i<num_prods; i++) {
q = p[i];
assert(q != empty_pp && q != end_pp && !pp_is_var(q));
printf("deleting p[%"PRIu32"] = %p = ", i, q);
print_pprod0(stdout, q);
printf("\n");
delete_pprod(&ptbl, q);
}
printf("\n\n");
p[5] = var_pp(4);
num_prods = 6;
// reconstruct more products
q = pprod_mul(&ptbl, p[1], p[2]);
printf("checking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[2], p[3]);
printf("checking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[3], p[2]);
printf("rechecking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[3], p[4]);
printf("checking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[4], p[3]);
printf("rechecking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[4], p[5]);
printf("checking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
q = pprod_mul(&ptbl, p[0], p[5]);
printf("checking q = %p = ", q);
print_pprod0(stdout, q);
printf("\n");
check_product(q);
printf("\n");
printf("*** Table content before GC ***\n");
print_pprod_table(stdout, &ptbl);
pprod_table_set_gc_mark(&ptbl, p[num_prods - 1]);
pprod_table_gc(&ptbl);
printf("\n*** Table content after GC ***\n");
print_pprod_table(stdout, &ptbl);
printf("\n");
delete_pp_buffer(&buffer);
delete_pprod_table(&ptbl);
return 0;
}
