static double compute_enode(enode *p, Value *list_args) {
int i;
Value m, param;
double res=0.0;
if (!p)
return(0.);
value_init(m);
value_init(param);
if (p->type == polynomial) {
if (p->size > 1)
value_assign(param,list_args[p->pos-1]);
/* Compute the polynomial using Horner's rule */
for (i=p->size-1;i>0;i--) {
res +=compute_evalue(&p->arr[i],list_args);
res *=VALUE_TO_DOUBLE(param);
}
res +=compute_evalue(&p->arr[0],list_args);
}
else if (p->type == periodic) {
value_assign(m,list_args[p->pos-1]);
/* Choose the right element of the periodic */
value_set_si(param,p->size);
value_pmodulus(m,m,param);
res = compute_evalue(&p->arr[VALUE_TO_INT(m)],list_args);
}
value_clear(m);
value_clear(param);
return res;
} /* compute_enode */
/**
* Given a system of equalities, looks if it has an integer solution in the
* combined space, and if yes, returns one solution.
* <p>pre-condition: the equalities are full-row rank (without the constant
* part)</p>
* @param Eqs the system of equations (as constraints)
* @param I a feasible integer solution if it exists, else NULL. Allocated if
* initially set to NULL, else reused.
*/
void Equalities_integerSolution(Matrix * Eqs, Matrix **I) {
Matrix * Hm, *H=NULL, *U, *Q, *M=NULL, *C=NULL, *Hi;
Matrix *Ip;
int i;
Value mod;
unsigned int rk;
if (Eqs==NULL){
if ((*I)!=NULL) Matrix_Free(*I);
I = NULL;
return;
}
/* we use: AI = C = (Ha 0).Q.I = (Ha 0)(I' 0)^T */
/* with I = Qinv.I' = U.I'*/
/* 1- compute I' = Hainv.(-C) */
/* HYP: the equalities are full-row rank */
rk = Eqs->NbRows;
Matrix_subMatrix(Eqs, 0, 1, rk, Eqs->NbColumns-1, &M);
left_hermite(M, &Hm, &Q, &U);
Matrix_Free(M);
Matrix_subMatrix(Hm, 0, 0, rk, rk, &H);
if (dbgCompParmMore) {
show_matrix(Hm);
show_matrix(H);
show_matrix(U);
}
Matrix_Free(Q);
Matrix_Free(Hm);
Matrix_subMatrix(Eqs, 0, Eqs->NbColumns-1, rk, Eqs->NbColumns, &C);
Matrix_oppose(C);
Hi = Matrix_Alloc(rk, rk+1);
MatInverse(H, Hi);
if (dbgCompParmMore) {
show_matrix(C);
show_matrix(Hi);
}
/* put the numerator of Hinv back into H */
Matrix_subMatrix(Hi, 0, 0, rk, rk, &H);
Ip = Matrix_Alloc(Eqs->NbColumns-2, 1);
/* fool Matrix_Product on the size of Ip */
Ip->NbRows = rk;
Matrix_Product(H, C, Ip);
Ip->NbRows = Eqs->NbColumns-2;
Matrix_Free(H);
Matrix_Free(C);
value_init(mod);
for (i=0; i< rk; i++) {
/* if Hinv.C is not integer, return NULL (no solution) */
value_pmodulus(mod, Ip->p[i][0], Hi->p[i][rk]);
if (value_notzero_p(mod)) {
if ((*I)!=NULL) Matrix_Free(*I);
value_clear(mod);
Matrix_Free(U);
Matrix_Free(Ip);
Matrix_Free(Hi);
I = NULL;
return;
}
else {
value_pdivision(Ip->p[i][0], Ip->p[i][0], Hi->p[i][rk]);
}
}
/* fill the rest of I' with zeros */
for (i=rk; i< Eqs->NbColumns-2; i++) {
value_set_si(Ip->p[i][0], 0);
}
value_clear(mod);
Matrix_Free(Hi);
/* 2 - Compute the particular solution I = U.(I' 0) */
ensureMatrix((*I), Eqs->NbColumns-2, 1);
Matrix_Product(U, Ip, (*I));
Matrix_Free(U);
Matrix_Free(Ip);
if (dbgCompParm) {
show_matrix(*I);
}
}
