tatara 0.2.0 → 0.3.0

data/ext/tatara/array/integer/int_array.hpp

@@ -0,0 +1,132 @@
+#ifndef INT_ARRAY_HPP_
+#define INT_ARRAY_HPP_
+
+#include <ruby.h>
+#include <vector>
+
+class IntArray {
+    std::vector<int> container;
+
+    public:
+        IntArray();
+        ~IntArray();
+        int first();
+        int last();
+        int bracket(const int index);
+        int bracket_equal(const int index, const int var);
+        void emplace_back(const int var);
+        int size();
+        void clear();
+        IntArray& push_back_object(const int var);
+ };
+
+IntArray::IntArray() {}
+
+IntArray::~IntArray() {}
+
+int IntArray::first() {
+    return this->container.front();
+}
+
+int IntArray::last() {
+    return this->container.back();
+}
+
+int IntArray::bracket(const int index) {
+    return this->container[index];
+}
+
+int IntArray::bracket_equal(const int index, const int var) {
+    return this->container[index] = var;
+}
+
+void IntArray::emplace_back(const int var) {
+    this->container.emplace_back(var);
+}
+
+int IntArray::size() {
+    return this->container.size();
+}
+
+void IntArray::clear() {
+    this->container.clear();
+}
+
+IntArray &IntArray::push_back_object(const int var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+static IntArray *getIntArray(VALUE self) {
+    IntArray *ptr;
+    Data_Get_Struct(self, IntArray, ptr);
+    return ptr;
+}
+
+static void wrap_int_array_free(IntArray *ptr) {
+    ptr->~IntArray();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_array_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(IntArray));
+    p = new IntArray;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_array_free, p);
+}
+
+static VALUE wrap_int_array_init(VALUE self) {
+    IntArray *p = getIntArray(self);
+    p = new IntArray;
+    return Qnil;
+}
+
+static VALUE wrap_int_array_first(VALUE self) {
+    const int value = getIntArray(self)->first();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_array_last(VALUE self) {
+    const int value = getIntArray(self)->last();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_array_bracket(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const int value = getIntArray(self)->bracket(i);
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_array_bracket_equal(VALUE self, VALUE index, VALUE value) {
+    const int i = NUM2INT(index);
+    const int v = NUM2INT(value);
+    getIntArray(self)->bracket_equal(i, v);
+    return value;
+}
+
+static VALUE wrap_int_array_emplace_back(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    getIntArray(self)->emplace_back(v);
+    return Qnil;
+}
+
+static VALUE wrap_int_array_size(VALUE self) {
+    const int size = getIntArray(self)->size();
+    VALUE result = INT2NUM(size);
+    return result;
+}
+
+static VALUE wrap_int_array_clear(VALUE self) {
+    getIntArray(self)->clear();
+    return Qnil;
+}
+
+static VALUE wrap_int_array_push_back_object(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    getIntArray(self)->push_back_object(v);
+    return self;
+}
+
+#endif

data/ext/tatara/array/string/string_array.hpp

@@ -0,0 +1,133 @@
+#ifndef STRING_ARRAY_HPP_
+#define STRING_ARRAY_HPP_
+
+#include <ruby.h>
+#include <string>
+#include <vector>
+
+class StringArray {
+    std::vector<std::string> container;
+
+    public:
+        StringArray();
+        ~StringArray();
+        std::string first();
+        std::string last();
+        std::string bracket(const int index);
+        std::string bracket_equal(const int index, const std::string var);
+        void emplace_back(const std::string var);
+        int size();
+        void clear();
+        StringArray& push_back_object(const std::string var);
+};
+
+StringArray::StringArray() {}
+
+StringArray::~StringArray() {}
+
+std::string StringArray::first() {
+    return this->container.front();
+}
+
+std::string StringArray::last() {
+    return this->container.back();
+}
+
+std::string StringArray::bracket(const int index) {
+    return this->container[index];
+}
+
+std::string StringArray::bracket_equal(const int index, const std::string var) {
+    return this->container[index] = var;
+}
+
+void StringArray::emplace_back(const std::string var) {
+    this->container.emplace_back(var);
+}
+
+int StringArray::size() {
+    return this->container.size();
+}
+
+void StringArray::clear() {
+    this->container.clear();
+}
+
+StringArray &StringArray::push_back_object(const std::string var) {
+    this->container.emplace_back(std::move(var));
+    return *this;
+}
+
+static StringArray *getStringArray(VALUE self) {
+    StringArray *ptr;
+    Data_Get_Struct(self, StringArray, ptr);
+    return ptr;
+}
+
+static void wrap_string_array_free(StringArray *ptr) {
+    ptr->~StringArray();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_string_array_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(StringArray));
+    p = new StringArray;
+    return Data_Wrap_Struct(klass, NULL, wrap_string_array_free, p);
+}
+
+static VALUE wrap_string_array_init(VALUE self) {
+    StringArray *p = getStringArray(self);
+    p = new StringArray;
+    return Qnil;
+}
+
+static VALUE wrap_string_array_first(VALUE self) {
+    const std::string value = getStringArray(self)->first();
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_array_last(VALUE self) {
+    const std::string value = getStringArray(self)->last();
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_array_bracket(VALUE self, VALUE index) {
+    const int i = NUM2INT(index);
+    const std::string value = getStringArray(self)->bracket(i);
+    VALUE result = rb_str_new(value.data(), value.size());
+    return result;
+}
+
+static VALUE wrap_string_array_bracket_equal(VALUE self, VALUE index, VALUE value) {
+    const int i = NUM2INT(index);
+    const std::string v = {StringValueCStr(value)};
+    getStringArray(self)->bracket_equal(i, v);
+    return value;
+}
+
+static VALUE wrap_string_array_emplace_back(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getStringArray(self)->emplace_back(v);
+    return Qnil;
+}
+
+static VALUE wrap_string_array_size(VALUE self) {
+    const int size = getStringArray(self)->size();
+    VALUE result = INT2NUM(size);
+    return result;
+}
+
+static VALUE wrap_string_array_clear(VALUE self) {
+    getStringArray(self)->clear();
+    return Qnil;
+}
+
+static VALUE wrap_string_array_push_back_object(VALUE self, VALUE value) {
+    const std::string v = {StringValueCStr(value)};
+    getStringArray(self)->push_back_object(v);
+    return self;
+}
+
+#endif

data/ext/tatara/extconf.rb

@@ -1,5 +1,5 @@
 
-require "mkmf-rice"
+require "mkmf"
 
 $CXXFLAGS = '-Ofast -mtune=native -march=native -mfpmath=both -std=c++17'
 

data/ext/tatara/float/float.hpp

@@ -1,6 +1,7 @@
 #ifndef FLOAT_H_
 #define FLOAT_H_
 
+#include <ruby.h>
 #include <string>
 #include <regex>
 
@@ -116,4 +117,151 @@ constexpr bool Float::equal(const double var) {
     return this->value == var;
 }
 
+static Float *getFloat(VALUE self) {
+    Float *ptr;
+    Data_Get_Struct(self, Float, ptr);
+    return ptr;
+}
+
+static void wrap_float_free(Float *ptr) {
+    ptr->~Float();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_float_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(Float));
+    p = new Float;
+    return Data_Wrap_Struct(klass, NULL, wrap_float_free, p);
+}
+
+static VALUE wrap_float_init(VALUE self) {
+    Float *p = getFloat(self);
+    p = new Float;
+    return Qnil;
+}
+
+static VALUE wrap_float_return_value(VALUE self) {
+    const double value = getFloat(self)->return_value();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_assignment(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    getFloat(self)->assignment(v);
+    return value;
+}
+
+static VALUE wrap_float_plus(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->plus(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_plus_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->plus_equal(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_minus(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->minus(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_minus_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->minus_equal(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_multiply(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->multiply(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_multiply_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->multiply_equal(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_divided(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->divided(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_divided_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->divided_equal(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_power(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->power(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_power_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    const double r = getFloat(self)->power_equal(v);
+    VALUE result = DBL2NUM(r);
+    return result;
+}
+
+static VALUE wrap_float_increment_value(VALUE self) {
+    const double value = getFloat(self)->increment_value();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_decrement_value(VALUE self) {
+    const double value = getFloat(self)->decrement_value();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_to_string(VALUE self) {
+    const std::string value = getFloat(self)->to_string();
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_float_to_integer(VALUE self) {
+    const int value = getFloat(self)->to_integer();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_clear(VALUE self) {
+    const double value = getFloat(self)->clear();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_float_equal(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    bool eval = getFloat(self)->equal(v);
+    return eval ? Qtrue : Qfalse;
+}
+
+static VALUE wrap_float_initialize_object(VALUE self, VALUE value) {
+    const double v = NUM2DBL(value);
+    getFloat(self)->initialize_object(v);
+    return self;
+}
+
 #endif

data/ext/tatara/integer/integer.hpp

@@ -1,6 +1,7 @@
 #ifndef INTEGER_H_
 #define INTEGER_H_
 
+#include <ruby.h>
 #include <string>
 #include <cmath>
 
@@ -122,4 +123,167 @@ constexpr bool Integer::equal(const int var) {
     return this->value == var;
 }
 
+static Integer *getInteger(VALUE self) {
+    Integer *ptr;
+    Data_Get_Struct(self, Integer, ptr);
+    return ptr;
+}
+
+static void wrap_int_free(Integer *ptr) {
+    ptr->~Integer();
+    ruby_xfree(ptr);
+}
+
+static VALUE wrap_int_alloc(VALUE klass) {
+    void *p = ruby_xmalloc(sizeof(Integer));
+    p = new Integer;
+    return Data_Wrap_Struct(klass, NULL, wrap_int_free, p);
+}
+
+static VALUE wrap_int_init(VALUE self) {
+    Integer *p = getInteger(self);
+    p = new Integer;
+    return Qnil;
+}
+
+
+static VALUE wrap_int_return_value(VALUE self) {
+    const int value = getInteger(self)->return_value();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_assignment(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->assignment(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_plus(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->plus(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_plus_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->plus_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_minus(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->minus(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_minus_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->minus_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_divided(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->divided(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_divided_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->divided_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_multiply(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->multiply(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_multiply_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->multiply_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_mod(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->mod(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_mod_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->mod_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_power(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->power(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_power_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    const int r = getInteger(self)->power_equal(v);
+    VALUE result = INT2NUM(r);
+    return result;
+}
+
+static VALUE wrap_int_increment_value(VALUE self) {
+    const int value = getInteger(self)->increment_value();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_decrement_value(VALUE self) {
+    const int value = getInteger(self)->decrement_value();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_to_string(VALUE self) {
+    const std::string value = getInteger(self)->to_string();
+    VALUE result = rb_str_new(value.c_str(), value.size());
+    return result;
+}
+
+static VALUE wrap_int_to_float(VALUE self) {
+    const double value = getInteger(self)->to_float();
+    VALUE result = DBL2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_clear(VALUE self) {
+    const int value = getInteger(self)->clear();
+    VALUE result = INT2NUM(value);
+    return result;
+}
+
+static VALUE wrap_int_equal(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    bool eval = getInteger(self)->equal(v);
+    return eval ? Qtrue : Qfalse;
+}
+
+static VALUE wrap_int_initialize_object(VALUE self, VALUE value) {
+    const int v = NUM2INT(value);
+    getInteger(self)->initialize_object(v);
+    return self;
+}
+
 #endif