param_util.c

   1 #include <assert.h>
   2 #include <barvinok/options.h>
   3 #include "param_util.h"
   4 #include "topcom.h"
   5 #include "config.h"
   6
   7 #define ALLOC(type) (type*)malloc(sizeof(type))
   8 #define ALLOCN(type,n) (type*)malloc((n) * sizeof(type))
   9
  10 void Param_Vertex_Common_Denominator(Param_Vertices *V)
  11 {
  12     unsigned dim;
  13     Value lcm;
  14     int i;
  15
  16     assert(V->Vertex->NbRows > 0);
  17     dim = V->Vertex->NbColumns-2;
  18
  19     value_init(lcm);
  20
  21     value_assign(lcm, V->Vertex->p[0][dim+1]);
  22     for (i = 1; i < V->Vertex->NbRows; ++i)
  23         value_lcm(lcm, V->Vertex->p[i][dim+1], lcm);
  24
  25     for (i = 0; i < V->Vertex->NbRows; ++i) {
  26         if (value_eq(V->Vertex->p[i][dim+1], lcm))
  27             continue;
  28         value_division(V->Vertex->p[i][dim+1], lcm, V->Vertex->p[i][dim+1]);
  29         Vector_Scale(V->Vertex->p[i], V->Vertex->p[i],
  30                      V->Vertex->p[i][dim+1], dim+1);
  31         value_assign(V->Vertex->p[i][dim+1], lcm);
  32     }
  33
  34     value_clear(lcm);
  35 }
  36
  37 /* Plug in the parametric vertex Vertex (nvar x (nparam + 2))
  38  * in the constraint constraint (1 + nvar + nparam + 1).
  39  * The result is stored in row (1 + nparam + 1),
  40  * with the denominator in position 0.
  41  */
  42 void Param_Inner_Product(Value *constraint, Matrix *Vertex, Value *row)
  43 {
  44     unsigned nparam = Vertex->NbColumns - 2;
  45     unsigned nvar = Vertex->NbRows;
  46     int j;
  47     Value tmp, tmp2;
  48
  49     value_set_si(row[0], 1);
  50     Vector_Set(row+1, 0, nparam+1);
  51
  52     value_init(tmp);
  53     value_init(tmp2);
  54
  55     for (j = 0 ; j < nvar; ++j) {
  56         value_set_si(tmp, 1);
  57         value_assign(tmp2,  constraint[1+j]);
  58         if (value_ne(row[0], Vertex->p[j][nparam+1])) {
  59             value_assign(tmp, row[0]);
  60             value_lcm(row[0], row[0], Vertex->p[j][nparam+1]);
  61             value_division(tmp, row[0], tmp);
  62             value_multiply(tmp2, tmp2, row[0]);
  63             value_division(tmp2, tmp2, Vertex->p[j][nparam+1]);
  64         }
  65         Vector_Combine(row+1, Vertex->p[j], row+1, tmp, tmp2, nparam+1);
  66     }
  67     value_set_si(tmp, 1);
  68     Vector_Combine(row+1, constraint+1+nvar, row+1, tmp, row[0], nparam+1);
  69
  70     value_clear(tmp);
  71     value_clear(tmp2);
  72 }
  73
  74 static Param_Polyhedron *PL_P2PP(Polyhedron *Din, Polyhedron *Cin,
  75                                               struct barvinok_options *options)
  76 {
  77     unsigned MaxRays = options->MaxRays;
  78     if (MaxRays & (POL_NO_DUAL | POL_INTEGER))
  79         MaxRays = 0;
  80     return Polyhedron2Param_Domain(Din, Cin, MaxRays);
  81 }
  82
  83 /* Compute a dummy Param_Domain that contains all vertices of Param_Domain D
  84  * (which contains the vertices of P) that lie on the facet obtained by
  85  * saturating constraint c of P
  86  */
  87 Param_Domain *Param_Polyhedron_Facet(Param_Polyhedron *PP, Param_Domain *D,
  88                                      Polyhedron *P, int c)
  89 {
  90     int nv;
  91     Param_Vertices *V;
  92     unsigned nparam = PP->V->Vertex->NbColumns-2;
  93     Vector *row = Vector_Alloc(1+nparam+1);
  94     Param_Domain *FD = ALLOC(Param_Domain);
  95     FD->Domain = 0;
  96     FD->next = 0;
  97
  98     nv = (PP->nbV - 1)/(8*sizeof(int)) + 1;
  99     FD->F = ALLOCN(unsigned, nv);
 100     memset(FD->F, 0, nv * sizeof(unsigned));
 101
 102     FORALL_PVertex_in_ParamPolyhedron(V, D, PP) /* _i, _ix, _bx internal counters */
 103         int n;
 104         Param_Inner_Product(P->Constraint[c], V->Vertex, row->p);
 105         if (First_Non_Zero(row->p+1, nparam+1) == -1)
 106             FD->F[_ix] |= _bx;
 107     END_FORALL_PVertex_in_ParamPolyhedron;
 108
 109     Vector_Free(row);
 110
 111     return FD;
 112 }
 113
 114 #ifndef POINTS2TRIANGS_PATH
 115 Param_Polyhedron *TC_P2PP(Polyhedron *P, Polyhedron *C,
 116                           struct barvinok_options *options)
 117 {
 118     return NULL;
 119 }
 120 #endif
 121
 122 Param_Polyhedron *Polyhedron2Param_Polyhedron(Polyhedron *P, Polyhedron *C,
 123                                               struct barvinok_options *options)
 124 {
 125     switch(options->chambers) {
 126     case BV_CHAMBERS_POLYLIB:
 127         return PL_P2PP(P, C, options);
 128         break;
 129     case BV_CHAMBERS_TOPCOM:
 130         return TC_P2PP(P, C, options);
 131         break;
 132     default:
 133         assert(0);
 134     }
 135 }
 136
 137 #define INT_BITS (sizeof(unsigned) * 8)
 138
 139 /* Wegner's method for counting the number of ones in a bit vector */
 140 int bit_vector_count(unsigned *F, int F_len)
 141 {
 142     int i;
 143     int count = 0;
 144
 145     for (i = 0; i < F_len; ++i) {
 146         unsigned v = F[i];
 147         while (v) {
 148             v &= v-1;
 149             ++count;
 150         }
 151     }
 152     return count;
 153 }
 154
 155 Polyhedron *Param_Vertex_Cone(Param_Polyhedron *PP, Param_Vertices *V,
 156                               struct barvinok_options *options)
 157 {
 158     int i, j, ix;
 159     unsigned bx;
 160     int len = (PP->Constraints->NbRows+INT_BITS-1)/INT_BITS;
 161     int n;
 162     Matrix *M;
 163     Polyhedron *C;
 164     unsigned nvar = V->Vertex->NbRows;
 165     unsigned nparam = V->Vertex->NbColumns - 2;
 166
 167     if (!V->Facets) {
 168         int i, ix;
 169         unsigned bx;
 170         Vector *row = Vector_Alloc(1 + nparam + 1);
 171
 172         V->Facets = (unsigned *)calloc(len, sizeof(unsigned));
 173         for (i = 0, ix = 0, bx = MSB; i < PP->Constraints->NbRows; ++i) {
 174             Param_Inner_Product(PP->Constraints->p[i], V->Vertex, row->p);
 175             if (First_Non_Zero(row->p+1, nparam+1) == -1)
 176                 V->Facets[ix] |= bx;
 177             NEXT(ix, bx);
 178         }
 179         Vector_Free(row);
 180     }
 181     n = bit_vector_count(V->Facets, len);
 182
 183     M = Matrix_Alloc(n, 1+nvar+1);
 184     assert(M);
 185     for (i = 0, j = 0, ix = 0, bx = MSB; i < PP->Constraints->NbRows; ++i) {
 186         if (V->Facets[ix] & bx)
 187             Vector_Copy(PP->Constraints->p[i], M->p[j++], 1+nvar);
 188         NEXT(ix, bx);
 189     }
 190     C = Constraints2Polyhedron(M, options->MaxRays);
 191     assert(C);
 192     Matrix_Free(M);
 193     return C;
 194 }
 195
 196 /* Compute activity domain of a parametric vertex. */
 197 void Param_Vertex_Domain(Param_Vertices *V, Polyhedron *P)
 198 {
 199     int i;
 200     unsigned nparam = V->Vertex->NbColumns-2;
 201
 202     if (V->Domain)
 203         return;
 204
 205     V->Domain = Matrix_Alloc(P->NbConstraints, 1+nparam+1);
 206     for (i = 0; i < P->NbConstraints; ++i) {
 207         Param_Inner_Product(P->Constraint[i], V->Vertex, V->Domain->p[i]);
 208         value_assign(V->Domain->p[i][0], P->Constraint[i][0]);
 209     }
 210 }