rupee 0.1.0 → 0.1.1

data/README.md

@@ -56,8 +56,16 @@ this in the Ruby console (i.e. `irb` in a command prompt):
 
     require "rupee"
     Rupee::Option.black_scholes "c", 60, 65, 0.25, 0.08, 0, 0.3
+    Rupee::Call.new(
+      :underlying => 60,
+      :strike     => 65,
+      :time       =>  0.25,
+      :rate       =>  0.08,
+      :div_yield  =>  0.00,
+      :volatility =>  0.3
+    ).black_scholes
 
-which should return `2.1334`.
+both of which should return `2.1334`.
 
 You should also be able to get the latest stock info for, for example, Wells
 Fargo using the following (note that you only need to `require` the `quote`
@@ -72,14 +80,30 @@ Performance
 -----------
 
 This is just a simple benchmark I ran on my own laptop, where I value a simple
-call option with Black-Scholes one million times. You can test the same on
-yours with rake, but in any case it makes the point that for the mathematical
-side of finance a native extension has substantial benefits:
+call option with Black-Scholes 100,000 times. You can test the same on yours
+with rake, but in any case it makes the point that for the mathematical side
+of finance a native extension has substantial benefits:
 
     rake benchmark:black_scholes
 
 Results:
 
-                     user     system      total        real
-    rupee:       1.388000   0.000000   1.388000 (  1.440000)
-    pure ruby:  18.580000   0.000000  18.580000 ( 18.817000)
+                              user     system      total        real
+    Rupee (class):        0.190000   0.000000   0.190000 (  0.194001)
+    Rupee (one object):   0.180000   0.000000   0.180000 (  0.183091)
+    Rupee (new object):   2.210000   0.000000   2.210000 (  2.213351)
+    Pure Ruby:            2.320000   0.000000   2.320000 (  2.324259)
+
+In words, for math-intensive operations, using a C implementation is clearly
+faster than the same thing in Ruby.
+
+Also, if you're doing a valuation on a one-off set of examples (e.g. in a Monte
+Carlo simulation), you probably don't want to create an object every time.
+Something like `Rupee::Option.black_scholes ...` should work just fine.
+Creating a `Rupee::Option` object takes roughly the same amount of time as
+running `Rupee::Option.black_scholes` a dozen times.
+
+However, if you're creating and reusing an object, I strongly recommend
+preserving the object orientation of Ruby: the penalty for using a new instance
+rather than calling the class method directly is almost entirely in the object
+initialization itself.

data/ext/rupee/bond.c

@@ -1,82 +1,274 @@
 #include "rupee.h"
 
+#define ACCURACY 0.00001
+#define MAX_ITERATIONS 200
+
 double
-bond_price(cf_times, cfs, r, len)
-  double *cf_times, *cfs, r;
+bond_conv(times, cflows, r, len, discrete)
+  double *times, *cflows, r;
   int len;
+  bool discrete;
 {
-  double p, *cft;
+  double C, B;
   int i;
+  C = 0;
+
+  for (i = 0; i < len; i++) {
+    double time, time_sq;
+    time = times[i];
+
+    // I'm a little skeptical this is correct
+    if (discrete)
+      time_sq = time * (times[i] + 1);
+    else
+      time_sq = pow(time, 2);
+
+    C += cflows[i] * time_sq * simple_df(r, time, discrete);
+  }
 
+  B = bond_price(times, cflows, r, len, discrete);
+
+  // Same goes for this; I don't know why you'd discount only under discrete
+  // compounding. That doesn't seem like a market convention.
+  if (discrete)
+    return C / pow(1 + r, 2) / B;
+  else
+    return C / B;
+};
+
+double
+bond_dur(times, cflows, r, len, discrete)
+  double *times, *cflows, r;
+  int len;
+  bool discrete;
+{
+  double S, D1;
+  int i;
+  S = 0;
+  D1 = 0;
+
+  for (i = 0; i < len; i++) {
+    double time, dcflow;
+
+    time = times[i];
+    dcflow = cflows[i] * simple_df(r, time, discrete);
+
+  	S  += dcflow;
+ 	  D1 += dcflow * time;
+  }
+
+  return D1 / S;
+}
+
+double
+bond_price(times, cflows, r, len, discrete)
+  double *times, *cflows, r;
+  int len;
+  bool discrete;
+{
+  double p, *cft;
+  int i;
   p = 0;
 
   for (i = 0; i < len; i++)
-  	p += exp(-r * cf_times[i]) * cfs[i];
+  	p += cflows[i] * simple_df(r, times[i], discrete);
 
   return p;
 };
 
