divsufsort 0.1.0

data/ext/divsufsort.h

@@ -0,0 +1,191 @@
+/*
+ * divsufsort.h for libdivsufsort
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _DIVSUFSORT_H
+#define _DIVSUFSORT_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+// modified by SUGAWARA Genki <sgwr_dts@yahoo.co.jp>
+#define PROJECT_VERSION_FULL "2.0.0"
+
+#ifdef _WIN32
+#include <stdlib.h>
+#include <stdint.h>
+#define INLINE _inline
+#define PRId32 "ld"
+#else
+#define INLINE inline
+#include <inttypes.h>
+#endif
+
+#ifndef DIVSUFSORT_API
+# ifdef DIVSUFSORT_BUILD_DLL
+#  define DIVSUFSORT_API 
+# else
+#  define DIVSUFSORT_API 
+# endif
+#endif
+
+/*- Datatypes -*/
+#ifndef SAUCHAR_T
+#define SAUCHAR_T
+typedef uint8_t sauchar_t;
+#endif /* SAUCHAR_T */
+#ifndef SAINT_T
+#define SAINT_T
+typedef int32_t saint_t;
+#endif /* SAINT_T */
+#ifndef SAIDX_T
+#define SAIDX_T
+typedef int32_t saidx_t;
+#endif /* SAIDX_T */
+#ifndef PRIdSAINT_T
+#define PRIdSAINT_T PRId32
+#endif /* PRIdSAINT_T */
+#ifndef PRIdSAIDX_T
+#define PRIdSAIDX_T PRId32
+#endif /* PRIdSAIDX_T */
+
+
+/*- Prototypes -*/
+
+/**
+ * Constructs the suffix array of a given string.
+ * @param T[0..n-1] The input string.
+ * @param SA[0..n-1] The output array of suffixes.
+ * @param n The length of the given string.
+ * @return 0 if no error occurred, -1 or -2 otherwise.
+ */
+DIVSUFSORT_API
+saint_t
+divsufsort(const sauchar_t *T, saidx_t *SA, saidx_t n);
+
+/**
+ * Constructs the burrows-wheeler transformed string of a given string.
+ * @param T[0..n-1] The input string.
+ * @param U[0..n-1] The output string. (can be T)
+ * @param A[0..n-1] The temporary array. (can be NULL)
+ * @param n The length of the given string.
+ * @return The primary index if no error occurred, -1 or -2 otherwise.
+ */
+DIVSUFSORT_API
+saidx_t
+divbwt(const sauchar_t *T, sauchar_t *U, saidx_t *A, saidx_t n);
+
+/**
+ * Returns the version of the divsufsort library.
+ * @return The version number string.
+ */
+DIVSUFSORT_API
+const char *
+divsufsort_version(void);
+
+
+/**
+ * Constructs the burrows-wheeler transformed string of a given string and suffix array.
+ * @param T[0..n-1] The input string.
+ * @param U[0..n-1] The output string. (can be T)
+ * @param SA[0..n-1] The suffix array. (can be NULL)
+ * @param n The length of the given string.
+ * @param idx The output primary index.
+ * @return 0 if no error occurred, -1 or -2 otherwise.
+ */
+DIVSUFSORT_API
+saint_t
+bw_transform(const sauchar_t *T, sauchar_t *U,
+             saidx_t *SA /* can NULL */,
+             saidx_t n, saidx_t *idx);
+
+/**
+ * Inverse BW-transforms a given BWTed string.
+ * @param T[0..n-1] The input string.
+ * @param U[0..n-1] The output string. (can be T)
+ * @param A[0..n-1] The temporary array. (can be NULL)
+ * @param n The length of the given string.
+ * @param idx The primary index.
+ * @return 0 if no error occurred, -1 or -2 otherwise.
+ */
+DIVSUFSORT_API
+saint_t
+inverse_bw_transform(const sauchar_t *T, sauchar_t *U,
+                     saidx_t *A /* can NULL */,
+                     saidx_t n, saidx_t idx);
+
+/**
+ * Checks the correctness of a given suffix array.
+ * @param T[0..n-1] The input string.
+ * @param SA[0..n-1] The input suffix array.
+ * @param n The length of the given string.
+ * @param verbose The verbose mode.
+ * @return 0 if no error occurred.
+ */
+DIVSUFSORT_API
+saint_t
+sufcheck(const sauchar_t *T, const saidx_t *SA, saidx_t n, saint_t verbose);
+
+/**
+ * Search for the pattern P in the string T.
+ * @param T[0..Tsize-1] The input string.
+ * @param Tsize The length of the given string.
+ * @param P[0..Psize-1] The input pattern string.
+ * @param Psize The length of the given pattern string.
+ * @param SA[0..SAsize-1] The input suffix array.
+ * @param SAsize The length of the given suffix array.
+ * @param idx The output index.
+ * @return The count of matches if no error occurred, -1 otherwise.
+ */
+DIVSUFSORT_API
+saidx_t
+sa_search(const sauchar_t *T, saidx_t Tsize,
+          const sauchar_t *P, saidx_t Psize,
+          const saidx_t *SA, saidx_t SAsize,
+          saidx_t *left);
+
+/**
+ * Search for the character c in the string T.
+ * @param T[0..Tsize-1] The input string.
+ * @param Tsize The length of the given string.
+ * @param SA[0..SAsize-1] The input suffix array.
+ * @param SAsize The length of the given suffix array.
+ * @param c The input character.
+ * @param idx The output index.
+ * @return The count of matches if no error occurred, -1 otherwise.
+ */
+DIVSUFSORT_API
+saidx_t
+sa_simplesearch(const sauchar_t *T, saidx_t Tsize,
+                const saidx_t *SA, saidx_t SAsize,
+                saint_t c, saidx_t *left);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* _DIVSUFSORT_H */

