pnmatrix 1.2.4

data/ext/nmatrix/storage/yale/yale.h

@@ -0,0 +1,203 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == yale.h
+//
+// "new yale" storage format for 2D matrices (like yale, but with
+// the diagonal pulled out for O(1) access).
+//
+// Specifications:
+// * dtype and index dtype must necessarily differ
+//      * index dtype is defined by whatever unsigned type can store
+//        max(rows,cols)
+//      * that means vector ija stores only index dtype, but a stores
+//        dtype
+// * vectors must be able to grow as necessary
+//      * maximum size is rows*cols+1
+
+#ifndef YALE_H
+#define YALE_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <limits> // for std::numeric_limits<T>::max()
+#include <stdexcept>
+
+/*
+ * Project Includes
+ */
+
+#include "../../types.h"
+#include "../../data/data.h"
+#include "../common.h"
+#include "../../nmatrix.h"
+
+extern "C" {
+
+  /*
+   * Macros
+   */
+
+  #ifndef NM_CHECK_ALLOC
+   #define NM_CHECK_ALLOC(x) if (!x) rb_raise(rb_eNoMemError, "insufficient memory");
+  #endif
+
+  /*
+   * Types
+   */
+
+
+  /*
+   * Data
+   */
+
+
+  /*
+   * Functions
+   */
+
+  ///////////////
+  // Lifecycle //
+  ///////////////
+
+  YALE_STORAGE* nm_yale_storage_create(nm::dtype_t dtype, size_t* shape, size_t dim, size_t init_capacity);
+  YALE_STORAGE* nm_yale_storage_create_from_old_yale(nm::dtype_t dtype, size_t* shape, char* ia, char* ja, char* a, nm::dtype_t from_dtype);
+  YALE_STORAGE*  nm_yale_storage_create_merged(const YALE_STORAGE* merge_template, const YALE_STORAGE* other);
+  void          nm_yale_storage_delete(STORAGE* s);
+  void          nm_yale_storage_delete_ref(STORAGE* s);
+  void          nm_yale_storage_init(YALE_STORAGE* s, void* default_val);
+  void          nm_yale_storage_mark(STORAGE*);
+  void          nm_yale_storage_register(const STORAGE* s);
+  void          nm_yale_storage_unregister(const STORAGE* s);
+  void    nm_yale_storage_register_a(void* a, size_t size);
+  void    nm_yale_storage_unregister_a(void* a, size_t size); 
+    
+  ///////////////
+  // Accessors //
+  ///////////////
+
+  VALUE nm_yale_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_each_stored_with_indices(VALUE nmatrix);
+  VALUE nm_yale_stored_diagonal_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_stored_nondiagonal_each_with_indices(VALUE nmatrix);
+  VALUE nm_yale_each_ordered_stored_with_indices(VALUE nmatrix);
+  void* nm_yale_storage_get(const STORAGE* s, SLICE* slice);
+  void*  nm_yale_storage_ref(const STORAGE* s, SLICE* slice);
+  void  nm_yale_storage_set(VALUE left, SLICE* slice, VALUE right);
+
+  //char  nm_yale_storage_vector_insert(YALE_STORAGE* s, size_t pos, size_t* js, void* vals, size_t n, bool struct_only, nm::dtype_t dtype, nm::itype_t itype);
+  //void  nm_yale_storage_increment_ia_after(YALE_STORAGE* s, size_t ija_size, size_t i, size_t n);
+
+  size_t  nm_yale_storage_get_size(const YALE_STORAGE* storage);
+  VALUE   nm_yale_default_value(VALUE self);
+  VALUE   nm_yale_map_stored(VALUE self);
+  VALUE   nm_yale_map_merged_stored(VALUE left, VALUE right, VALUE init);
+
+  ///////////
+  // Tests //
+  ///////////
+
+  bool nm_yale_storage_eqeq(const STORAGE* left, const STORAGE* right);
+
+  //////////
+  // Math //
+  //////////
+
+  STORAGE* nm_yale_storage_matrix_multiply(const STORAGE_PAIR& casted_storage, size_t* resulting_shape, bool vector);
+
+  /////////////
+  // Utility //
+  /////////////
+
+
+
+  /////////////////////////
+  // Copying and Casting //
+  /////////////////////////
+
+  STORAGE*      nm_yale_storage_cast_copy(const STORAGE* rhs, nm::dtype_t new_dtype, void*);
+  STORAGE*      nm_yale_storage_copy_transposed(const STORAGE* rhs_base);
+
+
+
+  void nm_init_yale_functions(void);
+
+  VALUE nm_vector_set(int argc, VALUE* argv, VALUE self);
+
+
+} // end of extern "C" block
+
+namespace nm {
+
+namespace yale_storage {
+
+  /*
+   * Typedefs
+   */
+
+  typedef size_t IType;
+
+
+  /*
+   * Templated Functions
+   */
+
+  int binary_search(YALE_STORAGE* s, IType left, IType right, IType key);
+
+  /*
+   * Clear out the D portion of the A vector (clearing the diagonal and setting
+   * the zero value).
+   *
+   * Note: This sets a literal 0 value. If your dtype is RUBYOBJ (a Ruby object),
+   * it'll actually be INT2FIX(0) instead of a string of NULLs. You can actually
+   * set a default for Ruby objects other than zero -- you generally want it to
+   * be Qfalse, Qnil, or INT2FIX(0). The last is the default.
+   */
+  template <typename DType>
+  inline void clear_diagonal_and_zero(YALE_STORAGE* s, void* init_val) {
+    DType* a = reinterpret_cast<DType*>(s->a);
+
+    // Clear out the diagonal + one extra entry
+    if (init_val) {
+      for (size_t i = 0; i <= s->shape[0]; ++i) // insert Ruby zeros, falses, or whatever else.
+        a[i] = *reinterpret_cast<DType*>(init_val);
+    } else {
+      for (size_t i = 0; i <= s->shape[0]; ++i) // insert zeros.
+        a[i] = 0;
+    }
+  }
+
+  template <typename DType>
+  void init(YALE_STORAGE* s, void* init_val);
+
+  size_t  get_size(const YALE_STORAGE* storage);
+
+  IType binary_search_left_boundary(const YALE_STORAGE* s, IType left, IType right, IType bound);
+
+
+}} // end of namespace nm::yale_storage
+
+#endif // YALE_H

