void test_fold(void)
{
printf("\nfold dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dim_t dd[3];
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
do {
dd[0] = rand() % dim;
if (dd[0]<d.intdim) dd[1] = rand() % (d.intdim-1);
else dd[1] = d.intdim + rand() % (d.realdim-1);
}
while (dd[0]>=dd[1]);
pkr = ap_abstract0_fold(pk,false,pka,dd,2);
pplr = ap_abstract0_fold(ppl,false,ppla,dd,2);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"fold %i,%i,%i\n",(int)dd[0],(int)dd[1],(int)dd[2]);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_permute(void)
{
printf("\npermute dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dimperm_t* p = ap_dimperm_alloc(dim);
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
/* random permutation */
ap_dimperm_set_id(p);
for (i=0;i<p->size-1;i++) {
int a, j;
if (i<d.intdim) j = i + (rand() % (d.intdim-i));
else j = i + (rand() % (d.intdim+d.realdim-i));
a = p->dim[j]; p->dim[j] = p->dim[i]; p->dim[i] = a;
}
pkr = ap_abstract0_permute_dimensions(pk,false,pka,p);
pplr = ap_abstract0_permute_dimensions(ppl,false,ppla,p);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_dimperm_fprint(stderr,p);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_dimperm_free(p);
} ENDLOOP;
}
void test_box(void)
{
printf("\nbox conversion\n");
LOOP {
size_t i, dim = 5;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_interval_t** pki,**ppli;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pki = ap_abstract0_to_box(pk,pka);
ppli = ap_abstract0_to_box(ppl,ppla);
pkr = ap_abstract0_of_box(pk,0,dim,(ap_interval_t**)pki);
pplr = ap_abstract0_of_box(ppl,0,dim,(ap_interval_t**)ppli);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
for (i=0;i<dim;i++) {
fprintf(stderr,"pki[%i]=",(int)i); ap_interval_fprint(stderr,pki[i]);
fprintf(stderr," ppli[%i]=",(int)i); ap_interval_fprint(stderr,ppli[i]);
fprintf(stderr,"\n");
}
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_interval_array_free(pki,dim); ap_interval_array_free(ppli,dim);
} ENDLOOP;
}
static void poly_test(const char* a, const char* b)
{
poly_t* p; /* Polynomial made from A. */
poly_t* q; /* Polynomial made from B. */
poly_t* r; /* Product of P and Q. */
printf("\n-------------------------------------------------\n");
printf("[M] Beginning polynomial test of (%s) * (%s)\n", a, b);
printf("\n[M] Creating poly p:\n");
p = new_poly_from_string(a);
printf("\n[M] Creating poly q:\n");
q = new_poly_from_string(b);
printf("\n[M] Printing poly p:\n");
print_poly(p);
printf("\n[M] Printing poly q:\n");
print_poly(q);
printf("\n[M] Multiplying p and q:\n");
r = mul(p, q);
printf("\n[M] Printing poly r: ");
print_poly(r);
printf("\n[M] Freeing poly p, q, r:\n");
free_poly(p);
free_poly(q);
free_poly(r);
printf("\n[M] Ending polynomial test of (%s) * (%s)\n", a, b);
printf("-------------------------------------------------\n\n");
}
void test_forget(void)
{
printf("\nforget\n");
LOOP {
size_t i, dim = 5;
ap_dimchange_t* a = ap_dimchange_alloc(0,2);
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
int proj = rand()%2;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
for (i=0;i<a->intdim+a->realdim;i++) {
a->dim[i] = rand()%2 + 1;
if (i) a->dim[i] += a->dim[i-1];
if (a->dim[i]<d.intdim) { a->intdim++; a->realdim--; }
assert(a->dim[i]<dim);
}
pkr = ap_abstract0_forget_array(pk,false,pka,a->dim,a->realdim,proj);
pplr = ap_abstract0_forget_array(ppl,false,ppla,a->dim,a->realdim,proj);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_dimchange_fprint(stderr,a);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_dimchange_free(a);
} ENDLOOP;
}
void test_par_subst(void)
{
printf("\nparallel subst\n");
LOOP {
size_t i, dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dim_t d[NB];
ap_linexpr0_t *l[NB];
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<NB;i++) {
l[i] = random_linexpr(dim);
if (!i) d[i] = rand()%(dim-NB);
else d[i] = d[i-1] + 1 + (rand()%(dim-NB+i-d[i-1]));
}
pkr = ap_abstract0_substitute_linexpr_array(pk,false,pka,d,(ap_linexpr0_t**)l,NB,NULL);
pplr = ap_abstract0_substitute_linexpr_array(ppl,false,ppla,d,(ap_linexpr0_t**)l,NB,NULL);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
for (i=0;i<NB;i++) {
fprintf(stderr,"x%i -> ",d[i]);
ap_linexpr0_fprint(stderr,l[i],NULL);
fprintf(stderr,"\n");
}
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
for (i=0;i<NB;i++) ap_linexpr0_free(l[i]);
} ENDLOOP;
}
std::ostream& operator<<(std::ostream& s, const divisor& a)
{
s << "###" << endl;
s << "Divisor [u(x), v(x)] for Jacobian group of curve y^2 + h(x)*y = f(x)."
<< endl;
// print curve info
s << a.get_curve();
// print u, v
s << "[u(x), v(x)]:" << endl;
s << " u(x) = ";
print_poly(a.get_upoly(), &s);
s << " v(x) = ";
print_poly(a.get_vpoly(), &s);
// Is divisor valid?
if (a.is_valid_divisor())
s << " Divisor is valid" << endl;
else
s << " Divisor is invalid" << endl;
s << "###" << endl;
return s;
}
void test_add_lincons(void)
{
printf("\nadd lincons\n");
LOOP {
size_t i, dim = 5, nb = 4;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_lincons0_array_t ar = ap_lincons0_array_make(nb);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<nb;i++) {
ar.p[i] = ap_lincons0_make((rand()%100>=90)?AP_CONS_EQ:
(rand()%100>=90)?AP_CONS_SUP:AP_CONS_SUPEQ,
random_linexpr(dim),NULL);
}
pkr = ap_abstract0_meet_lincons_array(pk,false,pka,&ar);
pplr = ap_abstract0_meet_lincons_array(ppl,false,ppla,&ar);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_lincons0_array_fprint(stderr,&ar,NULL);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_lincons0_array_clear(&ar);
} ENDLOOP;
}
int main(int argc, char** argv){
poly_t* p;
poly_t* q;
p = new_poly_from_string("x^2 - 7x");
q = new_poly_from_string("x^3 + x");
print_poly(p);
print_poly(q);
}
// all elements of v should be in the same class: check wether that's true
// in the equality queue
static void check_good_class(test_bench_t *bench, int32_t *v) {
active_poly_table_t *table;
equality_queue_t *queue;
polynomial_t *p;
uint32_t i, n;
int32_t k, x, y;
queue = &bench->equeue;
table = &bench->act;
n = iv_size(v);
assert(n >= 2);
k = v[0];
assert(0 <= k && k < table->npolys);
x = table->id[k];
for (i=1; i<n; i++) {
k = v[i];
assert(0 <= k && k < table->npolys);
y = table->id[k];
if (root_of_var(queue, x) != root_of_var(queue, y)) {
printf("BUG: MISSED Propagation: x%"PRId32" and x%"PRId32" should be equal\n\n", x, y);
printf(" act[%"PRId32"]: x%"PRId32, v[0], x);
p = bench->ptable->poly[x];
if (p != NULL) {
printf(" = ");
print_poly(p);
}
printf("\n");
printf(" act[%"PRId32"]: x%"PRId32, k, y);
p = bench->ptable->poly[y];
if (p != NULL) {
printf(" = ");
print_poly(p);
}
printf("\n\n");
print_all_equalities(bench);
printf(" norm(x%"PRId32") = ", x);
print_normal_form(bench->act.norm[v[0]]);
printf("\n");
printf(" norm(x%"PRId32") = ", y);
print_normal_form(bench->act.norm[k]);
printf("\n\n");
fflush(stdout);
exit(1);
}
}
}
void test_csat(void)
{
printf("\nconstraint saturation\n");
LOOP {
size_t dim = 5;
ap_abstract0_t* pka,*ppla;
ap_lincons0_t l = ap_lincons0_make((rand()%100>=90)?AP_CONS_EQ:
(rand()%100>=90)?AP_CONS_SUP:AP_CONS_SUPEQ,
random_linexpr(dim),NULL);
bool pks,ppls;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pks = ap_abstract0_sat_lincons(pk,pka,&l);
ppls = ap_abstract0_sat_lincons(ppl,ppla,&l);
RESULT('*');
if (pks!=ppls) {
ERROR("different results");
print_poly("pka",pka);
ap_lincons0_fprint(stderr,&l,NULL);
fprintf(stderr,"\npks=%i ppls=%i\n",pks,ppls);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_lincons0_clear(&l);
} ENDLOOP;
}
void test_isat(void)
{
printf("\ninterval saturation\n");
LOOP {
size_t dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*ppla;
ap_interval_t* i = ap_interval_alloc();
bool pks,ppls;
random_interval(i);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pks = ap_abstract0_sat_interval(pk,pka,p,i);
ppls = ap_abstract0_sat_interval(ppl,ppla,p,i);
RESULT('*');
if (pks!=ppls) {
ERROR("different results");
print_poly("pka",pka);
ap_interval_fprint(stderr,i);
fprintf(stderr,"\nvar=%i\npks=%i ppls=%i\n",(int)p,pks,ppls);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_interval_free(i);
} ENDLOOP;
}
void test_lbound(void)
{
printf("\nlinear expression bound\n");
LOOP {
size_t dim = 5;
ap_abstract0_t* pka,*ppla;
ap_interval_t* pki,*ppli;
ap_linexpr0_t* l = random_linexpr(dim);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pki = ap_abstract0_bound_linexpr(pk,pka,l);
ppli = ap_abstract0_bound_linexpr(ppl,ppla,l);
RESULT('*');
if (ap_interval_cmp(pki,ppli)) {
ERROR("different results");
print_poly("pka",pka);
ap_linexpr0_fprint(stderr,l,NULL);
fprintf(stderr,"\npki="); ap_interval_fprint(stderr,pki);
fprintf(stderr,"\nppli="); ap_interval_fprint(stderr,ppli);
fprintf(stderr,"\n");
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_interval_free(pki); ap_interval_free(ppli);
ap_linexpr0_free(l);
} ENDLOOP;
}
void test_vbound(void)
{
printf("\nvariable bound\n");
LOOP {
size_t i, dim = 5;
ap_abstract0_t* pka,*ppla;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
RESULT('*');
for (i=0;i<dim;i++) {
bool pkd,ppld;
ap_interval_t* pki,*ppli;
pkd = ap_abstract0_is_dimension_unconstrained(pk,pka,i);
ppld = ap_abstract0_is_dimension_unconstrained(ppl,ppla,i);
pki = ap_abstract0_bound_dimension(pk,pka,i);
ppli = ap_abstract0_bound_dimension(ppl,ppla,i);
if (pkd!=ppld || ap_interval_cmp(pki,ppli)) {
ERROR("different results");
print_poly("pka",pka);
fprintf(stderr,"pki[%i]=",(int)i); ap_interval_fprint(stderr,pki);
fprintf(stderr," ppli[%i]=",(int)i); ap_interval_fprint(stderr,ppli);
fprintf(stderr," pkd=%i ppld=%i\n",pkd,ppld);
}
ap_interval_free(pki);
ap_interval_free(ppli);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
} ENDLOOP;
}
void test_conv(void)
{
int dim = 5;
printf("\nconversions\n");
LOOP {
ap_abstract0_t* pk0 = random_poly(pk,dim);
ap_abstract0_t* ppl0 = convert(ppl,pk0);
ap_abstract0_t* pk1 = convert(pk,ppl0);
ap_abstract0_t* ppl1 = convert(ppl,pk1);
RESULT('*');
if (!is_eq(pk0,pk1) || !is_eq(ppl0,ppl1)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("ppl0",ppl0);
print_poly("pk1",pk1); print_poly("ppl1",ppl1);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1);
} ENDLOOP;
}
void multiply_poly(void)
{
int n;
printf("Enter the maximum degree of your polynomials:\n");
scanf("%d", &n);
double f[n * 2 + 1], g[n + 1], h[n + 1];
scan_to_arr("Enter the coefficients of your first polynomial. Enter zero for values with no coefficients.", g, n);
print_poly(g, n);
scan_to_arr("Enter the coefficients of your second polynomial.", h, n);
print_poly(g, n);
mult(f, g, h, n);
printf("Result: \n");
print_poly(f, n * 2);
}
static void print_poly_def(poly_table_t *table, int32_t id) {
polynomial_t *p;
assert(0 <= id && id < table->npolys);
p = table->poly[id];
if (p != NULL) {
printf(" x%"PRId32" := ", id);
print_poly(p);
printf("\n");
}
}
void test_meet(void)
{
int dim = 4;
printf("\nbinary meet\n");
LOOP {
ap_abstract0_t* pk0 = random_poly(pk,dim);
ap_abstract0_t* pk1 = random_poly(pk,dim);
ap_abstract0_t* pkr = ap_abstract0_meet(pk,false,pk0,pk1);
ap_abstract0_t* ppl0 = convert(ppl,pk0);
ap_abstract0_t* ppl1 = convert(ppl,pk1);
ap_abstract0_t* pplr = ap_abstract0_meet(ppl,false,ppl0,ppl1);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("pk1",pk1);
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1); ap_abstract0_free(pk,pkr);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_meet_array(void)
{
int i,dim = 3;
printf("\narray meet\n");
LOOP {
ap_abstract0_t* pka[NB], *pkr;
ap_abstract0_t* ppla[NB], *pplr;
for (i=0;i<NB;i++) {
pka[i] = random_poly(pk,dim);
ppla[i] = convert(ppl,pka[i]);
}
pkr = ap_abstract0_meet_array(pk,(ap_abstract0_t**)pka,NB);
pplr = ap_abstract0_meet_array(ppl,(ap_abstract0_t**)ppla,NB);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
for (i=0;i<NB;i++) { ap_abstract0_free(pk,pka[i]); ap_abstract0_free(ppl,ppla[i]); }
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
static void print_poly_table(poly_table_t *table) {
polynomial_t *p;
uint32_t i, n;
n = table->npolys;
for (i=0; i<n; i++) {
p = table->poly[i];
if (p != NULL) {
printf(" x%"PRIu32" := ", i);
print_poly(p);
printf("\n");
}
}
}
void test_subst(void)
{
printf("\nsubst\n");
LOOP {
size_t i, dim = 5;
size_t p = rand() % dim;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_linexpr0_t* l = random_linexpr(dim);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
pkr = ap_abstract0_substitute_linexpr(pk,false,pka,p,l,NULL);
pplr = ap_abstract0_substitute_linexpr(ppl,false,ppla,p,l,NULL);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"x%i -> ",(int)p); ap_linexpr0_fprint(stderr,l,NULL); fprintf(stderr,"\n");
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_linexpr0_free(l);
} ENDLOOP;
}
int main()
{
polynomial poly1 = create_poly();
insert_node(poly1,10,1000);
insert_node(poly1,5,14);
insert_node(poly1,1,0);
print_poly(poly1);
polynomial poly2 = create_poly();
insert_node(poly2,3,1990);
insert_node(poly2,-2,14);
print_poly(poly2);
polynomial poly3 = create_poly();
add_polynomial(poly1,poly2,poly3);
print_poly(poly3);
/*free the memory*/
dispose_poly(poly1);
dispose_poly(poly2);
dispose_poly(poly3);
}
bool QCanvas::razor_Cazerlend_Hodzhmen(bool time_sleep)
{
if(obj_lines.isEmpty())
return false;
ssize_t direction_value;
if(!(direction_value = isConvex()))
return false;
else
if(direction_value < 0)
{
size_t size = obj_Polyhedrons.size();
for(size_t i = 0; i< size/2. ; ++i)
{
line_t line_tmp_1 = obj_Polyhedrons.value(i);
line_t line_tmp_2 = obj_Polyhedrons.value(size-1-i);
std::swap(line_tmp_1.S,line_tmp_1.F);
std::swap(line_tmp_2.S,line_tmp_2.F);
obj_Polyhedrons.replace(i,line_tmp_2);
obj_Polyhedrons.replace(size-1-i,line_tmp_1);
}
}
QVector< QVector<QPointF> > arr_poli;
QPointF start = obj_lines.first().S;
QVector<QPointF> tmp;
tmp.push_back(start);
for(size_t i = 0; i < obj_lines.size(); ++i)
if(obj_lines.value(i).F != tmp.first())
tmp.push_back(obj_lines.value(i).F);
else
{
arr_poli.push_back(tmp);
tmp.clear();
if(i+1 != obj_lines.size())
tmp.push_back(obj_lines.value(i+1).S);
else
break;
}
for(size_t i = 0; i< arr_poli.size(); ++i)
{
QVector<QPointF> tmp = arr_poli.value(i);
razor_CH(obj_Polyhedrons,tmp,false);
print_poly(tmp);
}
}
void test_expand(void)
{
printf("\nexpand dimensions\n");
LOOP {
size_t i, dim = 5;
ap_dim_t dd = rand() % dim;
size_t n = (rand() % 2) + 1;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_dimension_t d;
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
d = ap_abstract0_dimension(pk,pka);
pkr = ap_abstract0_expand(pk,false,pka,dd,n);
pplr = ap_abstract0_expand(ppl,false,ppla,dd,n);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
fprintf(stderr,"dim %i expanded %i times\n",(int)dd,(int)n);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
void test_widen(void)
{
int dim = 5;
printf("\nwidening\n");
LOOP {
ap_abstract0_t* pk0, *pk1, *pkr;
ap_abstract0_t* ppl0, *ppl1, *pplr;
pk0 = random_poly(pk,dim);
pk1 = random_poly(pk,dim);
pk1 = ap_abstract0_join(pk,true,pk1,pk0);
pkr = ap_abstract0_widening(pk,pk0,pk1);
ppl0 = convert(ppl,pk0);
ppl1 = convert(ppl,pk1);
pplr = ap_abstract0_widening(ppl,ppl0,ppl1);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
print_poly("pk0",pk0); print_poly("pk1",pk1);
print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pk0); ap_abstract0_free(pk,pk1); ap_abstract0_free(pk,pkr);
ap_abstract0_free(ppl,ppl0); ap_abstract0_free(ppl,ppl1); ap_abstract0_free(ppl,pplr);
} ENDLOOP;
}
static void poly_test(const char* a, const char* b)
{
poly_t* p; /* Polynomial made from A. */
poly_t* q; /* Polynomial made from B. */
poly_t* r; /* Product of P and Q. */
printf("Begin polynomial test of (%s) * (%s)\n", a, b);
p = new_poly_from_string(a);
q = new_poly_from_string(b);
print_poly(p);
print_poly(q);
r = mul(p, q);
print_poly(r);
free_poly(p);
free_poly(q);
free_poly(r);
printf("End polynomial test of (%s) * (%s)\n\n\n", a, b);
}
void test_add_ray(void)
{
printf("\nadd rays\n");
LOOP {
size_t i, dim = 4, nb = 4;
ap_abstract0_t* pka,*pkr, *ppla,*pplr;
ap_generator0_array_t ar = ap_generator0_array_make(nb);
pka = random_poly(pk,dim);
ppla = convert(ppl,pka);
for (i=0;i<nb;i++)
ar.p[i] = random_generator(dim,(rand()%100>=80)?AP_GEN_LINE:AP_GEN_RAY);
pkr = ap_abstract0_add_ray_array(pk,false,pka,&ar);
pplr = ap_abstract0_add_ray_array(ppl,false,ppla,&ar);
RESULT('*');
if (!is_eq(pkr,pplr)) {
ERROR("different results");
ap_generator0_array_fprint(stderr,&ar,NULL);
print_poly("pka",pka); print_poly("pkr",pkr); print_poly("pplr",pplr);
}
ap_abstract0_free(pk,pka); ap_abstract0_free(ppl,ppla);
ap_abstract0_free(pk,pkr); ap_abstract0_free(ppl,pplr);
ap_generator0_array_clear(&ar);
} ENDLOOP;
}
static void print_active_polys(test_bench_t *bench) {
polynomial_t *p;
uint32_t i, n;
int32_t idx;
n = bench->act.npolys;
for (i=0; i<n; i++) {
idx = bench->act.id[i];
printf(" act[%"PRIu32"]: x%"PRId32, i, idx);
p = bench->ptable->poly[idx];
if (p != NULL) {
printf(" = ");
print_poly(p);
}
printf("\n");
}
printf("\n");
}
int elim_2(fm_system* system){
unsigned int i, j;
//Sort
unsigned int* ns = sort_by_coeffs(system);
unsigned int n_pos = ns[0];
unsigned int n_neg = ns[1];
unsigned int n_zero = ns[2];
unsigned int n_non_zero = n_pos + n_neg;
fm_poly *tmp_poly;
fm_poly_entry tmp_poly_entry;
//Divide
for(i = 0; i < n_pos + n_neg; ++i){
tmp_poly = system->rows[i].lesser;
tmp_poly_entry = tmp_poly->poly[tmp_poly->poly_len - 1];
for(j = 0; j < tmp_poly->poly_len; ++j){
tmp_poly->poly[j].numerator = tmp_poly->poly[j].numerator * tmp_poly_entry.denominator;
tmp_poly->poly[j].denominator = tmp_poly->poly[j].denominator * tmp_poly_entry.numerator;
}
system->rows[i].greater->poly[0].numerator = system->rows[i].greater->poly[0].numerator * tmp_poly_entry.denominator;
system->rows[i].greater->poly[0].denominator = system->rows[i].greater->poly[0].denominator * tmp_poly_entry.numerator;
if((tmp_poly_entry.numerator < 0 && tmp_poly_entry.denominator > 0) || (tmp_poly_entry.numerator > 0 && tmp_poly_entry.denominator < 0)){
system->rows[i].lesser = system->rows[i].greater;
system->rows[i].greater = tmp_poly;
}
}
printf("\nDivide:\n");print_system(system);
//Isolate
fm_row *new_rows = (fm_row*) malloc(sizeof(fm_row)*n_non_zero);
fm_poly *new_poly = (fm_poly*) malloc(sizeof(fm_poly)*n_non_zero);
fm_poly_entry *new_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*system->nbr_rows*system->curr_nbr_x);
fm_poly *curr_poly;
printf("\nIsolate:\n");
for(i = 0; i < n_non_zero; ++i){
curr_poly = &(new_poly[i]);
curr_poly->poly_len = system->curr_nbr_x;
curr_poly->poly = &(new_entries[i*curr_poly->poly_len]);
if(system->rows[i].lesser->poly_len == 1 && system->rows[i].lesser->poly[0].index == 0){ //if lesser == const side
for(j=0; j < system->curr_nbr_x-1; ++j){
curr_poly->poly[j].numerator = -system->rows[i].greater->poly[j].numerator;
curr_poly->poly[j].denominator = system->rows[i].greater->poly[j].denominator;
curr_poly->poly[j].index = system->rows[i].greater->poly[j].index;
}
curr_poly->poly[j].numerator = system->rows[i].lesser->poly[0].numerator;
curr_poly->poly[j].denominator = system->rows[i].lesser->poly[0].denominator;
curr_poly->poly[j].index = system->rows[i].lesser->poly[0].index;
new_rows[i].greater = NULL;
new_rows[i].lesser = curr_poly;
} else {
for(j=0; j < system->curr_nbr_x-1; ++j){
curr_poly->poly[j].numerator = -system->rows[i].lesser->poly[j].numerator;
curr_poly->poly[j].denominator = system->rows[i].lesser->poly[j].denominator;
curr_poly->poly[j].index = system->rows[i].lesser->poly[j].index;
}
curr_poly->poly[j].numerator = system->rows[i].greater->poly[0].numerator;
curr_poly->poly[j].denominator = system->rows[i].greater->poly[0].denominator;
curr_poly->poly[j].index = system->rows[i].greater->poly[0].index;
new_rows[i].lesser = NULL;
new_rows[i].greater = curr_poly;
}
print_row(&(new_rows[i]));
}
//B's
fm_poly *b1 = (fm_poly*) malloc(sizeof(fm_poly)*(system->nbr_rows));
fm_poly *b2 = (fm_poly*) malloc(sizeof(fm_poly)*(system->nbr_rows));
unsigned int n_b1 = 0;
unsigned int n_b2 = 0;
for(i = 0; i < n_non_zero; ++i){
if(new_rows[i].lesser == NULL){
b2[n_b2++] = *(new_rows[i].greater);
} else {
b1[n_b1++] = *(new_rows[i].lesser);
}
}
printf("\nCreate b1:\n");
for(i = 0; i<n_b1;++i) {print_poly(&(b1[i])); printf("\n");}
printf("Create b2:\n");
for(i = 0; i<n_b2;++i) {print_poly(&(b2[i])); printf("\n");}
printf("#b1: %u\t #b2: %u\n", n_b1, n_b2);
//Merge b's
printf("\nMerge b*:\n");
fm_row *b_rows = (fm_row*) malloc(sizeof(fm_row)*(n_b1*n_b2+n_zero));
for(i = 0; i < n_b1; ++i){
for(j = 0; j < n_b2; ++j){
b_rows[i*n_b1+j].lesser = &(b1[i]);
b_rows[i*n_b1+j].greater = &(b2[j]);
}
}
for(i = 0; i < n_b1*n_b2; ++i) print_row(&(b_rows[i]));
//Add rows with 0 coeff
printf("\nAdd zero-coeff rows:\n");
i = n_b1*n_b2;
for(j = n_pos + n_neg; j < system->nbr_rows; ++j){
b_rows[i] = system->rows[j];
b_rows[i].lesser->poly_len = system->curr_nbr_x-1;
++i;
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
//Simplify
printf("\nSimplify:\n");
fm_poly_entry *great_e, *less_e;
for(i = 0; i < n_b1*n_b2+n_zero; ++i){
//Move non-constants to lesser side
for(j = 0; j < b_rows[i].greater->poly_len-1; ++j){
great_e = &(b_rows[i].greater->poly[j]);
less_e = &(b_rows[i].lesser->poly[j]);
printf("(%lld/%lld) - (%lld/%lld) = ", less_e->numerator, less_e->denominator, great_e->numerator, great_e->denominator);
less_e->numerator = less_e->numerator*great_e->denominator - great_e->numerator*less_e->denominator;
less_e->denominator = less_e->denominator*great_e->denominator;
printf("(%lld/%lld)\n\n", less_e->numerator, less_e->denominator);
great_e->numerator = 0;
great_e->denominator = 1;
}
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
for(i = 0; i < n_b1*n_b2+n_zero; ++i){
//Move constants to greater side
great_e = &(b_rows[i].greater->poly[b_rows[i].greater->poly_len-1]);
less_e = &(b_rows[i].lesser->poly[b_rows[i].greater->poly_len-1]);
great_e->numerator = great_e->numerator*less_e->denominator - less_e->numerator*great_e->denominator;
great_e->denominator = great_e->denominator*less_e->denominator;
}
for(i = 0; i < n_b1*n_b2+n_zero; ++i) print_row(&(b_rows[i]));
printf("elim_2 done\n");
return 7;
}
int f_m_elim(fm_system* system){
return 5;
unsigned int r = system->nbr_rows;
unsigned int s = system->curr_nbr_x;
unsigned int s2;
printf("sizeof(fm_poly_entry): %llu\n", (unsigned long long) sizeof(fm_poly_entry));
printf("system->nbr_rows: %u\n", system->nbr_rows);
printf("system->nbr_x: %u\n", system->nbr_x);
printf("system->curr_nbr_x: %u\n", system->curr_nbr_x);
fm_poly_entry* t = (fm_poly_entry*)malloc(sizeof(fm_poly_entry)*system->nbr_rows*system->nbr_x);
fm_poly_entry* q = (fm_poly_entry*)malloc(sizeof(fm_poly_entry)*system->nbr_rows);
unsigned int i, j, n1, n2;
unsigned int* ns;
fm_poly_entry entry;
fm_poly *b1, *b2;
fm_row row;
fm_poly *poly_lesser, *poly_greater;
for(i = 0; i < system->nbr_rows; ++i){
row = system->rows[i];
poly_lesser = row.lesser;
poly_greater = row.greater;
if(poly_lesser->poly_len == 1 && poly_lesser->poly[0].index == 0){ //lesser == const side
for(j = 0; j < system->nbr_x; ++j){
t[i + j] = poly_greater->poly[j];
}
q[i] = poly_lesser->poly[0];
} else if(poly_greater->poly_len == 1 && poly_greater->poly[0].index == 0){ //greater == const side
for(j = 0; j < system->nbr_x; ++j){
t[i + j] = poly_lesser->poly[j];
}
q[i] = poly_greater->poly[0];
}
}
while(1){
ns = sort_by_coeffs(system);
n1 = ns[0];
n2 = n1 + ns[1];
for(i = 0; i < r - 1; ++i){
for(j = 0; j < n2; ++j){
entry = t[i + j];
entry.numerator = entry.numerator * t[r + j].denominator;
entry.denominator = entry.denominator * t[r + j].numerator;
}
}
for(j = 0; j < n2; ++j){
entry = q[j];
entry.numerator = entry.numerator * t[r + j].denominator;
entry.denominator = entry.denominator * t[r + j].numerator;
}
printf("B1:\n");
if(n2 > n1){
int c = 0;
b1 = (fm_poly*)malloc(sizeof(fm_poly)*(n2 - (n1)));
//b1->poly_len = 0;
for(j = n1; j < n2; ++j){
fm_poly_entry* tmp = malloc(sizeof(fm_poly_entry)*(r+1));
for(i = 0; i < r - 1; ++i){
tmp[i] = t[i + j]; //TODO: neg?
}
tmp[i+1] = q[j];
b1[c].poly_len = r - 1;
b1[c].poly = tmp;
c++;
}
print_poly(&(b1[c]));
//free(tmp);
}else{
b1 = NULL;
}
printf("B2:\n");
if(n1 > 0){
int c = 0;
b2 = (fm_poly*)malloc(sizeof(fm_poly)*(n1));
//b2->poly_len = 0;
for(j = 0; j < n1; ++j){
fm_poly_entry* tmp = malloc(sizeof(fm_poly_entry)*(r+1));
for(i = 0; i < r - 1; ++i){
tmp[i] = t[i + j]; //TODO: neg?
}
tmp[i+1] = q[j];
b2[c].poly_len = r - 1;
b2[c].poly = tmp;
c++;
}
print_poly(&(b2[c]));
}else{
b2 = NULL;
}
if(r == 1){
if((b1 != NULL && b2 != NULL) && (b1[0].poly->numerator * b2[0].poly->denominator) > (b2[0].poly->numerator * b1[0].poly->denominator)){
return 0;
}
for(j = n2; j < s; ++j){
if(q[j].numerator < 0){
return 0;
}
}
return 1;
}
s2 = s - n2 + n1 * (n2 - n1);
if(s2 == 0){
return 1;
}
//s - n2 + n1n2 -n1n1
//n2
r--;
s = s2;
//fm_row *b_combined_rows = (fm_row*) malloc(sizeof(fm_row)*n1*(n2-n1)); //TODO: wutwutwut
fm_row *b_combined_rows = (fm_row*) malloc(sizeof(fm_row)*s);
fm_poly l, g;
unsigned int k, row_count;
row_count = 0;
fm_row *tmp_test_row = (fm_row*) malloc(sizeof(fm_row));
for(i = 0; i < (n2-n1); ++i){
for(j = 0; j < n1; ++j){
l = b1[i];
g = b2[j];
tmp_test_row->lesser = &l;
tmp_test_row->greater = &g;
printf("tem test? ");
print_row(tmp_test_row);
fm_poly *poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly_entry *entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*(l.poly_len-1));
for(k = 0; k < l.poly_len - 2; ++k){
fm_poly_entry pe_l = l.poly[k];
fm_poly_entry pe_g = g.poly[k];
fm_poly_entry *tmp_entry = &(entries[k]);
tmp_entry->numerator = pe_l.numerator * pe_g.denominator - pe_g.numerator * pe_l.denominator;
tmp_entry->denominator = pe_l.denominator * pe_g.denominator;
tmp_entry->index = pe_g.index;
}
poly->poly = entries;
poly->poly_len = k;
b_combined_rows[row_count].lesser = poly;
fm_poly_entry pe_l = l.poly[k];
fm_poly_entry pe_g = g.poly[k];
poly = (fm_poly*) malloc(sizeof(fm_poly));
poly->poly = (fm_poly_entry*) malloc(sizeof(fm_poly_entry));
poly->poly_len = 1;
b_combined_rows[row_count].greater = poly;
poly->poly[0].numerator = pe_l.numerator * pe_g.denominator - pe_g.numerator * pe_l.denominator;
poly->poly[0].denominator = pe_l.denominator * pe_g.denominator;
poly->poly[0].index = pe_g.index;
printf("comb rows \n");
print_row(b_combined_rows);
row_count++;
}
for(i = n2; i < s; ++i){
b_combined_rows[row_count].lesser = system->rows[i].lesser;
b_combined_rows[row_count].greater = system->rows[i].greater;
print_row(b_combined_rows);
row_count++;
}
}
system->rows = b_combined_rows;
printf("Changed system?!?!?!?\n");
print_system(system);
/*
typedef struct {
long long numerator;
long long denominator;
unsigned long long index; // 14*x_{index} + -2x_{index} <= 68. 0 designates no x variable
} fm_poly_entry;
typedef struct {
unsigned int poly_len;
fm_poly_entry *poly;
} fm_poly;
typedef struct {
fm_poly *lesser;
fm_poly *greater;
} fm_row;
typedef struct{
unsigned int nbr_rows;
unsigned int nbr_x; //largest x index in system
unsigned int curr_nbr_x; //current largest x index, changes with elimination
fm_row* rows;
} fm_system;
*/
/*
fm_poly *b_combined = (fm_poly*) malloc(sizeof(fm_poly)*s);
fm_poly_entry b_constants
*/
/*///////////////////////////
fm_poly_entry *t_ik;
fm_poly_entry *t_il;
fm_poly_entry *q_k;
fm_poly_entry *q_l;
unsigned int k, l;
fm_poly_entry *new_t = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*(r-1)*s2);
fm_poly_entry *new_q = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*s2);
fm_poly_entryb1plusb2 =
for(i = 0; i < r - 1; ++i){
for(k = 0; k < n1; ++k){
for(l = n1; l < n2; ++l){
t_ik = t[i + k];
t_il = t[i + l];
q_k = q[k];
q_l = q[l];
//TODO: wut?
new_t[ + i].numerator = (t_ik->numerator * t_il->denominator) - (t_il->numerator * t_ik->denominator);
new_t[ + i].denominator = t_ik->denominator * t_il->denominator;
new_t[ + i].index = i;
new_q[].numerator = (q_k->numerator * q_l->denominator) - (q_l->numerator * q_k->denominator);
new_q[].denominator = q_k->denominator * q_l->denominator;
new_q[].index = 0;
}
}
for(j = n2; j < s2; ++j){
new_t[].numerator = t[i +j].numerator;
new_t[].denominator = t[i +j].denominator;
new_t[].index = t[i +j].index;
new_q[].numerator = q[j].numerator;
new_q[].denominator = q[j].denominator;
new_q[].index = 0;
}
}
//TODO: move up
r--;
s = s2;
*/
/*
fm_poly_entry *new_t = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*r*s);
fm_poly_entry *new_q = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*s);
fm_row *new_rows = (fm_row*) malloc(sizeof(fm_row)*s);
for(j = 0; j < s; ++j){
fm_poly *lesser_poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly *greater_poly = (fm_poly*) malloc(sizeof(fm_poly));
fm_poly_entry *lesser_poly_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry)*r);
fm_poly_entry *greater_poly_entries = (fm_poly_entry*) malloc(sizeof(fm_poly_entry));
lesser_poly->poly_len = r;
greater_poly->poly_len = 1;
lesser_poly->poly = lesser_poly_entries;
greater_poly->poly = greater_poly_entries;
new_rows[j].lesser = lesser_poly;
new_rows[j].greater = greater_poly;
//memcpy(&(greater_poly->poly[0]), &(q[j]), sizeof(fm_poly_entry));
greater_poly->poly[0].numerator = q[j].numerator;
greater_poly->poly[0].denominator = q[j].denominator;
greater_poly->poly[0].index = q[j].index;
//memcpy(&(new_q[j]), &(q[j]), sizeof(fm_poly_entry));
new_q[j].numerator = q[j].numerator;
new_q[j].denominator = q[j].denominator;
new_q[j].index = q[j].index;
for(i = 0; i < r; ++i){
//memcpy(&(lesser_poly->poly[0]), &(t[i+j]), sizeof(fm_poly_entry));
lesser_poly->poly[0].numerator = t[i+j].numerator;
lesser_poly->poly[0].denominator = t[i+j].denominator;
lesser_poly->poly[0].index = t[i+j].index;
//memcpy(&(new_t[i+j]), &(t[i+j]), sizeof(fm_poly_entry));
new_t[i+j].numerator = t[i+j].numerator;
new_t[i+j].denominator = t[i+j].denominator;
new_t[i+j].index = t[i+j].index;
}
printf("ROW: ");
print_row(&(new_rows[j]));
}
//TODO: Free old t&&q
//t = new_t;
//q = new_q;
printf("SYSTEM #1?\n");
print_system(system);
system->nbr_rows = r;
system->curr_nbr_x -= 1;
system->rows = new_rows;
printf("SYSTEM #2?\n");
print_system(system);
*/
}
}
