symengine 0.0.1 → 0.0.2

data/ext/symengine/symengine.h

@@ -0,0 +1,15 @@
+#ifndef SYMENGINE_H_
+#define SYMENGINE_H_
+
+#include "ruby.h"
+
+//variable name for a module starts with m
+VALUE m_symengine;
+
+//variable names for classes begin with c
+VALUE c_basic;
+VALUE c_symbol;
+VALUE c_integer;
+VALUE c_rational;
+
+#endif //SYMENGINE_H_

data/ext/symengine/symengine_macros.c

@@ -0,0 +1,49 @@
+#include "symengine_macros.h"
+#include "symengine.h"
+
+void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
+    basic_struct *temp;
+    VALUE new_operand2, num, den;
+
+    switch(TYPE(operand2)) {
+        case T_FIXNUM:
+        case T_BIGNUM:
+            GET_SYMINTFROMVAL(operand2, cbasic_operand2);
+            break;
+
+        case T_RATIONAL:
+            num = rb_funcall(operand2, rb_intern("numerator"), 0, NULL);
+            den = 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);
+
+            rational_set(cbasic_operand2, num_basic, den_basic);
+
+            basic_free_stack(num_basic);
+            basic_free_stack(den_basic);
+            break;
+
+        case T_DATA:
+            Data_Get_Struct(operand2, basic_struct, temp);
+            basic_assign(cbasic_operand2, temp);
+            break;
+    }
+}
+
+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_RATIONAL:
+            return c_rational;
+        default:
+            return c_basic;
+    }
+}

data/ext/symengine/symengine_macros.h

@@ -0,0 +1,21 @@
+#ifndef SYMENGINE_MACROS_H_
+#define SYMENGINE_MACROS_H_
+
+#include "ruby.h"
+#include "symengine/cwrapper.h"
+
+//Returns the pointer wrapped inside the Ruby VALUE
+void sympify(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);
+
+//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_

data/spec/arit_spec.rb

@@ -0,0 +1,146 @@
+require 'spec_helper'
+
+describe 'Arithmetic test cases' do
+  before :each do
+  end
+
+  it 'test_arit1' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    e = x + y
+    e = x * y
+    e = SymEngine::Integer.new(2) * x
+    e = 2 * x
+    e = x + 1
+    e = 1 + x
+  end
+
+  it 'test_arit2' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert x + x == SymEngine::Integer.new(2) * x
+    assert x + x != SymEngine::Integer.new(3) * x
+    assert x + y == y + x
+    assert x + x == 2 * x
+    assert x + x == x * 2
+    assert x + x + x == 3 * x
+    assert x + y + x + x == 3 * x + y
+
+    assert(!(x + x == 3 * x))
+    assert(!(x + x != 2 * x))
+  end
+
+  it 'test_arit3' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    expect do
+      ('x' * x)
+    end.to raise_error(TypeError)
+  end
+
+  it 'test_arit4' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert x * x == x**2
+    assert x * y == y * x
+    assert x * x * x == x**3
+    assert x * y * x * x == x**3 * y
+  end
+
+  it 'test_arit5' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    e = (x + y)**2
+    f = e.expand
+    assert e == (x + y)**2
+    assert e != x**2 + 2 * x * y + y**2
+    expect(e).to be_an_instance_of SymEngine::Basic
+    assert f == x**2 + 2 * x * y + y**2
+    expect(f).to be_an_instance_of SymEngine::Basic
+  end
+
+  it 'test_arit6' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    e = x + y
+    assert(e.to_s == 'x + y') || 'y + x'
+    e = x * y
+    assert(e.to_s == 'x*y') || 'y*x'
+    e = Integer(2) * x
+    assert e.to_s == '2*x'
+    e = 2 * x
+    assert e.to_s == '2*x'
+  end
+
+  it 'test_arit7' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert x - x == 0
+    assert x - y != y - x
+    assert 2 * x - x == x
+    assert 3 * x - x == 2 * x
+
+    assert 2 * x * y - x * y == x * y
+  end
+
+  it 'test_arit8' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    z = SymEngine::Symbol.new('z')
+    assert x**y * x**x == x**(x + y)
+    assert x**y * x**x * x**z == x**(x + y + z)
+    assert x**y - x**y == 0
+
+    assert x**2 / x == x
+    assert y * x**2 / (x * y) == x
+    assert (2 * x**3 * y**2 * z)**3 / 8 == x**9 * y**6 * z**3
+    assert (2 * y**(-2 * x**2)) * (3 * y**(2 * x**2)) == 6
+  end
+
+  it 'test_expand1' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    z = SymEngine::Symbol.new('z')
+    assert ((2 * x + y)**2).expand == 4 * x**2 + 4 * x * y + y**2
+    assert (x**2)**3 == x**6
+    assert ((2 * x**2 + 3 * y)**2).expand == 4 * x**4 + 12 * x**2 * y + 9 * y**2
+    assert ((2 * x / 3 + y / 4)**2).expand == 4 * x**2 / 9 + x * y / 3 + y**2 / 16
+  end
+
+  it 'test_arit9' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert 1 / x == 1 / x
+    assert 1 / x != 1 / y
+  end
+
+  it 'test_expand2' do
+    y = SymEngine::Symbol.new('y')
+    z = SymEngine::Symbol.new('z')
+    assert ((1 / (y * z) - y * z) * y * z).expand == 1 - (y * z)**2
+  end
+
+  it 'test_expand3' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert ((1 / (x * y) - x * y + 2) * (1 + x * y)).expand == 3 + 1 / (x * y) + x * y - (x * y)**2
+  end
+
+  it 'test_args' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    assert (x**2).args == [x, 2]
+    assert (x**2 + 5).args == [5, x**2]
+    assert (x**2 + 2 * x * y + 5).args == [5, 2 * x * y, x**2]
+    assert (2 * x**2).args == [2, x**2]
+    assert (2 * x**2 * y).args == [2, x**2, y]
+  end
+
+  it 'test_free_Symbols' do
+    x = SymEngine::Symbol.new('x')
+    y = SymEngine::Symbol.new('y')
+    z = SymEngine::Symbol.new('z')
+    assert (x**2).free_symbols == Set.new([x])
+    assert (x**y + z).free_symbols == Set.new([x, y, z])
+  end
+end

