symengine 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e07b59a3ec9f3d16e63d9479290a8b4480ee721c
+  data.tar.gz: cfefed3f9860bad0a2a078968699c391d18df4d5
+SHA512:
+  metadata.gz: 38311d6fb31cd3c4fbc01223c7e39bb75e2fdfdb1d4e9501d76fb70e09f4e77cefa86f6c355a2abc4b54a6db13f18c8a7b3d67569f3b582d73decb16f8c2b146
+  data.tar.gz: 5486a9ad6d3fa9f7cb25ea49b2b89b7a6aff0174da7bf3259c8ddcc29a31a6ef5dd39de7e59b9f4d3ece7533d4ac5b0fbea01517ec07e535e9dd0c0a83705f3a

data/CMakeLists.txt

@@ -0,0 +1,15 @@
+cmake_minimum_required(VERSION 2.8)
+project(ruby_wrapper)
+
+set(CMAKE_PREFIX_PATH ${SymEngine_DIR} ${CMAKE_PREFIX_PATH})
+find_package(SymEngine 0.1.0 REQUIRED CONFIG
+             PATH_SUFFIXES lib/cmake/symengine CMake/)
+set(CMAKE_BUILD_TYPE ${SYMENGINE_BUILD_TYPE})
+set(CMAKE_CXX_FLAGS_RELEASE ${SYMENGINE_CXX_FLAGS_RELEASE})
+set(CMAKE_CXX_FLAGS_DEBUG ${SYMENGINE_CXX_FLAGS_DEBUG})
+include_directories(${SYMENGINE_INCLUDE_DIRS})
+
+set(CMAKE_MODULE_PATH ${CMAKE_MODULE_PATH} "${CMAKE_CURRENT_SOURCE_DIR}/cmake/")
+find_package(Ruby REQUIRED)
+
+add_subdirectory(ext/symengine)

data/LICENSE

@@ -0,0 +1,20 @@
+Copyright (c) 2015 SymEngine Development Team
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
+

data/README.md

