Merge branch 'master' of https://github.com/symengine/symengine.rb into exception

Author: rajithv

ext/symengine/ruby_basic.c

@@ -23,7 +23,7 @@ VALUE cbasic_binary_op(VALUE self, VALUE operand2,
                                          const basic_struct *))
 {
     basic_struct *this, *cresult;
-    VALUE result;
+    VALUE result = Qnil;
 
     basic cbasic_operand2;
     basic_new_stack(cbasic_operand2);
@@ -38,18 +38,18 @@ VALUE cbasic_binary_op(VALUE self, VALUE operand2,
         result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL,
                                   cbasic_free_heap, cresult);
         basic_free_stack(cbasic_operand2);
-        return result;
     } else {
         basic_free_stack(cbasic_operand2);
         raise_exception(error_code);
     }
+    return result;
 }
 
 VALUE cbasic_unary_op(VALUE self,
                       int (*cwfunc_ptr)(basic_struct *, const basic_struct *))
 {
     basic_struct *this, *cresult;
-    VALUE result;
+    VALUE result = Qnil;
 
     Data_Get_Struct(self, basic_struct, this);
 
@@ -59,10 +59,10 @@ VALUE cbasic_unary_op(VALUE self,
     if (error_code == 0) {
         result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL,
                                   cbasic_free_heap, cresult);
-        return result;
     } else {
         raise_exception(error_code);
     }
+    return result;
 }
 
 VALUE cbasic_add(VALUE self, VALUE operand2)

ext/symengine/ruby_utils.c

@@ -17,7 +17,7 @@ VALUE cutils_sympify(VALUE self, VALUE operand)
 
 VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real)
 {
-    VALUE result;
+    VALUE result = Qnil;
 
     basic_struct *cresult;
     cresult = basic_new_heap();
@@ -29,8 +29,8 @@ VALUE cutils_evalf(VALUE self, VALUE operand, VALUE prec, VALUE real)
     if (error_code == 0) {
         result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL,
                                   cbasic_free_heap, cresult);
-        return result;
     } else {
         raise_exception(error_code);
     }
+    return result;
 }

ext/symengine/symengine_utils.c