data/spec/basic_spec.rb

@@ -0,0 +1,217 @@
+require 'spec_helper'
+
+describe SymEngine do
+  before :each do
+  end
+
+  describe SymEngine::Basic do
+    before :each do
+    end
+
+    describe '.new' do
+      context 'with no arguments' do
+        it 'returns a Basic object' do
+          basic = SymEngine::Basic.new
+          expect(basic).to be_an_instance_of SymEngine::Basic
+        end
+      end
+    end
+
+    describe 'binary operations' do
+      before :each do
+        @a = SymEngine::Symbol.new('x')
+        @b = SymEngine::Symbol.new('y')
+      end
+      describe '#+' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns a initialised Basic object that is result of
+                        self added to the argument' do
+            c = @a + @b
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c.to_s).to eql('x + y')
+          end
+        end
+      end
+      describe '#-' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns a initialised Basic object that is result of
+                        argument subtracted from self' do
+            c = @a - @b
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c.to_s).to eql('x - y')
+          end
+        end
+      end
+      describe '#*' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns a initialised Basic object that is result of
+                        self multiplied by the argument' do
+            c = @a * @b
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c.to_s).to eql('x*y')
+          end
+        end
+      end
+      describe '#/' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns a initialised Basic object that is result of
+                        self divided by the argument' do
+            c = @a / @b
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c.to_s).to eql('x/y')
+          end
+        end
+      end
+      describe '#**' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns a initialised Basic object that is result of
+                        self raised to the power of argument' do
+            c = @a**@b
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c.to_s).to eql('x**y')
+          end
+        end
+      end
+      describe '#diff' do
+        context 'with another initialised Basic object as argument' do
+          it 'differentiates self with respect to the argument
+              and returns the result' do
+            a = @a**3
+            c = a.diff(@a)
+            expect(c).to be_an_instance_of SymEngine::Basic
+            expect(c).to eq(3 * @a**2)
+            expect(a.diff(2)).to be_nil
+          end
+        end
+      end
+      describe '#==' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns true if they are the same expression
+                        false if not' do
+            a = SymEngine::Symbol.new('x')
+            b = SymEngine::Symbol.new('y')
+            c = ((a * b) == (@a * @b))
+            expect(c).to be true
+          end
+        end
+      end
+      describe '#eql?' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns true if they are the same expression
+                        false if not' do
+            a = SymEngine::Symbol.new('x')
+            b = SymEngine::Symbol.new('y')
+            c = ((a * b).eql?(@a * @b))
+            expect(c).to be true
+          end
+        end
+      end
+      describe '#!=' do
+        context 'with another initialised Basic object as argument' do
+          it 'returns true is they are not the same expression
+                        false if they are' do |_variable|
+            a = SymEngine::Symbol.new('x')
+            b = SymEngine::Symbol.new('y')
+            c = ((a * b) != (@a * @b))
+            expect(c).to be false
+          end
+        end
+      end
+    end
+
+    describe 'unary operations' do
+      before :each do
+        @x = SymEngine::Symbol.new('a')
+      end
+      describe '#-@' do
+        context "doesn't take any argument" do
+          it 'returns the negation of self' do
+            p = -@x
+            expect(p).to be_an_instance_of SymEngine::Basic
+            expect(p.to_s).to eql('-a')
+          end
+        end
+      end
+    end
+
+    describe '#args' do
+      context 'with nothing as argument' do
+        it 'returns array of arguments' do
+          x = SymEngine::Symbol.new('x')
+          y = SymEngine::Symbol.new('y')
+          z = SymEngine::Symbol.new('z')
+          e = (x**y + z)
+          f = e.args
+          expect(f).to be_an_instance_of Array
+          expect(f.length).to be 2
+          expect(f.to_set).to eql([x**y, z].to_set)
+        end
+      end
+    end
+
+    describe '#free_symbols' do
+      context 'with nothing as argument' do
+        it 'returns the set of symbols' do
+          x = SymEngine::Symbol.new('x')
+          y = SymEngine::Symbol.new('y')
+          z = SymEngine::Symbol.new('z')
+          e = (x**y / z)
+          f = e.free_symbols
+          expect(f).to be_an_instance_of Set
+          expect(f.length).to be 3
+          expect(f).to eql([x, y, z].to_set)
+        end
+      end
+    end
+
+    describe '#expand' do
+      context 'with nothing as argument' do
+        it 'returns the expanded form' do
+          x = SymEngine::Symbol.new('x')
+          y = SymEngine::Symbol.new('y')
+          z = SymEngine::Symbol.new('z')
+          e = (x + y + z) * (x + y + z)
+          f = e.expand
+          expect(e.to_s).to eql('(x + y + z)**2')
+          expect(f).to be_an_instance_of SymEngine::Basic
+          expect(f.to_s).to eql('2*x*y + 2*x*z + 2*y*z + x**2 + y**2 + z**2')
+          expect(e == f).to be false
+        end
+      end
+    end
+
+    describe '#subs' do
+      before :each do
+        @x = SymEngine::Symbol.new('x')
+        @y = SymEngine::Symbol.new('y')
+        @z = SymEngine::Symbol.new('z')
+        @e = @x + @y + @z
+      end
+
+      context 'with two basic objects as argument' do
+        it 'returns the expression with first
+            substituted with second in self' do
+          expect(@e.subs(@x, @y)).to eql(2 * @y + @z)
+        end
+      end
+
+      context 'with a Hash as argument' do
+        it 'returns the expression with
+            each key subtituted with its mapped value' do
+          expect(@e.subs(@x => @y, @z => @y)).to eql(3 * @y)
+          k = SymEngine::Symbol.new('k')
+          e = @e.subs(@x => k, @y => k / 2, @z => 2 * k)
+          expect(e).to eql((7 * k) / 2)
+        end
+      end
+
+      context ' with less than one or more than two or wrong argument' do
+        it 'raises errors' do
+          expect { @e.subs }.to raise_error(ArgumentError)
+          expect { @e.subs(@x, @y, @z) }.to raise_error(ArgumentError)
+          expect { @e.subs(@x) }.to raise_error(TypeError)
+        end
+      end
+    end
+  end
+end