data/ext/divsufsort_private.h

@@ -0,0 +1,207 @@
+/*
+ * divsufsort_private.h for libdivsufsort
+ * Copyright (c) 2003-2008 Yuta Mori All Rights Reserved.
+ *
+ * Permission is hereby granted, free of charge, to any person
+ * obtaining a copy of this software and associated documentation
+ * files (the "Software"), to deal in the Software without
+ * restriction, including without limitation the rights to use,
+ * copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the
+ * Software is furnished to do so, subject to the following
+ * conditions:
+ *
+ * The above copyright notice and this permission notice shall be
+ * included in all copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+ * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+ * OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+ * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+ * HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+ * WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+ * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+ * OTHER DEALINGS IN THE SOFTWARE.
+ */
+
+#ifndef _DIVSUFSORT_PRIVATE_H
+#define _DIVSUFSORT_PRIVATE_H 1
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#if HAVE_CONFIG_H
+# include "config.h"
+#endif
+#include <assert.h>
+#include <stdio.h>
+#if HAVE_STRING_H
+# include <string.h>
+#endif
+#if HAVE_STDLIB_H
+# include <stdlib.h>
+#endif
+#if HAVE_MEMORY_H
+# include <memory.h>
+#endif
+#if HAVE_STDDEF_H
+# include <stddef.h>
+#endif
+#if HAVE_STRINGS_H
+# include <strings.h>
+#endif
+#if HAVE_INTTYPES_H
+# include <inttypes.h>
+#else
+# if HAVE_STDINT_H
+#  include <stdint.h>
+# endif
+#endif
+#if defined(BUILD_DIVSUFSORT64)
+# include "divsufsort64.h"
+# ifndef SAIDX_T
+#  define SAIDX_T
+#  define saidx_t saidx64_t
+# endif /* SAIDX_T */
+# ifndef PRIdSAIDX_T
+#  define PRIdSAIDX_T PRIdSAIDX64_T
+# endif /* PRIdSAIDX_T */
+# define divsufsort divsufsort64
+# define divbwt divbwt64
+# define divsufsort_version divsufsort64_version
+# define bw_transform bw_transform64
+# define inverse_bw_transform inverse_bw_transform64
+# define sufcheck sufcheck64
+# define sa_search sa_search64
+# define sa_simplesearch sa_simplesearch64
+# define sssort sssort64
+# define trsort trsort64
+#else
+# include "divsufsort.h"
+#endif
+
+
+/*- Constants -*/
+#if !defined(UINT8_MAX)
+# define UINT8_MAX (255)
+#endif /* UINT8_MAX */
+#if defined(ALPHABET_SIZE) && (ALPHABET_SIZE < 1)
+# undef ALPHABET_SIZE
+#endif
+#if !defined(ALPHABET_SIZE)
+# define ALPHABET_SIZE (UINT8_MAX + 1)
+#endif
+/* for divsufsort.c */
+#define BUCKET_A_SIZE (ALPHABET_SIZE)
+#define BUCKET_B_SIZE (ALPHABET_SIZE * ALPHABET_SIZE)
+/* for sssort.c */
+#if defined(SS_INSERTIONSORT_THRESHOLD)
+# if SS_INSERTIONSORT_THRESHOLD < 1
+#  undef SS_INSERTIONSORT_THRESHOLD
+#  define SS_INSERTIONSORT_THRESHOLD (1)
+# endif
+#else
+# define SS_INSERTIONSORT_THRESHOLD (8)
+#endif
+#if defined(SS_BLOCKSIZE)
+# if SS_BLOCKSIZE < 0
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (0)
+# elif 32768 <= SS_BLOCKSIZE
+#  undef SS_BLOCKSIZE
+#  define SS_BLOCKSIZE (32767)
+# endif
+#else
+# define SS_BLOCKSIZE (1024)
+#endif
+/* minstacksize = log(SS_BLOCKSIZE) / log(3) * 2 */
+#if SS_BLOCKSIZE == 0
+# if defined(BUILD_DIVSUFSORT64)
+#  define SS_MISORT_STACKSIZE (96)
+# else
+#  define SS_MISORT_STACKSIZE (64)
+# endif
+#elif SS_BLOCKSIZE <= 4096
+# define SS_MISORT_STACKSIZE (16)
+#else
+# define SS_MISORT_STACKSIZE (24)
+#endif
+#if defined(BUILD_DIVSUFSORT64)
+# define SS_SMERGE_STACKSIZE (64)
+#else
+# define SS_SMERGE_STACKSIZE (32)
+#endif
+/* for trsort.c */
+#define TR_INSERTIONSORT_THRESHOLD (8)
+#if defined(BUILD_DIVSUFSORT64)
+# define TR_STACKSIZE (96)
+#else
+# define TR_STACKSIZE (64)
+#endif
+
+
+/*- Macros -*/
+#ifndef SWAP
+# define SWAP(_a, _b) do { t = (_a); (_a) = (_b); (_b) = t; } while(0)
+#endif /* SWAP */
+#ifndef MIN
+# define MIN(_a, _b) (((_a) < (_b)) ? (_a) : (_b))
+#endif /* MIN */
+#ifndef MAX
+# define MAX(_a, _b) (((_a) > (_b)) ? (_a) : (_b))
+#endif /* MAX */
+#define STACK_PUSH(_a, _b, _c, _d)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize++].d = (_d);\
+  } while(0)
+#define STACK_PUSH5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(ssize < STACK_SIZE);\
+    stack[ssize].a = (_a), stack[ssize].b = (_b),\
+    stack[ssize].c = (_c), stack[ssize].d = (_d), stack[ssize++].e = (_e);\
+  } while(0)
+#define STACK_POP(_a, _b, _c, _d)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d;\
+  } while(0)
+#define STACK_POP5(_a, _b, _c, _d, _e)\
+  do {\
+    assert(0 <= ssize);\
+    if(ssize == 0) { return; }\
+    (_a) = stack[--ssize].a, (_b) = stack[ssize].b,\
+    (_c) = stack[ssize].c, (_d) = stack[ssize].d, (_e) = stack[ssize].e;\
+  } while(0)
+/* for divsufsort.c */
+#define BUCKET_A(_c0) bucket_A[(_c0)]
+#if ALPHABET_SIZE == 256
+#define BUCKET_B(_c0, _c1) (bucket_B[((_c1) << 8) | (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[((_c0) << 8) | (_c1)])
+#else
+#define BUCKET_B(_c0, _c1) (bucket_B[(_c1) * ALPHABET_SIZE + (_c0)])
+#define BUCKET_BSTAR(_c0, _c1) (bucket_B[(_c0) * ALPHABET_SIZE + (_c1)])
+#endif
+
+
+/*- Private Prototypes -*/
+/* sssort.c */
+void
+sssort(const sauchar_t *Td, const saidx_t *PA,
+       saidx_t *first, saidx_t *last,
+       saidx_t *buf, saidx_t bufsize,
+       saidx_t depth, saidx_t n, saint_t lastsuffix);
+/* trsort.c */
+void
+trsort(saidx_t *ISA, saidx_t *SA, saidx_t n, saidx_t depth);
+
+
+#ifdef __cplusplus
+} /* extern "C" */
+#endif /* __cplusplus */
+
+#endif /* _DIVSUFSORT_PRIVATE_H */

