ruby_da 0.0.3

data/libda/src/double_array_static.cc

@@ -0,0 +1,228 @@
+#ifndef _DOUBLE_ARRAY_H_
+#define _DOUBLE_ARRAY_H_
+#include <vector>
+#include <iostream>
+#include <stack>
+#include <string>
+#include <utility>
+#include <algorithm>
+#include <stdexcept>
+#include <cassert>
+
+
+class DoubleArray {
+  typedef unsigned char uchar;
+  struct node {
+    int base;
+    int check;
+  };
+
+  struct StackNode {
+    size_t depth;
+    size_t low;
+    size_t up;
+    int base;
+    StackNode(int d, int l, int u, int b) :
+      depth(d), low(l), up(u), base(b) {}
+  };
+
+  void set_check(int pos, int base){
+    if(pos == empty_head){
+      empty_head = -array[pos].check;
+      array[pos].check = base;
+    }else{
+      size_t i;
+      for(i = empty_head; i < array.size(); i = -array[i].check){
+	if(pos == -array[i].check){
+	  break;
+	}
+      }
+      array[i].check = array[pos].check;
+      array[pos].check = base;
+    }
+  }
+
+  void expand(size_t pos){
+    while(pos >= array.size()){
+      int i = array.size();
+      array.resize(array.size() * 2);
+      int n = array.size();
+      for(; i < n; i++){
+	array[i].check = -(i+1);
+      }
+    }
+  }
+
+  void build(std::vector<std::pair<std::string,int> > &words){
+    std::sort(words.rbegin(), words.rend());
+    std::stack<StackNode> st;
+    st.push(StackNode(0,0,words.size(),0));
+    array.resize(512);
+    array[0].check=0;
+    for(size_t i = 1; i < array.size(); i++)
+      array[i].check=-(i+1);
+    empty_head = 1;
+
+    while(!st.empty()){
+      StackNode stn = st.top(); st.pop();
+
+      if(stn.up - stn.low == 1 && words[stn.low].first.size() < stn.depth){
+	array[stn.base].base = -words[stn.low].second;
+	continue;
+      }
+
+      // extract traverses
+      std::vector<uchar> codes;
+      std::vector<std::pair<size_t, size_t> > ranges;
+      uchar c_before =  0;
+      if(words[stn.low].first.size() > stn.depth)
+	c_before = static_cast<uchar>((words[stn.low].first)[stn.depth]);
+
+      size_t low_before = stn.low;
+      for(size_t i = stn.low+1; i < stn.up; i++){
+	uchar c = 0;
+	if(stn.depth < words[i].first.size())
+	  c = static_cast<uchar>((words[i].first)[stn.depth]);
+
+	if(c != c_before){
+	  codes.push_back(c_before);
+	  ranges.push_back(std::make_pair(low_before,i));
+	  c_before = c;
+	  low_before = i;
+	}
+      }
+      codes.push_back(c_before);
+      ranges.push_back(std::make_pair(low_before, stn.up));
+
+      // check a invalid input
+      if(codes.size() == 1 && codes[0] == 0 && stn.up - stn.low > 1)
+	throw std::logic_error("overlapped");
+      assert(codes.size() != 0);
+
+      // find a base cand
+      int fcode = *(codes.begin());
+      int base_cand = empty_head - fcode;
+      int empty_index = empty_head;
+      while(1){
+	expand(empty_index);
+	if(empty_index - fcode < 0){
+	  empty_index = -array[empty_index].check;
+	  continue;
+	}
+	bool found = true;
+	base_cand = empty_index - fcode;
+	for(size_t i = 1; i < codes.size(); i++){
+	  expand(base_cand + codes[i]);
+	  if(array[base_cand + codes[i]].check >= 0){
+	    found = false;
+	    break;
+	  }
+	}
+	if(found) break;
+	empty_index = -array[empty_index].check;
+      }
+
+      // set a base and checks
+      array[stn.base].base = base_cand;
+      for(size_t i = 0; i < codes.size(); i++){
+	size_t pos = base_cand + codes[i];
+	set_check(pos,stn.base);
+	st.push(StackNode(stn.depth+1,ranges[i].first,
+	      ranges[i].second,pos));
+      }
+    }
+  }
+  public:
+
+  void commonPrefixSearch(const char *str,
+      std::vector<int> &res_len,
+      std::vector<int> &res_id) const {
+    const char *p = str;
+    int state = 0;
+    while(1){
+      int t = array[state].base;
+      if(state != 0 && t < static_cast<int>(array.size()) &&
+	  array[t].check == state){
+	res_len.push_back(std::distance(str,p));
+	res_id.push_back(-array[t].base);
+      }
+      uchar c = static_cast<uchar>(*p);
+      if(t+c < static_cast<int>(array.size()) && array[t+c].check == state){
+	if(c == 0){
+	  return;
+	}
+	state = t+c;
+	++p;
+      }else{
+	return;
+      }
+    }
+  }
+
+  DoubleArray(std::vector<std::pair<std::string,int> > &v) {
+    build(v);
+  }
+
+  DoubleArray() : array(1) {}
+
+  bool save(std::ostream &os){
+    int i;
+    int n = array.size();
+    for(i = n - 1; i >= 0; i--){
+      if(array[i].check >= 0) break;
+    }
+    std::vector<int> v((i+1) * 2 + 1);
+    for(int j = 0; j <= i; j++){
+      v[j*2+1] = array[j].base;
+      v[j*2+2] = array[j].check;
+    }
+    v[0] = i;
+    os.write(reinterpret_cast<const char *>(&v[0]), v.size()*sizeof(int));
+    if(os.fail()) return false;
+    return true;
+  }
+
+  bool load(std::istream &is){
+    int i = 0;
+    is.read((char *)&i, sizeof(int));
+    if(is.fail()) return false;
+    array.resize(i);
+    std::vector<int> v((i+1) * 2);
+    is.read(reinterpret_cast<char *>(&v[0]), v.size()*sizeof(int));
+    if(is.fail() && !is.eof()) return false;
+    for(int j = 0; j <= i; j++){
+      array[j].base = v[j*2];
+      array[j].check = v[j*2+1];
+    }
+    return true;
+  }
+
+  private:
+  std::vector<node> array;
+  int empty_head;
+};
+
+#include <fstream>
+using namespace std;
+int
+main(int argc, char *argv[]){
+  string line;
+  vector<pair<string,int> > lines;
+  int n = 1;
+  while(getline(cin,line)){
+    lines.push_back(make_pair(line,n++));
+  }
+  ofstream ofs("test.dat");
+  DoubleArray da(lines);
+  vector<int> v1;
+  vector<int> v2;
+  if(argc < 1 || argv[1] == NULL){
+    da.commonPrefixSearch("bisons",v1,v2);
+    for(size_t i = 0; i < v1.size(); i++)
+      cout << v1[i] << " " << v2[i] << endl;
+  }else{
+    da.commonPrefixSearch(argv[1],v1,v2);
+  }
+  return 0;
+}
+#endif /* _DOUBLE_ARRAY_H_ */

