nysol-zdd 3.0.2

data/ext/zdd_so/include/problem.h

@@ -0,0 +1,160 @@
+/*  Common problem input/output routines /structure
+            25/Nov/2007   by Takeaki Uno  e-mail:uno@nii.jp, 
+    homepage:   http://research.nii.ac.jp/~uno/index.html  */
+/* This program is available for only academic use, basically.
+   Anyone can modify this program, but he/she has to write down 
+    the change of the modification on the top of the source code.
+   Neither contact nor appointment to Takeaki Uno is needed.
+   If one wants to re-distribute this code, do not forget to 
+    refer the newest code, and show the link to homepage of 
+    Takeaki Uno, to notify the news about the codes for the users.
+   For the commercial use, please make a contact to Takeaki Uno. */
+
+/***************************************************/
+
+#ifndef _problem_h_
+#define _problem_h_
+
+#include"stdlib2.h"
+#include"queue.h"
+#include"itemset.h"
+
+#define PROBLEM_FREQSET 1
+#define PROBLEM_MAXIMAL 2
+#define PROBLEM_CLOSED 4
+#define PROBLEM_EX_MAXIMAL 8
+#define PROBLEM_EX_CLOSED 16
+
+/*****  parameters for PROBLEM initialization, given to flag  *****/
+
+#define PROBLEM_PRINT_DENSE 4  // print density threshold
+#define PROBLEM_PRINT_SHRINK 8  // print properties of shrinked database
+#define PROBLEM_PRINT_FRQ   16  // print density threshold
+#define PROBLEM_NORMALIZE   32  // print density threshold
+
+#define PROBLEM_ITEMARY 128 // alloc itemary
+#define PROBLEM_ITEMJUMP 256 // alloc itemjump
+#define PROBLEM_ITEMFLAG 512  // alloc itemflag
+#define PROBLEM_ITEMMARK 1024  // alloc itemmark
+#define PROBLEM_ITEMCAND 2048 // alloc itemcand
+#define PROBLEM_VECARY 4096 // alloc itemary
+#define PROBLEM_VECJUMP 8192 // alloc vecjump
+#define PROBLEM_VECFLAG 16384  // alloc vecflag
+#define PROBLEM_VECMARK 32768  // alloc vecmark
+#define PROBLEM_VECCAND 65536 // alloc veccand
+//4194304
+#define PROBLEM_OCC_T 524288 // alloc occ_t
+#define PROBLEM_SHIFT 1048576  // allocate shift
+#define PROBLEM_OCC_W 2097152  // weight/positive-weight sum for items
+#define PROBLEM_OCC_PW 4194304  // weight/positive-weight sum for items
+#define PROBLEM_OCC_W2 8388608  // weight/positive-weight sum for items
+
+#define PROBLEM_OCC1 16 // alloc occ
+#define PROBLEM_OCC2 32 // alloc occ and ins all to list 0
+#define PROBLEM_OCC3 48 // alloc occ and ins all to list "siz"
+
+typedef struct {
+  clock_t start_time, end_time;
+  int problem;
+  LONG prog;
+  int prog2;
+  double dense;
+  char *input_fname;
+  char *output_fname;
+  char *weight_fname;
+  char *table_fname, *table2_fname;
+  char *position_fname, *position2_fname;
+
+  char *sgraph_fname, *sgraph2_fname;
+  char *sgraph_wfname, *sgraph2_wfname;
+  char *agraph_fname, *agraph2_fname;
+  char *trsact_fname, *trsact_fname2, *trsact_wfname, *trsact_wfname2, *trsact_pfname;
+  char *trsact2_fname, *trsact2_fname2, *trsact2_wfname, *trsact2_wfname2, *trsact2_pfname;
+  char *seq_fname, *seq2_fname;
+  char *fstar_fname, *fstar2_fname;
+  char *mat_fname, *mat2_fname;
+  char *smat_fname, *smat2_fname;
+  char *setfamily_fname, *setfamily2_fname;
+  char *setfamily_wfname, *setfamily2_wfname;
+  
+  ITEMSET II, II2;
+  QUEUE ff;      // for agraph search
+  int *vf, *dep; // for agraph search
+
+  int root, dir, edge_dir;
+  double th, th2, th3;   // thresholds
+  double ratio, ratio2;  // ratio
+  int num, siz, dim, len;
+  QUEUE_INT clms;
+  VEC_ID rows;
+
+  QUEUE_ID **shift;
+  QUEUE itemjump, itemcand, vecjump, veccand, *OQ, *OQ2, *VQ, *VQ2;   // for delivery
+  QUEUE_INT *itemary;
+  int *itemmark, *itemflag, *vecmark, *vecflag;  // mark for vector
+  VEC_ID *vecary, *occ_t;
+  WEIGHT *occ_w, *occ_pw, *occ_w2, *occ_pw2;
+  QUEUE oo;
+
+  char *pat;   // pattern string
+  int plen, perr;  // pattern length and #error allowed
+
+#ifdef _alist_h_
+  MALIST occ;
+#endif
+
+#ifdef _sgraph_h_
+  SGRAPH SG, SG2;
+#endif
+
+#ifdef _agraph_h_
+  AGRAPH AG, AG2;
+#endif
+
+#ifdef _trsact_h_
+  TRSACT TT, TT2;
+#endif
+
+#ifdef _seq_h_
+  SEQ SS, SS2;
+#endif
+
+#ifdef _fstar_h_
+  FSTAR FS, FS2;
+#endif
+
+#ifdef _vec_h_
+  MAT MM, MM2;
+  SMAT SM, SM2;
+  SETFAMILY FF, FF2;
+#endif
+
+} PROBLEM;
+
+
+/*****  print filename information  ****/
+void PROBLEM_print (PROBLEM *P);
+
+/*****  print usage of the program *****/
+void PROBLEM_error ();
+
+/*****  read parameters given by command line  *****/
+void PROBLEM_read_param (int argc, char *argv[], PROBLEM *P);
+
+/*****  PROBLEM and ITEMSET initialization *****/
+/* all pointers are set to NULL, but don't touch filenames */
+void PROBLEM_init (PROBLEM *P);
+
+/*****  PROBLEM initialization: load the files given by filenames   ******/
+void PROBLEM_init2 (PROBLEM *P, int flag);
+
+/*****  allocate memory according to flag  *****/
+void PROBLEM_alloc (PROBLEM *PP, QUEUE_ID siz, QUEUE_ID siz2, size_t siz3, PERM *p, int f);
+
+/* termination of problem */
+void PROBLEM_end (PROBLEM *PP);
+
+
+#endif
+
+