+double
+bond_ytm(times, cflows, price, len, discrete)
+  double *times, *cflows, price;
+  int len;
+  bool discrete;
+{
+  double bot, top, r;
+  int i;
+  bot = 0;
+  top = 1;
+
+  while (bond_price(times, cflows, top, len, discrete) > price)
+    top *= 2;
+
+  r = avg(top, bot);
+
+  for (i = 0; i < MAX_ITERATIONS; i++) {
+    double diff;
+    diff = bond_price(times, cflows, r, len, discrete) - price;
+
+    if (fabs(diff) < ACCURACY)
+      return r;
+    
+    if (diff > 0.0)
+      bot = r;
+    else
+      top = r;
+
+    r = avg(top, bot);
+  };
+
+  return r;
+};
+
+// Ruby singleton functions
+
+static VALUE
+convexity(self, _times, _cflows, _r, discrete)
+  VALUE self, _times, _cflows, _r;
+  bool discrete;
+{
+  int len = RARRAY_LEN(_cflows);
+  double times[len], cflows[len], r;
+
+  rtofa(times, _times, len);
+  rtofa(cflows, _cflows, len);
+  r = NUM2DBL(_r);
+
+  return rb_float_new(bond_conv(times, cflows, r, len, discrete));
+};
+
 static VALUE
-price(self, rcf_times, rcfs, rr)
-  VALUE self, rcf_times, rcfs, rr;
+duration(self, _times, _cflows, _r, discrete)
+  VALUE self, _times, _cflows, _r;
+  bool discrete;
 {
-  int len = RARRAY_LEN(rcfs);
-  double r, cf_times[len], cfs[len];
+  int len = RARRAY_LEN(_cflows);
+  double times[len], cflows[len], r;
   
-  r = NUM2DBL(rr);
-  rtofa(cf_times, rcf_times, len);
-  rtofa(cfs, rcfs, len);
+  rtofa(times, _times, len);
+  rtofa(cflows, _cflows, len);
+  r = NUM2DBL(_r);
 
-  return rb_float_new(bond_price(cf_times, cfs, r, len));
+  return rb_float_new(bond_dur(times, cflows, r, len, discrete));
 }
 
 static VALUE
-convexity(self, rcf_times, rcfs, rr)
-  VALUE self, rcf_times, rcfs, rr;
+macaulay(self, _times, _cflows, _price, discrete)
+  VALUE self, _times, _cflows, _price;
+  bool discrete;
 {
-  int len = RARRAY_LEN(rcfs);
-  double r, C, B, cf_times[len], cfs[len];
-  int i;
-
-  rtofa(cf_times, rcf_times, len);
-  rtofa(cfs, rcfs, len);
-  r = NUM2DBL(rr);
-  C = 0;
+  int len = RARRAY_LEN(_cflows);
+  double times[len], cflows[len], price, ytm;
 
-  for (i = 0; i < len; i++)
-  	C += cfs[i] * pow(cf_times[i], 2) * exp(-r * cf_times[i]);
+  rtofa(times, _times, len);
+  rtofa(cflows, _cflows, len);
+  price = NUM2DBL(price);
 
-  B = bond_price(cf_times, cfs, r, len);
+  ytm = bond_ytm(times, cflows, price, len, discrete);
 
-  return rb_float_new(C / B);
+  return rb_float_new(bond_dur(times, cflows, ytm, len, discrete));
 };
 
 static VALUE