data/ext/nmatrix/types.h

@@ -0,0 +1,55 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == types.h
+//
+// Definition of simple types used throughout NMatrix.
+
+#ifndef NMATRIX_TYPES_H
+#define NMATRIX_TYPES_H
+
+/*
+ * Standard Includes
+ */
+
+#include <ruby.h>
+#include <cstdint>
+
+/*
+ * Macros
+ */
+
+#define EPSILON 1E-10
+#define FP_IS_ZERO(n) (-EPSILON < n && n < EPSILON)
+#define FP_EQUAL(a, b) FP_IS_ZERO((a - b))
+
+/*
+ * Types
+ */
+
+typedef float    float32_t;
+typedef double  float64_t;
+
+typedef size_t  IType;
+
+#endif

data/ext/nmatrix/util/io.cpp

@@ -0,0 +1,279 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == io.cpp
+//
+// Input/output support functions.
+
+#include "io.h"
+
+#include <ruby.h>
+
+namespace nm { namespace io {
+
+  const char* const MATLAB_DTYPE_NAMES[NUM_MATLAB_DTYPES] = {
+    "miUNDEFINED0",
+    "miINT8",
+    "miUINT8",
+    "miINT16",
+    "miUINT16",
+    "miINT32",
+    "miUINT32",
+    "miSINGLE",
+    "miRESERVED8",
+    "miDOUBLE",
+    "miRESERVED10",
+    "miRESERVED11",
+    "miINT64",
+    "miUINT64",
+    "miMATRIX"
+  };
+
+  const size_t MATLAB_DTYPE_SIZES[NUM_MATLAB_DTYPES] = {
+    1, // undefined
+    1, // int8
+    1, // uint8
+    2, // int16
+    2, // uint16
+    4, // int32
+    4, // uint32
+    sizeof(float),
+    1, // reserved
+    sizeof(double),
+    1, // reserved
+    1, // reserved
+    8, // int64
+    8, // uint64
+    1  // matlab array?
+  };
+
+
+/*
+ * Templated function for converting from MATLAB dtypes to NMatrix dtypes.
+ */
+template <typename DType, typename MDType>
+char* matlab_cstring_to_dtype_string(size_t& result_len, const char* str, size_t bytes) {
+
+  result_len   = sizeof(DType) * bytes / sizeof(MDType);
+  char* result = NM_ALLOC_N(char, result_len);
+
+  if (bytes % sizeof(MDType) != 0) {
+    rb_raise(rb_eArgError, "the given string does not divide evenly for the given MATLAB dtype");
+  }
+
+  for (size_t i = 0, j = 0; i < bytes; i += sizeof(MDType), j += sizeof(DType)) {
+    *reinterpret_cast<DType*>(result+j) = (DType)(*reinterpret_cast<const MDType*>(str + i));
+  }
+
+  return result;
+}
+
+
+
+}} // end of namespace nm::io
+
+extern "C" {
+
+///////////////////////
+// Utility Functions //
+///////////////////////
+
+/*
+ * Converts a string to a data type.
+ */
+nm::dtype_t nm_dtype_from_rbstring(VALUE str) {
+
+  for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
+    if (!std::strncmp(RSTRING_PTR(str), DTYPE_NAMES[index], RSTRING_LEN(str))) {
+      return static_cast<nm::dtype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "invalid data type string (%s) specified", RSTRING_PTR(str));
+}
+
+
+/*
+ * Converts a symbol to a data type.
+ */
+nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym) {
+  ID sym_id = SYM2ID(sym);
+
+  for (size_t index = 0; index < NM_NUM_DTYPES; ++index) {
+    if (sym_id == rb_intern(DTYPE_NAMES[index])) {
+      return static_cast<nm::dtype_t>(index);
+    }
+  }
+
+  VALUE str = rb_any_to_s(sym);
+  rb_raise(rb_eArgError, "invalid data type symbol (:%s) specified", RSTRING_PTR(str));
+}
+
+
+/*
+ * Converts a string to a storage type. Only looks at the first three
+ * characters.
+ */
+nm::stype_t nm_stype_from_rbstring(VALUE str) {
+
+  for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
+    if (!std::strncmp(RSTRING_PTR(str), STYPE_NAMES[index], 3)) {
+      return static_cast<nm::stype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid storage type string specified");
+  return nm::DENSE_STORE;
+}
+
+/*
+ * Converts a symbol to a storage type.
+ */
+nm::stype_t nm_stype_from_rbsymbol(VALUE sym) {
+
+  for (size_t index = 0; index < NM_NUM_STYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(STYPE_NAMES[index])) {
+      return static_cast<nm::stype_t>(index);
+    }
+  }
+
+  VALUE str = rb_any_to_s(sym);
+  rb_raise(rb_eArgError, "invalid storage type symbol (:%s) specified", RSTRING_PTR(str));
+  return nm::DENSE_STORE;
+}
+
+
+/*
+ * Converts a MATLAB data-type symbol to an enum.
+ */
+static nm::io::matlab_dtype_t matlab_dtype_from_rbsymbol(VALUE sym) {
+  for (size_t index = 0; index < nm::io::NUM_MATLAB_DTYPES; ++index) {
+    if (SYM2ID(sym) == rb_intern(nm::io::MATLAB_DTYPE_NAMES[index])) {
+      return static_cast<nm::io::matlab_dtype_t>(index);
+    }
+  }
+
+  rb_raise(rb_eArgError, "Invalid matlab type specified.");
+}
+
+
+/*
+ * Take a string of bytes which represent MATLAB data type values and repack them into a string
+ * of bytes representing values of an NMatrix dtype (or itype).
+ *
+ * Returns what appears to be a Ruby String.
+ *
+ * Arguments:
+ * * str        :: the data
+ * * from       :: symbol representing MATLAB data type (e.g., :miINT8)
+ * * type       :: either :itype or some dtype symbol (:byte, :uint32, etc)
+ */
+static VALUE nm_rbstring_matlab_repack(VALUE self, VALUE str, VALUE from, VALUE type) {
+  nm::io::matlab_dtype_t from_type = matlab_dtype_from_rbsymbol(from);
+  uint8_t to_type;
+
+  if (SYMBOL_P(type)) {
+    if (rb_to_id(type) == rb_intern("itype")) {
+      if (sizeof(size_t) == sizeof(int64_t)) {
+        to_type = static_cast<int8_t>(nm::INT64);
+      } else if (sizeof(size_t) == sizeof(int32_t)) {
+        to_type = static_cast<int8_t>(nm::INT32);
+      } else if (sizeof(size_t) == sizeof(int16_t)) {
+        to_type = static_cast<int8_t>(nm::INT16);
+      } else {
+        rb_raise(rb_eStandardError, "unhandled size_t definition");
+      }
+    } else {
+      to_type = static_cast<uint8_t>(nm_dtype_from_rbsymbol(type));
+    }
+  } else {
+    rb_raise(rb_eArgError, "expected symbol for third argument");
+  }
+
+  // For next few lines, see explanation above NM_MATLAB_DTYPE_TEMPLATE_TABLE definition in io.h.
+  if (to_type >= static_cast<uint8_t>(nm::COMPLEX64)) {
+    rb_raise(rb_eArgError, "can only repack into a simple dtype, no complex/VALUE");
+  }
+
+  // Do the actual repacking -- really simple!
+  NM_MATLAB_DTYPE_TEMPLATE_TABLE(ttable, nm::io::matlab_cstring_to_dtype_string, char*, size_t& result_len, const char* str, size_t bytes);
+
+  size_t repacked_data_length;
+  char* repacked_data = ttable[to_type][from_type](repacked_data_length, RSTRING_PTR(str), RSTRING_LEN(str));
+
+  // Encode as 8-bit ASCII with a length -- don't want to hiccup on \0
+  VALUE result = rb_str_new(repacked_data, repacked_data_length);
+  NM_FREE(repacked_data); // Don't forget to free what we allocated!
+
+  return result;
+}
+
+
+/*
+ * Take two byte-strings (real and imaginary) and treat them as if they contain
+ * a sequence of data of type dtype. Merge them together and return a new string.
+ */
+static VALUE nm_rbstring_merge(VALUE self, VALUE rb_real, VALUE rb_imaginary, VALUE rb_dtype) {
+
+  // Sanity check.
+  if (RSTRING_LEN(rb_real) != RSTRING_LEN(rb_imaginary)) {
+    rb_raise(rb_eArgError, "real and imaginary components do not have same length");
+  }
+
+  nm::dtype_t dtype = nm_dtype_from_rbsymbol(rb_dtype);
+  size_t len        = DTYPE_SIZES[dtype];
+
+  char *real        = RSTRING_PTR(rb_real),
+       *imag        = RSTRING_PTR(rb_imaginary);
+
+  char* merge       = NM_ALLOCA_N(char, RSTRING_LEN(rb_real)*2);
+
+  size_t merge_pos  = 0;
+
+  // Merge the two sequences
+  for (size_t i = 0; i < (size_t)RSTRING_LEN(rb_real); i += len) {
+
+    // Copy real number
+    memcpy(merge + merge_pos, real + i, len);
+    merge_pos += len;
+
+    // Copy imaginary number
+    memcpy(merge + merge_pos, imag + i, len);
+    merge_pos += len;
+  }
+
+  return rb_str_new(merge, merge_pos);
+}
+
+
+void nm_init_io() {
+  cNMatrix_IO = rb_define_module_under(cNMatrix, "IO");
+  cNMatrix_IO_Matlab = rb_define_module_under(cNMatrix_IO, "Matlab");
+
+  rb_define_singleton_method(cNMatrix_IO_Matlab, "repack", (METHOD)nm_rbstring_matlab_repack, 3);
+  rb_define_singleton_method(cNMatrix_IO_Matlab, "complex_merge", (METHOD)nm_rbstring_merge, 3);
+}
+
+
+
+}