data/ext/zdd_so/include/queue.c

@@ -0,0 +1,518 @@
+/* Library of queue: spped priority implementation 
+            12/Apr/2001   by Takeaki Uno  e-mail:uno@nii.jp, 
+    homepage:   http://research.nii.ac.jp/~uno/index.html  */
+/* This program is available for only academic use, basically.
+   Anyone can modify this program, but he/she has to write down 
+    the change of the modification on the top of the source code.
+   Neither contact nor appointment to Takeaki Uno is needed.
+   If one wants to re-distribute this code, do not forget to 
+    refer the newest code, and show the link to homepage of 
+    Takeaki Uno, to notify the news about the codes for the users.
+   For the commercial use, please make a contact to Takeaki Uno. */
+
+#ifndef _queue_c_
+#define _queue_c_
+
+
+#include"queue.h"
+#include"stdlib2.c"
+
+QSORT_TYPE(QUEUE_INT, QUEUE_INT)
+QSORT_TYPE(QUEUE_ID, QUEUE_ID)
+QUEUE INIT_QUEUE = {TYPE_QUEUE,NULL,0,0,0};
+QUEUE_INT *common_QUEUE_INTp;
+
+/* initialization, not fill the memory by 0 */
+void QUEUE_alloc (QUEUE *Q, QUEUE_ID siz){
+  *Q = INIT_QUEUE;
+  Q->end = siz+1;
+  malloc2 (Q->v, siz+1, "QUEUE_alloc: Q->v", EXIT);
+}
+
+/* termination processing */
+void QUEUE_end (QUEUE *Q){
+  free2 (Q->v);
+  *Q = INIT_QUEUE;
+}
+
+
+/* tranpose the matrix ; counting/transpose/memory_allocate */
+void QUEUE_delivery(QUEUE *OQ, VEC_ID *c, QUEUE *jump, QUEUE *Q, QUEUE *occ, VEC_ID t, QUEUE_INT M){  VEC_ID i, e;
+  QUEUE_INT *x;
+  FLOOP(i, 0, occ? occ->t: t){
+    e = occ? occ->v[i]: i;
+    if ( c ){
+      if ( jump ){ MLOOP (x, Q[e].v, M){ if ( c[*x]==0 ) ARY_INS (*jump, *x); c[*x]++; }
+      } else { MLOOP (x, Q[e].v, M){ c[*x]++; }}
+    } else {
+      if ( jump ){ MLOOP (x, Q[e].v, M){ if ( OQ[*x].t==0 ) ARY_INS (*jump, *x); ARY_INS (OQ[*x], e); }
+      } else MLOOP (x, Q[e].v, M){ ARY_INS (OQ[*x], e); }
+    }
+  }
+}
+
+/* sort a QUEUE with WEIGHT, with already allocated memory */
+void QUEUE_perm_WEIGHT (QUEUE *Q, WEIGHT *w, PERM *invperm, int flag){
+  WEIGHT y;
+  if ( w ){
+    qsort_perm__QUEUE_INT (Q->v, Q->t, invperm, flag);
+    ARY_INVPERMUTE_ (w, invperm, y, Q->t);
+  }
+  qsort_QUEUE_INT (Q->v, Q->t, flag);
+}
+
+/* remove (or unify) the consecutive same ID's in a QUEUE (duplication delete, if sorted) */
+void QUEUE_rm_dup_WEIGHT (QUEUE *Q, WEIGHT *w){
+  VEC_ID j, jj=0;
+  if ( w ){
+    FLOOP (j, 1, Q->t){
+      if ( Q->v[j-1] != Q->v[j] ){
+        Q->v[++jj] = Q->v[j];
+        w[jj] = w[j];
+      } else w[jj] += w[j];
+    }
+  } else FLOOP (j, 1, Q->t){
+    if ( Q->v[j-1] != Q->v[j] ) Q->v[++jj] = Q->v[j];
+  }
+  if ( Q->t>0 ) Q->t = jj+1;
+}
+
+/***********************************************************************/
+/* duplicate occ's in jump, ( copy occ's to allocated QUEUE array) */
+/* Q[i].end := original item, clear each original occ */
+/* buffer size is multiplied by u */
+/*******************************************************/
+void QUEUE_occ_dup (QUEUE *jump, QUEUE **QQ, QUEUE *Q, WEIGHT **ww, WEIGHT *w, WEIGHT **ppw, WEIGHT *pw, int u){
+  QUEUE_ID i, l=QUEUE_LENGTH_(*jump);
+  size_t cnt=0;
+  QUEUE_INT e, *x;
+  char *buf;
+  int unit = sizeof(*Q) + (w?sizeof(*w):0) + (pw?sizeof(*pw):0);
+ 
+  ENMAX (u, sizeof(*x));
+  MQUE_FLOOP (*jump, x) cnt += Q[*x].t;
+  if ( cnt == 0 ){ *QQ=NULL; return; }
+  malloc2 (buf, l*unit + (cnt+l)*u, "QUEUE_occ_dup: buf", EXIT);
+  *QQ = (QUEUE*)buf; buf += sizeof(*Q) *l;
+  if ( w ){ *ww = (WEIGHT *)buf; buf += sizeof(*w)*l; }
+  if ( pw ){ *ppw = (WEIGHT *)buf; buf += sizeof(*pw)*l; }
+  ARY_FLOOP (*jump, i, e){
+    (*QQ)[i].end = e;
+    (*QQ)[i].v = (QUEUE_INT *)buf;
+    (*QQ)[i].t = Q[e].t;
+    memcpy (buf, Q[e].v, (Q[e].t+1)*u);
+    buf += (Q[e].t+1) *u;
+    if ( w ) (*ww)[i] = w[e];
+    if ( pw ) (*ppw)[i] = pw[e];
+  }
+}
+
+
+/* return the position of the first element having value e. return -1 if no such element exists */
+LONG QUEUE_ele (QUEUE *Q, QUEUE_INT e){
+  QUEUE_INT *x;
+  MQUE_FLOOP (*Q, x)
+    if ( *x == e ) return (x - Q->v);
+  return (-1);
+}
+
+/* insert an element to the tail */
+void QUEUE_ins_ (QUEUE *Q, QUEUE_INT e){
+  Q->v[Q->t] = e;
+  Q->t++;
+}
+void QUEUE_ins (QUEUE *Q, QUEUE_INT e){
+  Q->v[Q->t] = e;
+  QUEUE_INCREMENT (*Q, Q->t);
+  if (Q->s == Q->t ) error_num ("QUEUE_ins: overflow", Q->s, EXIT);
+}
+
+/* insert an element to the head */
+void QUEUE_ins_head_ (QUEUE *Q, QUEUE_INT e){
+  Q->s--;
+  Q->v[Q->s] = e;
+}
+void QUEUE_ins_head (QUEUE *Q, QUEUE_INT e){
+  QUEUE_DECREMENT(*Q,Q->s);
+  Q->v[Q->s] = e;
+  if (Q->s == Q->t ) error_num ("QUEUE_ins_head: underflow", Q->s, EXIT);
+}
+
+/* extract an element from the head, without checking underflow */
+QUEUE_INT QUEUE_ext_ (QUEUE *Q){
+  (Q->s)++;
+  return (Q->v[Q->s-1]);
+}
+QUEUE_INT QUEUE_ext (QUEUE *Q){
+  QUEUE_INT e;
+  if (Q->s == Q->t ) error_num ("QUEUE_ext: empty queue", Q->s, EXIT0);
+  e = Q->v[Q->s];
+  QUEUE_INCREMENT(*Q,Q->s);
+  return ( e);
+}
+
+/* extract an element from the tail, without checking underflow */
+QUEUE_INT QUEUE_ext_tail_ (QUEUE *Q){
+  (Q->t)--;
+  return (Q->v[Q->t]);
+}
+QUEUE_INT QUEUE_ext_tail (QUEUE *Q){
+  if ( Q->s == Q->t ) error_num ("QUEUE_ext_tail: empty queue", Q->s, EXIT0);
+  QUEUE_DECREMENT(*Q,Q->t);
+  return (Q->v[Q->t]);
+}
+
+/* remove the j-th element and replace it by the tail */
+void QUEUE_rm_ (QUEUE *Q, QUEUE_ID j){
+  Q->t--;
+  Q->v[j] = Q->v[Q->t];
+}
+void QUEUE_rm (QUEUE *Q, QUEUE_ID j){
+  if ( Q->s <= Q->t ){
+    if ( j < Q->s || j >= Q->t ) error ("QUEUE_rm: j is out of queue", EXIT);
+  } else if ( j < Q->s && j >= Q->t ) error ("QUEUE_rm: j is out of queue", EXIT);
+  QUEUE_DECREMENT(*Q,Q->t);
+  Q->v[j] = Q->v[Q->t];
+}
+
+/* remove the j-th element and replace it by the head */
+void QUEUE_rm_head_ (QUEUE *Q, QUEUE_ID j){
+  Q->v[j] = Q->v[Q->s];
+  Q->s++;
+}
+void QUEUE_rm_head (QUEUE *Q, QUEUE_ID j){
+  if ( Q->s <= Q->t ){
+    if ( j < Q->s || j >= Q->t ) error ("QUEUE_rm: j is out of queue", EXIT);
+  } else if ( j < Q->s && j >= Q->t ) error ("QUEUE_rm: j is out of queue", EXIT);
+  Q->v[j] = Q->v[Q->s];
+  QUEUE_INCREMENT(*Q,Q->s);
+}
+
+/* remove the j-th element and shift the following elements to fill the gap */
+int QUEUE_rm_ele_ (QUEUE *Q, QUEUE_INT e){
+  QUEUE_ID i;
+  QUEUE_F_LOOP (*Q, i){
+    if ( Q->v[i] == e ){
+      memcpy ( &(Q->v[i]), &(Q->v[i+1]), (Q->t-i-1)*sizeof(QUEUE_INT));
+      Q->t--;
+      return (1);
+    }
+  }
+  return (0);
+}  
+/* insert e to the position determined by the increasing order of elements */
+void QUEUE_ins_ele_ (QUEUE *Q, QUEUE_INT e){
+  QUEUE_ID i;
+  QUEUE_INT ee;
+  QUEUE_BE_LOOP_ (*Q, i, ee){
+    if ( ee<e ) break;
+    Q->v[i+1] = ee;
+  }
+  Q->v[i+1] = e;
+  Q->t++;
+}
+
+/* Append Q2 to the tail of Q1. Q2 will not be deleted */
+void QUEUE_concat_ (QUEUE *Q1, QUEUE *Q2){
+  memcpy ( &(Q1->v[Q1->t]), &(Q2->v[Q2->s]), (Q2->t-Q2->s)*sizeof(QUEUE_INT));
+  Q1->t += Q2->t-Q2->s;
+}
+void QUEUE_concat (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID e = Q2->s;
+  while ( e != Q2->t){
+    QUEUE_ins (Q1, Q2->v[e]);
+    QUEUE_INCREMENT(*Q2,e);
+  }
+}
+/* Append Q2 to the tail of Q1. Q2 will be deleted */
+void QUEUE_append_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_concat_ (Q1, Q2);
+  QUEUE_RMALL (*Q2);
+}
+void QUEUE_append (QUEUE *Q1, QUEUE *Q2){ // more improvement can be
+  while ( Q2->s != Q2->t )
+      QUEUE_ins (Q1, QUEUE_ext(Q2));
+}
+
+/* Append from j to jj th elements to the tail of Q1. Q2 will not be deleted */
+void QUEUE_subconcat_ (QUEUE *Q1, QUEUE *Q2, QUEUE_ID j, QUEUE_ID jj){
+  for ( ; j<=jj ; j++){
+    Q1->v[Q1->t] = Q2->v[j];
+    Q1->t++;
+  }
+}
+void QUEUE_subconcat (QUEUE *Q1, QUEUE *Q2, QUEUE_ID j, QUEUE_ID jj){
+  while (1){
+    QUEUE_ins (Q1, Q2->v[j]);
+    if ( j == jj ) break;
+    QUEUE_INCREMENT(*Q2,j);
+  } 
+}
+
+/* initialize Q1 by length of Q2, and copy Q2 to Q1 */
+void QUEUE_store_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_alloc (Q1, QUEUE_LENGTH(*Q2));
+  QUEUE_concat_ (Q1, Q2);
+}
+void QUEUE_store (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_alloc (Q1, QUEUE_LENGTH(*Q2));
+  QUEUE_concat (Q1, Q2);
+}
+/* copy Q2 to Q1 and delete Q2 */
+void QUEUE_restore_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_RMALL (*Q1);
+  QUEUE_concat_ (Q1, Q2);
+  QUEUE_end (Q2);
+}
+void QUEUE_restore (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_RMALL (*Q1);
+  QUEUE_concat (Q1, Q2);
+  QUEUE_end (Q2);
+}
+
+/* copy Q2 to Q1 */
+void QUEUE_cpy_ (QUEUE *Q1, QUEUE *Q2){
+  Q1->s = Q1->t = 0;
+  QUEUE_concat_ (Q1, Q2);
+}
+void QUEUE_cpy (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_RMALL (*Q1);
+  QUEUE_concat (Q1, Q2);
+}
+/* copy l elements of Q2 starting from s2 to the s1th position of Q1.
+   size of Q1 is not increasing */
+void QUEUE_subcpy_ (QUEUE *Q1, QUEUE_ID s1, QUEUE *Q2, QUEUE_ID s2, QUEUE_ID l){
+  memcpy ( &(Q1->v[s1]), &(Q2->v[s2]), (l-s2)*sizeof(QUEUE_INT));
+}
+void QUEUE_subcpy (QUEUE *Q1, QUEUE_ID s1, QUEUE *Q2, QUEUE_ID s2, QUEUE_ID l){
+  for ( ; s2!=l ; QUEUE_INCREMENT(*Q1,s1),QUEUE_INCREMENT(*Q2,s2) )
+      Q1->v[s1] = Q2->v[s2];
+  Q1->v[s1] = Q2->v[s2];
+}
+
+/* duplicate Q2 to Q1. The memory size will be the length of Q2 */
+QUEUE QUEUE_dup_ (QUEUE *Q){
+  QUEUE QQ;
+  QUEUE_alloc (&QQ, QUEUE_LENGTH_(*Q));
+  QUEUE_cpy_ (&QQ, Q);
+  return (QQ);
+}
+
+/* merge Q1 and Q2 by insert all elements of Q2 to Q1 with deleting duplications. Both Q1 and Q2 have to be sorted in increasing order */
+void QUEUE_merge_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->t-1, j=Q2->t-1, t=i+j-Q2->s+1;
+  QUEUE_INT ei, ej;
+  if ( i+1 == Q1->s || j+1 == Q2->s ){
+    QUEUE_concat_ (Q1, Q2);
+    return;
+  }
+  Q1->t = t+1;
+  ei = Q1->v[i];
+  ej = Q2->v[j];
+  while (1){
+    if ( ei > ej ){
+      Q1->v[t] = ei;
+      if ( i == Q1->s ){
+        QUEUE_subcpy_ (Q1, Q1->s, Q2, Q2->s, j);
+        return;
+      }
+      i--;
+      ei = Q1->v[i];
+    } else {
+      Q1->v[t] = ej;
+      if ( j == Q2->s ) return;
+      j--;
+      ej = Q2->v[j];
+    }
+    t--;
+  }
+}
+void QUEUE_merge (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->t, j=Q2->t;
+  QUEUE_INT ei, ej;
+  QUEUE_ID t = (Q1->t + QUEUE_LENGTH(*Q2)-1) % Q1->end;
+  if ( QUEUE_LENGTH(*Q1) + QUEUE_LENGTH(*Q2) >= Q1->end ){
+    printf ("QUEUE_merge: overflow Q1->end="QUEUE_INTF", Q1length="QUEUE_INTF", Q2length="QUEUE_INTF"\n", Q1->end, QUEUE_LENGTH(*Q1), QUEUE_LENGTH(*Q2));
+    exit (1);
+  }
+  if ( i == Q1->s || j == Q2->s ){
+    QUEUE_concat (Q1, Q2);
+    return;
+  }
+
+  Q1->t = t;
+  QUEUE_DECREMENT(*Q1,i);
+  QUEUE_DECREMENT(*Q2,j);
+  ei = Q1->v[i];
+  ej = Q2->v[j];
+  while (1){
+    if ( ei > ej ){
+      Q1->v[t] = ei;
+      if ( i == Q1->s ){
+        QUEUE_subcpy (Q1, Q1->s, Q2, Q2->s, (j+Q2->end-Q2->s)%Q2->end);
+        return;
+      }
+      QUEUE_DECREMENT(*Q1,i);
+      ei = Q1->v[i];
+    } else {  
+      Q1->v[t] = ej;
+      if ( j == Q2->s ) return;
+      QUEUE_DECREMENT(*Q2,j);
+      ej = Q2->v[j];
+    }
+    QUEUE_DECREMENT(*Q1,t);
+  }
+}
+
+/* delete all elements of Q1 included in Q2.
+ both Q1 and Q2 have to be sorted in increasing order */
+void QUEUE_minus_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->s, i2 = Q2->s, ii=Q1->s;
+  while ( i != Q1->t && i2 != Q2->t){
+    if (Q1->v[i] > Q2->v[i2] ) i2++;
+    else {
+      if (Q1->v[i] < Q2->v[i2] ){
+        Q1->v[ii] = Q1->v[i];
+        ii++;
+      }
+      i++;
+    }
+  }
+  while ( i != Q1->t ){
+    Q1->v[ii] = Q1->v[i];
+    i++;
+    ii++;
+  }
+  Q1->t = ii;
+}
+void QUEUE_minus (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->s, i2 = Q2->s, ii=Q1->s;
+  while ( i != Q1->t && i2 != Q2->t ){
+    if ( Q1->v[i] > Q2->v[i2] ) QUEUE_INCREMENT (*Q2, i2);
+    else {
+      if ( Q1->v[i] < Q2->v[i2] ){
+        Q1->v[ii] = Q1->v[i];
+        QUEUE_INCREMENT (*Q1, ii);
+      }
+      QUEUE_INCREMENT (*Q1, i);
+    }
+  }
+  while ( i != Q1->t ){
+    Q1->v[ii] = Q1->v[i];
+    QUEUE_INCREMENT (*Q1, i);
+    QUEUE_INCREMENT (*Q1, ii);
+  }
+  Q1->t = ii;
+}
+
+/* Delete all elements of Q1 which are not included in Q2. 
+ both Q1 and Q2 have to be sorted in increasing order */
+QUEUE_ID QUEUE_intsec_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->s, i2 = Q2->s, c=0;
+  while ( i != Q1->t ){
+    if ( Q1->v[i] > Q2->v[i2] ){
+      if ( ++i2 == Q2->t ) break;
+    } else {
+      if ( Q1->v[i] == Q2->v[i2] ) c++;
+      i++;
+    }
+  }
+  return (c);
+}
+void QUEUE_and_ (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->s, i2 = Q2->s, ii=Q1->s;
+  while ( i != Q1->t ){
+    if ( Q1->v[i] > Q2->v[i2] ){
+      if ( ++i2 == Q2->t ) break;
+    } else {
+      if ( Q1->v[i] == Q2->v[i2] ) Q1->v[ii++] = Q1->v[i];
+      i++;
+    }
+  }
+  Q1->t = ii;
+}
+void QUEUE_and (QUEUE *Q1, QUEUE *Q2){
+  QUEUE_ID i=Q1->s, i2 = Q2->s, ii=Q1->s;
+  while ( i != Q1->t && i2 != Q2->t){
+    if ( Q1->v[i] > Q2->v[i2] ) QUEUE_INCREMENT (*Q2, i2);
+    else {
+      if ( Q1->v[i] == Q2->v[i2] ){
+        Q1->v[ii] = Q1->v[i];
+        QUEUE_INCREMENT (*Q1, ii);
+      }
+      QUEUE_INCREMENT (*Q1, i);
+    }
+  }
+  Q1->t = ii;
+}
+
+/* insertion sort */
+void QUEUE_sort (QUEUE *Q){
+  QUEUE_ID i = Q->s, j, jj;
+  QUEUE_INT e;
+  if ( i== Q->t ) return;
+  QUEUE_INCREMENT(*Q,i);
+  for ( ; i!=Q->t ; QUEUE_INCREMENT(*Q,i) ){
+    e=Q->v[i]; 
+    j=i; 
+    while (1){
+      jj = j;
+      QUEUE_DECREMENT(*Q,j);
+      if ( Q->v[j] <= e ) { Q->v[jj] = e; break; }
+      Q->v[jj] = Q->v[j];
+      if ( j == Q->s) { Q->v[j] = e; break; }
+    }
+  }
+}
+
+
+/* print a queue */
+void QUEUE_print (QUEUE *Q){
+  QUEUE_ID i;
+  for ( i=Q->s ; i!=Q->t ; ){
+    printf (QUEUE_INTF" ", Q->v[i]);
+    QUEUE_INCREMENT(*Q,i);
+  }
+  printf ("\n");
+}
+/* permutation version */
+void QUEUE_perm_print (QUEUE *Q, QUEUE_ID *q){
+  QUEUE_ID i;
+  for ( i=Q->s ; i!=Q->t ; ){
+    printf (QUEUE_INTF" ", q[Q->v[i]]);
+    QUEUE_INCREMENT(*Q,i);
+  }
+  printf ("\n");
+}
+void QUEUE_printn (QUEUE *Q){
+  QUEUE_ID i;
+  for ( i=Q->s ; i!=Q->t ; ){
+    printf (QUEUE_INTF" ", Q->v[i]);
+    QUEUE_INCREMENT(*Q,i);
+  }
+}
+void QUEUE_perm_printn (QUEUE *Q, QUEUE_ID *q){
+  QUEUE_ID i;
+  for ( i=Q->s ; i!=Q->t ; ){
+    printf (QUEUE_INTF" ",q[Q->v[i]]);
+    QUEUE_INCREMENT(*Q,i);
+  }
+}
+void QUEUE_print_ (QUEUE *Q){
+  QUEUE_ID i;
+  printf("s="QUEUE_IDF",t="QUEUE_INTF": ", Q->s, Q->t);
+  for ( i=Q->s ; i!=Q->t ; ){
+    printf (QUEUE_INTF" ",Q->v[i]);
+    QUEUE_INCREMENT(*Q,i);
+  }
+  printf ("\n");
+}
+
+void QUEUE_print__ (QUEUE *Q){
+  QUEUE_ID i;
+  printf("s="QUEUE_IDF",t="QUEUE_IDF": ", Q->s, Q->t);
+  for ( i=Q->s ; i!=Q->t ; i++ ) printf (QUEUE_INTF" ",Q->v[i]);
+  printf ("\n");
+}
+
+#endif