pelutils.h

Gambit 是一个游戏库理论软件

typedef struct Imatrix_t *Imatrix;           
typedef struct Imatrix_t *Ivector;           

#define IMATRIX_FAST 1
#ifdef IMATRIX_FAST
  struct Imatrix_t {
       int store;
       int topc;
       int topr;
       int ncols;
       int *elts;
  };
  #define IVstore(V)    (((V)->store)) 
  #define IVlength(V)   (((V)->topc)) 
  #define IVref1(V,i)   (&((V)->elts[i-1]))
  #define IVref0(V,i)   (&((V)->elts[i]))
  #define IVref(V,i)    IVref1(V,i)
  #define IMstore(V)    (((V)->store))  
  #define IMMrows(V)    (((V)->store/(V)->ncols))
  #define IMrows(V)     (((V)->topr))  
  #define IMcols(V)     (((V)->topc)) 
  #define IMNcols(V)    (((V)->ncols))      
  #define IMref1(V,i,j) (&(((V))->elts[(i-1)*((V)->ncols)+j-1]))
  #define IMref0(V,i,j) (&((V)->elts[(i*(V)->ncols)+j]))
  #define IMref(V,i,j)  IMref1(V,i,j)
#else

  /*
  ** matrix access macroes
  */
  int IMstore(Imatrix M);                        /* maximum #elts available*/
  int IMMrows(Imatrix M);                        /* maximum #rows          */
  int IMrows(Imatrix M);                         /* number rows stored     */   
  int IMcols(Imatrix M);                         /* number cols stored     */   
  int* IMref1(Imatrix M,int i,int j);            /* acces starting at 1    */
  #define IMref0(M,i,j) (IMref(M,(i+1),(j+1)))   /* acces starting at 0    */
  #define IMref(M,i,j)  (IMref1((M),i,j))        /* use Mref1 by default   */

  /* 
  ** Vectors are implemented as 1xM matrices, and acces is through 
  ** usual matrix functions via macroes
  */
  #define IVstore(V)  (IMstore(V)) /* maximum #elts available */
  #define IVlength(V) (IMcols(V))  /* actual #elts stored      */
  #define IVref1(V,i)  (IMref1(V,1,i))  /* acces ith elt (starting at 1)*/
  #define IVref0(V,i)  (IMref0(V,0,i))   /* acces ith elt (starting at 0)*/
  #define IVref(V,i)   (IVref1(V,i))
#endif 

 /*
 **  Constructor/Destructors/Display
 */
 Imatrix Imatrix_new(int r, int c);
 Imatrix Imatrix_resize(Imatrix M, int r, int d);
 Imatrix Imatrix_submat(Imatrix R, int r, int c); 
 void    Imatrix_free(Imatrix V);
 Imatrix Imatrix_fprint(FILE *fout, Imatrix M);
 #define Imatrix_print(M) (Imatrix_fprint(stdout,M))
 #define Ivector_fprint(F,V) (Imatrix_fprint(F,V))
 #define Ivector_print(V)  (Imatrix_print(V))
 #define Ivector_new(n) (Imatrix_new(1,n))
 #define Ivector_free(V) (Imatrix_free(V))

 /*
 ** Arithmatic and other operations on Imatrices
 */
  Imatrix Imatrix_add(int i1, Imatrix M1,int i2, Imatrix M2, Imatrix M3);
  #define add_Ivector(V1,V2,V3) add_Imatrix(V1,V2,V3)
  Imatrix Imatrix_mul(Imatrix M1, Imatrix M2, Imatrix M3);  
  Imatrix Imatrix_dot(Imatrix M1, Imatrix M2, Imatrix M3);  
  int Ivector_dot(Imatrix M1, Imatrix M2);
  int Imatrix_equal(Imatrix M1,Imatrix M2);
  int Imatrix_rref(Imatrix M,int *);
  int Imatrix_backsolve(Imatrix M,Imatrix Sol);

  int Imatrix_order(Imatrix M1,Imatrix M2);
  int Imatrix_gcd_reduce(Imatrix M);
  int Imatrix_hermite(Imatrix S, Imatrix U);
  Imatrix Imatrix_dup(Imatrix S,Imatrix storeage);
  int Imatrix_is_zero(Imatrix S);

/* end Imatrix.h */

/**************************************************************************/
/*********************** declarations from Lists.h ************************/
/**************************************************************************/

node list_cat(node,node);
node list_push(node,node *);
node list_pop(node *);
node list_first(node);
node list_rest(node);
int  list_insert(node, node *, int (*comp) (node, node),int uniq);
node list_append(node,node *);
int  list_empty(node);
int  list_Imatrix_comp(node g1, node g2);
node list_cat(node l1,node l2);
void xpl_fprint(FILE *fout,node L);

/* end Lists.h */

