Merge branch 'master' into function_symbol

rajithv · rajithv · commit 6b32db914779 · 2016-06-12T23:54:51.000+05:30
diff --git a/.travis.yml b/.travis.yml
@@ -14,7 +14,6 @@ addons:
     - binutils-dev
     - g++-4.7
 rvm:
- - 1.9.3
  - 2.0
  - 2.1
  - 2.2
@@ -25,10 +24,10 @@ matrix:
     - os: osx
   include:
     - os: osx
-      rvm: 1.9.3
+      rvm: 2.0
   allow_failures:
     - os: osx
-      rvm: 1.9.3
+      rvm: 2.0
 
 install:
   - export RUBY_SOURCE_DIR=`pwd`
diff --git a/README.md b/README.md
@@ -15,6 +15,8 @@ Ruby wrappers gem for SymEngine, a fast symbolic manipulation library, written i
 
 - libsymengine        - See build [instructions](https://github.com/symengine/symengine/wiki/Building-SymEngine)
 
+- ruby >= 2.0.0       - Needs Ruby shared library and headers
+
 #### Installing
 
 - Simply do,
diff --git a/ext/symengine/CMakeLists.txt b/ext/symengine/CMakeLists.txt
@@ -3,6 +3,7 @@ set(RUBY_WRAPPER_SRC
     ruby_symbol.c
     ruby_integer.c
     ruby_real_double.c
+    ruby_real_mpfr.c
     ruby_complex.c
     ruby_complex_double.c
     ruby_constant.c
diff --git a/ext/symengine/ruby_constant.c b/ext/symengine/ruby_constant.c
@@ -26,3 +26,19 @@ VALUE cconstant_euler_gamma() {
 VALUE cconstant_i() {
     return cconstant_const(basic_const_I, c_complex);
 }
+
+VALUE cconstant_have_mpfr() {
+    #ifdef HAVE_SYMENGINE_MPFR
+        return Qtrue;
+    #else
+        return Qfalse;
+    #endif //HAVE_SYMENGINE_MPFR
+}
+
+VALUE cconstant_have_mpc() {
+    #ifdef HAVE_SYMENGINE_MPC
+        return Qtrue;
+    #else
+        return Qfalse;
+    #endif //HAVE_SYMENGINE_MPC
+}
diff --git a/ext/symengine/ruby_constant.h b/ext/symengine/ruby_constant.h
@@ -17,4 +17,8 @@ VALUE cconstant_euler_gamma();
 
 VALUE cconstant_i();
 
+VALUE cconstant_have_mpfr();
+
+VALUE cconstant_have_mpc();
+
 #endif //RUBY_CONSTANTS_H_
diff --git a/ext/symengine/ruby_real_mpfr.c b/ext/symengine/ruby_real_mpfr.c
@@ -0,0 +1,49 @@
+#include "ruby_real_mpfr.h"
+
+#ifdef HAVE_SYMENGINE_MPFR
+VALUE crealmpfr_init(VALUE self, VALUE num_value, VALUE prec_value)
+{
+    basic_struct *cresult;
+    double d;
+    char *c;
+    int prec = NUM2INT(prec_value);
+
+    Data_Get_Struct(self, basic_struct, cresult);
+
+    switch( TYPE(num_value) ) {
+        case T_FLOAT:
+            d = RFLOAT_VALUE(num_value);     
+            real_mpfr_set_d(cresult, d, prec);
+            break;
+        case T_STRING:
+            c = RSTRING_PTR(num_value);
+            real_mpfr_set_str(cresult, c, prec);
+            break;
+        case T_DATA:
+            c = rb_obj_classname(num_value);
+            if (strcmp(c, "BigDecimal") == 0) {
+                c = RSTRING_PTR(rb_funcall(num_value, rb_intern("to_s"), 1, rb_str_new2("F")));
+                real_mpfr_set_str(cresult, c, prec);
+                break;
+            }
+        default:
+            rb_raise(rb_eTypeError, "Invalid Type: Float, BigDecimal or String required.");
+            break;
+    }
+
+    return self;
+}
+
+VALUE crealmpfr_to_float(VALUE self)
+{
+    // TODO: Make the following method work
+    //VALUE result;
+    //basic cbasic_operand1;
+    //basic_new_stack(cbasic_operand1);
+    //sympify(self, cbasic_operand1);
+    //result = rb_float_new(real_mpfr_get_d(cbasic_operand1));
+
+    return rb_funcall(rb_funcall(self, rb_intern("to_s"), 0, NULL), rb_intern("to_f"), 0, NULL);
+}
+#endif //HAVE_SYMENGINE_MPFR
+
diff --git a/ext/symengine/ruby_real_mpfr.h b/ext/symengine/ruby_real_mpfr.h
@@ -0,0 +1,15 @@
+#ifndef RUBY_REAL_MPFR_H_
+#define RUBY_REAL_MPFR_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine.h"
+#include "symengine_utils.h"
+
+#ifdef HAVE_SYMENGINE_MPFR
+VALUE crealmpfr_init(VALUE self, VALUE num_value, VALUE prec_value);
+VALUE crealmpfr_to_float(VALUE self);
+#endif //HAVE_SYMENGINE_MPFR
+
+#endif //RUBY_REAL_MPFR_H_
diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c
@@ -6,6 +6,7 @@
 #include "ruby_constant.h"
 #include "ruby_complex.h"
 #include "ruby_complex_double.h"
+#include "ruby_real_mpfr.h"
 #include "ruby_function.h"
 #include "ruby_ntheory.h"
 #include "ruby_utils.h"
@@ -85,6 +86,20 @@ void Init_symengine() {
     rb_define_method(c_complex_double, "real", ccomplex_double_real_part, 0);
     rb_define_method(c_complex_double, "imaginary", ccomplex_double_imaginary_part, 0);
 
+    #ifdef HAVE_SYMENGINE_MPFR
+    //RealMPFR class
+    c_real_mpfr = rb_define_class_under(m_symengine, "RealMPFR", c_basic);
+    rb_define_alloc_func(c_real_mpfr, cbasic_alloc);
+    rb_define_method(c_real_mpfr, "initialize", crealmpfr_init, 2);
+    rb_define_method(c_real_mpfr, "to_f", crealmpfr_to_float, 0);
+    #endif //HAVE_SYMENGINE_MPFR
+
+    #ifdef HAVE_SYMENGINE_MPC
+    //ComplexMPC class
+    c_complex_mpc = rb_define_class_under(m_symengine, "ComplexMPC", c_basic);
+    rb_define_alloc_func(c_complex_mpc, cbasic_alloc);
+    #endif //HAVE_SYMENGINE_MPC
+
     //Constant class
     c_constant = rb_define_class_under(m_symengine, "Constant", c_basic);
 
@@ -93,6 +108,8 @@ void Init_symengine() {
     rb_define_const(m_symengine, "E", cconstant_e());
     rb_define_const(m_symengine, "EULER_GAMMA", cconstant_euler_gamma());
     rb_define_const(m_symengine, "I", cconstant_i());
+    rb_define_const(m_symengine, "HAVE_MPFR", cconstant_have_mpfr());
+    rb_define_const(m_symengine, "HAVE_MPC", cconstant_have_mpc());
     
     //Subs class
     c_subs = rb_define_class_under(m_symengine, "Subs", c_basic);
diff --git a/ext/symengine/symengine.h b/ext/symengine/symengine.h
@@ -14,6 +14,12 @@ VALUE c_real_double;
 VALUE c_rational;
 VALUE c_complex;
 VALUE c_complex_double;
+#ifdef HAVE_SYMENGINE_MPFR
+VALUE c_real_mpfr;
+#endif //HAVE_SYMENGINE_MPFR
+#ifdef HAVE_SYMENGINE_MPC
+VALUE c_complex_mpc;
+#endif //HAVE_SYMENGINE_MPC
 VALUE c_constant;
 VALUE c_subs;
 VALUE c_add;
diff --git a/ext/symengine/symengine_utils.c b/ext/symengine/symengine_utils.c
@@ -4,9 +4,11 @@
 void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
 
     basic_struct *temp;
-    VALUE new_operand2, num, den;
-    VALUE real, imag;
+    VALUE new_operand2;
+    VALUE a, b;
     double f;
+    char *c;
+    rb_cBigDecimal = CLASS_OF(rb_eval_string("BigDecimal.new('0.0001')"));
 
     switch(TYPE(operand2)) {
         case T_FIXNUM:
@@ -20,15 +22,15 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
             break;
 
         case T_RATIONAL:
-            num = rb_funcall(operand2, rb_intern("numerator"), 0, NULL);
-            den = rb_funcall(operand2, rb_intern("denominator"), 0, NULL);
+            a = rb_funcall(operand2, rb_intern("numerator"), 0, NULL);
+            b = rb_funcall(operand2, rb_intern("denominator"), 0, NULL);
 
             basic num_basic, den_basic;
             basic_new_stack(num_basic);
             basic_new_stack(den_basic);
 
-            get_symintfromval(num, num_basic);
-            get_symintfromval(den, den_basic);
+            get_symintfromval(a, num_basic);
+            get_symintfromval(b, den_basic);
 
             rational_set(cbasic_operand2, num_basic, den_basic);
 
@@ -37,17 +39,17 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
             break;
 
         case T_COMPLEX:
-            real = rb_funcall(operand2, rb_intern("real"), 0, NULL);
-            imag = rb_funcall(operand2, rb_intern("imaginary"), 0, NULL);
+            a = rb_funcall(operand2, rb_intern("real"), 0, NULL);
+            b = rb_funcall(operand2, rb_intern("imaginary"), 0, NULL);
 
             basic real_basic;
             basic imag_basic;
 
             basic_new_stack(real_basic);
             basic_new_stack(imag_basic);
 
-            sympify(real, real_basic);
-            sympify(imag, imag_basic);
+            sympify(a, real_basic);
+            sympify(b, imag_basic);
 
             basic_const_I(cbasic_operand2);
             basic_mul(cbasic_operand2, cbasic_operand2, imag_basic);
@@ -59,10 +61,18 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
             break;
 
         case T_DATA:
+            c = rb_obj_classname(operand2);
+            #ifdef HAVE_SYMENGINE_MPFR
+            if(CLASS_OF(operand2) == rb_cBigDecimal){
+                c = RSTRING_PTR( rb_funcall(operand2, rb_intern("to_s"), 1, rb_str_new2("F")) );
+                real_mpfr_set_str(cbasic_operand2, c, 200);
+                break;
+            }
+            #endif //HAVE_SYMENGINE_MPFR
+
             Data_Get_Struct(operand2, basic_struct, temp);
             basic_assign(cbasic_operand2, temp);
             break;
-            
     }
 }
 
@@ -87,12 +97,20 @@ VALUE Klass_of_Basic(const basic_struct *basic_ptr) {
             return c_integer;
         case SYMENGINE_REAL_DOUBLE:
             return c_real_double;
+        #ifdef HAVE_SYMENGINE_MPFR
+        case SYMENGINE_REAL_MPFR:
+            return c_real_mpfr;
+        #endif //HAVE_SYMENGINE_MPFR
         case SYMENGINE_RATIONAL:
             return c_rational;
         case SYMENGINE_COMPLEX:
             return c_complex;
         case SYMENGINE_COMPLEX_DOUBLE:
             return c_complex_double;
+        #ifdef HAVE_SYMENGINE_MPC
+        case SYMENGINE_COMPLEX_MPC:
+            return c_complex_mpc;
+        #endif //HAVE_SYMENGINE_MPFR
         case SYMENGINE_CONSTANT:
             return c_constant;
         case SYMENGINE_SUBS:
diff --git a/ext/symengine/symengine_utils.h b/ext/symengine/symengine_utils.h
@@ -5,6 +5,8 @@
 #include "ruby_basic.h"
 #include "symengine/cwrapper.h"
 
+VALUE rb_cBigDecimal;
+
 //Returns the pointer wrapped inside the Ruby VALUE
 void sympify(VALUE operand2, basic_struct *cbasic_operand2);
 //Returns the pointer wrapped inside the Ruby Fixnum or Bignum 
diff --git a/spec/real_mpfr_spec.rb b/spec/real_mpfr_spec.rb
@@ -0,0 +1,84 @@
+require 'bigdecimal'
+
+if SymEngine::HAVE_MPFR
+
+  describe SymEngine::RealMPFR do
+    describe 'Convert BigDemcimal to RealMPFR' do
+      shared_examples 'simple real check' do
+        subject { SymEngine(value) }
+
+        it { is_expected.to be_a SymEngine::RealMPFR }
+        its(:to_f) { is_expected.to eq value.to_f }
+      end
+
+      context 'positive BigDecimal' do
+        let(:value) { BigDecimal("12.3") }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'negative BigDecimal' do
+        let(:value) { BigDecimal("-12.3") }
+
+        it_behaves_like 'simple real check'
+      end
+    end
+
+    describe 'Initialize RealMPFR' do
+      shared_examples 'simple real check' do
+        subject { SymEngine::RealMPFR.new(value, 200) }
+
+        it { is_expected.to be_a SymEngine::RealMPFR }
+        its(:to_f) { is_expected.to eq value.to_f }
+      end
+
+      context 'positive BigDecimal' do
+        let(:value) { BigDecimal("12.3") }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'negative BigDecimal' do
+        let(:value) { BigDecimal("-12.3") }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'positive Float' do
+        let(:value) { 12.3 }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'negative Float' do
+        let(:value) { 12.3 }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'String representation of positive value' do
+        let(:value) { "12.3" }
+
+        it_behaves_like 'simple real check'
+      end
+
+      context 'String representation of negative value' do
+        let(:value) { "-12.3" }
+
+        it_behaves_like 'simple real check'
+      end
+    end
+    
+    if SymEngine::HAVE_MPC
+      describe SymEngine::ComplexMPC do
+        let(:i) { SymEngine::I }
+        let(:real) { SymEngine(BigDecimal("34.5")) }
+        let(:imag) { SymEngine(BigDecimal("65.8")) }
+        
+        subject { real + i * imag }
+        it { is_expected.to be_a SymEngine::ComplexMPC } 
+      end
+    end
+
+  end
+end
diff --git a/symengine_version.txt b/symengine_version.txt
@@ -1 +1 @@
-1d80d81096b66c08ad3fe4e43ee586cd91b5ccf8
+0086007c3f588e77c9b8ce8e071fee686ffc6b72