data/libda/src/profile.hpp

@@ -0,0 +1,38 @@
+/*
+ * WRITTEN BY Masahiko Higashiyama in 2010.
+ *
+ * THIS CODE IS IN PUBLIC DOMAIN.
+ * THIS SOFTWARE IS COMPLETELY FREE TO COPY, MODIFY AND/OR RE-DISTRIBUTE.
+ *
+ * THIS 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 _PROFILE_H_
+#define _PROFILE_H_
+
+#include <sys/resource.h>
+#include <limits.h>
+#include <stdlib.h>
+#include <errno.h>
+#include <cstdio>
+
+double GetusageSec()
+{
+  struct rusage t;
+  struct timeval tv;
+  getrusage(RUSAGE_SELF, &t);
+  tv = t.ru_utime;
+  return tv.tv_sec + (double)tv.tv_usec*1e-6;
+}
+
+void PrintTime(double before, double after)
+{
+  printf("  time = %10.30f\n", after-before);
+}
+
+#endif /* _PROFILE_H_ */

data/ruby_da.gemspec

@@ -0,0 +1,36 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_da/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_da"
+  spec.version       = RubyDa::VERSION
+  spec.authors       = ["Masahiko Higashiyama"] 
+  spec.email         = ["masahiko.higashiyama@gmail.com"]
+
+  spec.summary       = %q{Double Array Implementation}
+  spec.description   = %q{Double Array Implementation}
+  spec.homepage      = "https://github.com/shnya/ruby_da"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  if RUBY_PLATFORM =~ /java/
+    spec.platform = "java"
+    spec.files << "lib/java-da.jar"
+    spec.files << "lib/ruby_da.jar"
+    spec.files.concat(`find ./javada -print0`.split("\x0").reject{ |f| f.match(%r{(.git|.idea|test|target)}) })
+  else
+    spec.platform = Gem::Platform::RUBY
+    spec.extensions    = ["ext/ruby_da/extconf.rb"]
+    spec.files.concat(`find ./libda -print0 -name "*.hpp"`.split("\x0").reject{ |f| f.match(%r{(.git|test)}) })
+  end
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rake-compiler"
+  spec.add_development_dependency "minitest"
+end

metadata

@@ -0,0 +1,124 @@
+--- !ruby/object:Gem::Specification
+name: ruby_da
+version: !ruby/object:Gem::Version
+  version: 0.0.3
+platform: ruby
+authors:
+- Masahiko Higashiyama
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2015-05-20 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Double Array Implementation
+email:
+- masahiko.higashiyama@gmail.com
+executables: []
+extensions:
+- ext/ruby_da/extconf.rb
+extra_rdoc_files: []
+files:
+- "./libda/README.md"
+- "./libda/include/double_array.hpp"
+- "./libda/include/double_array_internal.hpp"
+- "./libda/include/utf8.hpp"
+- "./libda/src/double_array.cc"
+- "./libda/src/double_array_static.cc"
+- "./libda/src/profile.hpp"
+- ".gitignore"
+- ".gitmodules"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/ruby_da/RubyDaService.java
+- ext/ruby_da/extconf.rb
+- ext/ruby_da/ruby_da.cpp
+- ext/ruby_da/ruby_da.h
+- lib/ruby_da.rb
+- lib/ruby_da/version.rb
+- ruby_da.gemspec
+homepage: https://github.com/shnya/ruby_da
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.2.2
+signing_key: 
+specification_version: 4
+summary: Double Array Implementation
+test_files: []