tatara 0.2.0 → 0.3.0

data/ext/tatara/map/string/string_float_map.hpp

@@ -0,0 +1,67 @@
+#ifndef STRING_FLOAT_MAP_HPP_
+#define STRING_FLOAT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+#include <string>
+
+class StringFloatMap {
+    std::unordered_map<std::string, double> container;
+
+    public:
+        StringFloatMap();
+        ~StringFloatMap();
+        double bracket(const std::string key);
+        double bracket_equal(const std::string key, const double value);
+};
+
+StringFloatMap::StringFloatMap() {}
+
+StringFloatMap::~StringFloatMap() {}
+
+double StringFloatMap::bracket(const std::string key) {
+    return this->container[key];
+}
+
+double StringFloatMap::bracket_equal(const std::string key, const double value) {
+    return this->container[key] = value;
+}
+
+static StringFloatMap *getStringFloatMap(VALUE self) {
+    StringFloatMap *ptr;
+    Data_Get_Struct(self, StringFloatMap, ptr);
+    return ptr;
+}
+
+static void wrap_string_float_map_free(StringFloatMap *ptr) {
+    ptr->~StringFloatMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_float_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(StringFloatMap));
+    p = new StringFloatMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_float_map_free, p);
+}
+
+static VALUE wrap_string_float_map_init(VALUE self) {
+    StringFloatMap *p = getStringFloatMap(self);
+    p = new StringFloatMap;
+    return Qnil;
+}
+
+static VALUE wrap_string_float_map_bracket(VALUE self, VALUE key) {
+    const std::string k = {StringValueCStr(key)};
+    const double value = getStringFloatMap(self)->bracket(k);
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_string_float_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const std::string k = {StringValueCStr(key)};
+    const double v = NUM2DBL(value);
+    getStringFloatMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/string/string_int_map.hpp

@@ -0,0 +1,67 @@
+#ifndef STRING_INT_MAP_HPP_
+#define STRING_INT_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+#include <string>
+
+class StringIntMap {
+    std::unordered_map<std::string, int> container;
+
+    public:
+        StringIntMap();
+        ~StringIntMap();
+        int bracket(const std::string key);
+        int bracket_equal(const std::string key, const int value);
+};
+
+StringIntMap::StringIntMap() {}
+
+StringIntMap::~StringIntMap() {}
+
+int StringIntMap::bracket(const std::string key) {
+    return this->container[key];
+}
+
+int StringIntMap::bracket_equal(const std::string key, const int value) {
+    return this->container[key] = value;
+}
+
+static StringIntMap *getStringIntMap(VALUE self) {
+    StringIntMap *ptr;
+    Data_Get_Struct(self, StringIntMap, ptr);
+    return ptr;
+}
+
+static void wrap_string_int_map_free(StringIntMap *ptr) {
+    ptr->~StringIntMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_int_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(StringIntMap));
+    p = new StringIntMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_int_map_free, p);
+}
+
+static VALUE wrap_string_int_map_init(VALUE self) {
+    StringIntMap *p = getStringIntMap(self);
+    p = new StringIntMap;
+    return Qnil;
+}
+
+static VALUE wrap_string_int_map_bracket(VALUE self, VALUE key) {
+    const std::string k = {StringValueCStr(key)};
+    const int value = getStringIntMap(self)->bracket(k);
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_string_int_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const std::string k = {StringValueCStr(key)};
+    const int v = NUM2INT(value);
+    getStringIntMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/map/string/string_string_map.hpp

@@ -0,0 +1,67 @@
+#ifndef STRING_STRING_MAP_HPP_
+#define STRING_STRING_MAP_HPP_
+
+#include <ruby.h>
+#include <unordered_map>
+#include <string>
+
+class StringStringMap {
+    std::unordered_map<std::string, std::string> container;
+
+    public:
+        StringStringMap();
+        ~StringStringMap();
+        std::string bracket(const std::string key);
+        std::string bracket_equal(const std::string key, const std::string value);
+};
+
+StringStringMap::StringStringMap() {}
+
+StringStringMap::~StringStringMap() {}
+
+std::string StringStringMap::bracket(const std::string key) {
+    return this->container[key];
+}
+
+std::string StringStringMap::bracket_equal(const std::string key, const std::string value) {
+    return this->container[key] = value;
+}
+
+static StringStringMap *getStringStringMap(VALUE self) {
+    StringStringMap *ptr;
+    Data_Get_Struct(self, StringStringMap, ptr);
+    return ptr;
+}
+
+static void wrap_string_string_map_free(StringStringMap *ptr) {
+    ptr->~StringStringMap();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_string_map_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(StringStringMap));
+    p = new StringStringMap;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_string_map_free, p);
+}
+
+static VALUE wrap_string_string_map_init(VALUE self) {
+    StringStringMap *p = getStringStringMap(self);
+    p = new StringStringMap;
+    return Qnil;
+}
+
+static VALUE wrap_string_string_map_bracket(VALUE self, VALUE key) {
+    const std::string k = {StringValueCStr(key)};
+    const std::string value = getStringStringMap(self)->bracket(k);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_string_map_bracket_equal(VALUE self, VALUE key, VALUE value) {
+    const std::string k = {StringValueCStr(key)};
+    const std::string v = {StringValueCStr(value)};
+    getStringStringMap(self)->bracket_equal(k, v);
+    return value;
+}
+
+#endif

data/ext/tatara/string/string.hpp

@@ -1,6 +1,8 @@
 #ifndef STRING_H_
 #define STRING_H_
 
+#include <ruby.h>
+#include <iostream>
 #include <string>
 
 class CppString {
@@ -72,4 +74,107 @@ std::string CppString::slice_des(const int start, const int end) {
     return this->value;
 }
 
+static CppString *getCppString(VALUE self) {
+    CppString *ptr;
+    Data_Get_Struct(self, CppString, ptr);
+    return ptr;
+}
+
+static void wrap_string_free(CppString *ptr) {
+    ptr->~CppString();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(CppString));
+    p = new CppString;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_free, p);
+}
+
+static VALUE wrap_string_init(VALUE self) {
+    CppString *p = getCppString(self);
+    p = new CppString;
+    return Qnil;
+}
+
+static VALUE wrap_string_return_value(VALUE self) {
+    const std::string value = getCppString(self)->return_value();
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_assignment(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getCppString(self)->assignment(v);
+    return value;
+}
+
+static VALUE wrap_string_plus_equal(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    const std::string r = getCppString(self)->plus_equal(v);
+    VALUE result = rb_str_new(v.c_str(), v.size());
+    return result;
+}
+
+static VALUE wrap_string_to_integer(VALUE self) {
+    try {
+        const int value = getCppString(self)->to_integer();
+        VALUE result = INT2NUM(value);
+        return result;
+    } catch (...) {
+        std::cout << "Cannot Convert Integer!" << std::endl;
+    }
+}
+
+static VALUE wrap_string_to_float(VALUE self) {
+    try {
+        const double value = getCppString(self)->to_float();
+        VALUE result = DBL2NUM(value);
+        return result;
+    } catch (...) {
+        std::cout << "Cannot Convert Float!" << std::endl;
+    }
+}
+
+static VALUE wrap_string_clear(VALUE self) {
+    const std::string value = getCppString(self)->clear();
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_equal(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    bool eval = getCppString(self)->equal(v);
+    return eval ? Qtrue : Qfalse;
+}
+
+static VALUE wrap_string_initialize_object(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getCppString(self)->initialize_object(v);
+    return self;
+}
+
+static VALUE wrap_string_index_access(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const std::string value = getCppString(self)->index_access(i);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_slice(VALUE self, VALUE start, VALUE end) {
+    const int s = NUM2INT(start);
+    const int e = NUM2INT(end);
+    const std::string value = getCppString(self)->slice(s, e);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+} 
+
+static VALUE wrap_string_destructive_slice(VALUE self, VALUE start, VALUE end) {
+    const int s = NUM2INT(start);
+    const int e = NUM2INT(end);
+    const std::string value = getCppString(self)->slice_des(s, e);
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+} 
+
 #endif

data/ext/tatara/tatara.cpp

@@ -1,6 +1,4 @@
 #include <string>
-#include <rice/Data_Type.hpp>
-#include <rice/Constructor.hpp>
 #include "vector/vector.hpp"
 #include "array/array.hpp"
 #include "map/map.hpp"
@@ -8,249 +6,252 @@
 #include "float/float.hpp"
 #include "string/string.hpp"
 
-using namespace Rice;
-
 extern "C" {
     void Init_tatara() {
-        Rice::Module rb_mTatara = define_module("Tatara");
-
-        Data_Type<Integer> rbcInteger = define_class_under<Integer>(rb_mTatara, "Integer")
-            .define_constructor(Constructor<Integer>())
-            .define_method("value", &Integer::return_value)
-            .define_method("val", &Integer::return_value)
-            .define_method("value=", &Integer::assignment)
-            .define_method("val=", &Integer::assignment)
-            .define_method("value+", &Integer::plus)
-            .define_method("val+", &Integer::plus)
-            .define_method("value+=", &Integer::plus_equal)
-            .define_method("val+=", &Integer::plus_equal)
-            .define_method("value-", &Integer::minus)
-            .define_method("val-", &Integer::minus)
-            .define_method("value-=", &Integer::minus_equal)
-            .define_method("val-=", &Integer::minus_equal)
-            .define_method("value/", &Integer::divided)
-            .define_method("val/", &Integer::divided)
-            .define_method("value/=", &Integer::divided_equal)
-            .define_method("val/=", &Integer::divided_equal)
-            .define_method("value*", &Integer::multiply)
-            .define_method("val*", &Integer::multiply)
-            .define_method("value*=", &Integer::multiply_equal)
-            .define_method("val*=", &Integer::multiply_equal)
-            .define_method("value%", &Integer::mod)
-            .define_method("value%=", &Integer::mod_equal)
-            .define_method("value**", &Integer::power)
-            .define_method("val**", &Integer::power)
-            .define_method("value**=", &Integer::power_equal)
-            .define_method("val**=", &Integer::power_equal)
-            .define_method("inc", &Integer::increment_value)
-            .define_method("increment", &Integer::increment_value)
-            .define_method("dec", &Integer::decrement_value)
-            .define_method("decrement", &Integer::decrement_value)
-            .define_method("to_s", &Integer::to_string)
-            .define_method("to_f", &Integer::to_float)
-            .define_method("clear", &Integer::clear)
-            .define_method("value==", &Integer::equal)
-            .define_method("val==", &Integer::equal)
-            .define_method("equal?", &Integer::equal)
-            .define_method("<<", &Integer::initialize_object);
-
-        Data_Type<Float> rbcFloat = define_class_under<Float>(rb_mTatara, "Float")
-            .define_constructor(Constructor<Float>())
-            .define_method("value", &Float::return_value)
-            .define_method("val", &Float::return_value)
-            .define_method("value=", &Float::assignment)
-            .define_method("val=", &Float::assignment)
-            .define_method("value+", &Float::plus)
-            .define_method("val+", &Float::plus)
-            .define_method("value+=", &Float::plus_equal)
-            .define_method("val+=", &Float::plus_equal)
-            .define_method("value-", &Float::minus)
-            .define_method("val-", &Float::minus)
-            .define_method("value-=", &Float::minus_equal)
-            .define_method("val-=", &Float::minus_equal)
-            .define_method("value*", &Float::multiply)
-            .define_method("val*", &Float::multiply)
-            .define_method("value*=", &Float::multiply_equal)
-            .define_method("val*=", &Float::multiply_equal)
-            .define_method("value/", &Float::divided)
-            .define_method("val/", &Float::divided)
-            .define_method("value/=", &Float::divided_equal)
-            .define_method("val/=", &Float::divided_equal)
-            .define_method("value**", &Float::power)
-            .define_method("val**", &Float::power)
-            .define_method("value**=", &Float::power_equal)
-            .define_method("val**=", &Float::power_equal)
-            .define_method("inc", &Float::increment_value)
-            .define_method("dec", &Float::decrement_value)
-            .define_method("to_s", &Float::to_string)
-            .define_method("to_i", &Float::to_integer)
-            .define_method("clear", &Float::clear)
-            .define_method("value==", &Float::equal)
-            .define_method("val==", &Float::equal)
-            .define_method("equal?", &Float::equal)
-            .define_method("<<", &Float::initialize_object);
-
-        Data_Type<CppString> rbcString = define_class_under<CppString>(rb_mTatara, "String")
-            .define_constructor(Constructor<CppString>())
-            .define_method("value", &CppString::return_value)
-            .define_method("val", &CppString::return_value)
-            .define_method("value=", &CppString::assignment)
-            .define_method("val=", &CppString::assignment)
-            .define_method("value+=", &CppString::plus_equal)
-            .define_method("val+=", &CppString::plus_equal)
-            .define_method("to_i", &CppString::to_integer)
-            .define_method("to_f", &CppString::to_float)
-            .define_method("clear", &CppString::clear)
-            .define_method("value==", &CppString::equal)
-            .define_method("val==", &CppString::equal)
-            .define_method("equal?", &CppString::equal)
-            .define_method("<<", &CppString::initialize_object)
-            .define_method("[]", &CppString::index_access)
-            .define_method("slice", &CppString::slice)
-            .define_method("slice!", &CppString::slice_des);
-
-        Data_Type<Vector<int>> rb_cIntVector = define_class_under<Vector<int>>(rb_mTatara, "IntVector")
-            .define_constructor(Constructor<Vector<int>>())
-            .define_method("first", &Vector<int>::first)
-            .define_method("last", &Vector<int>::last)
-            .define_method("[]", &Vector<int>::bracket)
-            .define_method("[]=", &Vector<int>::bracket_equal)
-            .define_method("emplace_back", &Vector<int>::emplace_back)
-            .define_method("size", &Vector<int>::size)
-            .define_method("clear", &Vector<int>::clear)
-            .define_method("sum", &Vector<int>::sum)
-            .define_method("<<", &Vector<int>::push_back_object)
-            .define_method("intersection", &Vector<int>::intersection)
-            .define_method("sort", &Vector<int>::sort)
-            .define_method("sort!", &Vector<int>::destructive_sort)
-            .define_method("reverse", &Vector<int>::reverse)
-            .define_method("reverse!", &Vector<int>::destructive_reverse);
-
-        Data_Type<Vector<double>> rb_cFloatVector = define_class_under<Vector<double>>(rb_mTatara, "FloatVector")
-            .define_constructor(Constructor<Vector<double>>())
-            .define_method("first", &Vector<double>::first)
-            .define_method("last", &Vector<double>::last)
-            .define_method("[]", &Vector<double>::bracket)
-            .define_method("[]=", &Vector<double>::bracket_equal)
-            .define_method("emplace_back", &Vector<double>::emplace_back)
-            .define_method("size", &Vector<double>::size)
-            .define_method("clear", &Vector<double>::clear)
-            .define_method("sum", &Vector<double>::sum)
-            .define_method("<<", &Vector<double>::push_back_object)
-            .define_method("intersection", &Vector<double>::intersection)
-            .define_method("sort", &Vector<double>::sort)
-            .define_method("sort!", &Vector<double>::destructive_sort)
-            .define_method("reverse", &Vector<double>::reverse)
-            .define_method("reverse!", &Vector<double>::destructive_reverse);
-
-        Data_Type<Vector<std::string>> rb_cStringVector = define_class_under<Vector<std::string>>(rb_mTatara, "StringVector")
-            .define_constructor(Constructor<Vector<std::string>>())
-            .define_method("first", &Vector<std::string>::first)
-            .define_method("last", &Vector<std::string>::last)
-            .define_method("[]", &Vector<std::string>::bracket)
-            .define_method("[]=", &Vector<std::string>::bracket_equal)
-            .define_method("emplace_back", &    Vector<std::string>::emplace_back)
-            .define_method("size", &Vector<std::string>::size)
-            .define_method("clear", &Vector<std::string>::clear)
-            .define_method("sum", &Vector<std::string>::sum)
-            .define_method("<<", &Vector<std::string>::push_back_object)
-            .define_method("intersection", &Vector<std::string>::intersection)
-            .define_method("sort", &Vector<std::string>::sort)
-            .define_method("sort!", &Vector<std::string>::destructive_sort)
-            .define_method("reverse", &Vector<std::string>::reverse)
-            .define_method("reverse!", &Vector<std::string>::destructive_reverse);
-
-        Data_Type<CppArray<int>> rb_cIntArray = define_class_under<CppArray<int>>(rb_mTatara, "IntArray")
-            .define_constructor(Constructor<CppArray<int>>())
-            .define_method("first", &CppArray<int>::first)
-            .define_method("last", &CppArray<int>::last)
-            .define_method("[]", &CppArray<int>::bracket)
-            .define_method("[]=", &CppArray<int>::bracket_equal)
-            .define_method("push", &CppArray<int>::emplace_back)
-            .define_method("size", &CppArray<int>::size)
-            .define_method("clear", &CppArray<int>::clear)
-            .define_method("<<", &CppArray<int>::push_back_object)
-            .define_method("intersection", &CppArray<int>::intersection)
-            .define_method("sort", &CppArray<int>::sort)
-            .define_method("sort!", &CppArray<int>::destructive_sort)
-            .define_method("reverse", &CppArray<int>::reverse)
-            .define_method("reverse!", &CppArray<int>::destructive_reverse);
-
-        Data_Type<CppArray<double>> rb_cFloatArray = define_class_under<CppArray<double>>(rb_mTatara, "FloatArray")
-            .define_constructor(Constructor<CppArray<double>>())
-            .define_method("first", &CppArray<double>::first)
-            .define_method("last", &CppArray<double>::last)
-            .define_method("[]", &CppArray<double>::bracket)
-            .define_method("[]=", &CppArray<double>::bracket_equal)
-            .define_method("push", &CppArray<double>::emplace_back)
-            .define_method("size", &CppArray<double>::size)
-            .define_method("clear", &CppArray<double>::clear)
-            .define_method("<<", &CppArray<double>::push_back_object)
-            .define_method("intersection", &CppArray<double>::intersection)
-            .define_method("sort", &CppArray<double>::sort)
-            .define_method("sort!", &CppArray<double>::destructive_sort)
-            .define_method("reverse", &CppArray<double>::reverse)
-            .define_method("reverse!", &CppArray<double>::destructive_reverse);
-
-        Data_Type<CppArray<std::string>> rb_cStringArray = define_class_under<CppArray<std::string>>(rb_mTatara, "StringArray")
-            .define_constructor(Constructor<CppArray<std::string>>())
-            .define_method("first", &CppArray<std::string>::first)
-            .define_method("last", &CppArray<std::string>::last)
-            .define_method("[]", &CppArray<std::string>::bracket)
-            .define_method("[]=", &CppArray<std::string>::bracket_equal)            
-            .define_method("push", &CppArray<std::string>::emplace_back)
-            .define_method("size", &CppArray<std::string>::size)
-            .define_method("clear", &CppArray<std::string>::clear)
-            .define_method("<<", &CppArray<std::string>::push_back_object)
-            .define_method("intersection", &CppArray<std::string>::intersection)
-            .define_method("sort", &CppArray<std::string>::sort)
-            .define_method("sort!", &CppArray<std::string>::destructive_sort)
-            .define_method("reverse", &CppArray<std::string>::reverse)
-            .define_method("reverse!", &CppArray<std::string>::destructive_reverse);
-
-        Data_Type<Map<std::string, int>> rb_cStringIntMap = define_class_under<Map<std::string, int>>(rb_mTatara, "StringIntMap")
-            .define_constructor(Constructor<Map<std::string, int>>())
-            .define_method("[]", &Map<std::string, int>::bracket)
-            .define_method("[]=", &Map<std::string, int>::bracket_equal);
-
-        Data_Type<Map<std::string, double>> rb_cStringFloatMap = define_class_under<Map<std::string, double>>(rb_mTatara, "StringFloatMap")
-            .define_constructor(Constructor<Map<std::string, double>>())
-            .define_method("[]", &Map<std::string, double>::bracket)
-            .define_method("[]=", &Map<std::string, double>::bracket_equal);
-
-        Data_Type<Map<std::string, std::string>> rb_cStringStringMap = define_class_under<Map<std::string, std::string>>(rb_mTatara, "StringStringMap")
-            .define_constructor(Constructor<Map<std::string, std::string>>())
-            .define_method("[]", &Map<std::string, std::string>::bracket)
-            .define_method("[]=", &Map<std::string, std::string>::bracket_equal);
-
-        Data_Type<Map<int, int>> rb_cIntIntMap = define_class_under<Map<int, int>>(rb_mTatara, "IntIntMap")
-            .define_constructor(Constructor<Map<int, int>>())
-            .define_method("[]", &Map<int, int>::bracket)
-            .define_method("[]=", &Map<int, int>::bracket_equal);
-
-        Data_Type<Map<int, double>> rb_cIntFloatMap = define_class_under<Map<int, double>>(rb_mTatara, "IntFloatMap")
-            .define_constructor(Constructor<Map<int, double>>())
-            .define_method("[]", &Map<int, double>::bracket)
-            .define_method("[]=", &Map<int, double>::bracket_equal);
-
-        Data_Type<Map<int, std::string>> rb_cIntStringMap = define_class_under<Map<int, std::string>>(rb_mTatara, "IntStringMap")
-            .define_constructor(Constructor<Map<int, std::string>>())
-            .define_method("[]", &Map<int, std::string>::bracket)
-            .define_method("[]=", &Map<int, std::string>::bracket_equal);
-        
-        Data_Type<Map<double, int>> rb_cFloatIntMap = define_class_under<Map<double, int>>(rb_mTatara, "FloatIntMap")
-            .define_constructor(Constructor<Map<double, int>>())
-            .define_method("[]", &Map<double, int>::bracket)
-            .define_method("[]=", &Map<double, int>::bracket_equal);
-
-        Data_Type<Map<double, double>> rb_cFloatFloatMap = define_class_under<Map<double, double>>(rb_mTatara, "FloatFloatMap")
-            .define_constructor(Constructor<Map<double, double>>())
-            .define_method("[]", &Map<double, double>::bracket)
-            .define_method("[]=", &Map<double, double>::bracket_equal);
-
-        Data_Type<Map<double, std::string>> rb_cFloatStringMap = define_class_under<Map<double, std::string>>(rb_mTatara, "FloatStringMap")
-            .define_constructor(Constructor<Map<double, std::string>>())
-            .define_method("[]", &Map<double, std::string>::bracket)
-            .define_method("[]=", &Map<double, std::string>::bracket_equal);
+        VALUE mTatara = rb_define_module("Tatara");
+
+        VALUE rb_cInteger = rb_define_class_under(mTatara, "Integer", rb_cObject);
+
+        rb_define_alloc_func(rb_cInteger, wrap_int_alloc);
+        rb_define_private_method(rb_cInteger, "initialize", RUBY_METHOD_FUNC(wrap_int_init), 0);
+        rb_define_method(rb_cInteger, "value", RUBY_METHOD_FUNC(wrap_int_return_value), 0);
+        rb_define_method(rb_cInteger, "val", RUBY_METHOD_FUNC(wrap_int_return_value), 0);
+        rb_define_method(rb_cInteger, "value=", RUBY_METHOD_FUNC(wrap_int_assignment), 1);
+        rb_define_method(rb_cInteger, "val=", RUBY_METHOD_FUNC(wrap_int_assignment), 1);
+        rb_define_method(rb_cInteger, "value+", RUBY_METHOD_FUNC(wrap_int_plus), 1);
+        rb_define_method(rb_cInteger, "val+", RUBY_METHOD_FUNC(wrap_int_plus), 1);
+        rb_define_method(rb_cInteger, "value+=", RUBY_METHOD_FUNC(wrap_int_plus_equal), 1);
+        rb_define_method(rb_cInteger, "val+=", RUBY_METHOD_FUNC(wrap_int_plus_equal), 1);
+        rb_define_method(rb_cInteger, "value-", RUBY_METHOD_FUNC(wrap_int_minus), 1);
+        rb_define_method(rb_cInteger, "val-", RUBY_METHOD_FUNC(wrap_int_minus), 1);
+        rb_define_method(rb_cInteger, "value-=", RUBY_METHOD_FUNC(wrap_int_minus_equal), 1);
+        rb_define_method(rb_cInteger, "val-=", RUBY_METHOD_FUNC(wrap_int_minus_equal), 1);
+        rb_define_method(rb_cInteger, "value/", RUBY_METHOD_FUNC(wrap_int_divided), 1);
+        rb_define_method(rb_cInteger, "val/", RUBY_METHOD_FUNC(wrap_int_divided), 1);
+        rb_define_method(rb_cInteger, "value/=", RUBY_METHOD_FUNC(wrap_int_divided_equal), 1);
+        rb_define_method(rb_cInteger, "val/=", RUBY_METHOD_FUNC(wrap_int_divided_equal), 1);
+        rb_define_method(rb_cInteger, "value*", RUBY_METHOD_FUNC(wrap_int_multiply), 1);
+        rb_define_method(rb_cInteger, "val*", RUBY_METHOD_FUNC(wrap_int_multiply), 1);
+        rb_define_method(rb_cInteger, "value*=", RUBY_METHOD_FUNC(wrap_int_multiply_equal), 1);
+        rb_define_method(rb_cInteger, "val*=", RUBY_METHOD_FUNC(wrap_int_multiply_equal), 1);
+        rb_define_method(rb_cInteger, "value%", RUBY_METHOD_FUNC(wrap_int_mod), 1);
+        rb_define_method(rb_cInteger, "val%", RUBY_METHOD_FUNC(wrap_int_mod), 1);
+        rb_define_method(rb_cInteger, "value%=", RUBY_METHOD_FUNC(wrap_int_mod_equal), 1);
+        rb_define_method(rb_cInteger, "val%=", RUBY_METHOD_FUNC(wrap_int_mod_equal), 1);
+        rb_define_method(rb_cInteger, "value**", RUBY_METHOD_FUNC(wrap_int_power), 1);
+        rb_define_method(rb_cInteger, "val**", RUBY_METHOD_FUNC(wrap_int_power), 1);
+        rb_define_method(rb_cInteger, "value**=", RUBY_METHOD_FUNC(wrap_int_power_equal), 1);
+        rb_define_method(rb_cInteger, "val**=", RUBY_METHOD_FUNC(wrap_int_power_equal), 1);
+        rb_define_method(rb_cInteger, "inc", RUBY_METHOD_FUNC(wrap_int_increment_value), 0);
+        rb_define_method(rb_cInteger, "increment", RUBY_METHOD_FUNC(wrap_int_increment_value), 0);
+        rb_define_method(rb_cInteger, "dec", RUBY_METHOD_FUNC(wrap_int_decrement_value), 0);
+        rb_define_method(rb_cInteger, "decrement", RUBY_METHOD_FUNC(wrap_int_decrement_value), 0);
+        rb_define_method(rb_cInteger, "to_s", RUBY_METHOD_FUNC(wrap_int_to_string), 0);
+        rb_define_method(rb_cInteger, "to_f", RUBY_METHOD_FUNC(wrap_int_to_float), 0);
+        rb_define_method(rb_cInteger, "clear", RUBY_METHOD_FUNC(wrap_int_clear), 0);
+        rb_define_method(rb_cInteger, "value==", RUBY_METHOD_FUNC(wrap_int_equal), 1);
+        rb_define_method(rb_cInteger, "val==", RUBY_METHOD_FUNC(wrap_int_equal), 1);
+        rb_define_method(rb_cInteger, "equal?", RUBY_METHOD_FUNC(wrap_int_equal), 1);
+        rb_define_method(rb_cInteger, "<<", RUBY_METHOD_FUNC(wrap_int_initialize_object), 1);
+
+        VALUE rb_cFloat = rb_define_class_under(mTatara, "Float", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloat, wrap_float_alloc);
+        rb_define_private_method(rb_cFloat, "initialize", RUBY_METHOD_FUNC(wrap_float_init), 0);
+        rb_define_method(rb_cFloat, "value", RUBY_METHOD_FUNC(wrap_float_return_value), 0);
+        rb_define_method(rb_cFloat, "val", RUBY_METHOD_FUNC(wrap_float_return_value), 0);
+        rb_define_method(rb_cFloat, "value=", RUBY_METHOD_FUNC(wrap_float_assignment), 1);
+        rb_define_method(rb_cFloat, "val=", RUBY_METHOD_FUNC(wrap_float_assignment), 1);
+        rb_define_method(rb_cFloat, "value+", RUBY_METHOD_FUNC(wrap_float_plus), 1);
+        rb_define_method(rb_cFloat, "val+", RUBY_METHOD_FUNC(wrap_float_plus), 1);
+        rb_define_method(rb_cFloat, "value+=", RUBY_METHOD_FUNC(wrap_float_plus_equal), 1);
+        rb_define_method(rb_cFloat, "val+=", RUBY_METHOD_FUNC(wrap_float_plus_equal), 1);
+        rb_define_method(rb_cFloat, "value-", RUBY_METHOD_FUNC(wrap_float_minus), 1);
+        rb_define_method(rb_cFloat, "val-", RUBY_METHOD_FUNC(wrap_float_minus), 1);
+        rb_define_method(rb_cFloat, "value-=", RUBY_METHOD_FUNC(wrap_float_minus_equal), 1);
+        rb_define_method(rb_cFloat, "val-=", RUBY_METHOD_FUNC(wrap_float_minus_equal), 1);
+        rb_define_method(rb_cFloat, "value*", RUBY_METHOD_FUNC(wrap_float_multiply), 1);
+        rb_define_method(rb_cFloat, "val*", RUBY_METHOD_FUNC(wrap_float_multiply), 1);
+        rb_define_method(rb_cFloat, "value*=", RUBY_METHOD_FUNC(wrap_float_multiply_equal), 1);
+        rb_define_method(rb_cFloat, "val*=", RUBY_METHOD_FUNC(wrap_float_multiply_equal), 1);
+        rb_define_method(rb_cFloat, "value/", RUBY_METHOD_FUNC(wrap_float_divided), 1);
+        rb_define_method(rb_cFloat, "val/", RUBY_METHOD_FUNC(wrap_float_divided), 1);
+        rb_define_method(rb_cFloat, "value/=", RUBY_METHOD_FUNC(wrap_float_divided_equal), 1);
+        rb_define_method(rb_cFloat, "val/=", RUBY_METHOD_FUNC(wrap_float_divided_equal), 1);
+        rb_define_method(rb_cFloat, "value**", RUBY_METHOD_FUNC(wrap_float_power), 1);
+        rb_define_method(rb_cFloat, "val**", RUBY_METHOD_FUNC(wrap_float_power), 1);
+        rb_define_method(rb_cFloat, "value**=", RUBY_METHOD_FUNC(wrap_float_power_equal), 1);
+        rb_define_method(rb_cFloat, "val**=", RUBY_METHOD_FUNC(wrap_float_power_equal), 1);
+        rb_define_method(rb_cFloat, "inc", RUBY_METHOD_FUNC(wrap_float_increment_value), 0);
+        rb_define_method(rb_cFloat, "dec", RUBY_METHOD_FUNC(wrap_float_decrement_value), 0);
+        rb_define_method(rb_cFloat, "to_s", RUBY_METHOD_FUNC(wrap_float_to_string), 0);
+        rb_define_method(rb_cFloat, "to_i", RUBY_METHOD_FUNC(wrap_float_to_integer), 0);
+        rb_define_method(rb_cFloat, "clear", RUBY_METHOD_FUNC(wrap_float_clear), 0);
+        rb_define_method(rb_cFloat, "value==", RUBY_METHOD_FUNC(wrap_float_equal), 1);
+        rb_define_method(rb_cFloat, "val==", RUBY_METHOD_FUNC(wrap_float_equal), 1);
+        rb_define_method(rb_cFloat, "equal?", RUBY_METHOD_FUNC(wrap_float_equal), 1);
+        rb_define_method(rb_cFloat, "<<", RUBY_METHOD_FUNC(wrap_float_initialize_object), 1);
+
+        VALUE rb_cString = rb_define_class_under(mTatara, "String", rb_cObject);
+
+        rb_define_alloc_func(rb_cString, wrap_string_alloc);
+        rb_define_private_method(rb_cString, "initialize", RUBY_METHOD_FUNC(wrap_string_init), 0);
+        rb_define_method(rb_cString, "value", RUBY_METHOD_FUNC(wrap_string_return_value), 0);
+        rb_define_method(rb_cString, "val", RUBY_METHOD_FUNC(wrap_string_return_value), 0);
+        rb_define_method(rb_cString, "value=", RUBY_METHOD_FUNC(wrap_string_assignment), 1);
+        rb_define_method(rb_cString, "val=", RUBY_METHOD_FUNC(wrap_string_assignment), 1);
+        rb_define_method(rb_cString, "value+=", RUBY_METHOD_FUNC(wrap_string_plus_equal), 1);
+        rb_define_method(rb_cString, "val+=", RUBY_METHOD_FUNC(wrap_string_plus_equal), 1);
+        rb_define_method(rb_cString, "to_i", RUBY_METHOD_FUNC(wrap_string_to_integer), 0);
+        rb_define_method(rb_cString, "to_f", RUBY_METHOD_FUNC(wrap_string_to_float), 0);
+        rb_define_method(rb_cString, "clear", RUBY_METHOD_FUNC(wrap_string_clear), 0);
+        rb_define_method(rb_cString, "value==", RUBY_METHOD_FUNC(wrap_string_equal), 1);
+        rb_define_method(rb_cString, "val==", RUBY_METHOD_FUNC(wrap_string_equal), 1);
+        rb_define_method(rb_cString, "equal?", RUBY_METHOD_FUNC(wrap_string_equal), 1);
+        rb_define_method(rb_cString, "<<", RUBY_METHOD_FUNC(wrap_string_initialize_object), 1);
+        rb_define_method(rb_cString, "[]", RUBY_METHOD_FUNC(wrap_string_index_access), 1);
+        rb_define_method(rb_cString, "slice", RUBY_METHOD_FUNC(wrap_string_slice), 2);
+        rb_define_method(rb_cString, "slice!", RUBY_METHOD_FUNC(wrap_string_destructive_slice), 2);
+
+        VALUE rb_cIntVector = rb_define_class_under(mTatara, "IntVector", rb_cObject);
+
+        rb_define_alloc_func(rb_cIntVector, wrap_int_vector_alloc);
+        rb_define_private_method(rb_cIntVector, "initialize", RUBY_METHOD_FUNC(wrap_int_vector_init), 0);
+        rb_define_method(rb_cIntVector, "first", RUBY_METHOD_FUNC(wrap_int_vector_first), 0);
+        rb_define_method(rb_cIntVector, "last", RUBY_METHOD_FUNC(wrap_int_vector_last), 0);
+        rb_define_method(rb_cIntVector, "[]", RUBY_METHOD_FUNC(wrap_int_vector_bracket), 1);
+        rb_define_method(rb_cIntVector, "[]=", RUBY_METHOD_FUNC(wrap_int_vector_bracket_equal), 2);
+        rb_define_method(rb_cIntVector, "emplace_back", RUBY_METHOD_FUNC(wrap_int_vector_emplace_back), 1);
+        rb_define_method(rb_cIntVector, "size", RUBY_METHOD_FUNC(wrap_int_vector_size), 0);
+        rb_define_method(rb_cIntVector, "clear", RUBY_METHOD_FUNC(wrap_int_vector_clear), 0);
+        rb_define_method(rb_cIntVector, "<<", RUBY_METHOD_FUNC(wrap_int_vector_push_back_object), 1);
+
+        VALUE rb_cFloatVector = rb_define_class_under(mTatara, "FloatVector", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloatVector, wrap_float_vector_alloc);
+        rb_define_private_method(rb_cFloatVector, "initialize", RUBY_METHOD_FUNC(wrap_float_vector_init), 0);
+        rb_define_method(rb_cFloatVector, "first", RUBY_METHOD_FUNC(wrap_float_vector_first), 0);
+        rb_define_method(rb_cFloatVector, "last", RUBY_METHOD_FUNC(wrap_float_vector_last), 0);
+        rb_define_method(rb_cFloatVector, "[]", RUBY_METHOD_FUNC(wrap_float_vector_bracket), 1);
+        rb_define_method(rb_cFloatVector, "[]=", RUBY_METHOD_FUNC(wrap_float_vector_bracket_equal), 2);
+        rb_define_method(rb_cFloatVector, "emplace_back", RUBY_METHOD_FUNC(wrap_float_vector_emplace_back), 1);
+        rb_define_method(rb_cFloatVector, "size", RUBY_METHOD_FUNC(wrap_float_vector_size), 0);
+        rb_define_method(rb_cFloatVector, "clear", RUBY_METHOD_FUNC(wrap_float_vector_clear), 0);
+        rb_define_method(rb_cFloatVector, "<<", RUBY_METHOD_FUNC(wrap_float_vector_push_back_object), 1);
+
+        VALUE rb_cStringVector = rb_define_class_under(mTatara, "StringVector", rb_cObject);
+
+        rb_define_alloc_func(rb_cStringVector, wrap_string_vector_alloc);
+        rb_define_private_method(rb_cStringVector, "initialize", RUBY_METHOD_FUNC(wrap_string_vector_init), 0);
+        rb_define_method(rb_cStringVector, "first", RUBY_METHOD_FUNC(wrap_string_vector_first), 0);
+        rb_define_method(rb_cStringVector, "last", RUBY_METHOD_FUNC(wrap_string_vector_last), 0);
+        rb_define_method(rb_cStringVector, "[]", RUBY_METHOD_FUNC(wrap_string_vector_bracket), 1);
+        rb_define_method(rb_cStringVector, "[]=", RUBY_METHOD_FUNC(wrap_string_vector_bracket_equal), 2);
+        rb_define_method(rb_cStringVector, "emplace_back", RUBY_METHOD_FUNC(wrap_string_vector_emplace_back), 1);
+        rb_define_method(rb_cStringVector, "size", RUBY_METHOD_FUNC(wrap_string_vector_size), 0);
+        rb_define_method(rb_cStringVector, "clear", RUBY_METHOD_FUNC(wrap_string_vector_clear), 0);
+        rb_define_method(rb_cStringVector, "<<", RUBY_METHOD_FUNC(wrap_string_vector_push_back_object), 1);
+
+        VALUE rb_cIntArray = rb_define_class_under(mTatara, "IntArray", rb_cObject);
+
+        rb_define_alloc_func(rb_cIntArray, wrap_int_array_alloc);
+        rb_define_private_method(rb_cIntArray, "initialize", RUBY_METHOD_FUNC(wrap_int_array_init), 0);
+        rb_define_method(rb_cIntArray, "first", RUBY_METHOD_FUNC(wrap_int_array_first), 0);
+        rb_define_method(rb_cIntArray, "last", RUBY_METHOD_FUNC(wrap_int_array_last), 0);
+        rb_define_method(rb_cIntArray, "[]", RUBY_METHOD_FUNC(wrap_int_array_bracket), 1);
+        rb_define_method(rb_cIntArray, "[]=", RUBY_METHOD_FUNC(wrap_int_array_bracket_equal), 2);
+        rb_define_method(rb_cIntArray, "push", RUBY_METHOD_FUNC(wrap_int_array_emplace_back), 1);
+        rb_define_method(rb_cIntArray, "size", RUBY_METHOD_FUNC(wrap_int_array_size), 0);
+        rb_define_method(rb_cIntArray, "clear", RUBY_METHOD_FUNC(wrap_int_array_clear), 0);
+        rb_define_method(rb_cIntArray, "<<", RUBY_METHOD_FUNC(wrap_int_array_push_back_object), 1);
+
+        VALUE rb_cFloatArray = rb_define_class_under(mTatara, "FloatArray", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloatArray, wrap_float_array_alloc);
+        rb_define_private_method(rb_cFloatArray, "initialize", RUBY_METHOD_FUNC(wrap_float_array_init), 0);
+        rb_define_method(rb_cFloatArray, "first", RUBY_METHOD_FUNC(wrap_float_array_first), 0);
+        rb_define_method(rb_cFloatArray, "last", RUBY_METHOD_FUNC(wrap_float_array_last), 0);
+        rb_define_method(rb_cFloatArray, "[]", RUBY_METHOD_FUNC(wrap_float_array_bracket), 1);
+        rb_define_method(rb_cFloatArray, "[]=", RUBY_METHOD_FUNC(wrap_float_array_bracket_equal), 2);
+        rb_define_method(rb_cFloatArray, "push", RUBY_METHOD_FUNC(wrap_float_array_emplace_back), 1);
+        rb_define_method(rb_cFloatArray, "size", RUBY_METHOD_FUNC(wrap_float_array_size), 0);
+        rb_define_method(rb_cFloatArray, "clear", RUBY_METHOD_FUNC(wrap_float_array_clear), 0);
+        rb_define_method(rb_cFloatArray, "<<", RUBY_METHOD_FUNC(wrap_float_array_push_back_object), 1);
+
+        VALUE rb_cStringArray = rb_define_class_under(mTatara, "StringArray", rb_cObject);
+
+        rb_define_alloc_func(rb_cStringArray, wrap_string_array_alloc);
+        rb_define_private_method(rb_cStringArray, "initialize", RUBY_METHOD_FUNC(wrap_string_array_init), 0);
+        rb_define_method(rb_cStringArray, "first", RUBY_METHOD_FUNC(wrap_string_array_first), 0);
+        rb_define_method(rb_cStringArray, "last", RUBY_METHOD_FUNC(wrap_string_array_last), 0);
+        rb_define_method(rb_cStringArray, "[]", RUBY_METHOD_FUNC(wrap_string_array_bracket), 1);
+        rb_define_method(rb_cStringArray, "[]=", RUBY_METHOD_FUNC(wrap_string_array_bracket_equal), 2);
+        rb_define_method(rb_cStringArray, "push", RUBY_METHOD_FUNC(wrap_string_array_emplace_back), 1);
+        rb_define_method(rb_cStringArray, "size", RUBY_METHOD_FUNC(wrap_string_array_size), 0);
+        rb_define_method(rb_cStringArray, "clear", RUBY_METHOD_FUNC(wrap_string_array_clear), 0);
+        rb_define_method(rb_cStringArray, "<<", RUBY_METHOD_FUNC(wrap_string_array_push_back_object), 1);
+
+        VALUE rb_cStringIntMap = rb_define_class_under(mTatara, "StringIntMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cStringIntMap, wrap_string_int_map_alloc);
+        rb_define_private_method(rb_cStringIntMap, "initialize", RUBY_METHOD_FUNC(wrap_string_int_map_init), 0);
+        rb_define_method(rb_cStringIntMap, "[]", RUBY_METHOD_FUNC(wrap_string_int_map_bracket), 1);
+        rb_define_method(rb_cStringIntMap, "[]=", RUBY_METHOD_FUNC(wrap_string_int_map_bracket_equal), 2);
+
+        VALUE rb_cStringFloatMap = rb_define_class_under(mTatara, "StringFloatMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cStringFloatMap, wrap_string_float_map_alloc);
+        rb_define_private_method(rb_cStringFloatMap, "initialize", RUBY_METHOD_FUNC(wrap_string_float_map_init), 0);
+        rb_define_method(rb_cStringFloatMap, "[]", RUBY_METHOD_FUNC(wrap_string_float_map_bracket), 1);
+        rb_define_method(rb_cStringFloatMap, "[]=", RUBY_METHOD_FUNC(wrap_string_float_map_bracket_equal), 2);
+
+        VALUE rb_cStringStringMap = rb_define_class_under(mTatara, "StringStringMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cStringStringMap, wrap_string_string_map_alloc);
+        rb_define_private_method(rb_cStringStringMap, "initialize", RUBY_METHOD_FUNC(wrap_string_string_map_init), 0);
+        rb_define_method(rb_cStringStringMap, "[]", RUBY_METHOD_FUNC(wrap_string_string_map_bracket), 1);
+        rb_define_method(rb_cStringStringMap, "[]=", RUBY_METHOD_FUNC(wrap_string_string_map_bracket_equal), 2);
+
+        VALUE rb_cIntIntMap = rb_define_class_under(mTatara, "IntIntMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cIntIntMap, wrap_int_int_map_alloc);
+        rb_define_private_method(rb_cIntIntMap, "initialize", RUBY_METHOD_FUNC(wrap_int_int_map_init), 0);
+        rb_define_method(rb_cIntIntMap, "[]", RUBY_METHOD_FUNC(wrap_int_int_map_bracket), 1);
+        rb_define_method(rb_cIntIntMap, "[]=", RUBY_METHOD_FUNC(wrap_int_int_map_bracket_equal), 2);
+
+        VALUE rb_cIntFloatMap = rb_define_class_under(mTatara, "IntFloatMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cIntFloatMap, wrap_int_float_map_alloc);
+        rb_define_private_method(rb_cIntFloatMap, "initialize", RUBY_METHOD_FUNC(wrap_int_float_map_init), 0);
+        rb_define_method(rb_cIntFloatMap, "[]", RUBY_METHOD_FUNC(wrap_int_float_map_bracket), 1);
+        rb_define_method(rb_cIntFloatMap, "[]=", RUBY_METHOD_FUNC(wrap_int_float_map_bracket_equal), 2);
+
+        VALUE rb_cIntStringMap = rb_define_class_under(mTatara, "IntStringMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cIntStringMap, wrap_int_string_map_alloc);
+        rb_define_private_method(rb_cIntStringMap, "initialize", RUBY_METHOD_FUNC(wrap_int_string_map_init), 0);
+        rb_define_method(rb_cIntStringMap, "[]", RUBY_METHOD_FUNC(wrap_int_string_map_bracket), 1);
+        rb_define_method(rb_cIntStringMap, "[]=", RUBY_METHOD_FUNC(wrap_int_string_map_bracket_equal), 2);
+
+        VALUE rb_cFloatIntMap = rb_define_class_under(mTatara, "FloatIntMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloatIntMap, wrap_float_int_map_alloc);
+        rb_define_private_method(rb_cFloatIntMap, "initialize", RUBY_METHOD_FUNC(wrap_float_int_map_init), 0);
+        rb_define_method(rb_cFloatIntMap, "[]", RUBY_METHOD_FUNC(wrap_float_int_map_bracket), 1);
+        rb_define_method(rb_cFloatIntMap, "[]=", RUBY_METHOD_FUNC(wrap_float_int_map_bracket_equal), 2);
+
+        VALUE rb_cFloatFloatMap = rb_define_class_under(mTatara, "FloatFloatMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloatFloatMap, wrap_float_float_map_alloc);
+        rb_define_private_method(rb_cFloatFloatMap, "initialize", RUBY_METHOD_FUNC(wrap_float_float_map_init), 0);
+        rb_define_method(rb_cFloatFloatMap, "[]", RUBY_METHOD_FUNC(wrap_float_float_map_bracket), 1);
+        rb_define_method(rb_cFloatFloatMap, "[]=", RUBY_METHOD_FUNC(wrap_float_float_map_bracket_equal), 2);
+
+        VALUE rb_cFloatStringMap = rb_define_class_under(mTatara, "FloatStringMap", rb_cObject);
+
+        rb_define_alloc_func(rb_cFloatStringMap, wrap_float_string_map_alloc);
+        rb_define_private_method(rb_cFloatStringMap, "initialize", RUBY_METHOD_FUNC(wrap_float_string_map_init), 0);
+        rb_define_method(rb_cFloatStringMap, "[]", RUBY_METHOD_FUNC(wrap_float_string_map_bracket), 1);
+        rb_define_method(rb_cFloatStringMap, "[]=", RUBY_METHOD_FUNC(wrap_float_string_map_bracket_equal), 2);
     }
 }