ml4r 0.1.0 → 0.1.2

data/ext/ml4r/utils/RubyUtils.h

@@ -0,0 +1,174 @@
+#ifndef RubyUtils_h__
+#define RubyUtils_h__
+
+#include <string>
+#include <utility>
+using std::pair;
+using std::string;
+
+namespace RubyUtils
+{
+    //template<class T>           inline VALUE toValue(const T& v);
+    //template<class T>           inline VALUE toValue(const vector<T>& v);
+    // template<class T, class U>  inline VALUE toValue(const vector<pair<T,U>>& v);
+    //template<class T, class U, class V>  inline VALUE toValue(const map<pair<T,U>,V>& v);
+    //template<class T, class U>  inline VALUE toValue(const map<T,U>& v);
+    //template<class T, class U>  inline VALUE toValue(const pair<T,U>& v);
+                                inline VALUE toValue(const char* v) { return otRuby->ToNum(v); }
+
+    //template<class T>           inline T     fromValue(VALUE v);
+    //template<class T>           inline void  fromValue(VALUE v, T& t);
+    //template<class T, class U>  inline void  fromValue(VALUE v, pair<T,U>& t);
+    //template<class T>           inline void  fromValue(VALUE v, vector<T>& t);
+};
+
+template<> inline VALUE RubyUtils::toValue(const int& v)
+{
+    return otRuby->ToNum(v);
+}
+
+template<> inline VALUE RubyUtils::toValue(const float& v)
+{
+    return otRuby->ToNum(v);
+}
+
+template<> inline VALUE RubyUtils::toValue(const double& v)
+{
+    return otRuby->ToNum(v);
+}
+
+template<> inline VALUE RubyUtils::toValue(const string& v)
+{
+    return otRuby->ToNum(v.c_str());
+}
+
+template<> inline VALUE RubyUtils::toValue(const VALUE& v)
+{
+    return v;
+}
+
+template<class T> inline VALUE RubyUtils::toValue(const vector<T>& v)
+{
+    VALUE returnValue = otRuby->rb_ary_new();
+    BOOST_FOREACH(const T& val, v)
+        otRuby->rb_ary_push(returnValue, toValue(val));
+    return returnValue;
+}
+
+template<class T, class U> inline VALUE RubyUtils::toValue(const pair<T,U>& v)
+{
+    VALUE returnValue = otRuby->rb_ary_new();
+    otRuby->rb_ary_push(returnValue, toValue(v.first));
+    otRuby->rb_ary_push(returnValue, toValue(v.second));
+    return returnValue;
+}
+
+
+template<class T, class U> inline VALUE RubyUtils::toValue(const map<T,U>& v)
+{
+    VALUE returnValue = otRuby->rb_hash_new();
+    BOOST_FOREACH(auto& keyValue, v)
+    {
+        otRuby->rb_hash_aset(returnValue, toValue(keyValue.first), toValue(keyValue.second));
+    }
+    return returnValue;
+}
+
+//////////////////////////////////////////////////////////////////////////
+// FROM VALUE
+//////////////////////////////////////////////////////////////////////////
+
+template<class T> inline T RubyUtils::fromValue(VALUE v)
+{
+    T t;
+    fromValue(v,t);
+    return t; 
+}
+
+//////////////////////////////////////////////////////////////////////////
+// FROM VALUE Two argument
+//////////////////////////////////////////////////////////////////////////
+
+template<> inline void RubyUtils::fromValue(VALUE v, int& i)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_FIXNUM);
+    i = otRuby->AsLong(v);
+}
+
+template<> inline void RubyUtils::fromValue(VALUE v, double& d)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_FLOAT);
+    d = otRuby->AsDouble(v);
+}
+
+template<> inline void RubyUtils::fromValue(VALUE v, float& f)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_FLOAT);
+    f = (float) otRuby->AsDouble(v);
+}
+
+template<> inline void RubyUtils::fromValue(VALUE v, string& s)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_STRING);
+    s = otRuby->AsString(v);
+}
+
+template<> inline void RubyUtils::fromValue(VALUE v, bool& b)
+{
+    if (otRuby->rb_obj_is_kind_of(v, otRuby->rb_cTrueClass()))
+        b = true;
+    else if (otRuby->rb_obj_is_kind_of(v, otRuby->rb_cFalseClass()))
+        b = false;
+    else
+    {
+        otRuby->rb_raise(otRuby->rb_eRuntimeError(), "VALUE is not of type bool");
+    }
+
+}
+template<> inline void RubyUtils::fromValue(VALUE v, TOtSimpleVariable& sv)
+{
+    if (otRuby->rb_obj_is_kind_of(v, otRuby->rb_cString()))
+        sv = TOtSimpleVariable(fromValue<string>(v));
+    else if (otRuby->rb_obj_is_instance_of(v, otRuby->rb_cFixnum()))
+        sv = TOtSimpleVariable(fromValue<int>(v));
+    else if (otRuby->rb_obj_is_instance_of(v, otRuby->rb_cFloat()))
+        sv = TOtSimpleVariable(fromValue<float>(v));
+    else
+    {
+        otRuby->rb_raise(otRuby->rb_eRuntimeError(), "Unknown VALUE type");
+    }
+}
+
+
+template<> inline void RubyUtils::fromValue(VALUE v, TOtMatrix& f)
+{
+    //otRuby->rb_check_type(v, TOtRubyInterface::T_FLOAT);
+    if (!otRuby->rb_obj_is_kind_of(v, rb_cMatrix))
+    {
+        throw std::invalid_argument("[RubyUtils::fromValue] expected a matrix");
+    }
+    Gclib::TGcMatrix *m = (Gclib::TGcMatrix*)otRuby->GetDataPtr(v);
+    f.Connect(m);
+}
+
+template<class T, class U> inline void RubyUtils::fromValue(unsigned long v, pair<T,U> &returnValue)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_ARRAY);
+    VALUE*  v_array = otRuby->ToArray(v);
+    int     length  = otRuby->ArrayLen(v);
+    if (length != 2) throw runtime_error("Expected a pair, got an array with length " + ToString(length));
+    fromValue(v_array[0], returnValue.first);
+    fromValue(v_array[1], returnValue.second);
+}
+
+template<class T> inline void RubyUtils::fromValue(VALUE v, vector<T>& returnValue)
+{
+    otRuby->rb_check_type(v, TOtRubyInterface::T_ARRAY);
+    VALUE*  v_array = otRuby->ToArray(v);
+    int     length  = otRuby->ArrayLen(v);
+    returnValue.resize(length);
+    for (int i = 0; i < length; ++i)
+        fromValue(v_array[i], returnValue.at(i));
+}
+
+#endif // RubyUtils_h__

