chemruby 0.9.3 → 1.1.9

data/README

@@ -52,7 +52,7 @@ For testing and developing ChemRuby:
 
 == INSTALL
 
-In the chemruby source directory (such as chemruby-x.x.x/), run install.rb
+In the chemruby source directory (such as chemruby-x.x.x/), run setup.rb
 as follows:
 
   % ruby setup.rb config
@@ -109,7 +109,7 @@ Note that, setup.rb included in the ChemRuby package comes from
 
 License of This README file can be also distributed under the Ruby's license.
 
-  Copyright (C) 2006 TANAKA   Nobuya   <tanaka@chemruby.org>
+  Copyright (C) 2006 TANAKA   Nobuya   <t@chemruby.org>
                      KATAYAMA Toshiaki <k@bioruby.org>
 
 == CONTACT

data/Rakefile

@@ -8,12 +8,15 @@
 
 require 'rake/clean'
 require 'rake/testtask'
-require 'rake/gempackagetask'
+
+require "rake/gempackagetask"
+require 'rubygems'
 
 task :default => [:help]
 
-PKG_VERSION = "0.9.3"
 PKG_BUILD   = "RC1"
+PKG_VERSION = "1.1.9"
+
 
 PKG_FILES = FileList[
   "Rakefile", "README", #"ChangeLog", "Releases", "TODO", 
@@ -26,6 +29,7 @@ PKG_FILES = FileList[
   "lib/**/*.rb",
   "lib/**/*.ry",
   "test/**/*",
+  "temp/",
   "sample/**/*.rb",
   "sample/**/*.mol",
   "ext/**/*.h", 
@@ -37,76 +41,30 @@ PKG_FILES = FileList[
 #  "test/**/*"
 ]
 
-task :help do |t|
-  puts <<EOL
-
-  ChemRuby #{PKG_VERSION}
-
-  To install ChemRuby, you need at least
-
-    * ruby-1.8.2 (or later)
-    * Ruby header files (included in original Ruby)
-    * C language compilers  (such as gcc)
-
-  If the following modules are installed, ChemRuby will use it.
-  You can install them later.
-
-    * RMagick ( You will find how to install them in http://www.chemruby.org)
-
-  == Compiling and Installing
-
-  % rake compile
-  % sudo rake install
-
-  or just
-
-  % sudo ruby setup.rb
-
-  == Compiling RDOC
-
-  % rake doc
-
-  == Test
-
-  % rake test
-
-  You will need RMagick and other libraries to  pass all the tests.
-
-EOL
-  
-end
-
 task :doc do |t|
   system "rdoc --main README ./lib README"
 end
 
 
-task :dev => [:test]
+task :dev => [:compile]
 Rake::TestTask.new(:dev) do |t|
   t.libs << File.join('ext')
   t.libs << File.join('lib')
-  t.libs << File.join('dev/lib')
-  t.libs << File.join('dev/ext')
-#   cd 'dev/ext/chem/db/inchi/'  do
-#     ruby %{extconf.rb}
-#     sh "make"
-#   end
-  t.test_files = FileList['dev/test/test*.rb']
+  t.test_files = FileList['test/ts_current.rb']
 end
 
 task :test => [:compile]
 Rake::TestTask.new(:test) do |t|
   t.libs << File.join('ext')
   t.libs << File.join('lib')
-  t.test_files = FileList['test/test*.rb']
+  t.test_files = FileList['test/ts_main.rb']
 end
 
 task :light => [:compile]
 Rake::TestTask.new(:light) do |t|
   t.libs << File.join('ext')
   t.libs << File.join('lib')
-  t.test_files = FileList['test/test_subcomp.rb']
-  #'test/test_kegg.rb'# 'test/test_kcf_glycan.rb' #FileList['test/test_canonical_smiles.rb']
+  t.test_files = FileList['test/tc_sssr.rb']
 end
 
 task :rm do
@@ -179,17 +137,63 @@ end
 desc "Compiling library"
 task :compile => ['lib/chem/db/smiles/smiparser.rb', 'lib/chem/db/iupac/iuparser.rb', 'lib/chem/db/linucs/linparser.rb', "ext/subcomp.#{Config::CONFIG["DLEXT"]}"]
 
-spec = Gem::Specification.new do |s|
-  s.name = 'chemruby'
-  s.version = PKG_VERSION
-  s.require_path = 'lib'
-  s.autorequire = 'chem'
-  s.files = PKG_FILES
-  s.extensions << 'ext/extconf.rb'  
-  s.summary = "A framework program for cheminformatics"
+begin
+  require 'rake/gempackagetask'
+
+  spec = Gem::Specification.new do |s|
+    s.name = 'chemruby'
+    s.version = PKG_VERSION
+    s.require_path = 'lib'
+    s.autorequire = 'chem'
+    s.files = PKG_FILES
+    s.extensions << 'ext/extconf.rb'  
+    s.summary = "A framework program for cheminformatics"
+  end
+
+  Rake::GemPackageTask.new(spec) do |pkg|
+    pkg.need_tar = true
+    pkg.need_tar_gz = true
+    pkg.package_files += PKG_FILES
+  end
+rescue
+  puts 'Install RubyGems to make gem'
 end
 
-Rake::GemPackageTask.new(spec) do |pkg|
-  pkg.need_tar = true
-  pkg.package_files += PKG_FILES
+task :help do |t|
+  puts <<EOL
+
+  ChemRuby #{PKG_VERSION}
+
+  To install ChemRuby, you need at least
+
+    * ruby-1.8.2 (or later)
+    * Ruby header files (included in original Ruby)
+    * C language compilers  (such as gcc)
+
+  If the following modules are installed, ChemRuby will use it.
+  You can install them later.
+
+    * RMagick ( You will find how to install them in http://www.chemruby.org)
+
+  == Compiling and Installing
+
+  % rake compile
+  % sudo rake install
+
+  or just
+
+  % sudo ruby setup.rb
+
+  == Compiling RDOC
+
+  % rake doc
+
+  == Test
+
+  % rake test
+
+  You will need RMagick and other libraries to  pass all the tests.
+
+EOL
+  
 end

data/ext/extconf.rb

@@ -1,4 +1,6 @@
 
 require 'mkmf'
 
+# $CFLAGS = " -g -lefence"
+
 create_makefile("subcomp")

data/ext/subcomp.c

@@ -4,413 +4,554 @@
 
   $Author: nobyt $
 
-  Copyright (C) 2004-2006 Nobuya Tanaka
+  Copyright (C) 2004-2007 Nobuya Tanaka
 
 **********************************************************************/
 
-#define FULL 0xffffffff
-#define ZERO 0x0
-
-#define FAIL 0;
-#define SUCCESS 1;
-
 #include <ruby.h>
+// #include "bitdb.h"
+#include "utils.h"
 
 static void
-show(long *m, int pa, int pb)
-{
-  int i, j, k;
-  static int count = 0;
-  int n_words;
-
-  n_words = (pb - 1) / (sizeof(int) * 8) + 1;
+show(long * l, int h, int w){
+  int i, j;
+  int counter = 0;
+  int n_bytes;
 
-  //printf("count : %3d\n", count++);
+  n_bytes = NBYTES(w);
 
-  printf("\n  ");
-  for(i = 0 ; i < pb ; i++){
+  printf("    ");
+  for(i = 0 ; i < w ; i++){
     printf("%d", i % 10);
   }
   printf("\n");
-  for(i = 0 ; i < pa * n_words ; i += n_words){
-    printf("%d ", (i / n_words) % 10);
-    for(k = 0 ; k < n_words ; k++){
-      for(j = k * 32 ; j < ((k + 1) * 32 < pb ? (k + 1) * 32 : pb) ; j++){
-	if(m[i + k ] & (1 << (j - k * 32)))
-	  printf("@");
-	else
-	  printf(".");
-      }
-      //printf(" ");
+
+  for(i = 0 ; i < h ; i++){
+    printf("%3d ", i);
+    for(j = 0 ; j < n_bytes ; j++){
+      dump_long(l[counter], (j == n_bytes - 1) ? ((w - 1) % ARCH + 1) : ARCH);
+      counter++;
     }
     printf("\n");
   }
-  printf("\n");
 }
 
-/*
- *  call-seq:
- *     SubGraphDB.show  -> print out adjacency matrix
- *
- *  This function is mainly for debug.
- */
-
-static VALUE
-subcomp_show(VALUE self, VALUE str, VALUE pa, VALUE pb)
+static FILE *
+db_file_open(const char * filename, const char * extension)
 {
-  printf("subcomp_show called %3d %3d\n", FIX2INT(pa), FIX2INT(pb));
-  show((long * )RSTRING(str)->ptr, FIX2INT(pa), FIX2INT(pb));
-  return Qnil;
+  FILE * fp;
+  char new_filename[50];
+  
+  strncpy(new_filename, filename, sizeof(new_filename) - 5);
+  strncat(new_filename, extension, sizeof(new_filename) - strlen(extension) - 1);
+
+  fp = fopen(new_filename, "r");
+
+  if(fp == NULL){
+    rb_raise(rb_eException, "File can not open");
+  }
+  return fp;
 }
 
+struct CompoundDB{
+  FILE * mat;
+  FILE * idx;
+  FILE * typ;
+};
 
-/*
- * returns number of trailing zero of m-bit
- */
-static int ntz_m(long *y, int pb){
-  int i = 0;
-  int n;
-  long x;
+struct Query{
+  int    len;
+  int    edge_len;
 
-  n = 1;
+  long * type;
+  int ** ptr;
+  int  * num;
+  int  * idx;
+};
 
-  while(i < pb && y[i] == 0){
-    n += 32;
-    i++;
-  }
+struct Target{
+  int    n_bits;
+  int    n_bytes;
 
-  x = y[i];
+  int    max_length;
 
-  if((x & 0x0000FFFF) == 0) {n = n + 16 ; x = x >> 16;}
-  if((x & 0x000000FF) == 0) {n = n +  8 ; x = x >>  8;}
-  if((x & 0x0000000F) == 0) {n = n +  4 ; x = x >>  4;}
-  if((x & 0x00000003) == 0) {n = n +  2 ; x = x >>  2;}
-  return n - (x & 1);
-}
+  long * mat;
+  long * typ;
+};
+
+struct State{
+  int height;
+  int width;
+  int n_bytes;
+  
+  int    max_length;
+  int    length;
+  long * mat;
+  int    depth;
+
+  long * res;
+  int    res_counter;
+  int    res_max_len;
+};
+
+struct Record{
+  int   n_bits;
+  int   n_bytes;
+  int   mat_pos;
+  int   information;
+};
 
-static int ntz(long x){
-  int n;
+query_dump(struct Query * query){
+  int i, j;
 
-  if (x == 0) return (32);
-  n = 1;
-  if((x & 0x0000FFFF) == 0) {n = n + 16 ; x = x >> 16;}
-  if((x & 0x000000FF) == 0) {n = n +  8 ; x = x >>  8;}
-  if((x & 0x0000000F) == 0) {n = n +  4 ; x = x >>  4;}
-  if((x & 0x00000003) == 0) {n = n +  2 ; x = x >>  2;}
-  return n - (x & 1);
+  for(i = 0 ; i < query->len ; i++){
+    for(j = 0 ; j < query->num[i] ; j++){
+      printf("query->ptr[%d][%d] = %d\n", i, j, query->ptr[i][j]);
+    }
+  }
 }
 
-static int ntz_n_words(long * x, int n_words){
-  int i;
-  int words = 0;
-  for(i = 0 ; x[i] == 0 && i < n_words ; i++){
-    words += 32;
+static void
+target_free_db(struct Target * target)
+{
+  free(target->mat);
+  target->mat = NULL;
+  free(target->typ);
+  target->typ = NULL;
+}
+
+static void
+target_setup_db(struct Target * target, struct Record * record)
+{
+  target->n_bits  = record->n_bits;
+  target->n_bytes = record->n_bytes;
+  if(target->max_length < (record->n_bits * record->n_bytes)){
+    if(target->max_length != 0){ target_free_db(target); }
+
+    target->mat = talloc(sizeof(long) * record->n_bits * record->n_bytes);
+    target->typ = talloc(sizeof(long) * record->n_bits);
+    target->max_length = record->n_bits * record->n_bytes;
   }
-  return ntz(x[i]) + words;
 }
 
-long bit_mask[32] = {
-  0x1, 0x2, 0x4, 0x8,
-  0x10, 0x20, 0x40, 0x80,
-  0x100, 0x200, 0x400, 0x800,
-  0x1000, 0x2000, 0x4000, 0x8000,
-  0x10000, 0x20000, 0x40000, 0x80000,
-  0x100000, 0x200000, 0x400000, 0x800000,
-  0x1000000, 0x2000000, 0x4000000, 0x8000000,
-  0x10000000, 0x20000000, 0x40000000, 0x80000000,
-};
+static void
+state_push_result(struct State * state)
+{
+  if(state->res_max_len < state->res_counter){
+    state->res_max_len = state->res_max_len * 2;
+    state->res = (long *) trealloc(state->res, state->res_max_len);
+  }
+  memcpy(state->res + state->res_counter * state->length * sizeof(long),
+	 state->mat,
+	 state->height * state->n_bytes * sizeof(long));
+  state->res_counter++;
+}
 
-long reverse_bit[32] = {
-  0xfffffffe,
-  0xfffffffd,
-  0xfffffffb,
-  0xfffffff7,
-  0xffffffef,
-  0xffffffdf,
-  0xffffffbf,
-  0xffffff7f,
-  0xfffffeff,
-  0xfffffdff,
-  0xfffffbff,
-  0xfffff7ff,
-  0xffffefff,
-  0xffffdfff,
-  0xffffbfff,
-  0xffff7fff,
-  0xfffeffff,
-  0xfffdffff,
-  0xfffbffff,
-  0xfff7ffff,
-  0xffefffff,
-  0xffdfffff,
-  0xffbfffff,
-  0xff7fffff,
-  0xfeffffff,
-  0xfdffffff,
-  0xfbffffff,
-  0xf7ffffff,
-  0xefffffff,
-  0xdfffffff,
-  0xbfffffff,
-  0x7fffffff,
-};
+static VALUE
+state_get_result(struct State * state)
+{
+  VALUE result_array;
+  VALUE tmp;
+  int i, j;
+  int counter;
+
+  result_array = rb_ary_new();
+
+  for(i = 0 ; i < state->res_counter ; i++){
+    tmp = rb_ary_new();
+    counter = i * state->n_bytes * state->height * sizeof(long);
+    for(j = 0 ; j < state->height ; j++){
+      rb_ary_push(tmp,
+		  INT2FIX(m_ntz(state->res + counter + j * state->n_bytes,
+				state->n_bytes)));
+    }
+    rb_ary_push(result_array, tmp);
+  }
+  return result_array;
+}
 
-//int matchN(ADJACENCY *adj_ptr, long *b, long *m, int pa, int pb)
-static int matchN(const int * num_adj, long ** point, long *b, long *m, int pa, int pb)
+static void
+state_free(struct State * state)
 {
-  long * mm;// current matrix
-  long f[1000];//which columns has been used at an intermediate state of computing
-  long h[100];// pb < 100 * 32
+  free(state->mat);
+  free(state->res);
+  state->mat = NULL;
+}
 
-  int d;// depth for matrix
-  int k;// width for matrix
-  int dd;// depth of matrix in refinement step
-  int kk;// width of matrix in refinement step
+static void
+state_allocate(struct State * state, struct Query * query, struct Target * target)
+{
+  int i;
 
-  int i, j;//temp
-  long l;// temp
+  state->height      = query->len;
+  state->width       = target->n_bits;
+  state->n_bytes     = target->n_bytes;
+  state->res_counter = 0;
 
-  short vflag;//valid check flag
-  int n_words;// number of words needed for storing 'pb' bits.
-  long refine_mm;// pointer for mm(match matrix) used in refinment step.
+  if(state->max_length < query->len * target->n_bytes){
 
-  d = k = 0;
-  // start back track
-  for(i = 0 ; i < (pb / 32 + 1) ; i++)
-    h[i] = 0;
-  for(i = 0 ; i < 10 ; i++)
-    f[i] = 0;
+    if(state->max_length != 0){
+      printf("state->free called   max_length : %d\n", state->max_length);
+      state_free(state);
+    }
 
-  n_words = (pb - 1) / (sizeof(int) * 8) + 1;
+    state->mat = (long *)talloc((query->len + 2) *// Depth
+				target->n_bytes * // Width
+				state->height *   // Height
+				sizeof(long));    // sizeof(long)
+
+    state->res_max_len = (query->len + 2) *// Depth
+      target->n_bytes * // Width
+      state->height *   // Height
+      sizeof(long) * 100;
+    state->res = (long *)talloc(state->res_max_len);    // sizeof(long)
+    state->max_length = query->len * target->n_bytes;
+  }
+  state->length = query->len * target->n_bytes;
+  state->depth = -1;
 
-/*   show(b, pb, pb); */
-/*   show(m, pa, pb); */
+  for(i = 0 ; i < state->length ; i++){ state->mat[i] = 0;}
+}
 
-    if( d == 0 && k == 0){
-      k = ntz_n_words(m, n_words);
-      h[k / 32] |= bit_mask[k - (k / 32) * 32];//add bit
-    }
-  while(k <= pb && d <= pa){
-/*     printf("d : %3d     k : %3d  n_words : %3d\n", d, k, n_words); */
-    if(d < 0){
-      printf("d < 0 return \n");
-      return FAIL;
+static void
+state_setup(struct State * state, struct Query * query, struct Target * target)
+{
+  int i, j;
+  for(i = 0 ; i < query->len ; i++){
+    for(j = 0 ; j < target->n_bits ; j++){
+      if (query->type[i] == target->typ[j]){
+	BITON(state->mat, i, j, target->n_bytes);
+      }
     }
+  }
+}
 
-    // Idea for optimization :
-    // instead of using following equation, just (mm = mm + len) and (mm = mm - len).
-    mm = m + pa * (d + 1) * n_words;
-/*     printf("pa : %d  d : %d  k : %d  n_words : %d  hint : %d\n", pa, d, k, n_words, pa * (d + 1) * n_words); */
-
-    //printf("ntz : %d\n", ntz(mm));
-    //k = ntz(mm + d);
-    // set (k, d) bit '1', clear k-column and d-row '0'
-/*     printf("k : %d   d: %d\n", k, d); */
-    for(j = 0 ; j < n_words ; j++){
-      if(j == (k / 32)){
-	for(i = 0 ; i < pa ; i++){
-	  mm[i * n_words + j] = mm[(i - pa) * n_words + j] & reverse_bit[k - (k / 32) * 32];
-	}
-	mm[d * n_words + j] = bit_mask[k - (k / 32) * 32];
-      }else{
-	for(i = 0 ; i < pa ; i++){
-	  mm[i * n_words + j] = mm[(i - pa) * n_words + j];
-	}
-	mm[d * n_words + j] = ZERO;
+static void
+state_setup_block(struct State * state)
+{
+  int i, j;
+  for(i = 0 ; i < state->height ; i++){
+    for(j = 0 ; j < state->width ; j++){
+      if (rb_yield_values(2, INT2FIX(i), INT2FIX(j))){
+	BITON(state->mat, i, j, state->n_bytes);
       }
     }
-    // BEGIN
-/*     show(mm, pa, pb); */
-    // END
-
-    // Refinement step
-    // Hot Spot!!
-    dd = kk = 0;
-/*     printf("before refinement step \n"); */
-/*     show(mm, pa, pb); */
-
-    while(dd != pa){
-      while(kk != pb){
-	//Idea for optimization :
-	//refine_mm should not updated 1 / 32 times.mm[dd + ((kk - 1) / 32)]
-
-	//Idea for optimization :
-	// when mm is sparse there may be better algorithm
-	// for searching '1' bit.
-	if(mm[dd * n_words + ((kk - 1) / 32)] & bit_mask[kk - ((kk - 1) / 32) * 32]){
-	  // Following loop can be flattened
-	  for(i = 0 ; i < num_adj[dd] ; i++){
-	    l = 0;
-	    for(j = 0 ; j < n_words ; j++){
-	      l |= (b[kk * n_words + j] & mm[point[dd][i] * n_words + j]);
+  }
+}
+
+static void
+state_push(struct State * state)
+{
+  memmove(state->mat + state->length,
+	  state->mat,
+	  state->length * sizeof(long) );
+  state->mat += state->length;
+  state->depth++;
+}
+
+static void
+state_pop(struct State * state)
+{
+  state->mat -= state->length;
+  state->depth--;
+}
+
+inline static long
+has_bit(long * mat, int height, int width, int n_bytes){
+  return (mat[height * n_bytes + width / ARCH] & (1 << (width % ARCH)));
+}
+
+/*
+ * Hot spot
+ */
+inline static void
+refine(struct State * state, struct Query * query, struct Target * target){
+  int i, j, k, l, m, bit_removed;
+  bit_removed = 1;
+  while(bit_removed){
+    bit_removed = 0;// false
+    for(i = 0 ; i < query->len ; i++){
+      for(j = 0 ; j < target->n_bits ; j++){
+	if(has_bit(state->mat, i, j, target->n_bytes)){
+	  for(k = 0 ; k < query->num[i] ; k++){
+	    m = 0;
+	    for(l = 0 ; l < target->n_bytes ; l++){
+	      if((state->mat[query->ptr[i][k] * target->n_bytes + l] &
+		  target->mat[j * target->n_bytes + l]) != 0){
+		m++;
+	      }
 	    }
-	    if(l == 0){
-	      mm[dd * n_words + (kk / 32)] &= reverse_bit[kk - (kk / 32) * 32];//remove bit
-/* 	      break;//quit for loop */
+	    if(m == 0){
+	      BITOFF(state->mat, i, j, target->n_bytes);
+	      bit_removed = 1;
 	    }
 	  }
-
 	}
-	kk++;
       }
-      // Idea for optimization
-      // every 32 bit is tested here.
-      kk = 0;
-      dd++;
     }
-/*     show(mm, pa, pb); */
-
-    //Checking whether match matrices are valid.
-    // Subgraph isomorphism can be checked here before reaching d == pa.
-    vflag = SUCCESS;
-    for(i = 0 ; i < pa ; i++){
-      l = 0;
-      for(j = 0 ; j < n_words ; j++){
-	l |= mm[i * n_words + j];
-      }
-      if(l == 0){
-	vflag = FAIL;
-	break;
+  }
+}
+
+static void
+state_clear_bits(long * l, int h, int w, int n_bytes, int height){
+  int i;
+  for(i = 0 ; i < n_bytes ; i++){ l[i + h * n_bytes] = 0; }
+  for(i = 0 ; i < height  ; i++){ BITOFF(l, i, w, n_bytes); }
+  BITON(l, h, w, n_bytes);
+}
+
+#define TRUE  1
+#define FALSE 0
+
+inline static int
+state_is_valid(struct State * state){
+  int i, j, n_bytes, flag;
+  // n_bytes = NBYTES(state->length);
+  for(i = 0 ; i < state->height ; i++){
+    flag = 0;
+    for(j = 0 ; j < state->n_bytes ; j++){
+      if(state->mat[i * state->n_bytes + j] != 0){
+	flag++;
       }
     }
+    if(flag == 0)
+      return FALSE;
+  }
+  return TRUE;
+}
 
-    if(vflag){// Success
-      f[d] = k;
-      k = 0;
-      while(h[k / 32] & bit_mask[k - (k / 32) * 32])
-	k++;
-      d++;
-      if(d == pa){
-/* 	show(mm, pa, pb); */
-	//printf("FOUND!  d : %d\n", d);
-	return SUCCESS;
-      }
-      else{
-	h[k / 32] |= bit_mask[k - (k / 32) * 32];//add bit
-      }
-    }else{//Failed
-      h[k / 32] &= reverse_bit[k - (k / 32) * 32];//remove bit
-      k++;
-      //printf("d : %d k : %d\n", d, k);
-      while((h[k / 32] & bit_mask[k - (k / 32) * 32] ||
-	     (m[d * n_words + (k / 32)] & bit_mask[k - (k / 32) * 32] ) == 0) &&
-	    k < pb)
-	k++;
-/*       printf("d : %d k : %d\n", d, k); */
-      while(k > pb){
-	if(d == 0){
-	  return FAIL;
+static void
+search_by_ullmann(struct State * state, struct Query * query, struct Target * target){
+  int k;
+  // Idea for optimization
+  //show(state->mat, query->len, target->n_bits);
+  if(state->depth == state->height - 1){
+    //printf("FOUND!\n");
+    state_push_result(state);
+    //show(state->mat, query->len, target->n_bits);
+  }else{
+    for(k = 0 ; k < target->n_bits ; k++){
+      if(has_bit(state->mat,
+		 state->depth + 1,
+		 k,
+		 target->n_bytes)){
+	state_push(state);
+	state_clear_bits(state->mat, state->depth, k, target->n_bytes, query->len);
+	//show(state->mat, query->len, target->n_bits);
+	refine(state, query, target);
+	//show(state->mat, query->len, target->n_bits);
+	if(state_is_valid(state) == TRUE){
+	  //show(state->mat, query->len, target->n_bits);
+	  search_by_ullmann(state, query, target);
 	}
-	d--;
-	k = f[d];
-	h[k / 32] &= reverse_bit[k - (k / 32) * 32];//remove bit
-	k++;
-	while(h[k / 32] & bit_mask[k - (k / 32) * 32])
-	  k++;
+	state_pop(state);
       }
-      h[k / 32] |= bit_mask[k - (k / 32) * 32];//add bit
     }
   }
-  //printf("d : %d k : %d FAIL!\n", d, k);
-  return FAIL;
 }
 
-static void set_adjacency(int * num_adj, long ** point, long * adj, VALUE ret){
-  int i, j, n_words;
-  int off_set = 0;
+static void
+db_load(struct CompoundDB * db, struct Query * query){
+
+  int new_n_bits;
+  int new_n_bytes;
+  int mat_ptr;
+
+  struct Target target;
+  struct State state;
+  struct Record record;
+
+  int i, j;
 
-  n_words = (RARRAY(ret)->len - 1) / (sizeof(int) * 8) + 1;
+  target.n_bits  = 0;
+  target.n_bytes = 0;
+  target.max_length = 0;
+  state.max_length = 0;
 
-  for(i = 0 ; i < RARRAY(ret)->len ; i++){
-    num_adj[i] = FIX2INT(rb_funcall(RARRAY(ret)->ptr[i], rb_intern("length"), 0));
-    point[i] = adj + off_set;
-    for(j = 0 ; j < RARRAY(RARRAY(ret)->ptr[i])->len ; j++){
-      adj[off_set++] = FIX2INT(RARRAY(RARRAY(ret)->ptr[i])->ptr[j]);
-      //printf(" %d ", FIX2INT(RARRAY(RARRAY(ret)->ptr[i])->ptr[j]));
+  for(;;){
+    if(feof(db->idx) || feof(db->mat) || feof(db->mat)){
+      printf("Database broken!\n");
+      return;
+    }
+
+    fread(& record, sizeof(struct Record), 1, db->idx);
+    if(record.n_bits == -1){
+      return;
+    }
+    target_setup_db(& target, & record);
+    if(record.information != -1){
+
+      fread(target.mat, sizeof(long), target.n_bits * target.n_bytes, db->mat);
+      fread(target.typ, sizeof(long), target.n_bits,                  db->typ);
+
+      state_allocate(& state, query, & target);
+      state_setup(& state, query, & target);
+      //show(state.mat, query->len, target.n_bits);
+      search_by_ullmann(& state, query, & target);
+    }else{
+      fread(target.typ, sizeof(long), target.n_bytes, db->typ);
+      printf("atom_number : %d\n", target.typ[0]);
     }
-    //printf("\n");
   }
+  target_free_db(& target);
+  state_free(& state);
 }
 
-static VALUE subcomp_match_by_ullmann(VALUE self, VALUE a_matrix, VALUE pa, VALUE other_adj, VALUE pb, VALUE match){
-  // variables for adjacency list of graph A
-  int num_adj[1000];
-  long * point[1000];
-  long adj[3000];//adjacency list
+static void
+query_setup(VALUE mol, struct Query * query){
+  VALUE atom_type_str;
+  VALUE adj_index;
+  VALUE edges;
 
-  // match matrix; = pa * (n_words * pa)
-  long * mm;//[800000];
-  long * m;
+  int i, j, k;
 
-  //temporary variables
-  int i;
-  int result;
-  VALUE mapping;
+  // allocating and setting atom type
+  atom_type_str = rb_funcall(mol, rb_intern("typ_str"), 0);
+  Check_Type(atom_type_str, T_STRING);
 
-  int n_pb, n_pa;
-  int n_words;
-  int sizeof_mm;
+  query->len  = RSTRING(atom_type_str)->len / sizeof(long);
+  query->type = (long *)talloc(query->len * sizeof(long));
+  memcpy(query->type, RSTRING(atom_type_str)->ptr, sizeof(long) * query->len);
 
-  n_pb = NUM2INT(pb);
-  n_pa = NUM2INT(pa);
-  
-  if(n_pb > n_pa){
-    return Qfalse;
-  }
+  // allocatting and setting index
+  adj_index = rb_funcall(mol, rb_intern("adjacent_index"), 0);
+  Check_Type(adj_index, T_ARRAY);
 
-  sizeof_mm = n_pa * (n_pb + 1) * n_words;
+  edges = rb_funcall(mol, rb_intern("edges"), 0);
+  Check_Type(edges, T_ARRAY);
 
-  n_words = (n_pa - 1) / (sizeof(int) * 8) + 1;
+  query->edge_len = RARRAY(edges)->len;
 
-  mm = (long * )malloc(sizeof(long) * 800000);
-  if(RSTRING(match)->len > 800000 * sizeof(long))
-    rb_raise(rb_eArgError, "Length of match matrix too short! %d", sizeof(mm));
-  
-  memcpy(mm, (long *)RSTRING(match)->ptr, RSTRING(match)->len); // BUG!!
+  query->ptr = (int **) talloc(query->len      * sizeof(int **)     );
+  query->num = (int * ) talloc(query->len      * sizeof(int * )     );
+  query->idx = (int * ) talloc(query->edge_len * sizeof(int * ) * 2 );
 
-  Check_Type(a_matrix, T_STRING);
+  k = 0;
+  for(i = 0 ; i < query->len ; i++){
+    Check_Type(rb_ary_entry(adj_index, i), T_ARRAY);
+    query->num[i] = RARRAY(rb_ary_entry(adj_index, i))->len;
+    query->ptr[i] = query->idx + k;
+    for(j = 0 ; j < query->num[i] ; j++){
+      Check_Type(rb_ary_entry(rb_ary_entry(adj_index, i), j), T_FIXNUM);
+      query->idx[k] = FIX2INT(rb_ary_entry(rb_ary_entry(adj_index, i), j));
+      k++;
+    }
+  }
 
-  set_adjacency(num_adj, point, adj, other_adj);
+}
 
-  //show(mm, n_pa, n_pb);
-  //show((long *)RSTRING(a_matrix)->ptr, n_pa, n_pa);
+static void
+query_free(struct Query * query){
+  free(query->type);
+  free(query->ptr);
+  free(query->num);
+  free(query->idx);
+
+  query->type = NULL;
+  query->ptr  = NULL;
+  query->num  = NULL;
+  query->idx  = NULL;
+}
 
-  result = matchN(num_adj, point, (long *)RSTRING(a_matrix)->ptr, mm, n_pb, n_pa);
+static VALUE
+db_search(VALUE self, VALUE database_name, VALUE q_mol, VALUE block)
+{
+  char * filename;
+  struct CompoundDB db;
+  struct Query query;
 
-  if(result == 1){//?
-    mapping = rb_ary_new();
-    //printf("n_words : %d n_pa : %d n_pb : %d  n_words * n_pa * n_pa : %d", n_words, n_pa, n_pb, n_words * n_pa * n_pa);
-    //show(mm + n_words * n_pb * n_pb, n_pb, n_pa);
-  
-    for(i = 0 ; i < n_pb ; i++){
-      rb_ary_push(mapping, INT2FIX(ntz_m(mm + n_words * n_pb * n_pb + i * n_words, n_pa)));
-    }
-    return mapping;
+  filename = StringValuePtr(database_name);
+
+  if(strlen(filename) > 40){
+    rb_raise(rb_eException, "length of database name must less than 40!");
   }
-  return Qfalse;
+
+  query_setup(q_mol, & query);
+
+  db.mat = db_file_open(filename, ".mat");
+  db.idx = db_file_open(filename, ".idx");
+  db.typ = db_file_open(filename, ".typ");
+
+  db_load(& db, & query);
+
+  query_free(& query);
+
+  fclose(db.mat);
+  fclose(db.idx);
+  fclose(db.typ);
 }
 
-// DataBase for substructure search
+static void
+target_setup(VALUE t_mol, struct Target * target){
+  VALUE bit_mat;
+  VALUE bit_str;
+  VALUE atom_types;
 
-struct dbmdata {
-  int  di_size;
-};
+  int i;
+
+  atom_types = rb_funcall(t_mol, rb_intern("typ_str"), 0);
+  Check_Type(atom_types, T_STRING);
+
+  target->n_bits = RSTRING(atom_types)->len / sizeof(long);
+  target->typ = (long *)talloc(target->n_bits * sizeof(long));
+  memcpy(target->typ, RSTRING(atom_types)->ptr, target->n_bits * sizeof(long));
+
+  /*
+   * Set up adjacency matrix
+   */
+  bit_mat = rb_funcall(t_mol,   rb_intern("bit_mat"), 0);
+  bit_str = rb_funcall(bit_mat, rb_intern("bit_str"), 0);
+
+  target->n_bytes = NBYTES(target->n_bits);
 
-static VALUE sdb_s_search(VALUE dbname){
-  rb_p(dbname);
+  target->mat = (long *)talloc(target->n_bytes * target->n_bits * sizeof(long));
+  memcpy(target->mat, RSTRING(bit_str)->ptr, RSTRING(bit_str)->len);
 }
 
-Init_subcomp(){
-  VALUE subcomp_cGraph;
-  VALUE subcomp_cSubGraphDB;
+static void
+target_free(struct Target * target){
+  free(target->typ);
+  free(target->mat);
+}
+
+static VALUE
+mol_by_mol(VALUE self, VALUE q_mol, VALUE t_mol)
+{
+  struct Query  query;
+  struct Target target;
+  struct State  state;
+  VALUE result;
+
+  target.max_length = 0;
+  state.max_length = 0;
+
+  query_setup(  q_mol, & query  );
+  target_setup( t_mol, & target );
 
-  subcomp_cGraph = rb_define_module("Graph");
-  rb_define_method(subcomp_cGraph, "subcomp_match_by_ullmann", subcomp_match_by_ullmann, 5);
+  state_allocate(& state, & query, & target);
 
-  subcomp_cSubGraphDB = rb_define_class_under(subcomp_cGraph, "SubGraphDB", rb_cObject);
+  if(rb_block_given_p() == Qtrue){
+    state_setup_block(& state);
+  }
+  else{
+    state_setup(& state, & query, & target);
+  }
+
+  search_by_ullmann(& state, & query, & target);
+  result = state_get_result(& state);
+
+  query_free(& query);
+  target_free(& target);
+  state_free(& state);
+
+  return result;
+}
 
-  rb_define_method(subcomp_cSubGraphDB, "open_for_search", sdb_s_search, 0);
+void Init_subcomp(){
+  VALUE subcomp_mChem;
 
-  rb_define_singleton_method(subcomp_cSubGraphDB, "show", subcomp_show, 3);
-  rb_define_singleton_method(subcomp_cSubGraphDB, "match", subcomp_match_by_ullmann, 5);
+  subcomp_mChem = rb_define_module("Chem");
+  rb_define_singleton_method(subcomp_mChem, "match_by_ullmann", mol_by_mol, 2);
+  rb_define_singleton_method(subcomp_mChem, "db_search",        db_search,  2);
+  //define_bitdb_method();
 }