nysol-take 3.0.0

data/ext/lcmrun/src/vec.h

@@ -0,0 +1,171 @@
+/* library for sparse vector */
+/* Takeaki Uno    27/Dec/2008 */
+
+#ifndef _vec_h_
+#define _vec_h_
+
+//#define USE_MATH
+
+#include"math.h"
+#include"queue.h"
+
+#ifndef SVEC_VAL
+ #ifdef SVEC_VAL_INT
+  #define SVEC_VAL int
+  #define SVEC_VAL2 LONG
+  #define SVEC_VAL_END INTHUGE
+  #define SVEC_VAL2_END LONGHUGE
+  #define SVEC_VALF "%d"
+ #else
+  #define SVEC_VAL double
+  #define SVEC_VAL2 double
+  #define SVEC_VAL_END DOUBLEHUGE
+  #define SVEC_VAL2_END DOUBLEHUGE
+  #define SVEC_VALF "%f"
+ #endif
+#endif
+
+#define VEC_LOAD_BIN 16777216   // read binary file 
+#define VEC_LOAD_BIN2 33554432   // read binary file with 2byte for each number 
+#define VEC_LOAD_BIN4 67108864   // read binary file with 4byte for each number
+#define VEC_LOAD_CENTERIZE 134217728  // read binary file, and minus the half(128) from each number
+#define VEC_NORMALIZE 268435456  // read binary file, and minus the half(128) from each number
+
+/* matrix */
+typedef struct {
+  unsigned char type;  // mark to identify type of the structure
+  char *fname;      // input file name
+  int flag;         // flag
+
+  VEC *v;
+  VEC_ID end;
+  VEC_ID t;
+  VEC_VAL *buf, *buf2;
+  VEC_ID clms;
+  size_t eles;
+  VEC_VAL *buf_org, *buf2_org;
+} MAT;
+
+/* sparse vector, element */
+typedef struct {
+  QUEUE_ID i;
+  SVEC_VAL a;
+} SVEC_ELE;
+
+/* sparse vector, vector */
+typedef struct {
+  unsigned char type;  // mark to identify type of the structure
+  SVEC_ELE *v;
+  VEC_ID end;
+  VEC_ID t;
+} SVEC;
+
+/* sparse vector, matrix */
+typedef struct {
+  unsigned char type;  // mark to identify type of the structure
+  char *fname;      // input file name
+  int flag;         // flag
+
+  SVEC *v;
+  VEC_ID end;
+  VEC_ID t;
+  SVEC_ELE *buf, *buf2;
+  VEC_ID clms;
+  size_t eles, ele_end;
+} SMAT;
+
+/* set family */
+typedef struct {
+  unsigned char type;  // mark to identify type of the structure
+  char *fname;      // input file name
+  int flag;         // flag
+
+  QUEUE *v;
+  VEC_ID end;
+  VEC_ID t;
+  QUEUE_INT *buf, *buf2;
+  VEC_ID clms;
+  size_t eles, ele_end;
+  WEIGHT *cw, *rw, **w, *wbuf;
+  int unit;
+  char *wfname, *cwfname, *rwfname;     // weight file name
+} SETFAMILY;
+
+#define INIT_SETFAMILY_ {TYPE_SETFAMILY,NULL,0,NULL,0,0,NULL,NULL,0,0,0,NULL,NULL,NULL,NULL,sizeof(QUEUE_INT),NULL,NULL,NULL}
+
+extern MAT INIT_MAT;
+extern SVEC INIT_SVEC;
+extern SMAT INIT_SMAT;
+extern SETFAMILY INIT_SETFAMILY;
+
+QSORT_TYPE_HEADER (SVEC_VAL, SVEC_VAL)
+QSORT_TYPE_HEADER (SVEC_VAL2, SVEC_VAL2)
+
+#define   ARY_QUEUE_INPRO(f,U,V)  do{(f)=0;FLOOP(common_QUEUE_ID, 0, (QUEUE_ID)(U).t)(f)+=(V)[(U).v[common_QUEUE_ID]];}while(0)
+#define   ARY_SVEC_INPRO(f,U,V)  do{(f)=0;FLOOP(common_VEC_ID, 0, (VEC_ID)(U).t)(f)+=((double)(U).v[common_VEC_ID].a)*(V)[(U).v[common_VEC_ID].i];}while(0)
+
+/* terminate routine for VEC */
+void VEC_end (VEC *V);
+void MAT_end (MAT *M);
+void SVEC_end (SVEC *V);
+void SMAT_end (SMAT *M);
+void SETFAMILY_end (SETFAMILY *M);
+
+/* allocate memory according to rows and rowt */
+void VEC_alloc (VEC *V, VEC_ID clms);
+void MAT_alloc (MAT *M, VEC_ID rows, VEC_ID clms);
+void SVEC_alloc (SVEC *V, VEC_ID end);
+void SMAT_alloc (SMAT *M, VEC_ID rows, VEC_ID *rowt, VEC_ID clms, size_t eles);
+void SETFAMILY_alloc (SETFAMILY *M, VEC_ID rows, VEC_ID *rowt, VEC_ID clms, size_t eles);
+void SETFAMILY_alloc_weight (SETFAMILY *M);
+
+/* count/read the number in file for MAT */
+/* if *rows>0, only read count the numbers in a row, for the first scan. */
+void MAT_load_bin (MAT *M, FILE2 *fp, int unit);
+void MAT_file_load (MAT *M, FILE2 *fp);
+void MAT_load (MAT *M);
+void SMAT_load (SMAT *M);
+void SETFAMILY_load (SETFAMILY *M);
+void SETFAMILY_load_weight (SETFAMILY *M);
+void SETFAMILY_load_row_weight (SETFAMILY *M);
+void SETFAMILY_load_column_weight (SETFAMILY *M);
+
+void MAT_print (FILE *fp, MAT *M);
+void SVEC_print (FILE *fp, SVEC *M);
+void SMAT_print (FILE *fp, SMAT *M);
+void SETFAMILY_print (FILE *fp, SETFAMILY *M);
+void SETFAMILY_print_weight (FILE *fp, SETFAMILY *M);
+  
+
+/* norm, normalization **************************/
+double SVEC_norm (SVEC *V);
+void SVEC_normalize (SVEC *V);
+
+/* inner product **************************/
+SVEC_VAL2 SVEC_inpro (SVEC *V1, SVEC *V2);
+
+/** Euclidean distance routines *********************************/
+double VEC_eucdist (VEC *V1, VEC *V2);
+double SVEC_eucdist (SVEC *V1, SVEC *V2);
+double VEC_SVEC_eucdist (VEC *V1, SVEC *V2);
+double QUEUE_eucdist (QUEUE *Q1, QUEUE *Q2);
+double VEC_QUEUE_eucdist (VEC *V, QUEUE *Q);
+
+void VEC_rand_gaussian (VEC *V);
+
+double VEC_linfdist (VEC *V1, VEC *V2);
+
+/* compute the inner product, Euclidean distance for multi vector */
+double MVEC_norm (void *V);
+double MVEC_inpro (void *V, void *U);
+double MVEC_double_inpro (void *V, double *p);
+double MVEC_eucdist (void *V, void *U);
+
+/* compute the inner product, euclidean distance for i,jth vector */
+double MMAT_inpro_ij (void *M, int i, int j);
+double MMAT_double_inpro_i (void *M, int i, double *p);
+double MMAT_eucdist_ij (void *M, int i, int j);
+double MMAT_norm_i (void *M, int i);
+
+
+#endif