data/lib/ml4r.rb

@@ -1,2 +1,2 @@
 require 'rubygems'
-require 'test_cpp_extension'
+require 'ml4r/ml4r'

data/lib/test_cpp_extension.rb

@@ -0,0 +1,2 @@
+class TestCppExtension
+end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: ml4r
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.2
   prerelease: 
 platform: ruby
 authors:
@@ -10,17 +10,30 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-06-24 00:00:00.000000000 Z
+date: 2012-06-24 00:00:00.000000000Z
 dependencies: []
 description: A ruby based library of Maching Learning (ML) algorithms
 email:
 - jamie@ieee.org
 - tim.veitch@veitchlister.com.au
 executables: []
-extensions: []
+extensions:
+- ext/ml4r/extconf.rb
 extra_rdoc_files: []
 files:
 - lib/ml4r.rb
+- lib/test_cpp_extension.rb
+- ext/ml4r/swig/example_wrap.c
+- ext/ml4r/example.h
+- ext/ml4r/LinearRegression/ZenithRegression.h
+- ext/ml4r/LinearRegression.h
+- ext/ml4r/MathUtils.h
+- ext/ml4r/MatrixInversion.h
+- ext/ml4r/OLSLinearRegression.h
+- ext/ml4r/swig/example.h
+- ext/ml4r/utils/RubyUtils.h
+- ext/ml4r/Utils.h
+- ext/ml4r/extconf.rb
 homepage: https://github.com/vlc/ml4r
 licenses: []
 post_install_message: