Merge pull request #46 from rajithv/double2

isuruf · isuruf · commit f3d382134fae · 2016-06-01T08:55:32.000+05:30
Real Double Class
diff --git a/ext/symengine/CMakeLists.txt b/ext/symengine/CMakeLists.txt
@@ -2,7 +2,9 @@ set(RUBY_WRAPPER_SRC
     ruby_basic.c
     ruby_symbol.c
     ruby_integer.c
+    ruby_real_double.c
     ruby_complex.c
+    ruby_complex_double.c
     ruby_constant.c
     ruby_function.c
     ruby_ntheory.c
diff --git a/ext/symengine/ruby_complex_double.c b/ext/symengine/ruby_complex_double.c
@@ -0,0 +1,9 @@
+#include "ruby_complex_double.h"
+
+VALUE ccomplex_double_real_part(VALUE self) {
+    return function_onearg(complex_double_real_part, self);
+}
+
+VALUE ccomplex_double_imaginary_part(VALUE self) {
+    return function_onearg(complex_double_imaginary_part, self);
+}
diff --git a/ext/symengine/ruby_complex_double.h b/ext/symengine/ruby_complex_double.h
@@ -0,0 +1,13 @@
+#ifndef RUBY_COMPLEX_DOUBLE_H_
+#define RUBY_COMPLEX_DOUBLE_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine.h"
+#include "symengine_utils.h"
+
+VALUE ccomplex_double_real_part(VALUE self);
+VALUE ccomplex_double_imaginary_part(VALUE self);
+
+#endif //RUBY_COMPLEX_DOUBLE_H_
diff --git a/ext/symengine/ruby_integer.c b/ext/symengine/ruby_integer.c
@@ -3,7 +3,7 @@
 VALUE cinteger_init(VALUE self, VALUE num_value) {
     basic_struct *this;
     Data_Get_Struct(self, basic_struct, this);
-    GET_SYMINTFROMVAL(num_value, this);
+    get_symintfromval(num_value, this);
     return self;
 }
 
diff --git a/ext/symengine/ruby_real_double.c b/ext/symengine/ruby_real_double.c
@@ -0,0 +1,16 @@
+#include "ruby_real_double.h"
+
+
+VALUE crealdouble_to_float(VALUE self)
+{
+    VALUE result;
+
+    basic cbasic_operand1;
+    basic_new_stack(cbasic_operand1);
+    sympify(self, cbasic_operand1);
+
+    result = rb_float_new(real_double_get_d(cbasic_operand1));
+    basic_free_stack(cbasic_operand1);
+
+    return result;
+}
diff --git a/ext/symengine/ruby_real_double.h b/ext/symengine/ruby_real_double.h
@@ -0,0 +1,12 @@
+#ifndef RUBY_REAL_DOUBLE_H_
+#define RUBY_REAL_DOUBLE_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine.h"
+#include "symengine_utils.h"
+
+VALUE crealdouble_to_float(VALUE self);
+
+#endif //RUBY_REAL_DOUBLE_H_
diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c
@@ -2,8 +2,10 @@
 #include "ruby_basic.h"
 #include "ruby_symbol.h"
 #include "ruby_integer.h"
+#include "ruby_real_double.h"
 #include "ruby_constant.h"
 #include "ruby_complex.h"
+#include "ruby_complex_double.h"
 #include "ruby_function.h"
 #include "ruby_ntheory.h"
 #include "ruby_utils.h"
@@ -62,6 +64,11 @@ void Init_symengine() {
     rb_define_method(c_integer, "initialize", cinteger_init, 1);
     rb_define_method(c_integer, "%", cntheory_mod, 1);
 
+    //RealDouble Class
+    c_real_double = rb_define_class_under(m_symengine, "RealDouble", c_basic);
+    rb_define_alloc_func(c_real_double, cbasic_alloc);
+    rb_define_method(c_real_double, "to_f", crealdouble_to_float, 0);
+
     //Rational class
     c_rational = rb_define_class_under(m_symengine, "Rational", c_basic);
     rb_define_alloc_func(c_rational, cbasic_alloc);
@@ -75,6 +82,8 @@ void Init_symengine() {
     //ComplexDouble class
     c_complex_double = rb_define_class_under(m_symengine, "ComplexDouble", c_basic);
     rb_define_alloc_func(c_complex_double, cbasic_alloc);
+    rb_define_method(c_complex_double, "real", ccomplex_double_real_part, 0);
+    rb_define_method(c_complex_double, "imaginary", ccomplex_double_imaginary_part, 0);
 
     //Constant class
     c_constant = rb_define_class_under(m_symengine, "Constant", c_basic);
diff --git a/ext/symengine/symengine.h b/ext/symengine/symengine.h
@@ -10,6 +10,7 @@ VALUE m_symengine;
 VALUE c_basic;
 VALUE c_symbol;
 VALUE c_integer;
+VALUE c_real_double;
 VALUE c_rational;
 VALUE c_complex;
 VALUE c_complex_double;
diff --git a/ext/symengine/symengine_utils.c b/ext/symengine/symengine_utils.c
@@ -6,11 +6,17 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
     basic_struct *temp;
     VALUE new_operand2, num, den;
     VALUE real, imag;
+    double f;
 
     switch(TYPE(operand2)) {
         case T_FIXNUM:
         case T_BIGNUM:
-            GET_SYMINTFROMVAL(operand2, cbasic_operand2);
+            get_symintfromval(operand2, cbasic_operand2);
+            break;
+
+        case T_FLOAT:         
+            f = RFLOAT_VALUE(operand2);
+            real_double_set_d(cbasic_operand2, f);
             break;
 
         case T_RATIONAL:
@@ -21,8 +27,8 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
             basic_new_stack(num_basic);
             basic_new_stack(den_basic);
 
-            GET_SYMINTFROMVAL(num, num_basic);
-            GET_SYMINTFROMVAL(den, den_basic);
+            get_symintfromval(num, num_basic);
+            get_symintfromval(den, den_basic);
 
             rational_set(cbasic_operand2, num_basic, den_basic);
 
@@ -60,12 +66,27 @@ void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
     }
 }
 
+void get_symintfromval(VALUE operand2, basic_struct *cbasic_operand2)
+{
+    if ( TYPE(operand2) == T_FIXNUM ){
+        int i = NUM2INT( operand2 );
+        integer_set_si(cbasic_operand2, i);
+    } else if ( TYPE(operand2) == T_BIGNUM ){
+        VALUE Rb_Temp_String = rb_funcall(operand2, rb_intern("to_s"), 0, NULL);
+        integer_set_str(cbasic_operand2, StringValueCStr(Rb_Temp_String));
+    } else {
+        rb_raise(rb_eTypeError, "Invalid Type: Fixnum or Bignum required");
+    }
+}
+
 VALUE Klass_of_Basic(const basic_struct *basic_ptr) {
     switch(basic_get_type(basic_ptr)) {
         case SYMENGINE_SYMBOL:
             return c_symbol;
         case SYMENGINE_INTEGER:
             return c_integer;
+        case SYMENGINE_REAL_DOUBLE:
+            return c_real_double;
         case SYMENGINE_RATIONAL:
             return c_rational;
         case SYMENGINE_COMPLEX:
diff --git a/ext/symengine/symengine_utils.h b/ext/symengine/symengine_utils.h
@@ -1,12 +1,14 @@
-#ifndef SYMENGINE_MACROS_H_
-#define SYMENGINE_MACROS_H_
+#ifndef SYMENGINE_UTILS_H_
+#define SYMENGINE_UTILS_H_
 
 #include "ruby.h"
 #include "ruby_basic.h"
 #include "symengine/cwrapper.h"
 
 //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 
+void get_symintfromval(VALUE operand2, basic_struct *cbasic_operand2);
 //Returns the Ruby class of the corresponding basic_struct pointer
 VALUE Klass_of_Basic(const basic_struct *basic_ptr);
 //Returns the result from the function pointed by cwfunc_ptr: for one argument functions
@@ -15,13 +17,4 @@ VALUE function_onearg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*), VA
 VALUE function_twoarg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*, const basic_struct*),
                       VALUE operand1, VALUE operand2);
 
-//Obtains the value from Ruby Fixnum or Bignum to an already allocated basic_struct
-#define GET_SYMINTFROMVAL(num_value, this) { \
-    if ( ! RB_TYPE_P(num_value, T_FIXNUM) && ! RB_TYPE_P(num_value, T_BIGNUM) ) { \
-        rb_raise(rb_eTypeError, "Invalid Type: Fixnum or Bignum required"); \
-    } \
-    VALUE Rb_Temp_String = rb_funcall(num_value, rb_intern("to_s"), 0, NULL); \
-    integer_set_str(this, StringValueCStr(Rb_Temp_String)); \
-    }
-
-#endif //SYMENGINE_MACROS_H_
+#endif //SYMENGINE_UTILS_H_
diff --git a/lib/symengine.rb b/lib/symengine.rb
@@ -36,3 +36,4 @@ def symbols ary_or_string, *params
 require 'symengine/basic'
 require 'symengine/integer'
 require 'symengine/complex'
