POLY Inverse_Poly ( int n, POLY M[n][n] )
{
POLY P[n][n], Q[n][n], t_M1[n][n], t_M2[n][n];
POLY ds;
int i, j, dk, dl, dgcd, dc_gcd, dad, dbd;
dcmplx **gcd_coeff, tmp;
copy(n, n, M, t_M1);
Smith(n, n, t_M1, P, Q);
/* printf("the smith form is:\n"); print1(n, n, t_M1); */
ds=assign_poly(t_M1[n-1][n-1]);
for( i=0; i<n-1; i++ )
{
gcd_coeff = ExtPolyGcd(ds.d+1, ds.p, t_M1[i][i].d+1, t_M1[i][i].p, &dgcd, &dk, &dl, &dbd, &dad);
free(t_M1[i][i].p);
t_M1[i][i].d = dad;
t_M1[i][i].p = assign(dad,gcd_coeff[4]);
for( j=0; j<5; j++)
free(gcd_coeff[j]);
free(gcd_coeff);
}
free(t_M1[n-1][n-1].p);
t_M1[n-1][n-1].p = (dcmplx*) calloc(1, sizeof(dcmplx));
t_M1[n-1][n-1].d = 0;
t_M1[n-1][n-1].p[0] = one;
/* calculate ds*Q*(t_M1's inverse) * P = ds*M */
Multiply( n, n, n, Q, t_M1, t_M2 );
free_matrix ( n, n, M );
Multiply( n, n, n, t_M2, P, M );
if(ds.p[ds.d].re<0)
{
negative(ds.d, ds.p);
neg_polymatrix( n, n, M );
}
/* make the leading coefficient of ds one */
tmp = ds.p[ds.d];
divide_by_number(ds.d, ds.p, tmp);
for(i=0; i<n; i++)
for(j=0; j<n; j++)
{
divide_by_number(M[i][j].d, M[i][j].p, tmp);
}
/* printf("ds="); Print_Poly(ds.d , ds.p); */
free_matrix ( n, n, t_M1 );
free_matrix ( n, n, t_M2 );
free_matrix ( n, n, P );
free_matrix ( n, n, Q );
return ds;
}
int main(){
int n;
while(scanf("%d",&n)!=EOF&&n){
while(n++){
if(Smith(n)){
printf("%d\n",n);
break;
}
}
}
return 0;
}
void renderScene(void)
{
static int i = 0;
glClear(GL_COLOR_BUFFER_BIT);
glColor3f(0.0,0.0,1.0);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
setWindow(-1+dx,1+dx,-1+dy,1+dy);
setViewport(0,100,0,100);
renderPointList();
setWindow(0,1,0,1);
setViewport(100,200,0,100);
renderLogicDiagram(0.1,0.7);
setWindow(0.0,4.0,0.0,4.0);
setViewport(200,300,0,100);
renderClip();
glColor3f(0.0,0.0,1.0);
setWindow(-1,1,-1,1);
setViewport(300,400,0,100);
renderArc1(0.4,0.4);
setViewport(400,500,0,100);
renderArc2(0.4,0.4);
setViewport(500,600,0,100);
renderArc3(0.4,0.4,0.8);
setWindow(-5.0,5.0,-5.0,5.0);
setViewport(0,100,100,200);
ElectrostaticField(2.0,2.0,1.0);
setWindow(-5.0,5.0,-5.0,5.0);
setViewport(0,100,200,300);
Smith();
setWindow(-0.5,0.5,-0.5,0.5);
Layout(50,50,10,10);
glFlush();
}
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;
}