@@ -0,0 +1,55 @@
+## SymEngine Ruby Wrappers
+
+Ruby wrappers gem for SymEngine, a fast symbolic manipulation library, written in C++. https://github.com/sympy/symengine
+
+### Installation
+
+#### Prerequisites
+
+- C++ compiler        - See supported [compilers](https://github.com/sympy/symengine/wiki/Compiler-Support)
+
+- CMake               - with executable folder in the `PATH` variable
+
+- libsymengine        - See build [instructions](https://github.com/sympy/symengine/wiki/Building-SymEngine)
+
+#### Installing
+
+- Simply do,
+
+        gem install symengine
+
+- If `libsymengine` is not found, you can give the installation directory or build directory by doing,
+
+        gem install symengine -- -DSymEngine_DIR=/path/to/symengine/root
+
+### Development
+* Install bundler by `gem install bundler`
+* Execute `bundle install` this will install the gems required
+* Build the gem, `gem build symengine.gemspec`
+* Install the gem, `gem install symengine-0.0.0.gem`
+
+### Using the extensions
+SymEngine is a module in the extensions, and the classes are a part of it. So
+first you fire up the interpreter and load the file
+``` ruby
+~$ irb
+2.2.0 :001 > require 'symengine'
+ => true
+
+```
+Go ahead and try a function
+``` ruby
+2.2.0 :002 > SymEngine.ascii_art
+
+ _____           _____         _
+|   __|_ _ _____|   __|___ ___|_|___ ___
+|__   | | |     |   __|   | . | |   | -_|
+|_____|_  |_|_|_|_____|_|_|_  |_|_|_|___|
+      |___|               |___|
+ => nil
+```
+or create a variable
+``` ruby
+2.2.0 :003 > basic = SymEngine::Symbol.new("x")
+=> #<SymEngine::Symbol:0x0000000274d608>
+```

data/bin/callgrind_test.sh

@@ -0,0 +1,34 @@
+#!/bin/bash
+
+# Note: use this script from the root dir of the ruby wrappers gem as
+# your current dir.
+
+# Callgrind is a profiling tool that records the call history among functions
+# in a program's run as a call-graph. By default, the collected data consists
+# of the number of instructions executed, their relationship to source lines,
+# the caller/callee relationship between functions, and the numbers of such
+# calls.
+
+#--tool=callgrind: ask valgrind to use callgrind profiler plugin
+#--dump-instr=yes: specifies that event counting should be performed at per-instruction
+#                   granularity. This allows for assembly code annotation. The results can
+#                   only be displayed by KCachegrind.
+#--simulate-cache=yes: runs with cache simulation
+#--collect-jumps=yes: specifies whether information for (conditional) jumps should be
+#                   collected. You have to use KCachegrind to get jump arrows in the
+#                   annotated code.
+valgrind \
+    --tool=callgrind \
+    --dump-instr=yes \
+    --simulate-cache=yes \
+    --collect-jumps=yes \
+    ruby -S rspec spec
+
+# After program termination, a profile data file named callgrind.out.<pid> is generated,
+# where pid is the process ID of the program being profiled. The data file contains
+# information about the calls made in the program among the functions executed
+
+# To generate a function-by-function summary, use
+# `callfrind_annotate callgrind.out.<pid>`
+# or use Kcachegrind, the Call Graph Viewer.
+# documentation: http://kcachegrind.sourceforge.net/html/Documentation.html

data/bin/gdb.sh

@@ -0,0 +1,10 @@
+#!/bin/bash
+
+# Note: use this script from the root dir of the ruby wrappers gem as
+# your current dir.
+
+if [[ "$1" == "--help" || "$1" == "-h" || "$1" == "" ]]; then
+    echo "bin/gdb.sh [file-name you want to run with rspec]"
+    exit 0
+fi
+gdb -ex=r --args ruby -S rspec $1

data/bin/valgrind_test.sh

@@ -0,0 +1,31 @@
+#!/bin/bash
+
+# Note: use this script from the root dir of the ruby wrappers gem as
+# your current dir.
+
+# Memcheck is a memory error detector which can detect problems like
+# accessing memory you shouldn't, using undefined values, incorrect
+# freeing of heap memory, overlapping source and destination pointers
+# in `memcpy` and related functions, memory leaks, etc.
+
+# --tool=memcheck: specifies that memcheck is the tool to be used
+# --num-callers=15: specifies the amount of stack-trace to show. Can be
+#                   set to larger values if the stack trace is not big
+#                   enough
+# partial-loads-ok and undef-value-errors are necessary to ignore
+# spurious (and eminently ignorable) warnings from the ruby
+# interpreter. The MRI does a lot of funky things in the name of speed,
+# like using uninitialized variables and reading past the ends of
+# malloced blocks that aren't on an 8-byte boundary. For advanced info:
+# http://valgrind.org/docs/manual/manual-core.html#manual-core.suppress
+valgrind \
+    --tool=memcheck \
+    --num-callers=15 \
+    --partial-loads-ok=yes \
+    --undef-value-errors=no \
+    ruby -S rspec spec
+
+# additional options like `--leak-check=full` can be used if needed.
+# If --leak-check=full is specified, Memcheck will give details for
+# each definitely lost or possibly lost block, including where it was
+# allocated.

data/ext/symengine/CMakeLists.txt

@@ -0,0 +1,25 @@
+set(RUBY_WRAPPER_SRC
+    ruby_basic.c
+    ruby_symbol.c
+    ruby_integer.c
+    ruby_rational.c
+    symengine_macros.c
+    symengine.c
+    )
+
+include_directories(BEFORE ${RUBY_INCLUDE_DIRS})
+
+add_library(symengine_ruby SHARED ${RUBY_WRAPPER_SRC})
+target_link_libraries(symengine_ruby ${SYMENGINE_LIBRARIES} ${RUBY_LIBRARIES})
+set_target_properties(symengine_ruby PROPERTIES
+                        PREFIX ""
+                        OUTPUT_NAME "symengine"
+                        LIBRARY_OUTPUT_DIRECTORY "${ruby_wrapper_BINARY_DIR}/lib/symengine"
+                     )
+
+# Ruby gems require a install target.
+install(TARGETS symengine_ruby
+            RUNTIME DESTINATION lib/symengine
+            ARCHIVE DESTINATION lib/symengine
+            LIBRARY DESTINATION lib/symengine
+        )

data/ext/symengine/extconf.rb

@@ -0,0 +1 @@
+exec 'cmake -DCMAKE_INSTALL_PREFIX=../../ %s ../../ ' % [ARGV.join(" ")]

data/ext/symengine/ruby_basic.c

@@ -0,0 +1,254 @@
+#include "ruby_basic.h"
+
+void cbasic_free(void *ptr){
+    basic_struct *basic_ptr = ptr;
+    basic_free_stack(basic_ptr);
+}
+
+void cbasic_free_heap(void *ptr) {
+    basic_struct *basic_ptr = ptr;
+    basic_free_heap(basic_ptr);
+}
+
+VALUE cbasic_alloc(VALUE klass){
+    basic_struct *struct_ptr = basic_new_heap();
+    return Data_Wrap_Struct(klass, NULL, cbasic_free_heap, struct_ptr);
+}
+
+VALUE cbasic_binary_op(VALUE self, VALUE operand2, void (*cwfunc_ptr)(basic_struct*, const basic_struct*, const basic_struct*)){
+    basic_struct *this, *cresult;
+    VALUE result;
+
+    basic cbasic_operand2;
+    basic_new_stack(cbasic_operand2);
+
+    Data_Get_Struct(self, basic_struct, this);
+    sympify(operand2, cbasic_operand2);
+
+    cresult = basic_new_heap();
+    cwfunc_ptr(cresult, this, cbasic_operand2);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+    basic_free_stack(cbasic_operand2);
+
+    return result;
+}
+
+VALUE cbasic_unary_op(VALUE self, void (*cwfunc_ptr)(basic_struct*, const basic_struct*)){
+    basic_struct *this, *cresult;
+    VALUE result;
+
+    Data_Get_Struct(self, basic_struct, this);
+
+    cresult = basic_new_heap();
+    cwfunc_ptr(cresult, this);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+
+    return result;
+}
+
+VALUE cbasic_add(VALUE self, VALUE operand2){
+    return cbasic_binary_op(self, operand2, basic_add);
+}
+
+VALUE cbasic_sub(VALUE self, VALUE operand2){
+    return cbasic_binary_op(self, operand2, basic_sub);
+}
+
+VALUE cbasic_mul(VALUE self, VALUE operand2){
+    return cbasic_binary_op(self, operand2, basic_mul);
+}
+
+VALUE cbasic_div(VALUE self, VALUE operand2){
+    return cbasic_binary_op(self, operand2, basic_div);
+}
+
+VALUE cbasic_pow(VALUE self, VALUE operand2){
+    return cbasic_binary_op(self, operand2, basic_pow);
+}
+
+VALUE cbasic_diff(VALUE self, VALUE operand2) {
+    basic_struct *this, *cresult;
+    VALUE result;
+
+    basic cbasic_operand2;
+    basic_new_stack(cbasic_operand2);
+
+    Data_Get_Struct(self, basic_struct, this);
+    sympify(operand2, cbasic_operand2);
+
+    cresult = basic_new_heap();
+    int status = basic_diff(cresult, this, cbasic_operand2);
+    if (status == 0) {
+        basic_free_stack(cbasic_operand2);
+        basic_free_heap(cresult);
+        return Qnil;
+    }
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+    basic_free_stack(cbasic_operand2);
+
+    return result;
+}
+
+VALUE cbasic_eq(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);
+
+    VALUE ret_val = basic_eq(this, cbasic_operand2) ? Qtrue : Qfalse;
+    basic_free_stack(cbasic_operand2);
+
+    return ret_val;
+}
+
+VALUE cbasic_neq(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);
+
+    VALUE ret_val =  basic_neq(this, cbasic_operand2) ? Qtrue : Qfalse;
+    basic_free_stack(cbasic_operand2);
+
+    return ret_val;
+}
+
+VALUE cbasic_neg(VALUE self){
+    return cbasic_unary_op(self, basic_neg);
+}
+
+VALUE cbasic_get_args(VALUE self) {
+    basic_struct *this, *iterator_basic;
+    CVecBasic *args = vecbasic_new();
+    int size = 0;
+
+    Data_Get_Struct(self, basic_struct, this);
+    basic_get_args(this, args);
+
+    size = vecbasic_size(args);
+    VALUE ruby_array = rb_ary_new2(size);
+    int i = 0;
+    VALUE temp = NULL;
+    for(i = 0; i < size; i++) {
+        basic_struct *temp_basic = basic_new_heap();
+        vecbasic_get(args, i, temp_basic);
+        temp = Data_Wrap_Struct(rb_obj_class(self), NULL , cbasic_free_heap, temp_basic);
+        rb_ary_push(ruby_array, temp);
+    }
+    vecbasic_free(args);
+    return ruby_array;
+}
+
+VALUE cbasic_free_symbols(VALUE self) {
+    basic_struct *this, *iterator_basic;
+    CSetBasic *symbols = setbasic_new();
+    int size = 0;
+
+    Data_Get_Struct(self, basic_struct, this);
+    basic_free_symbols(this, symbols);
+
+    size = setbasic_size(symbols);
+    VALUE ruby_array = rb_ary_new2(size);
+    int i = 0;
+    VALUE temp = NULL;
+    for(i = 0; i < size; i++) {
+        basic_struct *temp_basic = basic_new_heap();
+        setbasic_get(symbols, i, temp_basic);
+        temp = Data_Wrap_Struct(rb_obj_class(self), NULL , cbasic_free_heap, temp_basic);
+        rb_ary_push(ruby_array, temp);
+    }
+    setbasic_free(symbols);
+    return ruby_array;
+}
+
+VALUE cbasic_to_str(VALUE self){
+    basic_struct *this;
+    char *str_ptr;
+    VALUE result;
+
+    Data_Get_Struct(self, basic_struct, this);
+
+    str_ptr = basic_str(this);
+    result = rb_str_new_cstr(str_ptr);
+    basic_str_free(str_ptr);
+
+    return result;
+}
+
+VALUE cbasic_expand(VALUE self){
+    return cbasic_unary_op(self, basic_expand);
+}
+
+VALUE cbasic_hash(VALUE self){
+    basic_struct *this;
+    Data_Get_Struct(self, basic_struct, this);
+    // All ruby objects return FIXNUM when `hash` method is called.
+    // Though this function returns BIGNUM it won't be a problem, since
+    // we need proper comparison only among objects in SymEngine.
+    // The objects that should have the same hash will always match
+    // and when comparing to the FIXNUM from hash of other ruby objects,
+    // it will return false as it is supposed to.
+    // However, an alternate implementation is given below
+    // long lhash = basic_hash(this) % FIX2LONG(FIXNUM_MAX);
+    // return LONG2FIX(lhash);
+    return SIZET2NUM(basic_hash(this));
+}
+
+int insert_entries(VALUE key, VALUE val, VALUE input) {
+    CMapBasicBasic *cmapbb;
+    Data_Get_Struct(input, CMapBasicBasic, cmapbb);
+
+    basic ckey, cval;
+    basic_new_stack(ckey);
+    basic_new_stack(cval);
+    sympify(key, ckey);
+    sympify(val, cval);
+
+    mapbasicbasic_insert(cmapbb, ckey, cval);
+
+    basic_free_stack(ckey);
+    basic_free_stack(cval);
+}
+
+VALUE cbasic_subs(int argc, VALUE *argv, VALUE self) {
+    basic_struct *this, *cresult;
+    cresult = basic_new_heap();
+
+    VALUE val_a, val_b;
+    Data_Get_Struct(self, basic_struct, this);
+
+    rb_scan_args(argc, argv, "11", &val_a, &val_b); // 1 mandatory and 1 optional parameter
+    if (argc == 1) {
+        Check_Type(val_a, T_HASH);
+        CMapBasicBasic *cmapbb = mapbasicbasic_new();
+        VALUE mapbb = Data_Wrap_Struct(rb_cObject, NULL, mapbasicbasic_free, cmapbb);
+
+        rb_hash_foreach(val_a, insert_entries, mapbb);
+        basic_subs(cresult, this, cmapbb);
+    } else {
+        basic a, b;
+        basic_new_stack(a);
+        basic_new_stack(b);
+
+        sympify(val_a, a);
+        sympify(val_b, b);
+        basic_subs2(cresult, this, a, b);
+
+        basic_free_stack(a);
+        basic_free_stack(b);
+    }
+
+    return Data_Wrap_Struct(Klass_of_Basic(cresult), NULL, cbasic_free_heap, cresult);
+}
+
+VALUE cbasic_coerce(VALUE self, VALUE other){
+    basic_struct *cbasic_operand2;
+    cbasic_operand2 = basic_new_heap();
+    sympify(other, cbasic_operand2);
+    VALUE new_other = Data_Wrap_Struct(Klass_of_Basic(cbasic_operand2), NULL , cbasic_free_heap, cbasic_operand2);
+    return rb_assoc_new(new_other, self);
+}

