From b6a2b4505ce5094331c1e209569efd91746b3960 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Fri, 17 Jun 2016 21:45:37 +0530 Subject: [PATCH 01/10] evals ruby wrapper --- ext/symengine/ruby_utils.c | 18 ++++++++++++++++++ ext/symengine/ruby_utils.h | 2 +- ext/symengine/symengine.c | 3 +++ 3 files changed, 22 insertions(+), 1 deletion(-) diff --git a/ext/symengine/ruby_utils.c b/ext/symengine/ruby_utils.c index 24ec50d..352b73c 100644 --- a/ext/symengine/ruby_utils.c +++ b/ext/symengine/ruby_utils.c @@ -14,3 +14,21 @@ VALUE cutils_sympify(VALUE self, VALUE operand) return result; } + +VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real) +{ + VALUE result; + + basic_struct *cbasic_operand; + basic_struct *cresult; + cbasic_operand = basic_new_heap(); + cresult = basic_new_heap(); + + sympify(operand, cbasic_operand); + basic_evalf(cresult, cbasic_operand, NUM2INT(prec), (real == Qtrue ? 1 : 0 )); + result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap, cresult); + + cbasic_free_heap(cbasic_operand); + + return result; +} diff --git a/ext/symengine/ruby_utils.h b/ext/symengine/ruby_utils.h index de004ff..65edbf2 100644 --- a/ext/symengine/ruby_utils.h +++ b/ext/symengine/ruby_utils.h @@ -5,5 +5,5 @@ // Returns the Ruby Value after going through sympify VALUE cutils_sympify(VALUE self, VALUE operand); - +VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real); #endif // RUBY_UTILS_H_ diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c index 98908f7..7961ae8 100644 --- a/ext/symengine/symengine.c +++ b/ext/symengine/symengine.c @@ -57,6 +57,9 @@ void Init_symengine() // Sympify as a Module Level Function rb_define_module_function(m_symengine, "convert", cutils_sympify, 1); rb_define_global_function("SymEngine", cutils_sympify, 1); + + // evalf as a Module Level Function + rb_define_module_function(m_symengine, "evalf", cutils_evalf, 3); // Symbol class c_symbol = rb_define_class_under(m_symengine, "Symbol", c_basic); From 2f716e1fc8e8411b9a0c78089dfa2c0eefb21872 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Fri, 17 Jun 2016 23:04:30 +0530 Subject: [PATCH 02/10] evalf specs for Ruby Wrapper --- spec/evalf_spec.rb | 29 +++++++++++++++++++++++++++++ 1 file changed, 29 insertions(+) create mode 100644 spec/evalf_spec.rb diff --git a/spec/evalf_spec.rb b/spec/evalf_spec.rb new file mode 100644 index 0000000..3f38c8e --- /dev/null +++ b/spec/evalf_spec.rb @@ -0,0 +1,29 @@ +describe 'SymEngine::evalf' do + context 'RealDouble values' do + subject { SymEngine::evalf(SymEngine::sin(SymEngine(2)), 53, true) } + it { is_expected.to be_a SymEngine::RealDouble } + its(:to_s) { is_expected.to eq "0.909297426825682" } + end + if SymEngine::HAVE_MPFR + context 'RealMPFR values' do + subject { SymEngine::evalf(SymEngine::PI * SymEngine(1963319607) - SymEngine(6167950454), 100, true) } + it { is_expected.to be_a SymEngine::RealMPFR } + its(:to_s) { is_expected.to eq "1.4973429143989597928099399837265e-10" } + end + end + context 'ComplexDouble values' do + subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 53, false) } + it { is_expected.to be_a SymEngine::ComplexDouble } + its(:to_s) { is_expected.to eq "0.0 + 0.841470984807897*I" } + end + context 'ComplexMPC values' do + + end + if SymEngine::HAVE_MPC + context 'ComplexMPC values' do + subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 100, false) } + it { is_expected.to be_a SymEngine::ComplexMPC } + its(:to_s) { is_expected.to eq "0.00000000000000000000000000000000 + 0.84147098480789650665250232163005*I" } + end + end +end From 81a0d7abe27218424e40e539a8f012ac70819c1f Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Wed, 22 Jun 2016 10:01:26 +0530 Subject: [PATCH 03/10] Changed symengine version --- symengine_version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/symengine_version.txt b/symengine_version.txt index bc0c91d..0082d95 100644 --- a/symengine_version.txt +++ b/symengine_version.txt @@ -1 +1 @@ -0c17ca9d88f25881c6d0ca382c26b2eb392b9b48 +59e17e37dd0f3441fcce5ebd18026ee4c3d4844d From a8e3dde122f499f3f7414d146a1f43d3016e2048 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Wed, 22 Jun 2016 23:11:28 +0530 Subject: [PATCH 04/10] Fixes #57 --- ext/symengine/symengine_utils.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/ext/symengine/symengine_utils.c b/ext/symengine/symengine_utils.c index f17489a..43dfdb3 100644 --- a/ext/symengine/symengine_utils.c +++ b/ext/symengine/symengine_utils.c @@ -91,7 +91,7 @@ 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); + long int i = NUM2LONG(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); From bb29a1bed85b8e877a3087a316c5d12f5293cfcd Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Thu, 23 Jun 2016 10:24:48 +0530 Subject: [PATCH 05/10] Update ruby_utils.h - removed cbasic_operand --- ext/symengine/ruby_utils.c | 8 ++------ 1 file changed, 2 insertions(+), 6 deletions(-) diff --git a/ext/symengine/ruby_utils.c b/ext/symengine/ruby_utils.c index 352b73c..2a5677c 100644 --- a/ext/symengine/ruby_utils.c +++ b/ext/symengine/ruby_utils.c @@ -19,16 +19,12 @@ VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real) { VALUE result; - basic_struct *cbasic_operand; basic_struct *cresult; - cbasic_operand = basic_new_heap(); cresult = basic_new_heap(); - sympify(operand, cbasic_operand); - basic_evalf(cresult, cbasic_operand, NUM2INT(prec), (real == Qtrue ? 1 : 0 )); + sympify(operand, cresult); + basic_evalf(cresult, cresult, NUM2INT(prec), (real == Qtrue ? 1 : 0 )); result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap, cresult); - cbasic_free_heap(cbasic_operand); - return result; } From d38b5c83de79523f101b055e30fc252ca245197d Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Thu, 7 Jul 2016 15:28:42 +0530 Subject: [PATCH 06/10] Default values for evalf, .abs object method --- ext/symengine/symengine.c | 2 +- lib/symengine.rb | 5 ++++- lib/symengine/basic.rb | 5 +++++ spec/evalf_spec.rb | 2 +- 4 files changed, 11 insertions(+), 3 deletions(-) diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c index 7961ae8..ca29188 100644 --- a/ext/symengine/symengine.c +++ b/ext/symengine/symengine.c @@ -59,7 +59,7 @@ void Init_symengine() rb_define_global_function("SymEngine", cutils_sympify, 1); // evalf as a Module Level Function - rb_define_module_function(m_symengine, "evalf", cutils_evalf, 3); + rb_define_module_function(m_symengine, "_evalf", cutils_evalf, 3); // Symbol class c_symbol = rb_define_class_under(m_symengine, "Symbol", c_basic); diff --git a/lib/symengine.rb b/lib/symengine.rb index e4d3477..a73590e 100644 --- a/lib/symengine.rb +++ b/lib/symengine.rb @@ -29,7 +29,10 @@ def symbols ary_or_string, *params end def Function(n) return SymEngine::UndefFunction.new(n) - end + end + def evalf(operand, prec=53, real=false) + return _evalf(operand, prec, real) + end end end diff --git a/lib/symengine/basic.rb b/lib/symengine/basic.rb index a46531c..6523e15 100644 --- a/lib/symengine/basic.rb +++ b/lib/symengine/basic.rb @@ -9,5 +9,10 @@ def inspect def free_symbols pr_free_symbols.to_set end + + def abs + return SymEngine::abs(self) + end + end end diff --git a/spec/evalf_spec.rb b/spec/evalf_spec.rb index 3f38c8e..2e3b648 100644 --- a/spec/evalf_spec.rb +++ b/spec/evalf_spec.rb @@ -2,7 +2,7 @@ context 'RealDouble values' do subject { SymEngine::evalf(SymEngine::sin(SymEngine(2)), 53, true) } it { is_expected.to be_a SymEngine::RealDouble } - its(:to_s) { is_expected.to eq "0.909297426825682" } + it { is_expected.to be_within(0.000000000000001).of(0.909297426825682) } end if SymEngine::HAVE_MPFR context 'RealMPFR values' do From 00d5633178eff29b9c71e8ab69110a017b735f5b Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Thu, 7 Jul 2016 22:51:59 +0530 Subject: [PATCH 07/10] comparisons for Number class --- ext/symengine/CMakeLists.txt | 1 + ext/symengine/ruby_number.c | 39 ++++++++++++++++++++++++++++++++++++ ext/symengine/ruby_number.h | 19 ++++++++++++++++++ ext/symengine/ruby_utils.c | 14 +++++++------ ext/symengine/symengine.c | 25 +++++++++++++++-------- ext/symengine/symengine.h | 1 + 6 files changed, 85 insertions(+), 14 deletions(-) create mode 100644 ext/symengine/ruby_number.c create mode 100644 ext/symengine/ruby_number.h diff --git a/ext/symengine/CMakeLists.txt b/ext/symengine/CMakeLists.txt index 5c85b3a..c8a47bd 100644 --- a/ext/symengine/CMakeLists.txt +++ b/ext/symengine/CMakeLists.txt @@ -1,6 +1,7 @@ set(RUBY_WRAPPER_SRC ruby_basic.c ruby_symbol.c + ruby_number.c ruby_integer.c ruby_real_double.c ruby_real_mpfr.c diff --git a/ext/symengine/ruby_number.c b/ext/symengine/ruby_number.c new file mode 100644 index 0000000..b50c455 --- /dev/null +++ b/ext/symengine/ruby_number.c @@ -0,0 +1,39 @@ +#include "ruby_number.h" + +int cnumber_comp(VALUE self, VALUE operand2) +{ + basic_struct *this; + + basic cbasic_operand2; + basic_new_stack(cbasic_operand2); + + Data_Get_Struct(self, basic_struct, this); + sympify(operand2, cbasic_operand2); + + basic_sub(operand2, this, operand2); + + int sign = basic_number_sign(operand2); + basic_free_stack(cbasic_operand2); + + return sign; +} + +VALUE cnumber_lt(VALUE self, VALUE operand2) +{ + return cnumber_comp(self, operand2) == -1 ? Qtrue : Qfalse; +} + +VALUE cbasic_gt(VALUE self, VALUE operand2) +{ + return cnumber_comp(self, operand2) == 1 ? Qtrue : Qfalse; +} + +VALUE cbasic_lt_e(VALUE self, VALUE operand2) +{ + return cnumber_comp(self, operand2) == 1 ? Qfalse : Qtrue; +} + +VALUE cbasic_gt_e(VALUE self, VALUE operand2) +{ + return cnumber_comp(self, operand2) == -1 ? Qfalse : Qtrue; +} diff --git a/ext/symengine/ruby_number.h b/ext/symengine/ruby_number.h new file mode 100644 index 0000000..7777b93 --- /dev/null +++ b/ext/symengine/ruby_number.h @@ -0,0 +1,19 @@ +#ifndef RUBY_NUMBER_H_ +#define RUBY_NUMBER_H_ + +#include +#include + +#include "symengine_utils.h" + +int cnumber_comp(VALUE self, VALUE operand2); + +VALUE cnumber_lt(VALUE self, VALUE operand2); + +VALUE cnumber_gt(VALUE self, VALUE operand2); + +VALUE cnumber_lt_e(VALUE self, VALUE operand2); + +VALUE cnumber_gt_e(VALUE self, VALUE operand2); + +#endif // RUBY_NUMBER_H_ diff --git a/ext/symengine/ruby_utils.c b/ext/symengine/ruby_utils.c index 352b73c..10adf25 100644 --- a/ext/symengine/ruby_utils.c +++ b/ext/symengine/ruby_utils.c @@ -18,17 +18,19 @@ VALUE cutils_sympify(VALUE self, VALUE operand) VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real) { VALUE result; - + basic_struct *cbasic_operand; basic_struct *cresult; cbasic_operand = basic_new_heap(); cresult = basic_new_heap(); - + sympify(operand, cbasic_operand); - basic_evalf(cresult, cbasic_operand, NUM2INT(prec), (real == Qtrue ? 1 : 0 )); - result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap, cresult); - + basic_evalf(cresult, cbasic_operand, NUM2INT(prec), + (real == Qtrue ? 1 : 0)); + result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap, + cresult); + cbasic_free_heap(cbasic_operand); - + return result; } diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c index ca29188..1abce7d 100644 --- a/ext/symengine/symengine.c +++ b/ext/symengine/symengine.c @@ -2,6 +2,7 @@ #include "ruby_basic.h" #include "ruby_symbol.h" #include "ruby_integer.h" +#include "ruby_number.h" #include "ruby_real_double.h" #include "ruby_constant.h" #include "ruby_complex.h" @@ -57,7 +58,7 @@ void Init_symengine() // Sympify as a Module Level Function rb_define_module_function(m_symengine, "convert", cutils_sympify, 1); rb_define_global_function("SymEngine", cutils_sympify, 1); - + // evalf as a Module Level Function rb_define_module_function(m_symengine, "_evalf", cutils_evalf, 3); @@ -66,30 +67,38 @@ void Init_symengine() rb_define_alloc_func(c_symbol, cbasic_alloc); rb_define_method(c_symbol, "initialize", csymbol_init, 1); + // Number class + c_number = rb_define_class_under(m_symengine, "Number", c_basic); + rb_define_alloc_func(c_number, cbasic_alloc); + rb_define_method(c_number, ">", cnumber_gt, 1); + rb_define_method(c_number, "<", cnumber_lt, 1); + rb_define_method(c_number, ">=", cnumber_gt_e, 1); + rb_define_method(c_number, "<=", cnumber_lt_e, 1); + // Integer class - c_integer = rb_define_class_under(m_symengine, "Integer", c_basic); + c_integer = rb_define_class_under(m_symengine, "Integer", c_number); rb_define_alloc_func(c_integer, cbasic_alloc); 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); + c_real_double = rb_define_class_under(m_symengine, "RealDouble", c_number); 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); + c_rational = rb_define_class_under(m_symengine, "Rational", c_number); rb_define_alloc_func(c_rational, cbasic_alloc); // Complex class - c_complex = rb_define_class_under(m_symengine, "Complex", c_basic); + c_complex = rb_define_class_under(m_symengine, "Complex", c_number); rb_define_alloc_func(c_complex, cbasic_alloc); rb_define_method(c_complex, "real", ccomplex_real_part, 0); rb_define_method(c_complex, "imaginary", ccomplex_imaginary_part, 0); // ComplexDouble class c_complex_double - = rb_define_class_under(m_symengine, "ComplexDouble", c_basic); + = rb_define_class_under(m_symengine, "ComplexDouble", c_number); 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", @@ -97,7 +106,7 @@ void Init_symengine() #ifdef HAVE_SYMENGINE_MPFR // RealMPFR class - c_real_mpfr = rb_define_class_under(m_symengine, "RealMPFR", c_basic); + c_real_mpfr = rb_define_class_under(m_symengine, "RealMPFR", c_number); 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); @@ -105,7 +114,7 @@ void Init_symengine() #ifdef HAVE_SYMENGINE_MPC // ComplexMPC class - c_complex_mpc = rb_define_class_under(m_symengine, "ComplexMPC", c_basic); + c_complex_mpc = rb_define_class_under(m_symengine, "ComplexMPC", c_number); rb_define_alloc_func(c_complex_mpc, cbasic_alloc); #endif // HAVE_SYMENGINE_MPC diff --git a/ext/symengine/symengine.h b/ext/symengine/symengine.h index 9284f61..3f7b233 100644 --- a/ext/symengine/symengine.h +++ b/ext/symengine/symengine.h @@ -10,6 +10,7 @@ VALUE m_symengine; // variable names for classes begin with c VALUE c_basic; VALUE c_symbol; +VALUE c_number; VALUE c_integer; VALUE c_real_double; VALUE c_rational; From c7ef75928526bc32cb5b2fa096392b6f6e857e27 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Thu, 7 Jul 2016 23:57:15 +0530 Subject: [PATCH 08/10] Changed spec and fixes for comparisons --- ext/symengine/ruby_number.c | 22 ++++++++++++++-------- spec/evalf_spec.rb | 10 ++++------ 2 files changed, 18 insertions(+), 14 deletions(-) diff --git a/ext/symengine/ruby_number.c b/ext/symengine/ruby_number.c index b50c455..16b8357 100644 --- a/ext/symengine/ruby_number.c +++ b/ext/symengine/ruby_number.c @@ -2,18 +2,24 @@ int cnumber_comp(VALUE self, VALUE operand2) { - basic_struct *this; - + basic cbasic_operand1; basic cbasic_operand2; + basic_new_stack(cbasic_operand1); basic_new_stack(cbasic_operand2); - Data_Get_Struct(self, basic_struct, this); + basic cbasic_sub; + basic_new_stack(cbasic_sub); + + sympify(self, cbasic_operand1); sympify(operand2, cbasic_operand2); - basic_sub(operand2, this, operand2); + basic_sub(cbasic_sub, cbasic_operand1, cbasic_operand2); + + int sign = basic_number_sign(cbasic_sub); - int sign = basic_number_sign(operand2); + basic_free_stack(cbasic_operand1); basic_free_stack(cbasic_operand2); + basic_free_stack(cbasic_sub); return sign; } @@ -23,17 +29,17 @@ VALUE cnumber_lt(VALUE self, VALUE operand2) return cnumber_comp(self, operand2) == -1 ? Qtrue : Qfalse; } -VALUE cbasic_gt(VALUE self, VALUE operand2) +VALUE cnumber_gt(VALUE self, VALUE operand2) { return cnumber_comp(self, operand2) == 1 ? Qtrue : Qfalse; } -VALUE cbasic_lt_e(VALUE self, VALUE operand2) +VALUE cnumber_lt_e(VALUE self, VALUE operand2) { return cnumber_comp(self, operand2) == 1 ? Qfalse : Qtrue; } -VALUE cbasic_gt_e(VALUE self, VALUE operand2) +VALUE cnumber_gt_e(VALUE self, VALUE operand2) { return cnumber_comp(self, operand2) == -1 ? Qfalse : Qtrue; } diff --git a/spec/evalf_spec.rb b/spec/evalf_spec.rb index 2e3b648..c92c4c5 100644 --- a/spec/evalf_spec.rb +++ b/spec/evalf_spec.rb @@ -8,22 +8,20 @@ context 'RealMPFR values' do subject { SymEngine::evalf(SymEngine::PI * SymEngine(1963319607) - SymEngine(6167950454), 100, true) } it { is_expected.to be_a SymEngine::RealMPFR } - its(:to_s) { is_expected.to eq "1.4973429143989597928099399837265e-10" } + it { is_expected.to be_within(SymEngine::RealMPFR.new(0.0000000000000000000000000000001e-10, 100)).of(SymEngine::RealMPFR.new(1.4973429143989597928099399837265e-10, 100)) } end end context 'ComplexDouble values' do subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 53, false) } - it { is_expected.to be_a SymEngine::ComplexDouble } - its(:to_s) { is_expected.to eq "0.0 + 0.841470984807897*I" } + it { is_expected.to be_a SymEngine::ComplexDouble } + its(:imaginary) { is_expected.to be_within(0.000000000000001).of(0.841470984807897) } end - context 'ComplexMPC values' do - end if SymEngine::HAVE_MPC context 'ComplexMPC values' do subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 100, false) } it { is_expected.to be_a SymEngine::ComplexMPC } - its(:to_s) { is_expected.to eq "0.00000000000000000000000000000000 + 0.84147098480789650665250232163005*I" } + its(:imaginary) { is_expected.to be_within(SymEngine::RealMPFR.new(0.00000000000000000000000000000001, 100)).of(SymEngine::RealMPFR.new(0.84147098480789650665250232163005, 100)) } end end end From 01d3743c92884151aee7cff3b959ebb33823c282 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Fri, 8 Jul 2016 15:40:15 +0530 Subject: [PATCH 09/10] ComplexMPC imaginary and real methods, evalf tests --- ext/symengine/CMakeLists.txt | 1 + ext/symengine/ruby_complex_mpc.c | 13 +++++++++++++ ext/symengine/ruby_complex_mpc.h | 15 +++++++++++++++ ext/symengine/ruby_number.c | 5 +++++ ext/symengine/symengine.c | 4 ++++ spec/evalf_spec.rb | 8 ++++---- 6 files changed, 42 insertions(+), 4 deletions(-) create mode 100644 ext/symengine/ruby_complex_mpc.c create mode 100644 ext/symengine/ruby_complex_mpc.h diff --git a/ext/symengine/CMakeLists.txt b/ext/symengine/CMakeLists.txt index c8a47bd..2fe3b65 100644 --- a/ext/symengine/CMakeLists.txt +++ b/ext/symengine/CMakeLists.txt @@ -7,6 +7,7 @@ set(RUBY_WRAPPER_SRC ruby_real_mpfr.c ruby_complex.c ruby_complex_double.c + ruby_complex_mpc.c ruby_constant.c ruby_function.c ruby_ntheory.c diff --git a/ext/symengine/ruby_complex_mpc.c b/ext/symengine/ruby_complex_mpc.c new file mode 100644 index 0000000..6ddfc98 --- /dev/null +++ b/ext/symengine/ruby_complex_mpc.c @@ -0,0 +1,13 @@ +#include "ruby_complex_mpc.h" + +#ifdef HAVE_SYMENGINE_MPC +VALUE ccomplex_mpc_real_part(VALUE self) +{ + return function_onearg(complex_mpc_real_part, self); +} + +VALUE ccomplex_mpc_imaginary_part(VALUE self) +{ + return function_onearg(complex_mpc_imaginary_part, self); +} +#endif // HAVE_SYMENGINE_MPC diff --git a/ext/symengine/ruby_complex_mpc.h b/ext/symengine/ruby_complex_mpc.h new file mode 100644 index 0000000..4f79b0d --- /dev/null +++ b/ext/symengine/ruby_complex_mpc.h @@ -0,0 +1,15 @@ +#ifndef RUBY_COMPLEX_MPC_H_ +#define RUBY_COMPLEX_MPC_H_ + +#include +#include + +#include "symengine.h" +#include "symengine_utils.h" + +#ifdef HAVE_SYMENGINE_MPC +VALUE ccomplex_mpc_real_part(VALUE self); +VALUE ccomplex_mpc_imaginary_part(VALUE self); +#endif // HAVE_SYMENGINE_MPC + +#endif // RUBY_COMPLEX_MPC_H_ diff --git a/ext/symengine/ruby_number.c b/ext/symengine/ruby_number.c index 16b8357..e2912fa 100644 --- a/ext/symengine/ruby_number.c +++ b/ext/symengine/ruby_number.c @@ -13,6 +13,11 @@ int cnumber_comp(VALUE self, VALUE operand2) sympify(self, cbasic_operand1); sympify(operand2, cbasic_operand2); + if (is_a_Number(cbasic_operand2) == 0) { + rb_raise(rb_eTypeError, "Expected SymEngine::Number found %s ", + rb_obj_classname(operand2)); + } + basic_sub(cbasic_sub, cbasic_operand1, cbasic_operand2); int sign = basic_number_sign(cbasic_sub); diff --git a/ext/symengine/symengine.c b/ext/symengine/symengine.c index 1abce7d..11af6a9 100644 --- a/ext/symengine/symengine.c +++ b/ext/symengine/symengine.c @@ -7,6 +7,7 @@ #include "ruby_constant.h" #include "ruby_complex.h" #include "ruby_complex_double.h" +#include "ruby_complex_mpc.h" #include "ruby_real_mpfr.h" #include "ruby_function.h" #include "ruby_ntheory.h" @@ -116,6 +117,9 @@ void Init_symengine() // ComplexMPC class c_complex_mpc = rb_define_class_under(m_symengine, "ComplexMPC", c_number); rb_define_alloc_func(c_complex_mpc, cbasic_alloc); + rb_define_method(c_complex_mpc, "real", ccomplex_mpc_real_part, 0); + rb_define_method(c_complex_mpc, "imaginary", ccomplex_mpc_imaginary_part, + 0); #endif // HAVE_SYMENGINE_MPC // Constant class diff --git a/spec/evalf_spec.rb b/spec/evalf_spec.rb index c92c4c5..c833165 100644 --- a/spec/evalf_spec.rb +++ b/spec/evalf_spec.rb @@ -2,26 +2,26 @@ context 'RealDouble values' do subject { SymEngine::evalf(SymEngine::sin(SymEngine(2)), 53, true) } it { is_expected.to be_a SymEngine::RealDouble } - it { is_expected.to be_within(0.000000000000001).of(0.909297426825682) } + it { is_expected.to be_within(1e-15).of(0.909297426825682) } end if SymEngine::HAVE_MPFR context 'RealMPFR values' do subject { SymEngine::evalf(SymEngine::PI * SymEngine(1963319607) - SymEngine(6167950454), 100, true) } it { is_expected.to be_a SymEngine::RealMPFR } - it { is_expected.to be_within(SymEngine::RealMPFR.new(0.0000000000000000000000000000001e-10, 100)).of(SymEngine::RealMPFR.new(1.4973429143989597928099399837265e-10, 100)) } + it { is_expected.to be_within(SymEngine::RealMPFR.new("1e-41", 100)).of(SymEngine::RealMPFR.new("1.4973429143989597928099399837265e-10", 100)) } end end context 'ComplexDouble values' do subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 53, false) } it { is_expected.to be_a SymEngine::ComplexDouble } - its(:imaginary) { is_expected.to be_within(0.000000000000001).of(0.841470984807897) } + its(:imaginary) { is_expected.to be_within(1e-15).of(0.841470984807897) } end if SymEngine::HAVE_MPC context 'ComplexMPC values' do subject { SymEngine::evalf(SymEngine::sin(1) * SymEngine::I, 100, false) } it { is_expected.to be_a SymEngine::ComplexMPC } - its(:imaginary) { is_expected.to be_within(SymEngine::RealMPFR.new(0.00000000000000000000000000000001, 100)).of(SymEngine::RealMPFR.new(0.84147098480789650665250232163005, 100)) } + its(:imaginary) { is_expected.to be_within(SymEngine::RealMPFR.new("1e-32", 100)).of(SymEngine::RealMPFR.new("0.84147098480789650665250232163005", 100)) } end end end From 9e2be3f6afa49e57104cc5b72879f44f02838721 Mon Sep 17 00:00:00 2001 From: Rajith Vidanaarachchi Date: Fri, 8 Jul 2016 20:00:08 +0530 Subject: [PATCH 10/10] Updated symengine version --- symengine_version.txt | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/symengine_version.txt b/symengine_version.txt index 0082d95..6e61f5d 100644 --- a/symengine_version.txt +++ b/symengine_version.txt @@ -1 +1 @@ -59e17e37dd0f3441fcce5ebd18026ee4c3d4844d +bb18f1c1f4cbc29765fe1bcbd2dbe9345279b659