+require 'symengine/complex_double'
diff --git a/lib/symengine/complex_double.rb b/lib/symengine/complex_double.rb
@@ -0,0 +1,7 @@
+module SymEngine
+  class ComplexDouble
+    def to_c
+        to_s.tr('I', 'i').delete(" *").to_c
+    end
+  end
+end 
diff --git a/spec/complex_double_spec.rb b/spec/complex_double_spec.rb
@@ -0,0 +1,38 @@
+describe SymEngine::ComplexDouble do
+  context 'Convert to SymEngine types' do
+    context 'with a Complex' do
+      subject { SymEngine(Complex(2.3, 3.2)) }
+
+      it { is_expected.to be_a SymEngine::ComplexDouble }
+      its(:to_s) { is_expected.to eq '2.3 + 3.2*I' }
+    end
+
+    context 'with an integer' do
+      subject { SymEngine(Complex(2.3, 0)) }
+
+      it { is_expected.to be_a SymEngine::RealDouble }
+      its(:to_s) { is_expected.to eq '2.3' }
+    end
+  end
+
+  context 'real_part and imaginary_part' do
+    let(:a) { SymEngine(Complex(2.3, 3.2)) }
+
+    context 'real_part' do
+      context 'using SymEngine RealDoubles' do
+        subject { a.real }
+        it { is_expected.to be_a SymEngine::RealDouble }
+        its(:to_s) { is_expected.to eq '2.3' }
+      end
+    end
+
+    context 'imaginary_part' do
+      context 'using SymEngine RealDoubles' do
+        subject { a.imaginary }
+        it { is_expected.to be_a SymEngine::RealDouble }
+        its(:to_s) { is_expected.to eq '3.2' }
+      end
+    end 
+  end
+end
+
diff --git a/spec/real_double_spec.rb b/spec/real_double_spec.rb
@@ -0,0 +1,70 @@
+describe SymEngine::RealDouble do
+  describe 'Convert Float to Real Double' do
+    shared_examples 'simple real check' do
+      subject { SymEngine(value) }
+
+      it { is_expected.to be_a SymEngine::RealDouble }
+      its(:to_s) { is_expected.to eq value.to_s }
+    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 'huge positive float' do
+      let(:value) { 1.12_345_678_912_345 }
+
+      it_behaves_like 'simple real check'
+    end
+
+    context 'huge negative float' do
+      let(:value) { -1.12_345_678_912_345 }
+
+      it_behaves_like 'simple real check'
+    end
+  end
+
+  describe 'coercion' do
+    let(:symbol) { sym('x') }
+
+    context 'using a ruby float as the second operand' do
+      context 'commutative operations' do
+        subject { symbol * 2.2 }
+
+        it { is_expected.to be_a SymEngine::Basic }
+        it { is_expected.to eq(symbol * SymEngine(2.2)) }
+      end
+
+      context 'non commutative operations' do
+        subject { symbol / 2.2 }
+
+        it { is_expected.to be_a SymEngine::Basic }
+        it { is_expected.to eq(symbol / SymEngine(2.2)) }
+      end
+    end
+
+    context 'using a ruby float as the first operand' do
+      context 'commutative operations' do
+        subject { 2.2 * symbol }
+
+        it { is_expected.to be_a SymEngine::Basic }
+        it { is_expected.to eq(symbol * SymEngine(2.2)) }
+      end
+
+      context 'non commutative operations' do
+        subject { 2.2 / symbol }
+
+        it { is_expected.to be_a SymEngine::Basic }
+        it { is_expected.to eq(SymEngine(2.2) / symbol) }
+      end
+    end
+  end
+end
diff --git a/symengine_version.txt b/symengine_version.txt
@@ -1,2 +1,2 @@
-3f58acc1246661323b1daf2adc3f9fa6a8762df4
+b91c64a3b82f15133f4a7df64749523bb0bed185
 

Original file line number	Diff line number	Diff line change
`@@ -3,7 +3,7 @@`
`3`	`3`	`VALUE cinteger_init(VALUE self, VALUE num_value) {`
`4`	`4`	`basic_struct *this;`
`5`	`5`	`Data_Get_Struct(self, basic_struct, this);`
`6`		`- GET_SYMINTFROMVAL(num_value, this);`
	`6`	`+ get_symintfromval(num_value, this);`
`7`	`7`	`return self;`
`8`	`8`	`}`
`9`	`9`