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); */ } }