@@ -256,7 +256,7 @@ VALUE function_twoarg(int (*cwfunc_ptr)(basic_struct *, const basic_struct *,
 
 void raise_exception(int error_code)
 {
-    char *str;
+    char *str = "";
     switch (error_code) {
         case -1:
             str = "Runtime Error";
@@ -265,5 +265,5 @@ void raise_exception(int error_code)
             str = "Division by Zero";
             break;
     }
-    rb_raise(rb_eRuntimeError, str);
+    rb_raise(rb_eRuntimeError, "%s", str);
 }

lib/symengine.rb

@@ -1,3 +1,5 @@
+require 'backports'
+
 module SymEngine
   class << self
     # Defines a shortcut for SymEngine::Symbol.new() allowing multiple symbols
@@ -28,10 +30,42 @@ def symbols ary_or_string, *params
       end
     end    
     def Function(n)
-      return SymEngine::UndefFunction.new(n)
+      SymEngine::UndefFunction.new(n)
     end
     def evalf(operand, prec=53, real=false)
-        return _evalf(operand, prec, real)
+      _evalf(operand, prec, real)
+    end
+    def lambdify(exp, *syms)
+      syms.flatten!
+      if exp.free_symbols.count > syms.length
+        raise ArgumentError, "Formula contains #{exp.free_symbols.count} free "\
+                             "symbols. You should provide at least this number "\
+                             "of arguments (only #{syms.length} given)."
+      end
+      eval(SymEngine::Utils::lambdify_code(exp, syms))
+    end
+  end
+  module Utils
+    class << self
+      REPLACEMENTS = { sin: 'Math.sin', cos: 'Math.cos', tan: 'Math.tan',
+                         asin: 'Math.asin', acos: 'Math.acos', atan: 'Math.atan',
+                         sinh: 'Math.sinh', cosh: 'Math.cosh', tanh: 'Math.tanh',
+                         asinh: 'Math.asinh', acosh: 'Math.acosh', atanh: 'Math.atanh', 
+                         pi: 'Math::PI', E: 'Math::E', I: '::Complex::I',
+                         dirichlet_eta: 'SymEngine::Utils::evalf_dirichlet_eta',
+                         zeta: 'SymEngine::Utils::evalf_zeta', gamma: 'Math.gamma' }.map { |from, to| [/(\b#{from}\b)/, to] }.to_h.freeze
+      def evalf_dirichlet_eta(exp)
+        SymEngine::evalf(SymEngine::dirichlet_eta(exp))
+      end
+      def evalf_zeta(exp)
+          SymEngine::evalf(SymEngine::zeta(exp))
+      end
+      def lambdify_code(exp, syms)
+        body = exp.to_s.gsub(/[\d\.]+/, 'Rational(\0,1)')
+        sym_map = syms.join(",")
+        rubified_body = REPLACEMENTS.inject(body) { |res, (from, to)| res.gsub(from, to)}
+        "proc { | #{sym_map} | #{rubified_body} }"
+      end
     end
   end
 end

lib/symengine/basic.rb

@@ -11,8 +11,25 @@ def free_symbols
     end
 
     def abs
-        return SymEngine::abs(self)
+      SymEngine::abs(self)
+    end
+    def to_proc(*args)
+      if args.empty?
+        if free_symbols.count > 1
+          raise ArgumentError, "You should provide symbols order for #to_proc"\
+                               ". Only formulae with 1 free symbol can deduce"\
+                               " its name automatically (#{free_symbols.count}"\
+                               " found in #{self})."
+        end
+        SymEngine::lambdify(self, free_symbols.map {|s| s})
+      else
+        if free_symbols.count > args.length
+          raise ArgumentError, "Formula contains #{free_symbols.count} free "\
+                               "symbols. You should provide at least this number "\
+                               "of arguments (only #{args.length} given)."
+        end
+        SymEngine::lambdify(self, args)
+      end
     end
-    
   end
 end

spec/lambdify_spec.rb

@@ -0,0 +1,84 @@
+describe 'SymEngine::lambdify_code' do
+  
+  let(:x) { SymEngine::Symbol.new('x') }
+  let(:y) { SymEngine::Symbol.new('y') }
+  let(:z) { SymEngine::Symbol.new('z') }
+  
+  def l(code)
+    SymEngine::Utils::lambdify_code(code, [x])
+  end
+  
+  it 'creates lambda codes' do
+    expect(SymEngine::Utils::lambdify_code( x + y + z, [x, y, z])).to eq("proc { | x,y,z | x + y + z }")
+    expect(l( x + 5 )).to eq("proc { | x | Rational(5,1) + x }")
+    expect(l( SymEngine::sin(x) )).to eq("proc { | x | Math.sin(x) }")
+    expect(l( SymEngine::cos(x) )).to eq("proc { | x | Math.cos(x) }")
+    expect(l( SymEngine::tan(x) )).to eq("proc { | x | Math.tan(x) }")
+    expect(l( SymEngine::asin(x) )).to eq("proc { | x | Math.asin(x) }")
+    expect(l( SymEngine::acos(x) )).to eq("proc { | x | Math.acos(x) }")
+    expect(l( SymEngine::atan(x) )).to eq("proc { | x | Math.atan(x) }")
+    expect(l( SymEngine::sinh(x) )).to eq("proc { | x | Math.sinh(x) }")
+    expect(l( SymEngine::cosh(x) )).to eq("proc { | x | Math.cosh(x) }")
+    expect(l( SymEngine::tanh(x) )).to eq("proc { | x | Math.tanh(x) }")
+    expect(l( SymEngine::asinh(x) )).to eq("proc { | x | Math.asinh(x) }")
+    expect(l( SymEngine::acosh(x) )).to eq("proc { | x | Math.acosh(x) }")
+    expect(l( SymEngine::atanh(x) )).to eq("proc { | x | Math.atanh(x) }")
+    expect(l( SymEngine::gamma(x) )).to eq("proc { | x | Math.gamma(x) }")
+    expect(l( x + SymEngine::PI )).to eq("proc { | x | x + Math::PI }")
+    expect(l( x + SymEngine::E )).to eq("proc { | x | x + Math::E }")
+    expect(l( x * SymEngine::I )).to eq("proc { | x | ::Complex::I*x }")
+    expect(l( SymEngine::dirichlet_eta(x) )).to eq("proc { | x | SymEngine::Utils::evalf_dirichlet_eta(x) }")
+    expect(l( SymEngine::zeta(x) )).to eq("proc { | x | SymEngine::Utils::evalf_zeta(x, Rational(1,1)) }")
+    
+    
+  end
+end
+
+describe 'SymEngine::lambdify' do  
+
+  let(:x) { SymEngine::Symbol.new('x') }
+  let(:y) { SymEngine::Symbol.new('y') }
+  let(:z) { SymEngine::Symbol.new('z') }
+  
+  describe 'lambda for Addition' do
+    let(:func) { x + y + z }
+    let(:lamb) { SymEngine::lambdify(func, x, y, z) }
+    it 'performs addition with a lambda function' do
+      expect(lamb.call(1, 1, 1)).to eq(3)
+      expect(lamb.call(1, -1, 1)).to eq(1)
+      expect(lamb.call(-1, -1, -1)).to eq(-3)
+    end
+  end
+  
+  describe 'lambda for Addition with FixNums' do
+    let(:func) { x + 5}
+    let(:lamb) { SymEngine::lambdify(func, [x]) }
+    it 'performs addition with a lambda function' do
+      expect(lamb.call(1)).to eq(6)
+      expect(lamb.call(0)).to eq(5)
+      expect(lamb.call(-1)).to eq(4)
+      expect(lamb.call(Math::PI)).to be_within(1e-15).of(8.141592653589793)
+    end
+  end
+  
+  describe 'lambda for sin' do
+    let(:func) { SymEngine::sin(x) }
+    let(:lamb) { SymEngine::lambdify(func, [x]) }
+    it 'performs sin calculation with a lambda function' do
+      expect(lamb.call(0)).to be_within(1e-15).of(0.0)
+      expect(lamb.call(Math::PI)).to be_within(1e-15).of(0.0)
+      expect(lamb.call(Math::PI/2)).to be_within(1e-15).of(1.0)
+    end
+  end
+  
+  describe 'to_proc' do
+    let(:func) { x * 10 }
+    let(:func2) { x + y + 10}
+    it 'creates procs' do
+      expect([1, 2, 3, 4, 5].map(&func)).to eq([10, 20, 30, 40, 50])
+      expect { [[1, 2], [3, 4]].map(&func2) }.to raise_error(ArgumentError)
+      expect([[1, 2], [3, 4]].map(&func2.to_proc(x, y))).to eq([13, 17])
+   end
+  end
+  
+end

symengine.gemspec

@@ -16,4 +16,5 @@ Gem::Specification.new do |gem|
     gem.add_development_dependency 'rspec', '~> 3.0'
     gem.add_development_dependency 'rspec-its'
     gem.add_development_dependency 'rdoc', '~> 4.0'
+    gem.add_runtime_dependency 'backports'
 end