ruby-mpc 0.0.2

data/History.txt

@@ -0,0 +1,9 @@
+=== 0.0.2 2009-12-15
+
+* 1 major enhancement:
+  * Support MPC 0.8.1
+
+=== 0.0.1 2009-08-13
+
+* 1 major enhancement:
+  * Initial release

data/Manifest.txt

@@ -0,0 +1,21 @@
+History.txt
+Manifest.txt
+PostInstall.txt
+README.rdoc
+Rakefile
+ext/mpc/extconf.rb
+ext/mpc/ruby_mpc.c
+ext/mpc/ruby_mpc.h
+ext/mpc/ruby_mpfr.h
+lib/mpc/version.rb
+ruby-mpc.gemspec
+script/console
+script/destroy
+script/generate
+spec/mpc/arithmetic_op_spec.rb
+spec/mpc/const_spec.rb
+spec/mpc/functions_spec.rb
+spec/mpc/generate_complex_number.rb
+spec/mpc/spec_helper.rb
+spec/spec.opts
+tasks/extconf.rake

data/PostInstall.txt

@@ -0,0 +1,7 @@
+
+For more information on ruby-mpc, see http://ruby-mpc.rubyforge.org
+
+NOTE: Change this information in PostInstall.txt 
+You can also delete it if you don't want it.
+
+

data/README.rdoc

@@ -0,0 +1,48 @@
+= ruby-mpc
+
+* http://github.com/#{github_username}/#{project_name}
+
+== DESCRIPTION:
+
+FIX (describe your package)
+
+== FEATURES/PROBLEMS:
+
+* FIX (list of features or problems)
+
+== SYNOPSIS:
+
+  FIX (code sample of usage)
+
+== REQUIREMENTS:
+
+* FIX (list of requirements)
+
+== INSTALL:
+
+* FIX (sudo gem install, anything else)
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 FIXME full name
+
+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/Rakefile

@@ -0,0 +1,26 @@
+require 'rubygems'
+gem 'hoe', '>= 2.1.0'
+require 'hoe'
+require 'fileutils'
+require './lib/mpc/version.rb'
+
+Hoe.plugin :newgem
+# Hoe.plugin :website
+# Hoe.plugin :cucumberfeatures
+
+# Generate all the Rake tasks
+# Run 'rake -T' to see list of generated tasks (from gem root directory)
+$hoe = Hoe.spec 'ruby-mpc' do
+  self.developer 'Takayuki YAMAGUCHI', 'd@ytak.info'
+  self.post_install_message = 'PostInstall.txt' # TODO remove if post-install message not required
+  self.rubyforge_name       = self.name # TODO this is default value
+  # self.extra_deps         = [['activesupport','>= 2.0.2']]
+  self.spec_extras[:extensions] = "ext/mpc/extconf.rb"
+end
+
+require 'newgem/tasks'
+Dir['tasks/**/*.rake'].each { |t| load t }
+
+# TODO - want other tests/tasks run by default? Add them to the list
+# remove_task :default
+# task :default => [:spec, :features]

data/ext/mpc/extconf.rb

@@ -0,0 +1,11 @@
+require 'mkmf'
+
+$CFLAGS += " -Wall"
+
+dir_config("mpfr")
+dir_config("mpc")
+dir_config("gmp")
+if have_header('mpfr.h') && have_library('mpfr') && have_header('mpc.h') && have_library('mpc') && have_header('gmp.h') && have_library('gmp')
+  create_makefile("mpc")
+end
+

data/ext/mpc/ruby_mpc.c