data/ext/nmatrix/util/io.h

@@ -0,0 +1,115 @@
+/////////////////////////////////////////////////////////////////////
+// = NMatrix
+//
+// A linear algebra library for scientific computation in Ruby.
+// NMatrix is part of SciRuby.
+//
+// NMatrix was originally inspired by and derived from NArray, by
+// Masahiro Tanaka: http://narray.rubyforge.org
+//
+// == Copyright Information
+//
+// SciRuby is Copyright (c) 2010 - 2014, Ruby Science Foundation
+// NMatrix is Copyright (c) 2012 - 2014, John Woods and the Ruby Science Foundation
+//
+// Please see LICENSE.txt for additional copyright notices.
+//
+// == Contributing
+//
+// By contributing source code to SciRuby, you agree to be bound by
+// our Contributor Agreement:
+//
+// * https://github.com/SciRuby/sciruby/wiki/Contributor-Agreement
+//
+// == io.h
+//
+// Header file for input/output support functions.
+
+#ifndef NMATRIX_IO_H
+#define NMATRIX_IO_H
+
+/*
+ * Project Includes
+ */
+
+#include "nmatrix.h"
+
+#include "data/data.h"
+#include "storage/storage.h"
+
+/*
+ * Extern Types
+ */
+extern const char* const DTYPE_NAMES[nm::NUM_DTYPES];
+
+namespace nm { namespace io {
+  /*
+   * Types
+   */
+  enum matlab_dtype_t {
+    miINT8 = 1,
+    miUINT8 = 2,
+    miINT16 = 3,
+    miUINT16 = 4,
+    miINT32 = 5,
+    miUINT32 = 6,
+    miSINGLE = 7,
+    miDOUBLE = 9,
+    miINT64 = 12,
+    miUINT64 = 13,
+    miMATRIX = 14
+  };
+
+  /*
+   * Constants
+   */
+
+  const size_t NUM_MATLAB_DTYPES = 15;
+}} // end of namespace nm::io
+
+extern "C" {
+
+  /*
+   * C accessors.
+   */
+  nm::dtype_t nm_dtype_from_rbsymbol(VALUE sym);
+  nm::dtype_t nm_dtype_from_rbstring(VALUE str);
+  nm::stype_t nm_stype_from_rbsymbol(VALUE sym);
+  nm::stype_t nm_stype_from_rbstring(VALUE str);
+
+  void nm_init_io(void);
+
+
+  /*
+   * Macros.
+   */
+
+  /*
+   * Macro for a function pointer table between NMatrix dtypes and MATLAB dtypes.
+   *
+   * You can't convert as freely between these two as you can between NMatrix dtypes, but there's no reason to. MATLAB
+   * stores its complex numbers in two separate arrays, for example, not as a single unit of data. If you want to convert
+   * to a VALUE, convert first to an appropriate integer or float type.
+   *
+   * FIXME: Maybe be a little more selective about which conversions we DO allow. This is really just for loading an
+   * already-constructed MATLAB matrix into memory, and most of these functions will never get called.
+   */
+  #define NM_MATLAB_DTYPE_TEMPLATE_TABLE(name,fun,ret,...)    \
+  static ret (*(name)[7][nm::io::NUM_MATLAB_DTYPES])(__VA_ARGS__) = {  \
+      { NULL, fun<uint8_t,int8_t>, fun<uint8_t,uint8_t>, fun<uint8_t,int16_t>, fun<uint8_t,uint16_t>, fun<uint8_t,int32_t>, fun<uint8_t,uint32_t>, fun<uint8_t,float>, NULL, fun<uint8_t,double>, NULL, NULL, fun<uint8_t,int64_t>, fun<uint8_t,uint64_t>, NULL },  \
+      { NULL, fun<int8_t,int8_t>, fun<int8_t,uint8_t>, fun<int8_t,int16_t>, fun<int8_t,uint16_t>, fun<int8_t,int32_t>, fun<int8_t,uint32_t>, fun<int8_t,float>, NULL, fun<int8_t,double>, NULL, NULL, fun<int8_t,int64_t>, fun<int8_t,uint64_t>, NULL },            \
+      { NULL, fun<int16_t,int8_t>, fun<int16_t,uint8_t>, fun<int16_t,int16_t>, fun<int16_t,uint16_t>, fun<int16_t,int32_t>, fun<int16_t,uint32_t>, fun<int16_t,float>, NULL, fun<int16_t,double>, NULL, NULL, fun<int16_t,int64_t>, fun<int16_t,uint64_t>, NULL },  \
+      { NULL, fun<int32_t,int8_t>, fun<int32_t,uint8_t>, fun<int32_t,int16_t>, fun<int32_t,uint16_t>, fun<int32_t,int32_t>, fun<int32_t,uint32_t>, fun<int32_t,float>, NULL, fun<int32_t,double>, NULL, NULL, fun<int32_t,int64_t>, fun<int32_t,uint64_t>, NULL },  \
+      { NULL, fun<int64_t,int8_t>, fun<int64_t,uint8_t>, fun<int64_t,int16_t>, fun<int64_t,uint16_t>, fun<int64_t,int32_t>, fun<int64_t,uint32_t>, fun<int64_t,float>, NULL, fun<int64_t,double>, NULL, NULL, fun<int64_t,int64_t>, fun<int64_t,uint64_t>, NULL },  \
+      { NULL, fun<float,int8_t>, fun<float,uint8_t>, fun<float,int16_t>, fun<float,uint16_t>, fun<float,int32_t>, fun<float,uint32_t>, fun<float,float>, NULL, fun<float,double>, NULL, NULL, fun<float,int64_t>, fun<float,uint64_t>, NULL },                      \
+      { NULL, fun<double,int8_t>, fun<double,uint8_t>, fun<double,int16_t>, fun<double,uint16_t>, fun<double,int32_t>, fun<double,uint32_t>, fun<double,float>, NULL, fun<double,double>, NULL, NULL, fun<double,int64_t>, fun<double,uint64_t>, NULL }             \
+    };
+
+  /*
+   * Hash#has_key? for symbols. Arguments are: hash (VALUE), string (char*).
+   */
+  #define RB_HASH_HAS_SYMBOL_KEY(hash, str)   (rb_funcall((hash), rb_intern("has_key?"), 1, ID2SYM(rb_intern(str))) == Qtrue)
+}
+
+
+#endif