data/ext/divsufsort_ruby.c

@@ -0,0 +1,227 @@
+#ifdef DIVSUFSORT_EXPORTS
+#define DLLEXPORT __declspec(dllexport)
+#else
+#define DLLEXPORT
+#endif
+
+#define VERSION "0.1.0"
+
+#include "divsufsort.h"
+#include "ruby.h"
+#include "rubysig.h"
+
+#ifndef RSTRING_PTR
+#define RSTRING_PTR(s) (RSTRING(s)->ptr)
+#endif
+#ifndef RSTRING_LEN
+#define RSTRING_LEN(s) (RSTRING(s)->len)
+#endif
+
+#define RB_STR_CAT_INT(o, n) do { \
+  unsigned char c[4]; \
+  c[0] = (unsigned char) (((n) >>  0) & 0xff); \
+  c[1] = (unsigned char) (((n) >>  8) & 0xff); \
+  c[2] = (unsigned char) (((n) >> 16) & 0xff); \
+  c[3] = (unsigned char) (((n) >> 24) & 0xff); \
+  rb_str_cat((o), c, 4); \
+} while(0)
+
+#define PTR_READ_INT(p, n, x) do { \
+  unsigned char c[4]; \
+  c[0] = (unsigned char) (p)[0]; \
+  c[1] = (unsigned char) (p)[1]; \
+  c[2] = (unsigned char) (p)[2]; \
+  c[3] = (unsigned char) (p)[3]; \
+  (x) = (c[0] <<  0) | (c[1] <<  8) | (c[2] << 16) | (c[3] << 24); \
+  (p) += 4; \
+  (n) -= 4; \
+} while(0)
+
+static VALUE Divsufsort;
+
+/* */
+static VALUE divsufsort_divsufsort(VALUE self, VALUE src) {
+  VALUE dst;
+  sauchar_t *T;
+  saidx_t *SA;
+  char *p;
+  long n, i;
+  saint_t err;
+
+  Check_Type(src, T_STRING);
+  p = RSTRING_PTR(src);
+  n = RSTRING_LEN(src);
+
+  if(n >= 0x7fffffff) {
+    rb_raise(rb_eRuntimeError, "Input data is too big.");
+  }
+
+  T = (sauchar_t *) xmalloc((size_t) n * sizeof(sauchar_t));
+  SA = (saidx_t *) xmalloc((size_t) n * sizeof(saidx_t));
+  dst = rb_ary_new();
+  memcpy(T, p, (size_t) n * sizeof(sauchar_t));
+
+  TRAP_BEG;
+  err = divsufsort(T, SA, (saidx_t) n);
+  TRAP_END;
+
+  if(err != 0) {
+    xfree(SA);
+    xfree(T);
+    rb_raise(rb_eRuntimeError, "Cannot allocate memory.");
+  }
+
+  TRAP_BEG;
+  err = sufcheck(T, SA, (saidx_t) n, 0);
+  TRAP_END;
+
+  if(err != 0) {
+    xfree(SA);
+    xfree(T);
+    rb_raise(rb_eRuntimeError, "Wrong suffix array.");
+  }
+
+  for(i = 0; i < n; i++) {
+    saidx_t SA_i = SA[i];
+    rb_ary_push(dst, LONG2NUM(SA_i));
+  }
+
+  xfree(SA);
+  xfree(T);
+
+  if(err != 0) {
+    rb_raise(rb_eRuntimeError, "Cannot allocate memory.");
+  }
+
+  return dst;
+}
+
+/* */
+static VALUE divsufsort_divbwt(int argc, VALUE *argv, VALUE self) {
+  VALUE src, v_blocksize, transformed;
+  sauchar_t *T;
+  saidx_t *SA;
+  char *p;
+  long n, T_len;
+  saint_t blocksize = 32;
+  saidx_t pidx;
+
+  rb_scan_args(argc, argv, "11", &src, &v_blocksize);
+  Check_Type(src, T_STRING);
+
+  if (!NIL_P(v_blocksize)) {
+    blocksize = (saint_t) NUM2INT(v_blocksize);
+  }
+
+  blocksize <<= 20;
+  p = RSTRING_PTR(src);
+  n = RSTRING_LEN(src);
+
+  if(n > 0x20000000L) {
+    n = 0x20000000L;
+  }
+
+  if(blocksize == 0 || n < blocksize) {
+    blocksize = (saidx_t) n;
+  }
+
+  T_len = blocksize * sizeof(sauchar_t);
+  T = (sauchar_t *) xmalloc(T_len);
+  SA = (saidx_t *) xmalloc(blocksize * sizeof(saidx_t));
+  transformed = rb_str_new("", 0);
+
+  RB_STR_CAT_INT(transformed, blocksize);
+
+  while (n > 0) {
+    int m = (n < T_len) ? n : T_len;
+
+    memcpy(T, p, m);
+    p += m; n -= m;
+
+    TRAP_BEG;
+    pidx = divbwt(T, T, SA, m);
+    TRAP_END;
+
+    if(pidx < 0) {
+      break;
+    }
+
+    RB_STR_CAT_INT(transformed, pidx);
+    rb_str_cat(transformed, T, m);
+  }
+
+  xfree(SA);
+  xfree(T);
+
+  if(pidx < 0) {
+    rb_raise(rb_eRuntimeError, "bw_transform: %s.", (pidx == -1) ? "Invalid arguments" : "Cannot allocate memory");
+  }
+
+  return transformed;
+}
+
+/* */
+static VALUE divsufsort_inverse_bw_transform(VALUE self, VALUE transformed) {
+  VALUE dst;
+  sauchar_t *T;
+  saidx_t *A;
+  char *p;
+  long n;
+  saint_t blocksize;
+  int err = 0;
+
+  Check_Type(transformed, T_STRING);
+  p = RSTRING_PTR(transformed);
+  n = RSTRING_LEN(transformed);
+
+  if (n < 4) {
+    rb_raise(rb_eRuntimeError, "reverseBWT: Invalid data.\n");
+  }
+
+  PTR_READ_INT(p, n, blocksize);
+  T = (sauchar_t *) xmalloc(blocksize * sizeof(sauchar_t));
+  A = (saidx_t *) xmalloc(blocksize * sizeof(saidx_t));
+  dst = rb_str_new("", 0);
+
+  while (n > 0) {
+    int m;
+    saidx_t pidx;
+
+    if (n < 4) {
+      err = -1;
+      break;
+    }
+
+    PTR_READ_INT(p, n, pidx);
+    m = (n < blocksize) ? n : blocksize;
+    memcpy(T, p, m);
+    p += m; n -= m;
+
+    TRAP_BEG;
+    err = inverse_bw_transform(T, T, A, m, pidx);
+    TRAP_END;
+
+    if(err != 0) {
+      break;
+    }
+
+    rb_str_cat(dst, T, m);
+  }
+
+  xfree(A);
+  xfree(T);
+
+  if (err != 0) {
+    rb_raise(rb_eRuntimeError, "reverseBWT: %s.\n", (err == -1) ? "Invalid data" : "Cannot allocate memory");
+  }
+
+  return dst;
+}
+
+void DLLEXPORT Init_divsufsort() {
+  Divsufsort = rb_define_module("Divsufsort");
+  rb_define_const(Divsufsort, "VERSION", rb_str_new2(VERSION));
+  rb_define_module_function(Divsufsort, "divsufsort", divsufsort_divsufsort, 1);
+  rb_define_module_function(Divsufsort, "divbwt", divsufsort_divbwt, -1);
+  rb_define_module_function(Divsufsort, "inverse_bw_transform", divsufsort_inverse_bw_transform, 1);
+}