data/ext/symengine/ruby_basic.h

@@ -0,0 +1,53 @@
+#ifndef RUBY_BASIC_H_
+#define RUBY_BASIC_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine_macros.h"
+
+void cbasic_free(void *ptr);
+
+void cbasic_free_heap(void *ptr);
+
+VALUE cbasic_alloc(VALUE klass);
+
+VALUE cbasic_binary_op(VALUE self, VALUE operand2, void (*cwfunc_ptr)(basic_struct*, const basic_struct*, const basic_struct*));
+
+VALUE cbasic_unary_op(VALUE self, void (*cwfunc_ptr)(basic_struct*, const basic_struct*));
+
+VALUE cbasic_add(VALUE self, VALUE operand2);
+
+VALUE cbasic_sub(VALUE self, VALUE operand2);
+
+VALUE cbasic_mul(VALUE self, VALUE operand2);
+
+VALUE cbasic_div(VALUE self, VALUE operand2);
+
+VALUE cbasic_pow(VALUE self, VALUE operand2);
+
+VALUE cbasic_diff(VALUE self, VALUE operand2);
+
+VALUE cbasic_eq(VALUE self, VALUE operand2);
+
+VALUE cbasic_neq(VALUE self, VALUE operand2);
+
+VALUE cbasic_neg(VALUE self);
+
+VALUE cbasic_get_args(VALUE self);
+
+VALUE cbasic_free_symbols(VALUE self);
+
+VALUE cbasic_to_str(VALUE self);
+
+VALUE cbasic_expand(VALUE self);
+
+VALUE cbasic_hash(VALUE self);
+
+int insert_entries(VALUE key, VALUE val, VALUE val_map_basic_basic);
+
+VALUE cbasic_subs(int argc, VALUE *argv, VALUE self);
+
+VALUE cbasic_coerce(VALUE self, VALUE other);
+
+#endif //RUBY_BASIC_H_

