int main() { Matrix *a, *b; Polyhedron *A, *B; Param_Polyhedron *PA; const char **param_name; a = Matrix_Read(); A = Constraints2Polyhedron(a,200); Matrix_Free(a); b = Matrix_Read(); B = Constraints2Polyhedron(b,200); Matrix_Free(b); /* Read the name of the parameters */ param_name = Read_ParamNames(stdin,B->Dimension); PA = Polyhedron2Param_Vertices(A,B,500); Param_Vertices_Print(stdout,PA->V,param_name); Domain_Free(A); Domain_Free(B); Param_Polyhedron_Free( PA ); free(param_name); return 0; } /* main */
int main(int argc, char **argv) { int i; char str[1024]; Matrix *C1, *P1; Polyhedron *C, *P; Enumeration *en; const char **param_name; int c, ind = 0; int hom = 0; #ifdef EP_EVALUATION Value *p, *tmp; int k; #endif while ((c = getopt_long(argc, argv, "h", options, &ind)) != -1) { switch (c) { case 'h': hom = 1; break; } } P1 = Matrix_Read(); C1 = Matrix_Read(); if(C1->NbColumns < 2) { fprintf( stderr, "Not enough parameters !\n" ); exit(0); } if (hom) { Matrix *C2, *P2; P2 = AddANullColumn(P1); Matrix_Free(P1); P1 = P2; C2 = AddANullColumn(C1); Matrix_Free(C1); C1 = C2; } P = Constraints2Polyhedron(P1,WS); C = Constraints2Polyhedron(C1,WS); Matrix_Free(P1); Matrix_Free(C1); /* Read the name of the parameters */ param_name = Read_ParamNames(stdin,C->Dimension - hom); if (hom) { const char **param_name2; param_name2 = (const char**)malloc(sizeof(char*) * (C->Dimension)); for (i = 0; i < C->Dimension - 1; i++) param_name2[i] = param_name[i]; param_name2[C->Dimension-1] = "_H"; free(param_name); param_name=param_name2; } en = Polyhedron_Enumerate(P,C,WS,param_name); if (hom) { Enumeration *en2; printf("inhomogeneous form:\n"); dehomogenize_enumeration(en, C->Dimension, WS); for (en2 = en; en2; en2 = en2->next) { Print_Domain(stdout, en2->ValidityDomain, param_name); print_evalue(stdout, &en2->EP, param_name); } } #ifdef EP_EVALUATION if( isatty(0) && C->Dimension != 0) { /* no tty input or no polyhedron -> no evaluation. */ printf("Evaluation of the Ehrhart polynomial :\n"); p = (Value *)malloc(sizeof(Value) * (C->Dimension)); for(i=0;i<C->Dimension;i++) value_init(p[i]); FOREVER { fflush(stdin); printf("Enter %d parameters : ",C->Dimension); for(k=0;k<C->Dimension;++k) { scanf("%s",str); value_read(p[k],str); } fprintf(stdout,"EP( "); value_print(stdout,VALUE_FMT,p[0]); for(k=1;k<C->Dimension;++k) { fprintf(stdout,","); value_print(stdout,VALUE_FMT,p[k]); } fprintf(stdout," ) = "); value_print(stdout,VALUE_FMT,*(tmp=compute_poly(en,p))); free(tmp); fprintf(stdout,"\n"); } }
int main( int argc, char **argv) { int i; const char **param_name; Matrix *C1, *P1; Polyhedron *P, *C; Enumeration *e, *en; Matrix * Validity_Lattice; int nb_parms; #ifdef EP_EVALUATION Value *p, *tmp; int k; #endif P1 = Matrix_Read(); C1 = Matrix_Read(); nb_parms = C1->NbColumns-2; if(nb_parms < 0) { fprintf( stderr, "Not enough parameters !\n" ); exit(0); } /* Read the name of the parameters */ param_name = Read_ParamNames(stdin,nb_parms); /* inflate the polyhedron, so that the inflated EP approximation will be an upper bound for the EP's polyhedron. */ mpolyhedron_deflate(P1,nb_parms); /* compute a polynomial approximation of the Ehrhart polynomial */ e = Ehrhart_Quick_Apx(P1, C1, &Validity_Lattice, 1024); Matrix_Free(C1); Matrix_Free(P1); printf("============ Ehrhart polynomial quick polynomial lower bound ============\n"); show_matrix(Validity_Lattice); for( en=e ; en ; en=en->next ) { Print_Domain(stdout,en->ValidityDomain, param_name); print_evalue(stdout,&en->EP, param_name); printf( "\n-----------------------------------\n" ); } #ifdef EP_EVALUATION if( isatty(0) && nb_parms != 0) { /* no tty input or no polyhedron -> no evaluation. */ printf("Evaluation of the Ehrhart polynomial :\n"); p = (Value *)malloc(sizeof(Value) * (nb_parms)); for(i=0;i<nb_parms;i++) value_init(p[i]); FOREVER { fflush(stdin); printf("Enter %d parameters : ",nb_parms); for(k=0;k<nb_parms;++k) { scanf("%s",str); value_read(p[k],str); } fprintf(stdout,"EP( "); value_print(stdout,VALUE_FMT,p[0]); for(k=1;k<nb_parms;++k) { fprintf(stdout,","); value_print(stdout,VALUE_FMT,p[k]); } fprintf(stdout," ) = "); value_print(stdout,VALUE_FMT,*(tmp=compute_poly(en,p))); free(tmp); fprintf(stdout,"\n"); } }
int main(int argc, char **argv) { isl_ctx *ctx; int i, nbPol, nbVec, nbMat, func, j, n; Polyhedron *A, *B, *C, *D, *E, *F, *G; char s[128]; struct barvinok_options *options = barvinok_options_new_with_defaults(); argc = barvinok_options_parse(options, argc, argv, ISL_ARG_ALL); ctx = isl_ctx_alloc_with_options(&barvinok_options_args, options); nbPol = nbVec = nbMat = 0; fgets(s, 128, stdin); while ((*s=='#') || ((sscanf(s, "D %d", &nbPol) < 1) && (sscanf(s, "V %d", &nbVec) < 1) && (sscanf(s, "M %d", &nbMat) < 1))) fgets(s, 128, stdin); for (i = 0; i < nbPol; ++i) { Matrix *M = Matrix_Read(); A = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); fgets(s, 128, stdin); while ((*s=='#') || (sscanf(s, "F %d", &func)<1)) fgets(s, 128, stdin); switch(func) { case 0: { Value cb, ck; value_init(cb); value_init(ck); fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; while ((*s=='#') || (value_read(ck, s) != 0)) { fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; } barvinok_count_with_options(A, &cb, options); if (value_ne(cb, ck)) return -1; value_clear(cb); value_clear(ck); break; } case 1: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = Polyhedron_Polar(A, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, B); C = Polyhedron_Polar(B, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, C); Polyhedron_Free(C); Polyhedron_Free(B); break; case 2: Polyhedron_Print(stdout, P_VALUE_FMT, A); for (j = 0; j < A->NbRays; ++j) { B = supporting_cone(A, j); Polyhedron_Print(stdout, P_VALUE_FMT, B); Polyhedron_Free(B); } break; case 3: Polyhedron_Print(stdout, P_VALUE_FMT, A); C = B = NULL; barvinok_decompose(A,&B,&C); puts("Pos:"); Polyhedron_Print(stdout, P_VALUE_FMT, B); puts("Neg:"); Polyhedron_Print(stdout, P_VALUE_FMT, C); Domain_Free(B); Domain_Free(C); break; case 4: { Value cm, cb; struct tms tms_before, tms_between, tms_after; value_init(cm); value_init(cb); Polyhedron_Print(stdout, P_VALUE_FMT, A); times(&tms_before); manual_count(A, &cm); times(&tms_between); barvinok_count(A, &cb, 100); times(&tms_after); printf("manual: "); value_print(stdout, P_VALUE_FMT, cm); puts(""); time_diff(&tms_before, &tms_between); printf("Barvinok: "); value_print(stdout, P_VALUE_FMT, cb); puts(""); time_diff(&tms_between, &tms_after); value_clear(cm); value_clear(cb); break; } case 5: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = triangulate_cone(A, 100); Polyhedron_Print(stdout, P_VALUE_FMT, B); check_triangulization(A, B); Domain_Free(B); break; case 6: Polyhedron_Print(stdout, P_VALUE_FMT, A); B = remove_equalities(A, options->MaxRays); Polyhedron_Print(stdout, P_VALUE_FMT, B); Polyhedron_Free(B); break; case 8: { evalue *EP; Matrix *M = Matrix_Read(); const char **param_name; C = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); Polyhedron_Print(stdout, P_VALUE_FMT, A); Polyhedron_Print(stdout, P_VALUE_FMT, C); EP = barvinok_enumerate_with_options(A, C, options); param_name = Read_ParamNames(stdin, C->Dimension); print_evalue(stdout, EP, (const char**)param_name); evalue_free(EP); Polyhedron_Free(C); } case 9: Polyhedron_Print(stdout, P_VALUE_FMT, A); Polyhedron_Polarize(A); C = B = NULL; barvinok_decompose(A,&B,&C); for (D = B; D; D = D->next) Polyhedron_Polarize(D); for (D = C; D; D = D->next) Polyhedron_Polarize(D); puts("Pos:"); Polyhedron_Print(stdout, P_VALUE_FMT, B); puts("Neg:"); Polyhedron_Print(stdout, P_VALUE_FMT, C); Domain_Free(B); Domain_Free(C); break; case 10: { evalue *EP; Value cb, ck; value_init(cb); value_init(ck); fgets(s, 128, stdin); sscanf(s, "%d", &n); for (j = 0; j < n; ++j) { Polyhedron *P; M = Matrix_Read(); P = Constraints2Polyhedron(M, options->MaxRays); Matrix_Free(M); A = DomainConcat(P, A); } fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; while ((*s=='#') || (value_read(ck, s) != 0)) { fgets(s, 128, stdin); /* workaround for apparent bug in older gmps */ *strchr(s, '\n') = '\0'; } C = Universe_Polyhedron(0); EP = barvinok_enumerate_union(A, C, options->MaxRays); value_set_double(cb, compute_evalue(EP, &ck)+.25); if (value_ne(cb, ck)) return -1; Domain_Free(C); value_clear(cb); value_clear(ck); evalue_free(EP); break; } case 11: { isl_space *dim; isl_basic_set *bset; isl_pw_qpolynomial *expected, *computed; unsigned nparam; expected = isl_pw_qpolynomial_read_from_file(ctx, stdin); nparam = isl_pw_qpolynomial_dim(expected, isl_dim_param); dim = isl_space_set_alloc(ctx, nparam, A->Dimension - nparam); bset = isl_basic_set_new_from_polylib(A, dim); computed = isl_basic_set_lattice_width(bset); computed = isl_pw_qpolynomial_sub(computed, expected); if (!isl_pw_qpolynomial_is_zero(computed)) return -1; isl_pw_qpolynomial_free(computed); break; } case 12: { Vector *sample; int has_sample; fgets(s, 128, stdin); sscanf(s, "%d", &has_sample); sample = Polyhedron_Sample(A, options); if (!sample && has_sample) return -1; if (sample && !has_sample) return -1; if (sample && !in_domain(A, sample->p)) return -1; Vector_Free(sample); } } Domain_Free(A); } for (i = 0; i < nbVec; ++i) { int ok; Vector *V = Vector_Read(); Matrix *M = Matrix_Alloc(V->Size, V->Size); Vector_Copy(V->p, M->p[0], V->Size); ok = unimodular_complete(M, 1); assert(ok); Matrix_Print(stdout, P_VALUE_FMT, M); Matrix_Free(M); Vector_Free(V); } for (i = 0; i < nbMat; ++i) { Matrix *U, *V, *S; Matrix *M = Matrix_Read(); Smith(M, &U, &V, &S); Matrix_Print(stdout, P_VALUE_FMT, U); Matrix_Print(stdout, P_VALUE_FMT, V); Matrix_Print(stdout, P_VALUE_FMT, S); Matrix_Free(M); Matrix_Free(U); Matrix_Free(V); Matrix_Free(S); } isl_ctx_free(ctx); return 0; }