data/ext/lcmseq0run/extconf.rb

@@ -0,0 +1,20 @@
+require "rubygems"
+require "mkmf"
+
+unless have_library("kgmod3")
+  puts("need libkgmod.")
+  puts("refer https://github.com/nysol/mcmd")
+  exit 1
+end
+
+
+cp = "$(srcdir)"
+
+$CFLAGS = " -O3 -Wall -I. -I#{cp}/src -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+$CPPFLAGS = " -O3 -Wall -I. -I#{cp}/src  -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+$CXXFLAGS = " -O3 -Wall -I. -I#{cp}/src  -DB_STATIC -D_NO_MAIN_ -DLINE -fPIC -Wno-error=format-security"
+
+$LOCAL_LIBS += " -lstdc++ -lkgmod3"
+
+create_makefile("nysol/lcmseq0run")
+

data/ext/lcmseq0run/lcmseq0run.cpp

@@ -0,0 +1,59 @@
+#include <stdio.h>
+#include <stdlib.h>
+#include <unistd.h>
+#include <fcntl.h>
+#include <sys/stat.h>
+#include <string>
+#include <ruby.h>
+
+#include "src/lcm_seq_zero.c"
+
+
+#include <kgMethod.h>
+
+extern "C" {
+	void Init_lcmseq0run(void);
+}
+
+
+VALUE lcmseq0(VALUE self,VALUE argvV){
+
+	string argstr=RSTRING_PTR(argvV);
+	vector<char *> opts = kglib::splitToken(const_cast<char*>(argstr.c_str()), ' ',true);
+
+	// 引数文字列へのポインタの領域はここでauto変数に確保する
+	kglib::kgAutoPtr2<char*> argv;
+	char** vv;
+	try{
+		argv.set(new char*[opts.size()+1]);
+		vv = argv.get();
+	}catch(...){
+		rb_raise(rb_eRuntimeError,"memory allocation error");
+	}
+
+	// vv配列0番目はコマンド名
+	vv[0]=const_cast<char*>("lcmseq");
+
+	size_t vvSize;
+	for(vvSize=0; vvSize<opts.size(); vvSize++){
+		vv[vvSize+1] = opts.at(vvSize);
+	}
+	vvSize+=1;
+
+	LCMseq_main(vvSize,vv);
+	return Qtrue;
+}
+
+
+
+// -----------------------------------------------------------------------------
+// ruby Mcsvin クラス init
+// -----------------------------------------------------------------------------
+void Init_lcmseq0run(void) 
+{
+	// モジュール定義:MCMD::xxxxの部分
+	VALUE mtake=rb_define_module("TAKE");
+	rb_define_module_function(mtake,"run_lcmseq_zero"       , (VALUE (*)(...))lcmseq0,1);
+}
+
+