data/ext/symengine/ruby_integer.c

@@ -0,0 +1,8 @@
+#include "ruby_integer.h"
+
+VALUE cinteger_init(VALUE self, VALUE num_value) {
+    basic_struct *this;
+    Data_Get_Struct(self, basic_struct, this);
+    GET_SYMINTFROMVAL(num_value, this);
+    return self;
+}

data/ext/symengine/ruby_integer.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_INTEGER_H_
+#define RUBY_INTEGER_H_
+
+#include "ruby_basic.h"
+
+VALUE cinteger_init(VALUE self, VALUE num_value);
+
+#endif //RUBY_INTEGER_H_

data/ext/symengine/ruby_rational.c

@@ -0,0 +1,23 @@
+#include "ruby_rational.h"
+
+VALUE crational_init(VALUE self, VALUE rat_value) {
+    basic_struct *this;
+    basic num_basic, den_basic;
+
+    basic_new_stack(num_basic);
+    basic_new_stack(den_basic);
+
+    Data_Get_Struct(self, basic_struct, this);
+
+    VALUE num, den;
+    num = rb_funcall(rat_value, rb_intern("numerator"), 0, NULL);
+    den = rb_funcall(rat_value, rb_intern("denominator"), 0, NULL);
+
+    GET_SYMINTFROMVAL(num, num_basic);
+    GET_SYMINTFROMVAL(den, den_basic);
+
+    rational_set(this, num_basic, den_basic);
+    basic_free_stack(num_basic);
+    basic_free_stack(den_basic);
+    return self;
+}

