nysol-zdd 3.0.2

data/ext/zdd_so/bddc.h

@@ -0,0 +1,132 @@
+/*****************************************
+*  BDD Package (SAPPORO-1.57)   - Header *
+*  (C) Shin-ichi MINATO  (June 14, 2013) *
+******************************************/
+
+#ifndef bddc_h
+#define bddc_h
+
+#if (defined BDD_CPP)||(! defined B_OLDC)
+#  define B_ARG(a) a       /* ANSI C style */
+#else
+#  define B_ARG(a) ()      /* K&R C style */
+#endif
+
+/***************** Internal macro for index *****************/
+#define B_VAR_WIDTH 16U  /* Width of variable index */
+#define B_VAR_MASK       ((1U << B_VAR_WIDTH) - 1U)
+
+/***************** Internal macro for bddp *****************/
+#ifdef B_64
+#  define B_MSB_POS   39ULL
+#  define B_LSB_MASK  1ULL
+#else
+#  define B_MSB_POS   31U
+#  define B_LSB_MASK  1U
+#endif
+#define B_MSB_MASK  (B_LSB_MASK << B_MSB_POS)
+#define B_INV_MASK  B_LSB_MASK /* Mask of inverter-flag */
+#define B_CST_MASK  B_MSB_MASK /* Mask of constant-flag */
+#define B_VAL_MASK  (B_MSB_MASK - 1U)
+                      /* Mask of value-field */
+
+/***************** For stack overflow limit *****************/
+extern const int BDD_RecurLimit;
+extern int BDD_RecurCount;
+ 
+/***************** External typedef *****************/
+typedef unsigned int bddvar;
+#ifdef B_64
+  typedef unsigned long long bddp;
+#else
+  typedef unsigned int bddp;
+#endif
+
+/***************** External Macro *****************/
+#define bddvarmax B_VAR_MASK /* Max value of variable index */
+#define bddnull   B_VAL_MASK /* Special value for null pointer */
+#define bddfalse  B_CST_MASK /* bddp of constant false (0) */
+#define bddtrue   (bddfalse ^ B_INV_MASK)
+                    /* bddp of constant true (1) */
+#define bddempty  bddfalse /* bddp of empty ZBDD (0) */
+#define bddsingle bddtrue  /* bddp of single unit ZBDD (1) */
+#define bddconst(c) (((c) & B_VAL_MASK) | B_CST_MASK)
+                    /* bddp of a constant valued node */
+#define bddvalmax B_VAL_MASK  /* Max constant value */
+
+#ifdef BDD_CPP
+  extern "C" {
+#endif /* BDD_CPP */
+
+/***************** External operations *****************/
+
+/***************** Init. and config. ****************/
+extern int    bddinit B_ARG((bddp initsize, bddp limitsize));
+extern bddvar bddnewvar B_ARG((void));
+extern bddvar bddnewvaroflev B_ARG((bddvar lev));
+extern bddvar bddlevofvar B_ARG((bddvar v));
+extern bddvar bddvaroflev B_ARG((bddvar lev));
+extern bddvar bddvarused B_ARG((void));
+
+/************** Basic logic operations *************/
+extern bddp   bddprime B_ARG((bddvar v));
+extern bddvar bddtop B_ARG((bddp f));
+extern bddp   bddcopy B_ARG((bddp f));
+extern bddp   bddnot B_ARG((bddp f));
+extern bddp   bddand B_ARG((bddp f, bddp g));
+extern bddp   bddor B_ARG((bddp f, bddp g));
+extern bddp   bddxor B_ARG((bddp f, bddp g));
+extern bddp   bddnand B_ARG((bddp f, bddp g));
+extern bddp   bddnor B_ARG((bddp f, bddp g));
+extern bddp   bddxnor B_ARG((bddp f, bddp g));
+extern bddp   bddat0 B_ARG((bddp f, bddvar v));
+extern bddp   bddat1 B_ARG((bddp f, bddvar v));
+
+/********** Memory management and observation ***********/
+extern void   bddfree B_ARG((bddp f));
+extern bddp   bddused B_ARG((void));
+extern int    bddgc B_ARG((void));
+extern bddp   bddsize B_ARG((bddp f));
+extern bddp   bddvsize B_ARG((bddp *p, int lim));
+extern void   bddexport B_ARG((FILE *strm, bddp *p, int lim));
+extern int    bddimport B_ARG((FILE *strm, bddp *p, int lim));
+extern void   bdddump B_ARG((bddp f));
+extern void   bddvdump B_ARG((bddp *p, int lim));
+extern void   bddgraph B_ARG((bddp f));
+extern void   bddgraph0 B_ARG((bddp f));
+extern void   bddvgraph B_ARG((bddp *p, int lim));
+extern void   bddvgraph0 B_ARG((bddp *p, int lim));
+
+/************** Advanced logic operations *************/
+extern bddp   bddlshift B_ARG((bddp f, bddvar shift));
+extern bddp   bddrshift B_ARG((bddp f, bddvar shift));
+extern bddp   bddsupport B_ARG((bddp f));
+extern bddp   bdduniv B_ARG((bddp f, bddp g));
+extern bddp   bddexist B_ARG((bddp f, bddp g));
+extern bddp   bddcofactor B_ARG((bddp f, bddp g));
+extern int    bddimply B_ARG((bddp f, bddp g));
+extern bddp   bddrcache B_ARG((unsigned char op, bddp f, bddp g));
+extern void   bddwcache
+              B_ARG((unsigned char op, bddp f, bddp g, bddp h));
+
+/************** ZBDD operations *************/
+extern bddp   bddoffset B_ARG((bddp f, bddvar v));
+extern bddp   bddonset B_ARG((bddp f, bddvar v));
+extern bddp   bddonset0 B_ARG((bddp f, bddvar v));
+extern bddp   bddchange B_ARG((bddp f, bddvar v));
+extern bddp   bddintersec B_ARG((bddp f, bddp g));
+extern bddp   bddunion B_ARG((bddp f, bddp g));
+extern bddp   bddsubtract B_ARG((bddp f, bddp g));
+extern bddp   bddcard B_ARG((bddp f));
+extern bddp   bddlit B_ARG((bddp f));
+extern bddp   bddlen B_ARG((bddp f));
+extern int    bddimportz B_ARG((FILE *strm, bddp *p, int lim));
+
+/************** SeqBDD operations *************/
+extern bddp   bddpush B_ARG((bddp f, bddvar v));
+
+#ifdef BDD_CPP
+  }
+#endif /* BDD_CPP */
+
+#endif /* bddc_h */