-duration(self, rcf_times, rcfs, rr)
-  VALUE self, rcf_times, rcfs, rr;
+price(self, _times, _cflows, _r, discrete)
+  VALUE self, _times, _cflows, _r;
+  bool discrete;
 {
-  double r, S, D1;
-  int i, cfs_len;
+  int len = RARRAY_LEN(_cflows);
+  double times[len], cflows[len], r;
+  
+  rtofa(times, _times, len);
+  rtofa(cflows, _cflows, len);
+  r = NUM2DBL(_r);
 
-  VALUE *cf_times = RARRAY_PTR(rcf_times);
-  VALUE *cfs = RARRAY_PTR(rcfs);
-  cfs_len = RARRAY_LEN(rcfs);
-  r = NUM2DBL(rr);
-  S = 0;
-  D1 = 0;
+  return rb_float_new(bond_price(times, cflows, r, len, discrete));
+}
 
-  for (i = 0; i < cfs_len; i++) {
-    double cfti, cfi, dcfi;
+// Helper functions
 
-    cfti = NUM2DBL(cf_times[i]);
-    cfi = NUM2DBL(cfs[i]);
-    dcfi = cfi * exp(-r * cfti);
+// Convexity of a continuously compounded bond
+static VALUE
+convexity_continuous(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return convexity(self, _times, _cflows, _r, false);
+}
 
-  	S  += dcfi;
- 	  D1 += cfti * dcfi;
-  }
+// Convexity of a discretely compounded bond
+static VALUE
+convexity_discrete(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return convexity(self, _times, _cflows, _r, true);
+}
+
+// Duration of a continuously compounded bond
+static VALUE
+duration_continuous(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return duration(self, _times, _cflows, _r, false);
+}
+
+// Duration of a discretely compounded bond
+static VALUE
+duration_discrete(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return duration(self, _times, _cflows, _r, true);
+}
+
+// Macaulay duration of a continuously compounded bond
+static VALUE
+macaulay_continuous(self, _times, _cflows, _price)
+  VALUE self, _times, _cflows, _price;
+{
+  return macaulay(self, _times, _cflows, _price, false);
+}
 
-  return rb_float_new(D1 / S);
+// Macaulay duration of a discretely compounded bond
+static VALUE
+macaulay_discrete(self, _times, _cflows, _price)
+  VALUE self, _times, _cflows, _price;
+{
+  return macaulay(self, _times, _cflows, _price, true);
+}
+
+// Price of a continuously compounded bond
+static VALUE
+price_continuous(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return price(self, _times, _cflows, _r, false);
+}
+
+// Price of a discretely compounded bond
+static VALUE
+price_discrete(self, _times, _cflows, _r)
+  VALUE self, _times, _cflows, _r;
+{
+  return price(self, _times, _cflows, _r, true);
+}
+
+static VALUE
+yield_to_maturity(self, _times, _cflows, _price, discrete)
+  VALUE self, _times, _cflows, _price;
+  bool discrete;
+{
+  int len = RARRAY_LEN(_cflows);
+  double times[len], cflows[len], price;
+
+  rtofa(times, _times, len);
+  rtofa(cflows, _cflows, len);
+  price = NUM2DBL(_price);
+
+  return rb_float_new(bond_ytm(times, cflows, price, len, discrete));
+};
+
+// Yield to maturity of a continuously compounded bond
+static VALUE
+yield_to_maturity_continuous(self, _times, _cflows, _price)
+  VALUE self, _times, _cflows, _price;
+{
+  return yield_to_maturity(self, _times, _cflows, _price, false);
+}
+
+// Yield to maturity of a discretely compounded bond
+static VALUE
+yield_to_maturity_discrete(self, _times, _cflows, _price)
+  VALUE self, _times, _cflows, _price;
+{
+  return yield_to_maturity(self, _times, _cflows, _price, true);
 }
 
 void
@@ -85,13 +277,28 @@ init_bond()
   VALUE klass, singleton;
 
 #if 0
-  value module = rb_define_module("rupee");
+  VALUE module = rb_define_module("Rupee");
+  VALUE superklass = rb_define_class_under(module, "Security", rb_cObject);
 #endif
 
-  klass = rb_define_class_under(module, "Bond", rb_cObject);
+  klass = rb_define_class_under(module, "Bond", superklass);
   singleton = rb_singleton_class(klass);
 