/**************************************************************************/
/********************** declarations from Pconfig.h ***********************/
/**************************************************************************/

  /* General purpose implementation of points*/
  void *node_get_ptr(node N, int side);
  #define pnt_coords(g) (((Imatrix)(node_get_ptr(g,RIGHT))))
  #define pnt_label(g) ((char *)node_get_ptr(g,LEFT))
  #define pnt_dim(g)   ((IVlength((Imatrix)node_get_ptr(g,RIGHT))))

  /* I don't remember where these are used? */
  #define LABLES_ONLY 1                               
  #define COORDS_ONLY 2                                      
  #define ALL 3                                                 

  node pnt_new(char *s,Imatrix m);
  void pnt_free(node n);
  int pnt_print(node n);      /* Display point */
  int pnt_is_point(node n);   /* return TRUE if node contains a point */
  char * pnt_lable(node n);   /* return lable for point */

  /* General purpose storage of point configurations  */
  int node_get_int(node N, int side);
  #define pcfg_npts(g) ((int)node_get_int(g,LEFT))
  #define pcfg_dim(g) ((pnt_dim(Car((node)node_get_ptr(g,RIGHT)))))
  node pcfg_new();
  int pcfg_in(node,node);
  node pcfg_print(node n);
  node pcfg_print_short(node n);
  int pcfg_add(node point, node config);
  Imatrix point_cfg_coords(node n, Imatrix R);
  Imatrix pcfg_M(node n, Imatrix R);
  node pcfg_face(node pc, Imatrix normal);
  int is_normal_good(Imatrix normal, Imatrix N);
  int pcfg_remove(node, node,node);

/* end Pconfig.h */

/**************************************************************************/
/********************** declarations from Pcomplex.h **********************/
/**************************************************************************/

typedef struct FCOMPLEX {double r,i;} fcomplex; 

#define Real(c) ((c).r)
#define Imag(c) ((c).i)
fcomplex ItoC(int i);
fcomplex DtoC(double );
fcomplex Cadd(fcomplex, fcomplex);
fcomplex Csub(fcomplex, fcomplex);
fcomplex Cmul(fcomplex, fcomplex);
fcomplex Cpow(fcomplex, int);
fcomplex Complex(double, double);
fcomplex Conjg(fcomplex);
fcomplex Cdiv(fcomplex, fcomplex);
double   Cabs(fcomplex);
fcomplex Csqrt(fcomplex);
fcomplex RCmul(double,fcomplex);
fcomplex RootOfOne(int,int);
fcomplex Croot(fcomplex,int);
void printC(fcomplex);

/* end Pcomplex.h */

/**************************************************************************/
/*********************** declarations from Poly.h *************************/
/**************************************************************************/

#define RING_VAR_L 10

struct Pring_tag {
            int n;
            char **vars;
            char *def;};

typedef struct Pring_tag *Pring;
 
struct mono_tag {
        Pring R;
        int *exps;
        int def;
        int homog;
        fcomplex coef;
 
  
       struct mono_tag *next;
      
  
 
    int remaining;}; 

typedef struct mono_tag *monomial;
typedef struct mono_tag *polynomial1;
 
void ring_set_var(Pring R, int n, char *lable);
void ring_set_def(Pring R,  char *lable);      
char *ring_var(Pring R, int n);
char *ring_def(Pring R);      
 int *poly_exp(monomial, int);
 int *poly_def(monomial);
 int *poly_homog(monomial);
 int poly_deg(polynomial1);
 int poly_dim(monomial);
 int ring_dim(Pring);
 Pring poly_ring(monomial);
 fcomplex *poly_coef(monomial);
 monomial poly_next(monomial);
 Pring poly_ring(monomial);
 Pring makePR(int);   
 Pring free_Pring(Pring);
 polynomial1 makeP(Pring);  
 polynomial1 freeP(polynomial1 p);  /* frees space allocated to a polynomial1*/
 polynomial1 copyP(polynomial1 p);
 polynomial1 copyM();
 void printP(polynomial1 P);
 int orderP();
 polynomial1 ItoP(int c,Pring R);
 polynomial1 DtoP(double c, Pring R);
 polynomial1 CtoP(fcomplex c, Pring R);
 polynomial1 addPPP(polynomial1 P1, polynomial1 P2, polynomial1 P3);
 polynomial1 subPPP(polynomial1 P1, polynomial1 P2, polynomial1 P3);
 polynomial1 mulPPP(polynomial1 P1, polynomial1 P2, polynomial1 P3);
 polynomial1 mulCPP(fcomplex c, polynomial1 P1, polynomial1 P2);
 polynomial1 divCPP(fcomplex c, polynomial1 P1, polynomial1 P2);
 polynomial1 mulMPP(polynomial1 mi, polynomial1 P1, polynomial1 P2);
 polynomial1 divMPP(polynomial1 mi, polynomial1 P1, polynomial1 P2);
 polynomial1 expIPP(int x, polynomial1 P, polynomial1 P3);
 polynomial1 unliftP(polynomial1 p);
 
 polynomial1 Homogenize();
 polynomial1 Prog_Eq();