data/ext/zdd_so/extconf.rb

@@ -0,0 +1,25 @@
+require 'mkmf'
+cp = "$(srcdir)"
+$CFLAGS = " -O3 -Wall -I. -I#{cp}/include -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+$CPPFLAGS = " -O3 -Wall -I. -I#{cp}/include  -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+$CXXFLAGS = " -O3 -Wall -I. -I#{cp}/include  -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+
+
+$LOCAL_LIBS += " -lstdc++"
+
+if RUBY_VERSION >= '2.0.0' then
+	if Gem::Platform::local.os =~ /darwin/ then
+	$CFLAGS += " -Wno-error=unused-command-line-argument-hard-error-in-future"
+	$CPPFLAGS += " -Wno-error=unused-command-line-argument-hard-error-in-future"
+	$LOCAL_LIBS += " -Wno-error=unused-command-line-argument-hard-error-in-future"
+	end
+end
+
+
+if RUBY_VERSION < '1.9.0'
+	$CFLAGS += " -o $@"
+end
+
+
+create_makefile("nysol/zdd_so")
+

data/ext/zdd_so/include/aheap.c

@@ -0,0 +1,211 @@
+/*
+    array-based simple heap (fixex size)
+            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 _aheap_c_
+#define _aheap_c_
+
+#include"aheap.h"
+
+QSORT_TYPE (AHEAP_KEY, AHEAP_KEY)
+QSORT_TYPE (AHEAP_ID, AHEAP_ID)
+AHEAP INIT_AHEAP = {TYPE_AHEAP,NULL,0,0};
+
+/* allocate memory */
+void AHEAP_alloc (AHEAP *H, AHEAP_ID num){
+  AHEAP_ID i;
+#ifdef ERROR_CHECK
+  if ( num<0 ) error_num ("size is out of range", num, EXIT);
+#endif
+  *H = INIT_AHEAP;
+  if ( num>0 ) malloc2 (H->v, num*2, "AHEAP_alloc: H->v", EXIT);
+  H->end = num;
+  ARY_FILL (H->v, 0, num*2, AHEAP_KEYHUGE);
+  for (i=0 ; i<num-1 ; i=i*2+1);
+  H->base = i - num + 1;
+}
+
+/* termination */
+void AHEAP_end (AHEAP *H){
+  free2 (H->v);
+  *H = INIT_AHEAP;
+}
+
+/* return the index of the leaf having the minimum key among the descendants
+  of the given node i. If several leaves with the smallest key are there, 
+  return the minimum index among them if f=0, maximum index if f=1, and
+  random choice if f=2  */
+/* random choice version. choose one child to go down randomly for each node,
+   thus it is not uniformly random */
+AHEAP_ID AHEAP_findmin_node (AHEAP *H, AHEAP_ID i, int f){
+  if ( H->end <= 0 ) return (-1); 
+  while ( i < H->end-1 ){
+    if ( H->v[i*2+1] == H->v[i] )
+      if ( H->v[i*2+2] == H->v[i] )
+        if ( f == 2 ) i = i*2 + 1 + rand()%2;
+        else i = i*2+1+f;
+      else i = i*2+1;
+    else i = i*2+2;
+  }
+  return (AHEAP_IDX(*H, i) );
+}
+AHEAP_ID AHEAP_findmin_head (AHEAP *H){ return (AHEAP_findmin_node (H, 0, 0) ); }
+AHEAP_ID AHEAP_findmin_tail (AHEAP *H){ return (AHEAP_findmin_node (H, 0, 1) ); }
+AHEAP_ID AHEAP_findmin_rnd (AHEAP *H){ return (AHEAP_findmin_node (H, 0, 2) ); }
+
+/* return the index of the leaf having smaller value than a among the
+  descendants of the given node i. If several leaves with the smallest key
+  are there, return the minimum index among them if f=0, maximum index if f=1,
+  and random choice if f=2  */
+AHEAP_ID AHEAP_findlow_node (AHEAP *H, AHEAP_KEY a, AHEAP_ID i, int f){
+  if ( H->end == 0 ) return (-1); 
+  if ( H->v[0] > a ) return (-1);
+  while ( i < H->end-1 ){
+    if ( f == 2 ) {
+      if ( H->v[i*2+1] <= a )
+          if ( H->v[i*2+2] <= a ) i = i*2 + 1 + rand()%2;
+          else i = i*2+1;
+      else i = i*2+2;
+    } else if ( H->v[i*2+1] <= a ) i = i*2+1+f; else i = i*2+2-f;
+  }
+  return (AHEAP_IDX(*H, i) );
+}
+AHEAP_ID AHEAP_findlow_head (AHEAP *H, AHEAP_KEY a){ return (AHEAP_findlow_node (H, a, 0, 0) ); }
+AHEAP_ID AHEAP_findlow_tail (AHEAP *H, AHEAP_KEY a){ return (AHEAP_findlow_node (H, a, 0, 1) ); }
+AHEAP_ID AHEAP_findlow_rnd (AHEAP *H, AHEAP_KEY a){ return (AHEAP_findlow_node (H, a, 0, 2) ); }
+
+/* return the index of the leaf having smaller value than a next/previous to
+  leaf i. return -1 if such a leaf does not exist  */
+AHEAP_ID AHEAP_findlow_nxt (AHEAP *H, AHEAP_ID i, AHEAP_KEY a){
+  if ( H->end == 0 ) return (-1); 
+  for (i=AHEAP_LEAF(*H,i); i>0 ; i=(i-1)/2){
+     /* i is the child of smaller index, and the key of the sibling of i is less than a */
+    if ( i%2 == 1 && H->v[i+1] <= a ) return (AHEAP_findlow_node (H, a, i+1, 0) );
+  }
+  return (-1);
+}
+AHEAP_ID AHEAP_findlow_prv (AHEAP *H, AHEAP_ID i, AHEAP_KEY a){
+  if ( H->end == 0 ) return (-1); 
+  for (i=AHEAP_LEAF(*H,i); i>0 ; i=(i-1)/2){
+     /* i is the child of larger index, and the key of the sibling of i is less than a */
+    if ( i%2 == 0 && H->v[i-1] <= a ) return (AHEAP_findlow_node (H, a, i-1, 1) );
+  }
+  return (-1);
+}
+
+/* change the key of node i to a /Add a to the key of node i, and update heap H */
+void AHEAP_chg (AHEAP *H, AHEAP_ID i, AHEAP_KEY a){
+  i = AHEAP_LEAF (*H, i);
+  H->v[i] = a;
+  AHEAP_update (H, i);
+}
+void AHEAP_add (AHEAP *H, AHEAP_ID i, AHEAP_KEY a){
+  i = AHEAP_LEAF (*H, i);
+  H->v[i] += a;
+  AHEAP_update (H, i);
+}
+
+/* update the ancestor of node i */
+void AHEAP_update (AHEAP *H, AHEAP_ID i){
+  AHEAP_ID j;
+  AHEAP_KEY a = H->v[i];
+  while ( i>0 ){
+    j = i - 1 + (i%2)*2;   /* j = the sibling of i */
+    i = (i-1) / 2;
+    if ( H->v[j] < a ) a = H->v[j];
+    if ( a == H->v[i] ) break;
+    H->v[i] = a;
+  }
+}
+
+/* find the leaf with the minimum key value among the leaves having index 
+ smaller/larger than i, or between i and j */
+AHEAP_ID AHEAP_upper_min (AHEAP *H, AHEAP_ID i){
+  AHEAP_ID fi=0, j = AHEAP_LEAF (*H, H->end - 1);
+  AHEAP_KEY fm = AHEAP_KEYHUGE;
+  if ( i == 0 ) return (AHEAP_findmin_head (H) );
+  i = AHEAP_LEAF (*H, i-1);
+  while ( i != j ){
+    if ( i%2 ){ /* if i is the child with smaller index */
+      if ( fm > H->v[i+1] ){
+        fm = H->v[i+1];
+        fi = i+1;
+      }
+    }
+    i = (i-1)/2;
+    if ( j == i ) break;  /* stop if the right pointer and the left pointer are the same */
+    j = (j-1)/2;
+  }
+  while ( fi < H->end-1 ) fi = fi*2 + (H->v[fi*2+1]<=fm?1:2);
+  return ( AHEAP_IDX(*H, fi) );
+}
+AHEAP_ID AHEAP_lower_min (AHEAP *H, AHEAP_ID i){
+  AHEAP_ID fi=0, j = AHEAP_LEAF (*H, 0);
+  AHEAP_KEY fm = AHEAP_KEYHUGE;
+  if ( i == H->end-1 ) return (AHEAP_findmin_head (H) );
+  i = AHEAP_LEAF (*H, i+1);
+  while ( i != j ){
+    if ( i%2 == 0 ){ /* if i is the child of larger index */
+      if ( fm > H->v[i-1] ){
+        fm = H->v[i-1];
+        fi = i-1;
+      }
+    }
+    j = (j-1)/2;
+    if ( j == i ) break;  /* stop if the right pointer and the left pointer are the same */
+    i = (i-1)/2;
+  }
+  while ( fi < H->end-1 ) fi = fi*2 + (H->v[fi*2+1]<=fm?1:2);
+  return (AHEAP_IDX(*H, fi) );
+}
+
+/* find the index having the minimum among given two indices */
+AHEAP_ID AHEAP_interval_min (AHEAP *H, AHEAP_ID i, AHEAP_ID j){
+  AHEAP_ID fi=0;
+  AHEAP_KEY fm = AHEAP_KEYHUGE;
+  if ( i == 0 ) return (AHEAP_lower_min (H, j) );
+  if ( j == H->end-1 ) return (AHEAP_upper_min (H, i) );
+  i = AHEAP_LEAF (*H, i-1);
+  j = AHEAP_LEAF (*H, j+1);
+  while ( i != j && i != j-1 ){
+    if ( i%2 ){ /* if i is the child of smaller index */
+      if ( fm > H->v[i+1] ){
+        fm = H->v[i+1];
+        fi = i+1;
+      }
+    }
+    i = (i-1)/2;
+    if ( j == i || j == i+1 ) break;  /* stop if the right pointer and the left pointer are the same */
+    if ( j%2 == 0 ){ /* if j is the child of larger index */
+      if ( fm > H->v[j-1] ){
+        fm = H->v[j-1];
+        fi = j-1;
+      }
+    }
+    j = (j-1)/2;
+  }
+  while ( fi < H->end-1 )
+      fi = fi*2 + (H->v[fi*2+1] <= fm?1:2);
+  return (AHEAP_IDX(*H, fi) );
+}
+
+/* print heap keys according to the structure of the heap */
+void AHEAP_print (AHEAP *H){
+  AHEAP_ID i, j=1;
+  while ( j<=H->end*2-1 ){
+    FLOOP (i, j-1, MIN(j, H->end)*2-1) printf (AHEAP_KEYF ",", H->v[i] );
+    printf ("\n");
+    j = j*2;
+  }
+}
+
+#endif