-  rb_define_singleton_method(klass, "convexity", convexity, 3);
-  rb_define_singleton_method(klass, "duration", duration, 3);
-  rb_define_singleton_method(klass, "price", price, 3);
+  rb_define_singleton_method(klass, "convexity", convexity_discrete, 3);
+  rb_define_singleton_method(klass, "continuous_convexity", convexity_continuous, 3);
+  rb_define_singleton_method(klass, "continuous_duration", duration_continuous, 3);
+  rb_define_singleton_method(klass, "continuous_macaulay", macaulay_continuous, 3);
+  rb_define_singleton_method(klass, "continuous_price", price_continuous, 3);
+  rb_define_singleton_method(klass, "continuous_yield_to_maturity", yield_to_maturity_continuous, 3);
+  rb_define_alias(singleton, "continuous_yield", "continuous_yield_to_maturity");
+  rb_define_alias(singleton, "continuous_ytm", "continuous_yield_to_maturity");
+  rb_define_singleton_method(klass, "duration", duration_discrete, 3);
+  rb_define_alias(singleton, "dur", "duration");
+  rb_define_singleton_method(klass, "macaulay", macaulay_discrete, 3);
+  rb_define_alias(singleton, "macaulary_duration", "macaulay");
+  rb_define_singleton_method(klass, "price", price_discrete, 3);
+  rb_define_alias(singleton, "value", "price");
+  rb_define_singleton_method(klass, "yield_to_maturity", yield_to_maturity_discrete, 3);
+  rb_define_alias(singleton, "yield", "yield_to_maturity");
+  rb_define_alias(singleton, "ytm", "yield_to_maturity");
 }

data/ext/rupee/future.c

@@ -0,0 +1,38 @@
+#include "rupee.h"
+
+double
+future_price(S, r, ttm)
+  double S, r, ttm;
+{
+  return S * exp(r * ttm);
+}
+
+static VALUE
+price(self, _S, _r, _ttm)
+  VALUE self, _S, _r, _ttm;
+{
+  double S, r, ttm;
+
+  S   = NUM2DBL(_S);
+  r   = NUM2DBL(_r);
+  ttm = NUM2DBL(_ttm);
+
+  return rb_float_new(future_price(S, r, ttm));
+}
+
+void
+init_future()
+{
+  VALUE klass, singleton;
+
+#if 0
+  VALUE module = rb_define_module("Rupee");
+  VALUE superklass = rb_define_class_under(module, "Security", rb_cObject);
+#endif
+
+  klass = rb_define_class_under(module, "Future", superklass);
+  singleton = rb_singleton_class(klass);
+
+  rb_define_singleton_method(klass, "price", price, 3);
+  rb_define_alias(singleton, "value", "price");
+}

data/ext/rupee/option.c

@@ -164,15 +164,16 @@ init_option()
 
 #if 0
   VALUE module = rb_define_module("Rupee");
+  VALUE superklass = rb_define_class_under(module, "Security", rb_cObject);
 #endif
 
-  klass = rb_define_class_under(module, "Option", rb_cObject);
+  klass = rb_define_class_under(module, "Option", superklass);
   singleton = rb_singleton_class(klass);
 
+  rb_define_singleton_method(klass, "black76", rupee_black76, 6);
   rb_define_singleton_method(klass, "black_scholes", rupee_black_scholes, 7);
   rb_define_alias(singleton, "bs", "black_scholes");
   rb_define_singleton_method(klass, "generalized_black_scholes",
       rupee_generalized_black_scholes, 7);
   rb_define_alias(singleton, "gbs", "generalized_black_scholes");
-  rb_define_singleton_method(klass, "black76", rupee_black76, 6);
 }

data/ext/rupee/rupee.c

@@ -1,13 +1,15 @@
 #include "rupee.h"
 
-VALUE module;
+VALUE module, superklass;
 
 void
 Init_rupee()
 {
   module = rb_define_module("Rupee");
+  superklass = rb_define_class_under(module, "Security", rb_cObject);
 
   init_distribution();
   init_option();
   init_bond();
+  init_future();
 }