monomial poly_set_next(monomial m,monomial m2);
int orderPP(polynomial1 P1,polynomial1 P2);

/* end Poly.h */

/**************************************************************************/
/*********************** declarations from utime.h ************************/
/**************************************************************************/

int set_mark(void);
int read_mark(int);

/* end utime.h */

/**************************************************************************/
/************************ declarations from Aset.h ************************/
/**************************************************************************/

/* end Aset.h */

  typedef struct node_t *point;
  typedef struct node_t *aset;
  typedef struct node_t *list;
  typedef struct Imatrix_t *norm_for_Aset;

  /* creation/display/access */
  aset aset_new(int R,int D);
  aset aset_print(aset);
  aset aset_print_short(aset);
  point aset_new_pt(int N,char *lable);
  int aset_add(aset, int, point );
  int aset_r(aset);
  int aset_dim(aset);
  int aset_npts(aset);
  int aset_pnt_set(point, int, int );
  int aset_pnt_get(point, int);
  /* controll for iteration */
  node aset_start_pnt(node ptr);
  point aset_next_pnt(aset *);
  aset  aset_start_cfg(aset);
  aset  aset_next_cfg(aset *);
  /* Manipulators */
  aset aset_face(aset,norm_for_Aset);
  int aset_randlift(node A, int seed, int L, int U);
  int aset_unlift(node A);
Imatrix aset_type(node A, Imatrix T);
Imatrix aset_M(node A, Imatrix M);

/**************************************************************************/
/*********************** declarations from Types.h ************************/
/**************************************************************************/

/* node node_print(node N); APPARENTLY REDUNDANT */
node ERRND(char *);
void atom_free(node N);
node atom_new(char *val, int tp);

/* end Types.h */

/**************************************************************************/
/*********************** definitions from Dtypes.h ************************/
/**************************************************************************/

/* 
** Dtypes.h--- Definition of access to several types represented
**             by Dvectors: (bundeled to make location of fields
**             within vector transparent)
**         
**        xpnt (=<hr,hi,x1r,x1i,.....,xnr,xni, t>)
**             represents a point of CP^nxC, 
**             where 
**             xj=(xjr+I*xji) is the coordinate associated 
**                          to the jth variable
**             h=(hr+I*hi)  is the coordinate associated to the 
**                          homog param
**             t         is the deformation variable.
**
**        ptrans (=<cr,ci,c1r,c1i,.....,cnr,cni>)         
**          represents a relation  h=c+c1x1+...+cnxn
**          usually used to define a random affine chart
**
*/

typedef  Dmatrix xpnt;
typedef  Dmatrix sclvect;

/* 
** access macroes treating an xpntM as a complex matrix:
**                      and an xpnt as a complex vector:
*/
#define xpnt_new(n)        Dvector_new(2*(n)+3)
#define xpnt_n(X)          ((DVlength(X)-3)/2)
#define xpnt_free(X)       Dvector_free(X);
#define xpnt_h_set(X,C)    {DVref(X,1)=(C).r;\
                            DVref(X,2)=(C).i;}
#define xpnt_h(X)          (Complex(DVref((X),1),\
                                    DVref((X),2)))
#define xpnt_xi(X,i)       (Complex(DVref((X),2*(i)+1),\
                                    DVref((X),2*(i)+2)))
#define xpnt_xi_set(X,j,C) {DVref((X),2*(j)+1)=(C).r;\
                            DVref((X),2*(j)+2)=(C).i;}
#define xpnt_t(X)          (DVref((X),DVlength(X)))
#define xpnt_t_set(X,i)    (DVref((X),DVlength(X))=i)



/*
** initializers, and manipulators, misc
*/
void xpnt_unscale(xpnt,Dvector);
void xpnt_affine(xpnt);                 /*verified*/
void xpnt_normalize(xpnt X);

/***********************************************************************/
/****************** header information from Extremal.h *****************/
/***********************************************************************/

node pcfg_extremal(node PC); /*verified*/
node aset_extremal(node A); /*verified*/


/* end Dtypes.h */

/* header information related to what was MSD.c */

node MSD(aset Ast, Ivector T);

typedef struct Aset_Itag{
     int r;
     int n;
     int m;
     node *pts;    /*a vector of points */
     int  *store;
}*Aset_I;

typedef struct Cell_Itag {
  int r;
  int *store;
}*Cell_I;

node set_up_FaceLists(Aset_I A, Cell_I C);

int IsLower();

/***********************************************************************/
/******************* header information for RSimp.c ********************/
/***********************************************************************/

int Rsimp(Dmatrix A, Dvector b, Dvector c,
      Dvector x,Ivector basis,Ivector nonbasis,
      Dmatrix DtypesR, Dmatrix Q, Dvector t1, Dvector t2);

#endif // PELUTILS