data/ext/zdd_so/include/aheap.h

@@ -0,0 +1,111 @@
+/*
+    array-based simple heap (fixed size)
+            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. */
+
+/* bench mark
+  PentiumIII 500MHz, Memory 256MB Linux
+  values 0-1,000,000 : set & del & get  1,000,000 times
+  2.55sec
+
+  # rotation  == 1/5 per 1 set/del
+
+   *** simple array *** 
+   value 0-1,000,000 set & set & set   1,000,000 times,
+   0.88sec 
+  */
+
+#ifndef _aheap_h_
+#define _aheap_h_
+
+#include"stdlib2.h"
+
+#ifndef AHEAP_KEY
+ #ifdef AHEAP_KEY_DOUBLE
+  #define AHEAP_KEY  double
+  #define AHEAP_KEYHUGE DOUBLEHUGE
+  #define AHEAP_KEYF "%f"
+ #elif defined(AHEAP_KEY_WEIGHT)
+  #define AHEAP_KEY  WEIGHT
+  #define AHEAP_KEYHUGE WEIGHTHUGE
+  #define AHEAP_KEYF WEIGHTF
+ #else
+#define AHEAP_KEY  int
+  #define AHEAP_KEYHUGE INTHUGE
+  #define AHEAP_KEYF "%d"
+ #endif
+#endif
+
+#ifndef AHEAP_ID
+ #define AHEAP_ID int
+ #define AHEAP_ID_END INTHUGE
+ #define AHEAP_IDF "%d"
+#endif
+
+#define AHEAP_IDX(H,i) (((i)+1-(H).base)%(H).end)
+#define AHEAP_LEAF(H,i)   (((i)+(H).base)%(H).end+(H).end-1)
+#define AHEAP_H(H,i)   (H).v[(((i)+(H).base)%(H).end+(H).end-1)]
+
+typedef struct {
+  unsigned char type;
+  AHEAP_KEY *v;       /* array for heap key */
+  int end;            /* the number of maximum elements */
+  int base;           /* the constant for set 0 to the leftmost leaf */
+} AHEAP;
+
+QSORT_TYPE_HEADER (AHEAP_KEY, AHEAP_KEY)
+QSORT_TYPE_HEADER (AHEAP_ID, AHEAP_ID)
+extern AHEAP INIT_AHEAP;
+
+/* initialization. allocate memory for H and fill it by +infinity */
+void AHEAP_alloc (AHEAP *H, int num);
+void AHEAP_end (AHEAP *H);
+
+/* return the index of the leaf having the minimum key among the descendants
+  of the given node i. If several leaves with the smallest key are there, 
+  return the minimum index among them if f=0, maximum index if f=1, and
+  random choice if f=2  */
+AHEAP_ID AHEAP_findmin_node (AHEAP *H, AHEAP_ID i, int f);
+AHEAP_ID AHEAP_findmin_head (AHEAP *H);
+AHEAP_ID AHEAP_findmin_tail (AHEAP *H);
+AHEAP_ID AHEAP_findmin_rnd (AHEAP *H);
+
+/* return the index of the leaf having smaller value than a among the
+  descendants of the given node i. If several leaves with the smallest key
+  are there, return the minimum index among them if f=0, maximum index if f=1,
+  and random choice if f=2  */
+AHEAP_ID AHEAP_findlow_node (AHEAP *H, AHEAP_KEY a, AHEAP_ID i, int f);
+AHEAP_ID AHEAP_findlow_head (AHEAP *H, AHEAP_KEY a);
+AHEAP_ID AHEAP_findlow_tail (AHEAP *H, AHEAP_KEY a);
+AHEAP_ID AHEAP_findlow_rnd (AHEAP *H, AHEAP_KEY a);
+
+/* return the index of the leaf having smaller value than a next/previous to
+  leaf i. return -1 if such a leaf does not exist  */
+AHEAP_ID AHEAP_findlow_nxt (AHEAP *H, AHEAP_ID i, AHEAP_KEY a);
+AHEAP_ID AHEAP_findlow_prv (AHEAP *H, AHEAP_ID i, AHEAP_KEY a);
+
+/* change the key of node i to a /Add a to the key of node i, and update heap H */
+void AHEAP_chg (AHEAP *H, AHEAP_ID i, AHEAP_KEY a);
+void AHEAP_add (AHEAP *H, AHEAP_ID i, AHEAP_KEY a);
+
+/* update the ancestor of node i */
+void AHEAP_update (AHEAP *H, AHEAP_ID i);
+
+/* find the leaf with the minimum key value among the leaves having index 
+ smaller/larger than i, or between i and j */
+AHEAP_ID AHEAP_upper_min (AHEAP *H, AHEAP_ID i);
+AHEAP_ID AHEAP_lower_min (AHEAP *H, AHEAP_ID i);
+AHEAP_ID AHEAP_interval_min (AHEAP *H, AHEAP_ID i, AHEAP_ID j);
+
+/* print heap keys according to the structure of the heap */
+void AHEAP_print (AHEAP *H);
+
+#endif