melisa 0.1.0

data/ext/marisa/lib/marisa/grimoire/vector/bit-vector.h

@@ -0,0 +1,179 @@
+#ifndef MARISA_GRIMOIRE_VECTOR_BIT_VECTOR_H_
+#define MARISA_GRIMOIRE_VECTOR_BIT_VECTOR_H_
+
+#include "marisa/grimoire/vector/rank-index.h"
+#include "marisa/grimoire/vector/vector.h"
+
+namespace marisa {
+namespace grimoire {
+namespace vector {
+
+class BitVector {
+ public:
+#if MARISA_WORD_SIZE == 64
+  typedef UInt64 Unit;
+#else  // MARISA_WORD_SIZE == 64
+  typedef UInt32 Unit;
+#endif  // MARISA_WORD_SIZE == 64
+
+  BitVector()
+      : units_(), size_(0), num_1s_(0), ranks_(), select0s_(), select1s_() {}
+
+  void build(bool enables_select0, bool enables_select1) {
+    BitVector temp;
+    temp.build_index(*this, enables_select0, enables_select1);
+    units_.shrink();
+    temp.units_.swap(units_);
+    swap(temp);
+  }
+
+  void map(Mapper &mapper) {
+    BitVector temp;
+    temp.map_(mapper);
+    swap(temp);
+  }
+  void read(Reader &reader) {
+    BitVector temp;
+    temp.read_(reader);
+    swap(temp);
+  }
+  void write(Writer &writer) const {
+    write_(writer);
+  }
+
+  void disable_select0() {
+    select0s_.clear();
+  }
+  void disable_select1() {
+    select1s_.clear();
+  }
+
+  void push_back(bool bit) {
+    MARISA_THROW_IF(size_ == MARISA_UINT32_MAX, MARISA_SIZE_ERROR);
+    if (size_ == (MARISA_WORD_SIZE * units_.size())) {
+      units_.resize(units_.size() + (64 / MARISA_WORD_SIZE), 0);
+    }
+    if (bit) {
+      units_[size_ / MARISA_WORD_SIZE] |=
+          (Unit)1 << (size_ % MARISA_WORD_SIZE);
+      ++num_1s_;
+    }
+    ++size_;
+  }
+
+  bool operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(i >= size_, MARISA_BOUND_ERROR);
+    return (units_[i / MARISA_WORD_SIZE]
+        & ((Unit)1 << (i % MARISA_WORD_SIZE))) != 0;
+  }
+
+  std::size_t rank0(std::size_t i) const {
+    MARISA_DEBUG_IF(ranks_.empty(), MARISA_STATE_ERROR);
+    MARISA_DEBUG_IF(i > size_, MARISA_BOUND_ERROR);
+    return i - rank1(i);
+  }
+  std::size_t rank1(std::size_t i) const;
+
+  std::size_t select0(std::size_t i) const;
+  std::size_t select1(std::size_t i) const;
+
+  std::size_t num_0s() const {
+    return size_ - num_1s_;
+  }
+  std::size_t num_1s() const {
+    return num_1s_;
+  }
+
+  bool empty() const {
+    return size_ == 0;
+  }
+  std::size_t size() const {
+    return size_;
+  }
+  std::size_t total_size() const {
+    return units_.total_size() + ranks_.total_size()
+        + select0s_.total_size() + select1s_.total_size();
+  }
+  std::size_t io_size() const {
+    return units_.io_size() + (sizeof(UInt32) * 2) + ranks_.io_size()
+        + select0s_.io_size() + select1s_.io_size();
+  }
+
+  void clear() {
+    BitVector().swap(*this);
+  }
+  void swap(BitVector &rhs) {
+    units_.swap(rhs.units_);
+    marisa::swap(size_, rhs.size_);
+    marisa::swap(num_1s_, rhs.num_1s_);
+    ranks_.swap(rhs.ranks_);
+    select0s_.swap(rhs.select0s_);
+    select1s_.swap(rhs.select1s_);
+  }
+
+ private:
+  Vector<Unit> units_;
+  std::size_t size_;
+  std::size_t num_1s_;
+  Vector<RankIndex> ranks_;
+  Vector<UInt32> select0s_;
+  Vector<UInt32> select1s_;
+
+  void build_index(const BitVector &bv,
+      bool enables_select0, bool enables_select1);
+
+  void map_(Mapper &mapper) {
+    units_.map(mapper);
+    {
+      UInt32 temp_size;
+      mapper.map(&temp_size);
+      size_ = temp_size;
+    }
+    {
+      UInt32 temp_num_1s;
+      mapper.map(&temp_num_1s);
+      MARISA_THROW_IF(temp_num_1s > size_, MARISA_FORMAT_ERROR);
+      num_1s_ = temp_num_1s;
+    }
+    ranks_.map(mapper);
+    select0s_.map(mapper);
+    select1s_.map(mapper);
+  }
+
+  void read_(Reader &reader) {
+    units_.read(reader);
+    {
+      UInt32 temp_size;
+      reader.read(&temp_size);
+      size_ = temp_size;
+    }
+    {
+      UInt32 temp_num_1s;
+      reader.read(&temp_num_1s);
+      MARISA_THROW_IF(temp_num_1s > size_, MARISA_FORMAT_ERROR);
+      num_1s_ = temp_num_1s;
+    }
+    ranks_.read(reader);
+    select0s_.read(reader);
+    select1s_.read(reader);
+  }
+
+  void write_(Writer &writer) const {
+    units_.write(writer);
+    writer.write((UInt32)size_);
+    writer.write((UInt32)num_1s_);
+    ranks_.write(writer);
+    select0s_.write(writer);
+    select1s_.write(writer);
+  }
+
+  // Disallows copy and assignment.
+  BitVector(const BitVector &);
+  BitVector &operator=(const BitVector &);
+};
+
+}  // namespace vector
+}  // namespace grimoire
+}  // namespace marisa
+
+#endif  // MARISA_GRIMOIRE_VECTOR_BIT_VECTOR_H_