data/ext/lcmseq0run/src/aheap.c

@@ -0,0 +1,216 @@
+/*
+    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, please
+    refer the newest code, and show the link to homepage of 
+    Takeaki Uno, to notify the news about the codes for the users. */
+
+#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, 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 */
+/* node_ returns the ID of leaf */
+AHEAP_ID AHEAP_findmin_node_ (AHEAP *H, AHEAP_ID i, int f){
+  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 (i);
+}
+AHEAP_ID AHEAP_findmin_node (AHEAP *H, AHEAP_ID i, int f){
+  if ( H->end <= 0 ) return (-1);
+  return (AHEAP_IDX(*H, AHEAP_findmin_node_ (H, i, f)));
+}
+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);
+  if ( i<0 || i>= H->end ) return ( AHEAP_findlow_head (H, a));
+  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); 
+  if ( i<0 || i>= H->end ) return ( AHEAP_findlow_head (H, a));
+  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/lcmseq0run/src/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, please
+    refer the newest code, and show the link to homepage of 
+    Takeaki Uno, to notify the news about the codes for the users. */
+
+/* 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_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

data/ext/lcmseq0run/src/base.c

@@ -0,0 +1,92 @@
+/*
+    blocked memory allocation library
+            12/Mar/2002   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, please
+    refer the newest code, and show the link to homepage of 
+    Takeaki Uno, to notify the news about the codes for the users. */
+
+#ifndef _base_c_
+#define _base_c_
+
+#include"base.h"
+
+BASE INIT_BASE = {TYPE_BASE,NULL,0,0,0,0,-1,NULL};
+
+/*  initialization, and allocate memory for header */
+void BASE_alloc (BASE *B, int unit, int block_siz){
+  *B = INIT_BASE;
+  B->dellist = B;
+  B->unit = unit;
+  B->block_siz = block_siz;
+  B->num = block_siz;
+  B->block_num = -1;
+  calloc2 (B->base, 20, EXIT);
+  B->block_end = 20;
+}
+
+/*  termination */
+void BASE_end (BASE *B){
+  int i;
+  FLOOP (i, 0, B->block_end) free2 (B->base[i]);
+  free2 (B->base);
+  *B = INIT_BASE;
+}
+
+/* return pointer to the cell corresponding to the given index */
+void *BASE_pnt (BASE *B, size_t i){
+  return ( B->base[i/BASE_BLOCK] + (i%BASE_BLOCK)*B->unit);
+}
+/* return index corresponding to the given pointer */
+size_t BASE_index (BASE *B, void *x){
+  size_t i;
+  FLOOP (i, 0, (size_t)(B->block_end+1)){
+    if ( ((char*)x)>= B->base[i] && ((char*)x)<=B->base[i]+B->unit*BASE_BLOCK )
+      return ( i*BASE_BLOCK + ((size_t)(((char *)x) - B->base[i])) / B->unit);
+  }
+  return (0);
+}
+
+/* increment the current memory block pointer and (re)allcate memory if necessary */
+void *BASE_get_memory (BASE *B, int i){
+  B->num += i;
+  if ( B->num >= B->block_siz ){  /* if reach to the end of base array */
+    B->num = i;  /* allocate one more base array, and increment the counter */
+    B->block_num++;
+    reallocx(B->base, B->block_end, B->block_num, NULL, EXIT0);
+    if ( B->base[B->block_num] == NULL )
+        malloc2 (B->base[B->block_num], B->block_siz*B->unit, EXIT0);
+    return (B->base[B->block_num]);
+  }
+  return (B->base[B->block_num] + (B->num-i)*B->unit);
+}
+
+
+/* allocate new cell */
+void *BASE_new (BASE *B){
+  char *x;
+  
+    /* use deleted cell if it exists */
+  if ( B->dellist != ((void *)B) ){
+    x = (char *)B->dellist;  /* return the deleted cell */
+    B->dellist = (void *)(*((char **)x));      /* increment the head of the list */
+  } else {
+     /* take a new cell from the base array if no deleted one exists */
+    x = (char *)BASE_get_memory (B, 1);
+  }
+  return (x);
+}
+
+/* delete one cell. (add to the deleted list)  */
+void BASE_del (BASE *B, void *x){
+  *((void **)x) = B->dellist;
+  B->dellist = x;
+}
+
+#endif
+
+