data/ext/symengine/ruby_rational.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_RATIONAL_H_
+#define RUBY_RATIONAL_H_
+
+#include "ruby_basic.h"
+
+VALUE crational_init(VALUE self, VALUE rat_value);
+
+#endif //RUBY_RATIONAL_H_

data/ext/symengine/ruby_symbol.c

@@ -0,0 +1,13 @@
+#include "ruby_symbol.h"
+
+VALUE csymbol_init(VALUE self, VALUE name) {
+    Check_Type(name, T_STRING);
+    basic_struct *this;
+    char *str_ptr = StringValueCStr(name);
+
+    Data_Get_Struct(self, basic_struct, this);
+
+    symbol_set(this, str_ptr);
+
+    return self;
+}

data/ext/symengine/ruby_symbol.h

@@ -0,0 +1,8 @@
+#ifndef RUBY_SYMBOL_H_
+#define RUBY_SYMBOL_H_
+
+#include "ruby_basic.h"
+
+VALUE csymbol_init(VALUE self, VALUE name);
+
+#endif //RUBY_SYMBOL_H_

data/ext/symengine/symengine.c

@@ -0,0 +1,49 @@
+#include "ruby_basic.h"
+#include "ruby_symbol.h"
+#include "ruby_integer.h"
+#include "ruby_rational.h"
+#include "symengine.h"
+
+///////////////////
+// Ruby Bindings //
+///////////////////
+
+void Init_symengine() {
+    m_symengine = rb_define_module("SymEngine");
+
+    //Basic class
+    c_basic = rb_define_class_under(m_symengine, "Basic", rb_cObject);
+    rb_define_alloc_func(c_basic, cbasic_alloc);
+    rb_define_method(c_basic, "+", cbasic_add, 1);
+    rb_define_method(c_basic, "-", cbasic_sub, 1);
+    rb_define_method(c_basic, "*", cbasic_mul, 1);
+    rb_define_method(c_basic, "/", cbasic_div, 1);
+    rb_define_method(c_basic, "**", cbasic_pow, 1);
+    rb_define_method(c_basic, "diff", cbasic_diff, 1);
+    rb_define_method(c_basic, "==", cbasic_eq, 1);
+    rb_define_method(c_basic, "eql?", cbasic_eq, 1);
+    rb_define_method(c_basic, "!=", cbasic_neq, 1);
+    rb_define_method(c_basic, "-@", cbasic_neg, 0);
+    rb_define_method(c_basic, "to_s", cbasic_to_str, 0);
+    rb_define_method(c_basic, "expand", cbasic_expand, 0);
+    rb_define_method(c_basic, "args", cbasic_get_args, 0);
+    rb_define_protected_method(c_basic, "pr_free_symbols", cbasic_free_symbols, 0);
+    rb_define_method(c_basic, "hash", cbasic_hash, 0);
+    rb_define_method(c_basic, "subs", cbasic_subs, -1);
+    rb_define_method(c_basic, "coerce", cbasic_coerce, 1);
+
+    //Symbol class
+    c_symbol = rb_define_class_under(m_symengine, "Symbol", c_basic);
+    rb_define_alloc_func(c_symbol, cbasic_alloc);
+    rb_define_method(c_symbol, "initialize", csymbol_init, 1);
+
+    //Integer class
+    c_integer = rb_define_class_under(m_symengine, "Integer", c_basic);
+    rb_define_alloc_func(c_integer, cbasic_alloc);
+    rb_define_method(c_integer, "initialize", cinteger_init, 1);
+
+    //Rational class
+    c_rational = rb_define_class_under(m_symengine, "Rational", c_basic);
+    rb_define_alloc_func(c_rational, cbasic_alloc);
+    rb_define_method(c_rational, "initialize", crational_init, 1);
+}

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/lib/symengine.rb