data/ext/marisa/lib/marisa/grimoire/vector/flat-vector.h

@@ -0,0 +1,205 @@
+#ifndef MARISA_GRIMOIRE_VECTOR_FLAT_VECTOR_H_
+#define MARISA_GRIMOIRE_VECTOR_FLAT_VECTOR_H_
+
+#include "marisa/grimoire/vector/vector.h"
+
+namespace marisa {
+namespace grimoire {
+namespace vector {
+
+class FlatVector {
+ public:
+#if MARISA_WORD_SIZE == 64
+  typedef UInt64 Unit;
+#else  // MARISA_WORD_SIZE == 64
+  typedef UInt32 Unit;
+#endif  // MARISA_WORD_SIZE == 64
+
+  FlatVector() : units_(), value_size_(0), mask_(0), size_(0) {}
+
+  void build(const Vector<UInt32> &values) {
+    FlatVector temp;
+    temp.build_(values);
+    swap(temp);
+  }
+
+  void map(Mapper &mapper) {
+    FlatVector temp;
+    temp.map_(mapper);
+    swap(temp);
+  }
+  void read(Reader &reader) {
+    FlatVector temp;
+    temp.read_(reader);
+    swap(temp);
+  }
+  void write(Writer &writer) const {
+    write_(writer);
+  }
+
+  UInt32 operator[](std::size_t i) const {
+    MARISA_DEBUG_IF(i >= size_, MARISA_BOUND_ERROR);
+
+    const std::size_t pos = i * value_size_;
+    const std::size_t unit_id = pos / MARISA_WORD_SIZE;
+    const std::size_t unit_offset = pos % MARISA_WORD_SIZE;
+
+    if ((unit_offset + value_size_) <= MARISA_WORD_SIZE) {
+      return (UInt32)(units_[unit_id] >> unit_offset) & mask_;
+    } else {
+      return (UInt32)((units_[unit_id] >> unit_offset)
+          | (units_[unit_id + 1] << (MARISA_WORD_SIZE - unit_offset))) & mask_;
+    }
+  }
+
+  std::size_t value_size() const {
+    return value_size_;
+  }
+  UInt32 mask() const {
+    return mask_;
+  }
+
+  bool empty() const {
+    return size_ == 0;
+  }
+  std::size_t size() const {
+    return size_;
+  }
+  std::size_t total_size() const {
+    return units_.total_size();
+  }
+  std::size_t io_size() const {
+    return units_.io_size() + (sizeof(UInt32) * 2) + sizeof(UInt64);
+  }
+
+  void clear() {
+    FlatVector().swap(*this);
+  }
+  void swap(FlatVector &rhs) {
+    units_.swap(rhs.units_);
+    marisa::swap(value_size_, rhs.value_size_);
+    marisa::swap(mask_, rhs.mask_);
+    marisa::swap(size_, rhs.size_);
+  }
+
+ private:
+  Vector<Unit> units_;
+  std::size_t value_size_;
+  UInt32 mask_;
+  std::size_t size_;
+
+  void build_(const Vector<UInt32> &values) {
+    UInt32 max_value = 0;
+    for (std::size_t i = 0; i < values.size(); ++i) {
+      if (values[i] > max_value) {
+        max_value = values[i];
+      }
+    }
+
+    std::size_t value_size = 0;
+    while (max_value != 0) {
+      ++value_size;
+      max_value >>= 1;
+    }
+
+    std::size_t num_units = values.empty() ? 0 : (64 / MARISA_WORD_SIZE);
+    if (value_size != 0) {
+      num_units = (std::size_t)(
+          (((UInt64)value_size * values.size()) + (MARISA_WORD_SIZE - 1))
+          / MARISA_WORD_SIZE);
+      num_units += num_units % (64 / MARISA_WORD_SIZE);
+    }
+
+    units_.resize(num_units);
+    if (num_units > 0) {
+      units_.back() = 0;
+    }
+
+    value_size_ = value_size;
+    if (value_size != 0) {
+      mask_ = MARISA_UINT32_MAX >> (32 - value_size);
+    }
+    size_ = values.size();
+
+    for (std::size_t i = 0; i < values.size(); ++i) {
+      set(i, values[i]);
+    }
+  }
+
+  void map_(Mapper &mapper) {
+    units_.map(mapper);
+    {
+      UInt32 temp_value_size;
+      mapper.map(&temp_value_size);
+      MARISA_THROW_IF(temp_value_size > 32, MARISA_FORMAT_ERROR);
+      value_size_ = temp_value_size;
+    }
+    {
+      UInt32 temp_mask;
+      mapper.map(&temp_mask);
+      mask_ = temp_mask;
+    }
+    {
+      UInt64 temp_size;
+      mapper.map(&temp_size);
+      MARISA_THROW_IF(temp_size > MARISA_SIZE_MAX, MARISA_SIZE_ERROR);
+      size_ = (std::size_t)temp_size;
+    }
+  }
+
+  void read_(Reader &reader) {
+    units_.read(reader);
+    {
+      UInt32 temp_value_size;
+      reader.read(&temp_value_size);
+      MARISA_THROW_IF(temp_value_size > 32, MARISA_FORMAT_ERROR);
+      value_size_ = temp_value_size;
+    }
+    {
+      UInt32 temp_mask;
+      reader.read(&temp_mask);
+      mask_ = temp_mask;
+    }
+    {
+      UInt64 temp_size;
+      reader.read(&temp_size);
+      MARISA_THROW_IF(temp_size > MARISA_SIZE_MAX, MARISA_SIZE_ERROR);
+      size_ = (std::size_t)temp_size;
+    }
+  }
+
+  void write_(Writer &writer) const {
+    units_.write(writer);
+    writer.write((UInt32)value_size_);
+    writer.write((UInt32)mask_);
+    writer.write((UInt64)size_);
+  }
+
+  void set(std::size_t i, UInt32 value) {
+    MARISA_DEBUG_IF(i >= size_, MARISA_BOUND_ERROR);
+    MARISA_DEBUG_IF(value > mask_, MARISA_RANGE_ERROR);
+
+    const std::size_t pos = i * value_size_;
+    const std::size_t unit_id = pos / MARISA_WORD_SIZE;
+    const std::size_t unit_offset = pos % MARISA_WORD_SIZE;
+
+    units_[unit_id] &= ~((Unit)mask_ << unit_offset);
+    units_[unit_id] |= (Unit)(value & mask_) << unit_offset;
+    if ((unit_offset + value_size_) > MARISA_WORD_SIZE) {
+      units_[unit_id + 1] &=
+          ~((Unit)mask_ >> (MARISA_WORD_SIZE - unit_offset));
+      units_[unit_id + 1] |=
+          (Unit)(value & mask_) >> (MARISA_WORD_SIZE - unit_offset);
+    }
+  }
+
+  // Disallows copy and assignment.
+  FlatVector(const FlatVector &);
+  FlatVector &operator=(const FlatVector &);
+};
+
+}  // namespace vector
+}  // namespace grimoire
+}  // namespace marisa
+
+#endif  // MARISA_GRIMOIRE_VECTOR_FLAT_VECTOR_H_

