Main Page | Class List | File List | Class Members | File Members

types.h

Go to the documentation of this file.
00001 /* types-polylib.h
00002      COPYRIGHT
00003           Both this software and its documentation are
00004 
00005               Copyright 1993, IRISA /Universite de Rennes I - France
00006               Copyright 1996,1997,1998, Doran Wilde and Vincent Loechner
00007               All rights reserved.
00008 
00009           Permission is granted to copy, use, and distribute
00010           for any commercial or noncommercial purpose under the terms
00011           of the GNU General Public license, version 2, June 1991
00012           (see file : LICENSING).
00013 */
00014 
00015 #ifndef _types_polylib_h_
00016 #define _types_polylib_h_
00017 
00018 #ifdef GNUMP
00019 #include<gmp.h>
00020 #endif 
00021 
00022 #include <limits.h>
00023 
00024 /*********************** USER DEFINES ******************************/
00025 
00026 /* first parameter name char.  */
00027 #define FIRST_PARAMETER_NAME 'P'
00028 
00029 /******************* END OF USER DEFINES ***************************/
00030 
00031 
00032 #define PCHAR (FIRST_PARAMETER_NAME-1)
00033 #define MAXNOOFRAYS 200 
00034 
00035 #if defined(LINEAR_VALUE_IS_LONGLONG)
00036 #define P_VALUE_FMT "%4lld "
00037 #elif defined(LINEAR_VALUE_IS_LONG)
00038 #define P_VALUE_FMT "%4ld "
00039 #elif defined(LINEAR_VALUE_IS_CHARS)
00040 #define P_VALUE_FMT "%s "
00041 #elif defined(LINEAR_VALUE_IS_INT) 
00042 #define P_VALUE_FMT "%4d "
00043 #else  /* GNUMP */
00044 #define P_VALUE_FMT "%4s "
00045 #endif
00046 
00047 /* Used in lower_upper_bounds */
00048 #define LB_INFINITY 1
00049 #define UB_INFINITY 2
00050 
00051 /* MSB, TOP, and NEXT are defined over integer type, not on value type */
00052 /* Put a one in the most significant bit of an int (portable) */
00053 #define MSB ((unsigned)(((unsigned)1)<<(sizeof(int)*8-1)))
00054 
00055 /* Largest representable positive number */
00056 #define TOP ((int)(MSB-1))
00057 
00058 /* Right shift the one bit in b and increment j if the last bit in b is one */
00059 #define NEXT(j,b) { if (!((b)>>=1)) { (b)=MSB; (j)++; } }
00060 
00061 /* Status of last Polyhedron operation */
00062 extern int Pol_status;
00063 
00064 #define POL_HIGH_BIT    (UINT_MAX - (UINT_MAX >> 1))
00065 #define POL_NO_DUAL     (POL_HIGH_BIT | 0x0001)
00066 
00067 typedef struct  {
00068   unsigned Size;
00069   Value *p;
00070 } Vector;
00071 
00072 typedef struct matrix {
00073   unsigned NbRows, NbColumns;
00074   Value **p;
00075   Value *p_Init;
00076   int p_Init_size;      /* needed to free the memory allocated by mpz_init */
00077 } Matrix;
00078 
00079 /* Macros to init/set/clear/test flags. */
00080 #define FL_INIT(l, f)   (l) = (f)               /* Specific flags location. */
00081 #define FL_SET(l, f)    ((l) |= (f))
00082 #define FL_CLR(l, f)    ((l) &= ~(f))
00083 #define FL_ISSET(l, f)  ((l) & (f))
00084 
00085 #define F_INIT(p, f)    FL_INIT((p)->flags, f)  /* Structure element flags. */
00086 #define F_SET(p, f)     FL_SET((p)->flags, f)
00087 #define F_CLR(p, f)     FL_CLR((p)->flags, f)
00088 #define F_ISSET(p, f)   FL_ISSET((p)->flags, f)
00089 
00090 typedef struct polyhedron { 
00091   unsigned Dimension, NbConstraints, NbRays, NbEq, NbBid;
00092   Value **Constraint;
00093   Value **Ray;
00094   Value *p_Init;
00095   int p_Init_size;
00096   struct polyhedron *next;
00097 #define    POL_INEQUALITIES     0x00000001
00098 #define    POL_FACETS           0x00000002
00099 #define    POL_POINTS           0x00000004
00100 #define    POL_VERTICES         0x00000008
00101 /* The flags field contains "valid" information,
00102  * i.e., the structure was created by PolyLib.
00103  */
00104 #define    POL_VALID            0x00000010
00105   unsigned flags;
00106 } Polyhedron;
00107 
00108 typedef struct interval {
00109   Value MaxN, MaxD;
00110   Value MinN, MinD; 
00111   int MaxI, MinI;
00112 } Interval;
00113 
00114 /* Test whether P is an empty polyhedron */
00115 #define emptyQ(P) (P->NbRays==0)
00116 
00117 /* Test whether P is a universe polyheron */
00118 #define universeQ(P) (P->Dimension==P->NbBid)
00119 
00120 typedef struct _Param_Vertex {          
00121   Matrix *Vertex; /* Each row is a coordinate of the vertex. The first  */
00122                   /* "m" values of each row are the coefficients of the */
00123                   /* parameters. The (m+1)th value is the constant, the */
00124                   /* The (m+2)th value is the common denominator.       */
00125   Matrix *Domain; /* Constraints on parameters (in Polyhedral format)   */
00126   struct _Param_Vertex *next;          /* Pointer to the next structure */
00127 } Param_Vertices;
00128 
00129 typedef struct _Param_Domain {
00130   unsigned *F;         /* Bit array of faces */
00131   Polyhedron *Domain;  /* Pointer to Domain (constraints on parameters) */
00132   struct _Param_Domain *next; /* Pointer to the next structure  */
00133 } Param_Domain;
00134 
00135 typedef struct _Param_Polyhedron {
00136         int nbV;            /* Number of parameterized vertices            */
00137         Param_Vertices *V;  /* Pointer to the list of parameteric vertices */
00138         Param_Domain *D;    /* Pointer to the list of validity domains     */
00139 } Param_Polyhedron;
00140 
00141 #define FORALL_PVertex_in_ParamPolyhedron(_V, _D, _P)   \
00142 {     int _i, _ix;                                   \
00143       unsigned _bx;                                  \
00144       for( _i=0, _ix=0, _bx=MSB, _V=_P->V ;            \
00145            _V && (_i<_P->nbV) ; _i++, _V=_V->next )      \
00146       {       if (_D->F[_ix] & _bx)                   \
00147               {
00148 
00149 #define END_FORALL_PVertex_in_ParamPolyhedron  \
00150               }                                \
00151               NEXT(_ix, _bx);                  \
00152       }                                        \
00153 }
00154 
00155 /* Data structures for pseudo-polynomial */
00156 
00157 typedef enum { polynomial, periodic, evector } enode_type;
00158 
00159 typedef struct _evalue {
00160   Value d;              /* denominator */
00161   union {
00162     Value n;            /* numerator (if denominator != 0) */
00163     struct _enode *p;   /* pointer   (if denominator == 0) */
00164   } x;
00165 } evalue;
00166 
00167 typedef struct _enode {
00168   enode_type type;      /* polynomial or periodic or evector */
00169   int size;             /* number of attached pointers */
00170   int pos;              /* parameter position */
00171   evalue arr[1];        /* array of rational/pointer */
00172 } enode;
00173 
00174 typedef struct _enumeration {
00175   
00176   Polyhedron *ValidityDomain;    /* contraints on the parameters     */
00177   evalue EP;                     /* dimension = combined space       */
00178   struct _enumeration *next;     /* Ehrhart Polynomial, corresponding
00179                                     to parameter values inside the
00180                                     domain ValidityDomain below      */
00181 } Enumeration;
00182 
00183 /*-----------------------------Example Usage------------------------------*/
00184 /* enode *e                                                               */
00185 /*     e->type = polynomial     e->type = periodic   e->type = evector    */
00186 /*     e->size = degree+1       e->size = period     e->size = length     */
00187 /*     e->pos  = [1..nb_param]                                            */
00188 /*     e->arr[i].d = denominator (Value)                                  */
00189 /*     e->arr[i].x.p = pointer to another enode (if denominator is zero)  */
00190 /*     e->arr[i].x.n = numerator (Value) (if denominator is non-zero)     */
00191 /*------------------------------------------------------------------------*/
00192 
00193 /*------------------------------------------------------------------------*/
00194 /* This representation has the following advantages:                      */
00195 /*   -- its dynamic, it can grow/shrink easily                            */
00196 /*   -- it is easy to evaluate for a given context (values of parameters) */
00197 /*   -- it allows pseudo-polynomial to be reduced with rules              */
00198 /*   -- it can be constructed recursively                                 */
00199 /*------------------------------------------------------------------------*/
00200 
00201 /* *********************** |Represnting Z-Polyhedron| ******************* */
00202 
00203 
00204 typedef enum {False = 0, True = 1} Bool;
00205 typedef Matrix Lattice;
00206 typedef struct LatticeUnion {
00207   Lattice *M;
00208   struct LatticeUnion *next;
00209 } LatticeUnion;
00210 
00211 typedef struct ZPolyhedron {
00212   Lattice *Lat ;
00213   Polyhedron *P;
00214   struct ZPolyhedron *next;
00215 } ZPolyhedron;
00216 
00217 #ifndef FOREVER
00218 #define FOREVER for(;;)
00219 #endif
00220 
00221 #endif /* _types_polylib_h_ */
00222 
00223 
00224 
00225 
00226 
00227 
00228 
00229 
00230 
00231 
00232 
00233 

Generated on Mon Sep 12 15:15:11 2005 for polylib by doxygen 1.3.5