@@ -0,0 +1,968 @@
+#include "ruby_mpc.h"
+
+#define CLASS_VAL_FUNCTION_STATE "@@function_state"
+
+static ID eqq, new,  object_id;
+static VALUE __mpc_class__, __mpfr_class__;
+
+/* Default rounding mode */
+mp_rnd_t __rb_mpc_default_rounding_mode = MPC_RNDNN;
+
+void rb_mpc_extended_set_default_rounding_mode (mpc_rnd_t rnd_mode)
+{
+  if (rnd_mode >= 0 && MPC_RND_RE(rnd_mode) < 4 && MPC_RND_IM(rnd_mode) < 4)
+    __rb_mpc_default_rounding_mode = rnd_mode;
+}
+
+mpc_rnd_t rb_mpc_extended_get_default_rounding_mode (void)
+{
+  return __rb_mpc_default_rounding_mode;
+}
+
+mp_prec_t rb_mpc_get_max_prec (mpc_t x)
+{
+  mp_prec_t precre = mpfr_get_prec(mpc_realref (x)), precim = mpfr_get_prec(mpc_imagref (x));
+  return (precre > precim ? precre : precim);
+}
+
+/* State of function */
+
+void r_mpc_set_c_function_state(int num)
+{
+  rb_cv_set(r_mpc_class, CLASS_VAL_FUNCTION_STATE, rb_ary_new3(2, INT2NUM(MPC_INEX_RE(num)), INT2NUM(MPC_INEX_IM(num))));
+}
+
+void r_mpc_set_fr_function_state(int num)
+{
+  rb_cv_set(r_mpc_class, CLASS_VAL_FUNCTION_STATE, INT2NUM(num));
+}
+
+
+/* If argc equals max, convert last argument to rounding mode number. */
+/* Otherwise, return defoult rounding mode number. */
+mpc_rnd_t r_mpc_rnd_from_optional_argument(int min, int max, int argc, VALUE *argv)
+{
+  mp_rnd_t rnd;
+  if(argc >= min && argc <= max){
+    if(argc == max){
+      rnd = r_mpc_rnd_from_value(argv[max-1]);
+    }else{
+      rnd = rb_mpc_extended_get_default_rounding_mode();
+    }
+  }else{
+    rb_raise(rb_eArgError, "Invalid number of arguments.");
+  }
+  return rnd;
+}
+
+/* If argc equals max, convert last argument to precision number. */
+/* Otherwise, return defoult precision number. */
+mpc_rnd_t r_mpc_prec_from_optional_argument(int min, int max, int argc, VALUE *argv)
+{
+  mp_prec_t prec;
+  if(argc >= min && argc <= max){
+    if(argc == max){
+      prec = NUM2INT(argv[max - 1]);
+    }else{
+      prec = mpfr_get_default_prec();
+    }
+  }else{
+    rb_raise(rb_eArgError, "Invalid number of arguments.");
+  }
+  return prec;
+}
+
+/* min is a minimum number of arguments. */
+/* max is a maximum number of arguments. */
+void r_mpc_get_rnd_prec_from_optional_arguments(mpc_rnd_t *rnd, mp_prec_t *prec, int min, int max,
+						int argc, VALUE *argv)
+{
+  if(argc >= min && argc <= max){
+    if(argc >= max - 1){
+      *rnd = r_mpc_rnd_from_value(argv[max - 2]);
+    }else{
+      *rnd = rb_mpc_extended_get_default_rounding_mode();
+    }
+    if(argc == max){
+      *prec = NUM2INT(argv[max - 1]);
+    }else{
+      *prec = mpfr_get_default_prec();
+    }
+  }else{
+    rb_raise(rb_eArgError, "Invalid number of arguments.");
+  }
+}
+
+/* Set the default rounding mode. The default rounding mode is MPC::RNDNN. */
+static VALUE r_mpc_set_default_rounding_mode(VALUE self, VALUE rnd)
+{
+  mp_rnd_t a = NUM2INT(rnd);
+  rb_mpc_extended_set_default_rounding_mode(a);
+  return INT2FIX(rb_mpc_extended_get_default_rounding_mode());
+}
+
+/* Get the default rounding mode. */
+static VALUE r_mpc_get_default_rounding_mode(VALUE self)
+{
+  return INT2NUM(rb_mpc_extended_get_default_rounding_mode());
+}
+
+/* Return function state. */
+static VALUE r_mpc_get_function_state(VALUE self)
+{
+  return rb_cv_get(r_mpc_class, CLASS_VAL_FUNCTION_STATE);
+}
+
+/* ---------- Allocation ---------- */
+
+void r_mpc_free(void *ptr){
+  mpc_clear(ptr);
+  free(ptr);
+}
+
+static VALUE r_mpc_alloc(VALUE self)
+{
+  MPC *ptr;
+  r_mpc_make_struct(self, ptr);
+  return self;
+}
+
+VALUE r_mpc_new_c_obj(VALUE obj)
+{
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, obj))){
+    return obj;
+  }else{
+    return rb_funcall(__mpc_class__, new, 1, obj);
+  }
+}
+
+
+static void r_mpc_set_from_two_objects(MPC *ptr, VALUE real, VALUE imag, mpc_rnd_t rnd)
+{
+  r_mpfr_set_robj(mpc_realref(ptr), real, MPC_RND_RE(rnd));
+  r_mpfr_set_robj(mpc_imagref(ptr), imag, MPC_RND_IM(rnd));
+}
+
+static void r_mpc_set_from_one_object(MPC *ptr, VALUE obj, mpc_rnd_t rnd)
+{
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, obj))){
+    MPC *ptr_obj;
+    r_mpc_get_struct(ptr_obj, obj);
+    mpc_set(ptr, ptr_obj, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, obj))){
+    MPFR *ptr_obj;
+    r_mpfr_get_struct(ptr_obj, obj);
+    mpc_set_fr(ptr, ptr_obj, rnd);
+  }else{
+    switch(TYPE(obj)){
+    case T_FLOAT:
+      mpc_set_d(ptr, NUM2DBL(obj), rnd);
+      break;
+    case T_FIXNUM:
+      mpc_set_si(ptr, FIX2LONG(obj), rnd);
+      break;
+    default:
+      r_mpfr_set_robj(mpc_realref(ptr), obj, MPC_RND_RE(rnd));
+      mpfr_set_si(mpc_imagref(ptr), 0, MPC_RND_IM(rnd));
+      break;
+    }
+  }
+}
+
+/* Arguments may be the following types by number. */
+/* 0. none */
+/* 1. MPC or array having two elements */
+/* 2. real part and imaginary part*/
+/* 3. real part, imaginary part, and rounding mode */
+/* 4. real part, imaginary part, rounding mode and precision */
+static VALUE r_mpc_initialize(int argc, VALUE *argv, VALUE self)
+{
+  MPC *ptr;
+  r_mpc_get_struct(ptr, self);
+  switch(argc){
+  case 0:
+    mpc_init2(ptr, mpfr_get_default_prec());
+    break;
+  case 1:
+    mpc_init2(ptr, mpfr_get_default_prec());
+    r_mpc_set_from_one_object(ptr, argv[0], rb_mpc_extended_get_default_rounding_mode());
+    break;
+  case 2:
+    mpc_init2(ptr, mpfr_get_default_prec());
+    r_mpc_set_from_two_objects(ptr, argv[0], argv[1], rb_mpc_extended_get_default_rounding_mode());
+    break;
+  case 3:
+    mpc_init2(ptr, mpfr_get_default_prec());
+    r_mpc_set_from_two_objects(ptr, argv[0], argv[1], r_mpc_rnd_from_value(argv[2]));
+    break;
+  case 4:
+    mpc_init2(ptr, NUM2INT(argv[3]));
+    r_mpc_set_from_two_objects(ptr, argv[0], argv[1], r_mpc_rnd_from_value(argv[2]));
+    break;
+  default:
+    rb_raise(rb_eArgError, "Invalid number of arguments.");
+    break;
+  }
+  return Qtrue;
+}
+
+static VALUE r_mpc_initialize_copy(VALUE self, VALUE other)
+{
+  MPC *ptr_self, *ptr_other;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_get_struct(ptr_other, other);
+  mpc_init2(ptr_self, rb_mpc_get_max_prec(ptr_other));
+  mpc_set(ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  return Qtrue;
+}
+
+/* Return array which have MPC instance converted to from p1 and self. */
+static VALUE r_mpc_coerce(VALUE self, VALUE other)
+{
+  VALUE val_other;
+  MPC *ptr_self, *ptr_other;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init2(val_other, ptr_other, rb_mpc_get_max_prec(ptr_self));
+  r_mpc_set_from_one_object(ptr_other, other, rb_mpc_extended_get_default_rounding_mode());
+  return rb_ary_new3(2, val_other, self);
+}
+
+/* String */
+
+static VALUE r_mpc_inspect(VALUE self)
+{
+  MPC *ptr_s;
+  r_mpc_get_struct(ptr_s, self);
+  char *ret_str;
+  mpfr_asprintf(&ret_str, "#<MPC:%lx,['%.Re','%.Re'],[%d,%d]>",
+		NUM2LONG(rb_funcall(self, object_id, 0)), mpc_realref (ptr_s), mpc_imagref (ptr_s),
+		mpfr_get_prec(mpc_realref (ptr_s)), mpfr_get_prec(mpc_imagref (ptr_s)));
+  VALUE ret_val = rb_str_new2(ret_str);
+  mpfr_free_str(ret_str);
+  return ret_val;
+}
+
+
+/* Projection and Decomposing Functions */
+
+/* Return the real part. */
+static VALUE r_mpc_real (VALUE self)
+{
+  MPC *ptr_self;
+  r_mpc_get_struct(ptr_self, self);
+  VALUE ret_val;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(ret_val, ptr_ret, mpfr_get_prec(mpc_realref(ptr_self)));
+  r_mpc_set_fr_function_state(mpc_real(ptr_ret, ptr_self, MPC_RNDNN));
+  return ret_val;
+}
+
+/* Return the imaginary part. */
+static VALUE r_mpc_imag (VALUE self)
+{
+  MPC *ptr_self;
+  r_mpc_get_struct(ptr_self, self);
+  VALUE ret_val;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(ret_val, ptr_ret, mpfr_get_prec(mpc_imagref(ptr_self)));
+  r_mpc_set_fr_function_state(mpc_imag(ptr_ret, ptr_self, MPC_RNDNN));
+  return ret_val;
+}
+
+/* Return the argument. */
+static VALUE r_mpc_arg (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self;
+  r_mpc_get_struct(ptr_self, self);
+  VALUE ret_val;
+  MPFR *ptr_ret;
+  r_mpfr_make_struct_init2(ret_val, ptr_ret, prec);
+  r_mpc_set_fr_function_state(mpc_arg(ptr_ret, ptr_self, rnd));
+  return ret_val;
+}
+
+/* Return the projection onto the Riemann sphere. */
+static VALUE r_mpc_proj (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self;
+  r_mpc_get_struct(ptr_self, self);
+  VALUE ret_val;
+  MPC *ptr_ret;
+  r_mpc_make_struct_init2(ret_val, ptr_ret, prec);
+  r_mpc_set_c_function_state(mpc_proj(ptr_ret, ptr_self, rnd));
+  return ret_val;
+}
+
+/* Basic Arithmetic Functions */
+static VALUE r_mpc_add(VALUE self, VALUE other)
+{
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init(val_ret, ptr_return);
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, other))){
+    MPC *ptr_other;
+    r_mpc_get_struct(ptr_other, other);
+    mpc_add(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpc_add_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else{
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, rb_funcall(__mpc_class__, new, 1, other));
+    mpc_add_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_sub(VALUE self, VALUE other)
+{
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init(val_ret, ptr_return);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, other))){
+    MPC *ptr_other;
+    r_mpc_get_struct(ptr_other, other);
+    mpc_sub(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpc_sub_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else{
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, rb_funcall(__mpc_class__, new, 1, other));
+    mpc_sub_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_mul(VALUE self, VALUE other)
+{
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init(val_ret, ptr_return);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, other))){
+    MPC *ptr_other;
+    r_mpc_get_struct(ptr_other, other);
+    mpc_mul(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpc_mul_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else{
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, rb_funcall(__mpc_class__, new, 1, other));
+    mpc_mul_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }
+  return val_ret;
+}
+
+
+static VALUE r_mpc_div(VALUE self, VALUE other)
+{
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init(val_ret, ptr_return);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, other))){
+    MPC *ptr_other;
+    r_mpc_get_struct(ptr_other, other);
+    mpc_div(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, other))){
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, other);
+    mpc_div_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }else{
+    MPFR *ptr_other;
+    r_mpfr_get_struct(ptr_other, rb_funcall(__mpc_class__, new, 1, other));
+    mpc_div_fr(ptr_return, ptr_self, ptr_other, rb_mpc_extended_get_default_rounding_mode());
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_mul_i (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_mul_i(ptr_return, ptr_self, NUM2INT(argv[0]), rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_neg (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_neg(ptr_return, ptr_self, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_conj (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self, *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_conj(ptr_return, ptr_self, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_abs (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self;
+  MPFR *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpfr_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_fr_function_state(mpc_abs(ptr_return, ptr_self, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_norm (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 0, 2, argc, argv);
+  MPC *ptr_self;
+  MPFR *ptr_return;
+  VALUE val_ret;
+  r_mpc_get_struct(ptr_self, self);
+  r_mpfr_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_fr_function_state(mpc_norm(ptr_return, ptr_self, rnd));
+  return val_ret;
+}
+
+/* module function */
+static VALUE r_mpc_math_add(int argc, VALUE *argv, VALUE self)
+{
+  mp_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg1, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg1, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, argv[1]))){
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, argv[1]);
+    mpc_add(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_arg2;
+    r_mpfr_get_struct(ptr_arg2, argv[1]);
+    r_mpc_set_c_function_state(mpc_add_fr(ptr_return, ptr_arg1, ptr_arg2, rnd));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    mpc_add_si(ptr_return, ptr_arg1, FIX2LONG(argv[1]), rnd);
+  }else{
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, rb_funcall(__mpc_class__, new, 1, argv[1]));
+    mpc_add(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_math_sub(int argc, VALUE *argv, VALUE self)
+{
+  mp_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg1, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg1, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, argv[1]))){
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, argv[1]);
+    mpc_sub(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_arg2;
+    r_mpfr_get_struct(ptr_arg2, argv[1]);
+    r_mpc_set_c_function_state(mpc_sub_fr(ptr_return, ptr_arg1, ptr_arg2, rnd));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    int other = FIX2LONG(argv[1]);
+    if (other >= 0) {
+      mpc_sub_ui(ptr_return, ptr_arg1, other, rnd);
+    } else {
+      mpc_add_ui(ptr_return, ptr_arg1, -other, rnd);
+    }
+  }else{
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, rb_funcall(__mpc_class__, new, 1, argv[1]));
+    mpc_sub(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_math_mul(int argc, VALUE *argv, VALUE self)
+{
+  mp_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg1, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg1, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, argv[1]))){
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, argv[1]);
+    mpc_mul(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_arg2;
+    r_mpfr_get_struct(ptr_arg2, argv[1]);
+    r_mpc_set_c_function_state(mpc_mul_fr(ptr_return, ptr_arg1, ptr_arg2, rnd));
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    mpc_mul_si(ptr_return, ptr_arg1, FIX2LONG(argv[1]), rnd);
+  }else{
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, rb_funcall(__mpc_class__, new, 1, argv[1]));
+    mpc_mul(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_math_div(int argc, VALUE *argv, VALUE self)
+{
+  mp_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg1, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg1, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, argv[1]))){
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, argv[1]);
+    mpc_div(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_arg2;
+    r_mpfr_get_struct(ptr_arg2, argv[1]);
+    r_mpc_set_c_function_state(mpc_div_fr(ptr_return, ptr_arg1, ptr_arg2, rnd));
+  }else{
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, rb_funcall(__mpc_class__, new, 1, argv[1]));
+    mpc_div(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }
+  return val_ret;
+}
+
+static VALUE r_mpc_math_mul_2exp (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_mul_2exp(ptr_return, ptr_arg, NUM2LONG(argv[1]), rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_div_2exp (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_div_2exp(ptr_return, ptr_arg, NUM2LONG(argv[1]), rnd));
+  return val_ret;
+}
+
+
+static VALUE r_mpc_math_sqr (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_sqr(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_sqrt (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_sqrt(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_pow(int argc, VALUE *argv, VALUE self)
+{
+  mp_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 2, 4, argc, argv);
+  MPC *ptr_arg1, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg1, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+
+  if(RTEST(rb_funcall(__mpc_class__, eqq, 1, argv[1]))){
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, argv[1]);
+    mpc_pow(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }else if(RTEST(rb_funcall(__mpfr_class__, eqq, 1, argv[1]))){
+    MPFR *ptr_arg2;
+    r_mpfr_get_struct(ptr_arg2, argv[1]);
+    r_mpc_set_c_function_state(mpc_pow_fr(ptr_return, ptr_arg1, ptr_arg2, rnd));
+  }else if(TYPE(argv[1]) == T_FLOAT){
+    mpc_pow_d(ptr_return, ptr_arg1, NUM2DBL(argv[1]), rnd);
+  }else if(TYPE(argv[1]) == T_FIXNUM){
+    mpc_pow_si(ptr_return, ptr_arg1, FIX2LONG(argv[1]), rnd);
+  }else{
+    MPC *ptr_arg2;
+    r_mpc_get_struct(ptr_arg2, rb_funcall(__mpc_class__, new, 1, argv[1]));
+    mpc_pow(ptr_return, ptr_arg1, ptr_arg2, rnd);
+  }
+  return val_ret;
+}
+
+
+
+static VALUE r_mpc_math_exp (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_exp(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_log (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_log(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_sin (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_sin(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_cos (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_cos(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_tan (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_tan(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_sinh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_sinh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_cosh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_cosh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_tanh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_tanh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_asin (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_asin(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_acos (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_acos(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_atan (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_atan(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_asinh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_asinh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_acosh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_acosh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+static VALUE r_mpc_math_atanh (int argc, VALUE *argv, VALUE self)
+{
+  mpc_rnd_t rnd;
+  mp_prec_t prec;
+  r_mpc_get_rnd_prec_from_optional_arguments(&rnd, &prec, 1, 3, argc, argv);
+  MPC *ptr_arg, *ptr_return;
+  VALUE val_ret;
+  volatile VALUE tmp_argv0 = r_mpc_new_c_obj(argv[0]);
+  r_mpc_get_struct(ptr_arg, tmp_argv0);
+  r_mpc_make_struct_init2(val_ret, ptr_return, prec);
+  r_mpc_set_c_function_state(mpc_atanh(ptr_return, ptr_arg, rnd));
+  return val_ret;
+}
+
+
+void Init_mpc(){
+  r_mpc_class = rb_define_class("MPC", rb_cNumeric);
+
+  rb_define_singleton_method(r_mpc_class, "set_default_rounding_mode", r_mpc_set_default_rounding_mode, 1);
+  rb_define_singleton_method(r_mpc_class, "get_default_rounding_mode", r_mpc_get_default_rounding_mode, 0);
+
+  rb_define_const(r_mpc_class, "RNDNN", INT2NUM(MPC_RNDNN));
+  rb_define_const(r_mpc_class, "RNDNZ", INT2NUM(MPC_RNDNZ));
+  rb_define_const(r_mpc_class, "RNDNU", INT2NUM(MPC_RNDNU));
+  rb_define_const(r_mpc_class, "RNDND", INT2NUM(MPC_RNDND));
+  rb_define_const(r_mpc_class, "RNDZN", INT2NUM(MPC_RNDZN));
+  rb_define_const(r_mpc_class, "RNDZZ", INT2NUM(MPC_RNDZZ));
+  rb_define_const(r_mpc_class, "RNDZU", INT2NUM(MPC_RNDZU));
+  rb_define_const(r_mpc_class, "RNDZD", INT2NUM(MPC_RNDZD));
+  rb_define_const(r_mpc_class, "RNDUN", INT2NUM(MPC_RNDUN));
+  rb_define_const(r_mpc_class, "RNDUZ", INT2NUM(MPC_RNDUZ));
+  rb_define_const(r_mpc_class, "RNDUU", INT2NUM(MPC_RNDUU));
+  rb_define_const(r_mpc_class, "RNDUD", INT2NUM(MPC_RNDUD));
+  rb_define_const(r_mpc_class, "RNDDN", INT2NUM(MPC_RNDDN));
+  rb_define_const(r_mpc_class, "RNDDZ", INT2NUM(MPC_RNDDZ));
+  rb_define_const(r_mpc_class, "RNDDU", INT2NUM(MPC_RNDDU));
+  rb_define_const(r_mpc_class, "RNDDD", INT2NUM(MPC_RNDDD));
+
+  rb_define_const(r_mpc_class, "VERSION_MAJOR", INT2NUM(MPC_VERSION_MAJOR));
+  rb_define_const(r_mpc_class, "VERSION_MINOR", INT2NUM(MPC_VERSION_MINOR));
+  rb_define_const(r_mpc_class, "VERSION_PATCHLEVEL", INT2NUM(MPC_VERSION_PATCHLEVEL));
+  rb_define_const(r_mpc_class, "VERSION_STRING", rb_str_new2(MPC_VERSION_STRING));
+  
+
+
+  rb_define_singleton_method(r_mpc_class, "get_function_state", r_mpc_get_function_state, 0);
+
+
+  rb_define_alloc_func(r_mpc_class, r_mpc_alloc);
+
+  rb_define_private_method(r_mpc_class, "initialize", r_mpc_initialize, -1);
+  rb_define_private_method(r_mpc_class, "initialize_copy", r_mpc_initialize_copy, 1);
+
+  rb_define_method(r_mpc_class, "coerce", r_mpc_coerce, 1);
+
+  rb_define_method(r_mpc_class, "inspect", r_mpc_inspect, 0);
+
+
+  rb_define_method(r_mpc_class, "real", r_mpc_real, 0);
+  rb_define_method(r_mpc_class, "imag", r_mpc_imag, 0);
+  rb_define_method(r_mpc_class, "arg", r_mpc_arg, -1);
+  rb_define_method(r_mpc_class, "proj", r_mpc_proj, -1);
+
+
+
+
+  /* Basic Arithmetic Functions */
+  rb_define_method(r_mpc_class, "+", r_mpc_add, 1);
+  rb_define_method(r_mpc_class, "-", r_mpc_sub, 1);
+  rb_define_method(r_mpc_class, "*", r_mpc_mul, 1);
+  rb_define_method(r_mpc_class, "/", r_mpc_div, 1);
+  rb_define_method(r_mpc_class, "mul_i", r_mpc_mul_i, -1);
+  rb_define_method(r_mpc_class, "neg", r_mpc_neg, -1);
+  rb_define_method(r_mpc_class, "conj", r_mpc_conj, -1);
+  rb_define_method(r_mpc_class, "abs", r_mpc_abs, -1);
+  rb_define_method(r_mpc_class, "norm", r_mpc_norm, -1);
+
+    
+  
+  r_mpc_math = rb_define_module_under(r_mpc_class, "Math");  
+
+  rb_define_module_function(r_mpc_math, "add", r_mpc_math_add, -1);
+  rb_define_module_function(r_mpc_math, "sub", r_mpc_math_sub, -1);
+  rb_define_module_function(r_mpc_math, "mul", r_mpc_math_mul, -1);
+  rb_define_module_function(r_mpc_math, "div", r_mpc_math_div, -1);
+  rb_define_module_function(r_mpc_math, "mul_2exp", r_mpc_math_mul_2exp, -1);
+  rb_define_module_function(r_mpc_math, "div_2exp", r_mpc_math_div_2exp, -1);
+
+  rb_define_module_function(r_mpc_math, "sqr", r_mpc_math_sqr, -1);
+  rb_define_module_function(r_mpc_math, "sqrt", r_mpc_math_sqrt, -1);
+  rb_define_module_function(r_mpc_math, "pow", r_mpc_math_pow, -1);
+  rb_define_module_function(r_mpc_math, "exp", r_mpc_math_exp, -1);
+  rb_define_module_function(r_mpc_math, "log", r_mpc_math_log, -1);
+  rb_define_module_function(r_mpc_math, "sin", r_mpc_math_sin, -1);
+  rb_define_module_function(r_mpc_math, "cos", r_mpc_math_cos, -1);
+  rb_define_module_function(r_mpc_math, "tan", r_mpc_math_tan, -1);
+  rb_define_module_function(r_mpc_math, "sinh", r_mpc_math_sinh, -1);
+  rb_define_module_function(r_mpc_math, "cosh", r_mpc_math_cosh, -1);
+  rb_define_module_function(r_mpc_math, "tanh", r_mpc_math_tanh, -1);
+  rb_define_module_function(r_mpc_math, "asin", r_mpc_math_asin, -1);
+  rb_define_module_function(r_mpc_math, "acos", r_mpc_math_acos, -1);
+  rb_define_module_function(r_mpc_math, "atan", r_mpc_math_atan, -1);
+  rb_define_module_function(r_mpc_math, "asinh", r_mpc_math_asinh, -1);
+  rb_define_module_function(r_mpc_math, "acosh", r_mpc_math_acosh, -1);
+  rb_define_module_function(r_mpc_math, "atanh", r_mpc_math_atanh, -1);
+
+  eqq = rb_intern("===");
+  new = rb_intern("new");
+  object_id = rb_intern("object_id");
+  __mpc_class__ = rb_eval_string("MPC");
+  __mpfr_class__ = rb_eval_string("MPFR");
+
+
+}
+