data/ext/marisa/lib/marisa/grimoire/vector/pop-count.h

@@ -0,0 +1,110 @@
+#ifndef MARISA_GRIMOIRE_VECTOR_POP_COUNT_H_
+#define MARISA_GRIMOIRE_VECTOR_POP_COUNT_H_
+
+#include "marisa/grimoire/intrin.h"
+
+namespace marisa {
+namespace grimoire {
+namespace vector {
+
+#if MARISA_WORD_SIZE == 64
+
+class PopCount {
+ public:
+  explicit PopCount(UInt64 x) : value_() {
+    x = (x & 0x5555555555555555ULL) + ((x & 0xAAAAAAAAAAAAAAAAULL) >> 1);
+    x = (x & 0x3333333333333333ULL) + ((x & 0xCCCCCCCCCCCCCCCCULL) >> 2);
+    x = (x & 0x0F0F0F0F0F0F0F0FULL) + ((x & 0xF0F0F0F0F0F0F0F0ULL) >> 4);
+    x *= 0x0101010101010101ULL;
+    value_ = x;
+  }
+
+  std::size_t lo8() const {
+    return (std::size_t)(value_ & 0xFFU);
+  }
+  std::size_t lo16() const {
+    return (std::size_t)((value_ >> 8) & 0xFFU);
+  }
+  std::size_t lo24() const {
+    return (std::size_t)((value_ >> 16) & 0xFFU);
+  }
+  std::size_t lo32() const {
+    return (std::size_t)((value_ >> 24) & 0xFFU);
+  }
+  std::size_t lo40() const {
+    return (std::size_t)((value_ >> 32) & 0xFFU);
+  }
+  std::size_t lo48() const {
+    return (std::size_t)((value_ >> 40) & 0xFFU);
+  }
+  std::size_t lo56() const {
+    return (std::size_t)((value_ >> 48) & 0xFFU);
+  }
+  std::size_t lo64() const {
+    return (std::size_t)((value_ >> 56) & 0xFFU);
+  }
+
+  static std::size_t count(UInt64 x) {
+#if defined(MARISA_X64) && defined(MARISA_USE_POPCNT)
+ #ifdef _MSC_VER
+    return __popcnt64(x);
+ #else  // _MSC_VER
+    return _mm_popcnt_u64(x);
+ #endif  // _MSC_VER
+#else  // defined(MARISA_X64) && defined(MARISA_USE_POPCNT)
+    return PopCount(x).lo64();
+#endif  // defined(MARISA_X64) && defined(MARISA_USE_POPCNT)
+  }
+
+ private:
+  UInt64 value_;
+};
+
+#else  // MARISA_WORD_SIZE == 64
+
+class PopCount {
+ public:
+  explicit PopCount(UInt32 x) : value_() {
+    x = (x & 0x55555555U) + ((x & 0xAAAAAAAAU) >> 1);
+    x = (x & 0x33333333U) + ((x & 0xCCCCCCCCU) >> 2);
+    x = (x & 0x0F0F0F0FU) + ((x & 0xF0F0F0F0U) >> 4);
+    x *= 0x01010101U;
+    value_ = x;
+  }
+
+  std::size_t lo8() const {
+    return value_ & 0xFFU;
+  }
+  std::size_t lo16() const {
+    return (value_ >> 8) & 0xFFU;
+  }
+  std::size_t lo24() const {
+    return (value_ >> 16) & 0xFFU;
+  }
+  std::size_t lo32() const {
+    return (value_ >> 24) & 0xFFU;
+  }
+
+  static std::size_t count(UInt32 x) {
+#ifdef MARISA_USE_POPCNT
+ #ifdef _MSC_VER
+    return __popcnt(x);
+ #else  // _MSC_VER
+    return _mm_popcnt_u32(x);
+ #endif  // _MSC_VER
+#else  // MARISA_USE_POPCNT
+    return PopCount(x).lo32();
+#endif  // MARISA_USE_POPCNT
+  }
+
+ private:
+  UInt32 value_;
+};
+
+#endif  // MARISA_WORD_SIZE == 64
+
+}  // namespace vector
+}  // namespace grimoire
+}  // namespace marisa
+
+#endif  // MARISA_GRIMOIRE_VECTOR_POP_COUNT_H_