data/ext/rupee/rupee.h

@@ -7,9 +7,12 @@
 #include <stdbool.h>
 
 extern VALUE module;
+extern VALUE superklass;
 
-/* Conversion */
+/* Utilities */
 double *rtofa(double *dest, VALUE src, int len);
+double avg(double x, double y);
+double simple_df(double r, double time, bool discrete);
 
 /* Statistics */
 double cnd(double);
@@ -21,7 +24,13 @@ double gbs(const char *call_put_flag, double S, double X, double T, double r,
 void init_option();
 
 /* Bonds */
-double bond_price(double *cf_times, double *cfs, double r, int len);
+double bond_dur(double *times, double *cflows, double r, int len, bool discrete);
+double bond_price(double *times, double *cflows, double r, int len, bool discrete);
+double bond_ytm(double *times, double *cflows, double r, int len, bool discrete);
 void init_bond();
 
+/* Futures */
+double future_price(double S, double r, double ttm);
+void init_future();
+
 #endif

data/ext/rupee/util.c

@@ -0,0 +1,36 @@
+#include "rupee.h"
+
+double
+simple_df(r, time, discrete)
+  double r, time;
+  bool discrete;
+{
+  if (discrete)
+    return 1.0 / pow(1.0 + r, time);
+  else
+    return exp(-r * time);
+}
+
+double *
+rtofa(dest, src, len)
+  double *dest;
+  VALUE src;
+  int len;
+{
+  int i;
+  VALUE *ary;
+
+  ary = RARRAY_PTR(src);
+
+  for (i = 0; i < len; i++)
+    dest[i] = NUM2DBL(ary[i]);
+
+  return dest;
+}
+
+double
+avg(x, y)
+  double x, y;
+{
+  return 0.5 * (x + y);
+}

data/lib/rupee.rb

@@ -1,5 +1,7 @@
 require "rupee/rupee" # keep this as the first require
 require "rupee/version"
+require "rupee/security"
+require "rupee/option.rb"
 
 # Rupee aims to provide user-friendly tools for use in financial applications.
 # The gem is in its development stages, but it currently offers:
@@ -16,5 +18,6 @@ require "rupee/version"
 
 # This module contains all modules and classes associated with Rupee
 module Rupee
+  # autoload :Option, "rupee/option.rb"
   autoload :Quote, "rupee/quote"
 end

data/lib/rupee/option.rb

@@ -0,0 +1,31 @@
+require "rupee/security"
+
+module Rupee
+  class Option < Security
+    attr_accessor :type, :underlying, :strike, :time, :rate, :div_yield, :volatility, :price
+    alias :rfr :rate
+    alias :rfr= :rate=
+    alias :risk_free_rate :rate
+    alias :risk_free_rate= :rate=
+    alias :value :price
+    alias :value= :price=
+
+    def black_scholes
+      @value = self.class.black_scholes @type.to_s, @underlying, @strike, @time, @rate, @div_yield, @volatility
+    end
+  end
+
+  class Call < Option
+    def initialize(opts = {})
+      @type = "call"
+      super
+    end
+  end
+
+  class Put < Option
+    def initialize(opts = {})
+      @type = :put
+      super
+    end
+  end
+end

data/lib/rupee/security.rb

@@ -0,0 +1,36 @@
+module Rupee
+  # An abstract class from which all Rupee security types inherit
+  class Security
+    # Automatically sets all arguments passed to <tt>initialize</tt> to
+    # instance variables if they exist (think Rails mass assignment).
+    #
+    #     require "rupee"
+    #
+    #     call = Rupee::Call.new(
+    #       :underlying => 60,
+    #       :strike     => 65,
+    #       :time       =>  0.25,
+    #       :rate       =>  0.08,
+    #       :div_yield  =>  0.00,
+    #       :volatility =>  0.3
+    #     )
+    #     puts call.black_scholes
+    #     #=> 2.1333718619275794
+    #
+    # You still have the option of avoiding the creation of an object (and the
+    # overhead it entails) by using the class methods directly:
+    #
+    #     require "rupee"
+    #
+    #     puts Rupee::Option.black_scholes "c", 60, 65, 0.25, 0.08, 0, 0.3
+    #     #=> 2.1333718619275794
+    def initialize(opts = {})
+      opts.each do |key, value|
+        writer = key.to_s.+("=").to_sym
+        if respond_to?(writer)
+          send writer, value
+        end
+      end
+    end
+  end
+end

data/lib/rupee/version.rb

@@ -1,4 +1,4 @@
 module Rupee
   # The current version
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 end

data/spec/c/bond_spec.rb

@@ -1,17 +1,10 @@
 require File.dirname(__FILE__) + "/../spec_helper"
 
 # Discrete discounting
-# bonds price    = 102.531
-# bond yield to maturity = 0.09
-# bond duration  = 2.73895
 # bond duration modified = 2.5128
-# bond convexity =8.93248
 # new bond price = 100
 #Continous discounting
-# bonds price    = 101.464
 # bond yield to maturity = 0.09
-# bond duration  = 2.73753
-# bond convexity =7.86779
 # new bond price = 104.282
 
 TOLERANCE = 0.001
@@ -23,17 +16,41 @@ describe Rupee::Bond do
     @r = 0.09
   end
 
+  describe "with discrete discounting" do
+    it "should produce an accurate price" do
+      Rupee::Bond.price(@times, @cflows, @r).should be_within(TOLERANCE).of 102.531
+    end
+
+    it "should produce an accurate duration" do
+      Rupee::Bond.duration(@times, @cflows, @r).should be_within(TOLERANCE).of 2.73895
+    end
+
+    it "should produce an accurate convexity" do
+      Rupee::Bond.convexity(@times, @cflows, @r).should be_within(TOLERANCE).of 8.93248
+    end
+
+    it "should produce an accurate yield to maturity" do
+      @price = Rupee::Bond.price(@times, @cflows, @r)
+      Rupee::Bond.yield_to_maturity(@times, @cflows, @price).should be_within(TOLERANCE).of @r
+    end
+  end
+
   describe "with continuous discounting" do
     it "should produce an accurate price" do
-      Rupee::Bond.price(@times, @cflows, @r).should be_within(TOLERANCE).of 101.464
+      Rupee::Bond.continuous_price(@times, @cflows, @r).should be_within(TOLERANCE).of 101.464
     end
 
     it "should produce an accurate duration" do
-      Rupee::Bond.duration(@times, @cflows, @r).should be_within(TOLERANCE).of 2.73753
+      Rupee::Bond.continuous_duration(@times, @cflows, @r).should be_within(TOLERANCE).of 2.73753
     end
 
     it "should produce an accurate convexity" do
-      Rupee::Bond.convexity(@times, @cflows, @r).should be_within(TOLERANCE).of 7.86779
+      Rupee::Bond.continuous_convexity(@times, @cflows, @r).should be_within(TOLERANCE).of 7.86779
+    end
+
+    it "should produce an accurate yield to maturity" do
+      @price = Rupee::Bond.continuous_price(@times, @cflows, @r)
+      Rupee::Bond.continuous_yield_to_maturity(@times, @cflows, @price).should be_within(TOLERANCE).of @r
     end
   end
 end

data/spec/c/future_spec.rb

@@ -0,0 +1,13 @@
+require File.dirname(__FILE__) + "/../spec_helper"
+
+describe Rupee::Future do
+  before :each do
+    @underlying = 100
+    @rfr = 0.10
+    @ttm = 0.5
+  end
+
+  it "should produce an accurate price" do
+    Rupee::Future.price(@underlying, @rfr, @ttm).should be_within(TOLERANCE).of 105.127
+  end
+end

data/tasks/benchmark.rake

@@ -3,19 +3,48 @@ autoload :Benchmark, "benchmark"
 namespace :benchmark do
   task :default => :black_scholes
 
-  desc "Run Black-Scholes one million times"
+  desc "Run Black-Scholes on a European call 100,000 times"
   task :black_scholes do
     require "rupee"
     require "rupee/benchmark"
 
-    n = 1_000_000
-    Benchmark.bm(11) do |x|
-      x.report "rupee:" do
+    n = 100_000
+    Benchmark.bm(19) do |x|
+      x.report "Rupee (class):" do
         n.times do
           Rupee::Option.black_scholes "c", 60, 65, 0.25, 0.08, 0, 0.3
         end
       end
-      x.report("pure ruby:") do
+
+      x.report "Rupee (one object):" do
+        call = Rupee::Call.new(
+          :underlying => 60,
+          :strike     => 65,
+          :time       =>  0.25,
+          :rate       =>  0.08,
+          :div_yield  =>  0.00,
+          :volatility =>  0.3
+        )
+
+        n.times do
+          call.black_scholes
+        end
+      end
+
+      x.report "Rupee (new object):" do
+        n.times do
+          Rupee::Call.new(
+           :underlying => 60,
+           :strike     => 65,
+           :time       =>  0.25,
+           :rate       =>  0.08,
+           :div_yield  =>  0.00,
+           :volatility =>  0.3
+         ).black_scholes
+        end
+      end
+
+      x.report("Pure Ruby:") do
         n.times do
           Rupee::Benchmark.black_scholes "c", 60, 65, 0.25, 0.08, 0.3
         end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rupee
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
   prerelease: 
 platform: ruby
 authors:
@@ -13,7 +13,7 @@ date: 2011-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
-  requirement: &84328270 !ruby/object:Gem::Requirement
+  requirement: &71003600 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -21,10 +21,10 @@ dependencies:
         version: '1.0'
   type: :development
   prerelease: false
-  version_requirements: *84328270
+  version_requirements: *71003600
 - !ruby/object:Gem::Dependency
   name: rspec
-  requirement: &84326450 !ruby/object:Gem::Requirement
+  requirement: &71002450 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -32,10 +32,10 @@ dependencies:
         version: '2.0'
   type: :development
   prerelease: false
-  version_requirements: *84326450
+  version_requirements: *71002450
 - !ruby/object:Gem::Dependency
   name: autotest
-  requirement: &84324740 !ruby/object:Gem::Requirement
+  requirement: &70999390 !ruby/object:Gem::Requirement
     none: false
     requirements:
     - - ~>
@@ -43,7 +43,7 @@ dependencies:
         version: '4.0'
   type: :development
   prerelease: false
-  version_requirements: *84324740
+  version_requirements: *70999390
 description: rupee aims to provide user-friendly tools for use in financial gems and
   applications.
 email:
@@ -61,20 +61,24 @@ files:
 - README.md
 - Rakefile
 - ext/rupee/bond.c
-- ext/rupee/conv.c
 - ext/rupee/distribution.c
 - ext/rupee/extconf.rb
+- ext/rupee/future.c
 - ext/rupee/option.c
 - ext/rupee/rupee.c
 - ext/rupee/rupee.h
+- ext/rupee/util.c
 - lib/rupee.rb
 - lib/rupee/benchmark.rb
+- lib/rupee/option.rb
 - lib/rupee/quote.rb
 - lib/rupee/quote/source.rb
+- lib/rupee/security.rb
 - lib/rupee/version.rb
 - rupee.gemspec
 - spec/c/bond_spec.rb
 - spec/c/distribution_spec.rb
+- spec/c/future_spec.rb
 - spec/c/option_spec.rb
 - spec/import/quote_spec.rb
 - spec/spec_helper.rb
@@ -107,5 +111,6 @@ summary: Financial tools for Ruby
 test_files:
 - spec/c/bond_spec.rb
 - spec/c/distribution_spec.rb
+- spec/c/future_spec.rb
 - spec/c/option_spec.rb
 - spec/import/quote_spec.rb

data/ext/rupee/conv.c

@@ -1,18 +0,0 @@
-#include "rupee.h"
-
-double *
-rtofa(dest, src, len)
-  double *dest;
-  VALUE src;
-  int len;
-{
-  int i;
-  VALUE *ary;
-
-  ary = RARRAY_PTR(src);
-
-  for (i = 0; i < len; i++)
-    dest[i] = NUM2DBL(ary[i]);
-
-  return dest;
-}