@@ -0,0 +1,14 @@
+require 'symengine/symengine'
+require 'symengine/iruby'
+require 'symengine/basic'
+
+module SymEngine
+  def SymEngine.ascii_art
+    puts "
+ _____           _____         _
+|   __|_ _ _____|   __|___ ___|_|___ ___
+|__   | | |     |   __|   | . | |   | -_|
+|_____|_  |_|_|_|_____|_|_|_  |_|_|_|___|
+      |___|               |___|          "
+  end
+end

data/lib/symengine/basic.rb

@@ -0,0 +1,9 @@
+require 'set'
+
+module SymEngine
+  class Basic
+    def free_symbols
+      pr_free_symbols.to_set
+    end
+  end
+end

data/lib/symengine/iruby.rb

@@ -0,0 +1,9 @@
+if defined?(IRuby)
+  module SymEngine
+    class Basic
+      def to_iruby
+        ['text/html', self.to_s] unless self.instance_of? Basic
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,127 @@
+--- !ruby/object:Gem::Specification
+name: symengine
+version: !ruby/object:Gem::Version
+  version: 0.0.0
+platform: ruby
+authors:
+- Abinash Meher
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-08-26 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.7'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: test-unit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.1'
+- !ruby/object:Gem::Dependency
+  name: rdoc
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.0'
+description: This gem provides a Ruby interface for SymEngine, a fast C++ library
+  for symbolic manipulation, so that the you can use the features of SymEngine in
+  ruby.
+email:
+- abinashdakshana999@gmail.com
+executables: []
+extensions:
+- ext/symengine/extconf.rb
+extra_rdoc_files: []
+files:
+- CMakeLists.txt
+- LICENSE
+- README.md
+- bin/callgrind_test.sh
+- bin/gdb.sh
+- bin/valgrind_test.sh
+- ext/symengine/CMakeLists.txt
+- ext/symengine/extconf.rb
+- ext/symengine/ruby_basic.c
+- ext/symengine/ruby_basic.h
+- ext/symengine/ruby_integer.c
+- ext/symengine/ruby_integer.h
+- ext/symengine/ruby_rational.c
+- ext/symengine/ruby_rational.h
+- ext/symengine/ruby_symbol.c
+- ext/symengine/ruby_symbol.h
+- ext/symengine/symengine.c
+- ext/symengine/symengine.h
+- ext/symengine/symengine_macros.c
+- ext/symengine/symengine_macros.h
+- lib/symengine.rb
+- lib/symengine/basic.rb
+- lib/symengine/iruby.rb
+homepage: https://github.com/sympy/symengine
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Ruby interface for SymEngine, a fast C++ library for symbolic manipulation
+test_files: []
+has_rdoc: