Ruby Wrappers for NTheory

ext/symengine/CMakeLists.txt

@@ -5,7 +5,8 @@ set(RUBY_WRAPPER_SRC
     ruby_rational.c
     ruby_constant.c
     ruby_function.c
-    symengine_macros.c
+    ruby_ntheory.c
+    symengine_utils.c
     symengine.c
     )
 

ext/symengine/ruby_basic.h

@@ -4,7 +4,7 @@
 #include <ruby.h>
 #include <symengine/cwrapper.h>
 
-#include "symengine_macros.h"
+#include "symengine_utils.h"
 
 void cbasic_free(void *ptr);
 

ext/symengine/ruby_constant.h

@@ -4,9 +4,8 @@
 #include <ruby.h>
 #include <symengine/cwrapper.h>
 
-#include "ruby_basic.h"
 #include "symengine.h"
-#include "symengine_macros.h"
+#include "symengine_utils.h"
 
 VALUE cconstant_const(void (*cwfunc_ptr)(basic_struct*));
 

ext/symengine/ruby_function.c

@@ -1,25 +1,8 @@
 #include "ruby_function.h"
 
-
-VALUE cfunction_onearg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*), VALUE operand1) {
-    basic_struct *cresult;
-    VALUE result;
-
-    basic cbasic_operand1;
-    basic_new_stack(cbasic_operand1);
-    sympify(operand1, cbasic_operand1);
-
-    cresult = basic_new_heap();
-    cwfunc_ptr(cresult, cbasic_operand1);
-    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
-    basic_free_stack(cbasic_operand1);
-
-    return result;
-}
-
 #define IMPLEMENT_ONE_ARG_FUNC(func) \
 VALUE cfunction_ ## func(VALUE self, VALUE operand1) { \
-    return cfunction_onearg(basic_ ## func, operand1); \
+    return function_onearg(basic_ ## func, operand1); \
 }
 
 IMPLEMENT_ONE_ARG_FUNC(abs);

ext/symengine/ruby_function.h

@@ -4,11 +4,8 @@
 #include <ruby.h>
 #include <symengine/cwrapper.h>
 
-#include "ruby_basic.h"
 #include "symengine.h"
-#include "symengine_macros.h"
-
-VALUE cfunction_func(void (*cwfunc_ptr)(basic_struct*, const basic_struct*), VALUE operand1);
+#include "symengine_utils.h"
 
 VALUE cfunction_abs(VALUE self, VALUE operand1);
 VALUE cfunction_sin(VALUE self, VALUE operand1);

ext/symengine/ruby_integer.c

@@ -6,3 +6,4 @@ VALUE cinteger_init(VALUE self, VALUE num_value) {
     GET_SYMINTFROMVAL(num_value, this);
     return self;
 }
+

ext/symengine/ruby_ntheory.c

@@ -0,0 +1,70 @@
+#include "ruby_ntheory.h"
+
+VALUE cntheory_nextprime(VALUE self, VALUE operand1) {
+    return function_onearg(ntheory_nextprime, operand1);
+}
+
+VALUE cntheory_gcd(VALUE self, VALUE operand1, VALUE operand2) {
+    return function_twoarg(ntheory_gcd, operand1, operand2);
+}
+
+VALUE cntheory_lcm(VALUE self, VALUE operand1, VALUE operand2) {
+    return function_twoarg(ntheory_lcm, operand1, operand2);
+}
+
+VALUE cntheory_mod(VALUE self, VALUE operand2) {
+    VALUE ans = function_twoarg(ntheory_mod, self, operand2);
+    VALUE ans1 = cbasic_add(ans, operand2);
+    return function_twoarg(ntheory_mod, ans1, operand2);
+}
+
+VALUE cntheory_quotient(VALUE self, VALUE operand1, VALUE operand2) {
+    return function_twoarg(ntheory_quotient, operand1, operand2);
+}
+
+VALUE cntheory_fibonacci(VALUE self, VALUE operand1){
+    basic_struct *cresult;
+    VALUE result;
+
+    unsigned long cbasic_operand1;
+    cbasic_operand1 = NUM2ULONG(operand1);
+
+    cresult = basic_new_heap();
+    ntheory_fibonacci(cresult, cbasic_operand1);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+
+    return result;
+}
+
+VALUE cntheory_lucas(VALUE self, VALUE operand1){
+    basic_struct *cresult;
+    VALUE result;
+
+    unsigned long cbasic_operand1;
+    cbasic_operand1 = NUM2ULONG(operand1);
+
+    cresult = basic_new_heap();
+    ntheory_lucas(cresult, cbasic_operand1);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+
+    return result;
+}
+
+VALUE cntheory_binomial(VALUE self, VALUE operand1, VALUE operand2){
+    basic_struct *cresult;
+    VALUE result;
+
+    basic cbasic_operand1;
+    basic_new_stack(cbasic_operand1);
+    sympify(operand1, cbasic_operand1);
+
+    unsigned long cbasic_operand2;
+    cbasic_operand2 = NUM2ULONG(operand2);
+
+    cresult = basic_new_heap();
+    ntheory_binomial(cresult, cbasic_operand1, cbasic_operand2);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+    basic_free_stack(cbasic_operand1);
+
+    return result;
+}

ext/symengine/ruby_ntheory.h

@@ -0,0 +1,20 @@
+#ifndef RUBY_NTHEORY_H_
+#define RUBY_NTHEORY_H_
+
+#include <ruby.h>
+#include <symengine/cwrapper.h>
+
+#include "symengine.h"
+#include "ruby_basic.h"
+#include "symengine_utils.h"
+
+VALUE cntheory_gcd(VALUE self, VALUE operand1, VALUE operand2);
+VALUE cntheory_lcm(VALUE self, VALUE operand1, VALUE operand2);
+VALUE cntheory_nextprime(VALUE self, VALUE operand1);
+VALUE cntheory_mod(VALUE self, VALUE operand2);
+VALUE cntheory_quotient(VALUE self, VALUE operand1, VALUE operand2);
+VALUE cntheory_fibonacci(VALUE self, VALUE operand1);
+VALUE cntheory_lucas(VALUE self, VALUE operand1);
+VALUE cntheory_binomial(VALUE self, VALUE operand1, VALUE operand2);
+
+#endif //RUBY_NTHEORY_H_

ext/symengine/symengine.c

@@ -5,6 +5,7 @@
 #include "ruby_rational.h"
 #include "ruby_constant.h"
 #include "ruby_function.h"
+#include "ruby_ntheory.h"
 #include "symengine.h"
 
 ///////////////////
@@ -52,6 +53,7 @@ void Init_symengine() {
     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);
+    rb_define_method(c_integer, "%", cntheory_mod, 1);
 
     //Rational class
     c_rational = rb_define_class_under(m_symengine, "Rational", c_basic);
@@ -145,4 +147,13 @@ void Init_symengine() {
     rb_define_module_function(m_symengine, "zeta", cfunction_zeta, 1);
     rb_define_module_function(m_symengine, "gamma", cfunction_gamma, 1); 
 
+    //NTheory Functions as Module Level Functions
+    rb_define_module_function(m_symengine, "gcd", cntheory_gcd, 2);
+    rb_define_module_function(m_symengine, "lcm", cntheory_lcm, 2);
+    rb_define_module_function(m_symengine, "nextprime", cntheory_nextprime, 1);
+    rb_define_module_function(m_symengine, "quotient", cntheory_quotient, 2);
+    rb_define_module_function(m_symengine, "fibonacci", cntheory_fibonacci, 1);
+    rb_define_module_function(m_symengine, "lucas", cntheory_lucas, 1);
+    rb_define_module_function(m_symengine, "binomial", cntheory_binomial, 2);
+
 }

ext/symengine/symengine_macros.c → ext/symengine/symengine_utils.c

@@ -1,4 +1,4 @@
-#include "symengine_macros.h"
+#include "symengine_utils.h"
 #include "symengine.h"
 
 void sympify(VALUE operand2, basic_struct *cbasic_operand2) {
@@ -111,3 +111,41 @@ VALUE Klass_of_Basic(const basic_struct *basic_ptr) {
             return c_basic;
     }
 }
+
+VALUE function_onearg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*), VALUE operand1) {
+    basic_struct *cresult;
+    VALUE result;
+
+    basic cbasic_operand1;
+    basic_new_stack(cbasic_operand1);
+    sympify(operand1, cbasic_operand1);
+
+    cresult = basic_new_heap();
+    cwfunc_ptr(cresult, cbasic_operand1);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+    basic_free_stack(cbasic_operand1);
+
+    return result;
+}
+
+VALUE function_twoarg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*, const basic_struct*),
+                      VALUE operand1, VALUE operand2) {
+    basic_struct *cresult;
+    VALUE result;
+
+    basic cbasic_operand1;
+    basic_new_stack(cbasic_operand1);
+    sympify(operand1, cbasic_operand1);
+
+    basic cbasic_operand2;
+    basic_new_stack(cbasic_operand2);
+    sympify(operand2, cbasic_operand2);
+
+    cresult = basic_new_heap();
+    cwfunc_ptr(cresult, cbasic_operand1, cbasic_operand2);
+    result = Data_Wrap_Struct(Klass_of_Basic(cresult), NULL , cbasic_free_heap, cresult);
+    basic_free_stack(cbasic_operand1);
+    basic_free_stack(cbasic_operand2);
+
+    return result;
+}

ext/symengine/symengine_macros.h → ext/symengine/symengine_utils.h

@@ -2,12 +2,18 @@
 #define SYMENGINE_MACROS_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 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
+VALUE function_onearg(void (*cwfunc_ptr)(basic_struct*, const basic_struct*), VALUE operand1);
+//Returns the result from the function pointed by cwfunc_ptr: for two argument functions
+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) { \

lib/symengine.rb

@@ -34,3 +34,4 @@ def symbols ary_or_string, *params
 require 'symengine/symengine'
 require 'symengine/iruby'
 require 'symengine/basic'
+require 'symengine/integer'

lib/symengine/integer.rb

@@ -0,0 +1,7 @@
+module SymEngine
+  class Integer
+    def to_int
+        self.to_s.to_i
+    end
+  end
+end