Ruby Wrappers for Real MPFR and Complex MPC

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

ext/symengine/ruby_real_mpfr.c

@@ -0,0 +1,48 @@
+#include "ruby_real_mpfr.h"
+
+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)
+{
+    VALUE result;
+    basic cbasic_operand1;
+    basic_new_stack(cbasic_operand1);
+    sympify(self, cbasic_operand1);
+
+    result = rb_float_new(real_mpfr_get_d(cbasic_operand1));
+
+    basic_free_stack(cbasic_operand1);
+    return result;
+}
+

ext/symengine/ruby_real_mpfr.h

@@ -0,0 +1,13 @@
+#ifndef RUBY_REAL_MPFR_H_
+#define RUBY_REAL_MPFR_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine.h"
+#include "symengine_utils.h"
+
+VALUE crealmpfr_init(VALUE self, VALUE num_value, VALUE prec_value);
+VALUE crealmpfr_to_float(VALUE self);
+
+#endif //RUBY_REAL_MPFR_H_

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,16 @@ 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);
 
+    //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);
+
+    //ComplexMPC class
+    c_complex_mpc = rb_define_class_under(m_symengine, "ComplexMPC", c_basic);
+    rb_define_alloc_func(c_complex_mpc, cbasic_alloc);
+
     //Constant class
     c_constant = rb_define_class_under(m_symengine, "Constant", c_basic);
 

ext/symengine/symengine.h

@@ -14,6 +14,8 @@ VALUE c_real_double;
 VALUE c_rational;
 VALUE c_complex;
 VALUE c_complex_double;
+VALUE c_real_mpfr;
+VALUE c_complex_mpc;
 VALUE c_constant;
 VALUE c_add;
 VALUE c_mul;

ext/symengine/symengine_utils.c

@@ -6,7 +6,9 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
     basic_struct *temp;
     VALUE new_operand2, num, den;
     VALUE real, imag;
+    VALUE a, b;
     double f;
+    char *c;
 
     switch(TYPE(operand2)) {
         case T_FIXNUM:
@@ -59,10 +61,16 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
             break;
 
         case T_DATA:
+            c = rb_obj_classname(operand2);
+            if(strcmp(c, "BigDecimal") == 0){
+                c = RSTRING_PTR( rb_funcall(operand2, rb_intern("to_s"), 1, rb_str_new2("F")) );
+                real_mpfr_set_str(cbasic_operand2, c, 200);
+                break;
+            }
+
             Data_Get_Struct(operand2, basic_struct, temp);
             basic_assign(cbasic_operand2, temp);
             break;
-
     }
 }
 
@@ -87,12 +95,16 @@ VALUE Klass_of_Basic(const basic_struct *basic_ptr) {
             return c_integer;
         case SYMENGINE_REAL_DOUBLE:
             return c_real_double;
+        case SYMENGINE_REAL_MPFR:
+            return c_real_mpfr;
         case SYMENGINE_RATIONAL:
             return c_rational;
         case SYMENGINE_COMPLEX:
             return c_complex;
         case SYMENGINE_COMPLEX_DOUBLE:
             return c_complex_double;
+        case SYMENGINE_COMPLEX_MPC:
+            return c_complex_mpc;
         case SYMENGINE_CONSTANT:
             return c_constant;
         case SYMENGINE_ADD:

spec/real_mpfr_spec.rb

@@ -0,0 +1,71 @@
+require 'bigdecimal'
+
+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
+
+
+end