tarf_monte_carlo 2.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: c8ba833192173c38b6d335d681469b91ba509ed41d330db20f63354bd439492f
+  data.tar.gz: afc0ec5bcabd7caaa37e908ac438e7e22f224ea43aaac86c850b3cd01e980f20
+SHA512:
+  metadata.gz: 8f7f2fd84332ee001f2ab4140cf93f1222f0052da5780547078d4f3719d34f54911003e9917c005787b7230244d345c6a154e041a895ec626ec6afaa3ebe90e6
+  data.tar.gz: 188688ac908a15933b3767e74a3d2ecef71db25c30a597800d173fa3435d74e5d888afbbc1641eca51e5d60b1ab3813bb1d81ae57f6bcf910793229e24944ca9

data/.gitignore

@@ -0,0 +1,15 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.swp
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source "https://rubygems.org"
+
+# Specify your gem's dependencies in tarf_monte_carlo.gemspec
+gemspec

data/README.md

@@ -0,0 +1,34 @@
+# TARFMonteCarlo
+
+TODO: ...
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'tarf_monte_carlo'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install tarf_monte_carlo
+
+## Usage
+
+TODO: ...
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+TODO ...
+# tarf_monte_carlo

data/Rakefile

@@ -0,0 +1,37 @@
+require "bundler"
+Bundler::GemHelper.install_tasks
+require "rspec/core/rake_task"
+require 'yard'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => [:compile, :spec]
+require "rake/extensiontask"
+
+task :build => :compile
+task :spec => :compile
+
+desc 'Generate YARD document'
+YARD::Rake::YardocTask.new(:doc) do |t|
+  t.files   = ['ext/tarf_monte_carlo/tarf_monte_carlo.c']
+  t.options = []
+  t.options << '--debug' << '--verbose' if $trace
+end
+
+spec = eval File.read("tarf_monte_carlo.gemspec")
+Rake::ExtensionTask.new("tarf_monte_carlo", spec) do |ext|
+  ext.ext_dir = 'ext/tarf_monte_carlo'
+  ext.cross_compile = true
+  ext.lib_dir = File.join(*['lib', 'tarf_monte_carlo', ENV['FAT_DIR']].compact)
+  # cross_platform names are of MRI's platform name
+  ext.cross_platform = ['x86-mingw32', 'x64-mingw32']
+end
+
+namespace :build do
+  desc 'Build gems for Windows per rake-compiler-dock'
+  task :windows do
+    require 'rake_compiler_dock'
+    RakeCompilerDock.sh 'bundle && rake cross native gem RUBY_CC_VERSION=2.0.0:2.1.6:2.2.2:2.3.0:2.4.0:2.5.0'
+  end
+end
+

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "tarf_monte_carlo"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/ext/tarf_monte_carlo/extconf.rb

@@ -0,0 +1,2 @@
+require "mkmf"
+create_makefile("tarf_monte_carlo/tarf_monte_carlo")

data/ext/tarf_monte_carlo/tarf_monte_carlo.c

@@ -0,0 +1,327 @@
+// S - spot_rate
+// X - strike price of forward
+// b - difference of ccy2 and ccy1 risk free interest rates - cost of carry rate
+// v - volatility
+// T - time to expiration in number of years
+// L - leverage ratio
+// N - notional
+// BS - direction of forward
+// eps - epsilon
+// NL - number of legs
+// SCount - number of simulations
+// MCType - Monte Carlo method type to run
+// KType - Knockout Type
+// DFs - discount factors for pv calculation
+
+#include <ruby.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <math.h>
+#include <time.h>
+#include <stdbool.h>
+#define PI_VALUE 3.14159
+#define BUY 1 // buy sell flag
+#define SELL 2 // buy sell flag
+#define CHAINED 1 // monte carlo method type to run
+#define UNCHAINED 2 // monte carlo method type to run
+#define ABSOLUTE 1 // knockout by absolute
+#define POINTS 2 // knockout by points
+#define LEGS 3 // knockout by legs
+
+// Defining a space for information and references
+// about the module to be stored internally
+// Qnil - Ruby nil in C scope.
+VALUE mTarfMonteCarlo = Qnil;
+VALUE cTarfMonteCarlo = Qnil;
+
+// Prototype for the initialization method - Ruby calls this, not you
+void Init_tarf_monte_carlo();
+
+// Prototype for our methods - methods are prefixed by 'method_' here
+VALUE method_box_muller( VALUE );
+VALUE method_run_monte_carlo( VALUE, VALUE );
+
+// BoxMuller method for epsilon calculations
+// eps = cos(2 * PI * z2) * sqrt( -2 * log( z1 ) )
+VALUE method_box_muller( VALUE self ) {
+  double eps, z1, z2;
+  int i;
+
+  for (i = 0; i < 100; ++i) {
+    z1 = ( (double)rand() / (double)RAND_MAX );
+  }
+
+  for (i = 0; i < 100; ++i) {
+    z2 = ( (double)rand() / (double)RAND_MAX );
+  }
+
+  eps = cos( 2 * PI_VALUE * z2 ) * sqrt( -2 * log( z1 ) );
+
+  return DBL2NUM(eps);
+}
+
+// main method for running monte carlo simulation from sidekiq worker/outside method
+VALUE method_run_monte_carlo( VALUE self, VALUE args ) {
+  VALUE MCInputs = rb_ary_shift(args);
+  rb_p(MCInputs);
+
+  // seed value for rand() function
+  srand( time(0) );
+
+  // initialize payoffs array
+  int leg, sim_count;
+  double pvs_pos_sum = 0.0, pvs_neg_sum = 0.0;
+
+  int SCount = NUM2INT( rb_hash_aref(MCInputs, rb_str_new2("scount")) ) * 2;
+  int MCType = NUM2INT( rb_hash_aref(MCInputs, rb_str_new2("mc_type")) );
+  int NL     = NUM2INT( rb_hash_aref(MCInputs, rb_str_new2("legs_count")) );
+  int BS     = NUM2INT( rb_hash_aref(MCInputs, rb_str_new2("buy_sell")) );
+  double K   = NUM2DBL( rb_hash_aref(MCInputs, rb_str_new2("knockout")) );
+  int KType  = NUM2INT( rb_hash_aref(MCInputs, rb_str_new2("knockout_type")) );
+  double S   = NUM2DBL( rb_hash_aref(MCInputs, rb_str_new2("spot_rate")) );
+
+  // assign leg specific attributes
+  double *pvs_pos   = ( double* ) malloc( SCount * sizeof(double) );
+  double *pvs_neg   = ( double* ) malloc( SCount * sizeof(double) );
+  double *Ls_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *Ts_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *Ns_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *Xs_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *vs_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *bs_array  = ( double* ) malloc( NL * sizeof(double) );
+  double *DFs_array = ( double* ) malloc( NL * sizeof(double) );
+
+  VALUE Ls = rb_hash_aref(MCInputs, rb_str_new2("leverage_ratios") );
+  VALUE Ts = rb_hash_aref(MCInputs, rb_str_new2("expiration_times") );
+  VALUE Ns = rb_hash_aref(MCInputs, rb_str_new2("notionals") );
+  VALUE Xs = rb_hash_aref(MCInputs, rb_str_new2("strikes") );
+  VALUE vs = rb_hash_aref(MCInputs, rb_str_new2("volatilities") );
+  VALUE bs = rb_hash_aref(MCInputs, rb_str_new2("carry_rates") );
+  VALUE DFs = rb_hash_aref(MCInputs, rb_str_new2("discount_factors") );
+
+  for (leg = 0; leg < NL; ++leg) {
+    Ls_array[leg] = NUM2DBL( rb_ary_entry(Ls, leg) );
+    Ts_array[leg] = NUM2DBL( rb_ary_entry(Ts, leg) );
+    Ns_array[leg] = NUM2DBL( rb_ary_entry(Ns, leg) );
+    Xs_array[leg] = NUM2DBL( rb_ary_entry(Xs, leg) );
+    vs_array[leg] = NUM2DBL( rb_ary_entry(vs, leg) );
+    bs_array[leg] = NUM2DBL( rb_ary_entry(bs, leg) );
+    DFs_array[leg] = NUM2DBL( rb_ary_entry(DFs, leg) );
+  }
+
+  // run simulations loop
+  for( sim_count = 0; sim_count < SCount; sim_count += 2 ) {
+    // initial spot rate for each iteration would be current spot rate
+    double Spot = S, Spot_dash = S;
+    double sim[NL], sim_pos[NL], sim_neg[NL], sim_dash[NL], sim_dash_pos[NL], sim_dash_neg[NL];
+
+    // reset all simulation leg specific results
+    for ( leg = 0; leg < NL; ++leg ) {
+      sim[leg] = 0.0;
+      sim_pos[leg] = 0.0;
+      sim_neg[leg] = 0.0;
+      sim_dash[leg] = 0.0;
+      sim_dash_pos[leg] = 0.0;
+      sim_dash_neg[leg] = 0.0;
+    }
+
+    // legs loop start
+    for( leg = 0; leg < NL; ++leg ) {
+      double eps, eps_dash, drift, vSqrdt, profit_loss, profit_loss_dash;
+
+      // get the random value for MC calculation
+      eps = NUM2DBL( method_box_muller( self ) );
+      eps_dash = eps * -1;
+
+      //NOTE: NEED NOT RUN THIS ON EVERY SIMULATION
+      // main formula of MC simulation
+      drift   = ( ( *( bs_array + leg ) ) - 0.5 * pow( ( *( vs_array + leg ) ), 2 ) ) * ( *( Ts_array + leg ) );
+      vSqrdt  = ( *( vs_array + leg ) ) * sqrt( *( Ts_array + leg ) );
+
+      // spot calculation with epsilon & epsilon reverse
+      Spot = Spot * exp( drift + vSqrdt * eps );
+      Spot_dash = Spot_dash * exp( drift + vSqrdt * eps_dash );
+
+      if ( BS == BUY ) {
+        // profit if spot is higher than market price
+        profit_loss = ( Spot - ( *( Xs_array + leg ) ) );
+        // profit if spot is higher than market price
+        profit_loss_dash = ( Spot_dash - ( *( Xs_array + leg ) ) );
+      } else if ( BS == SELL ) {
+        // profit if spot is lower than market price
+        profit_loss = ( ( *( Xs_array + leg ) ) - Spot );
+        // profit if spot is lower than market price
+        profit_loss_dash = ( ( *( Xs_array + leg ) ) - Spot_dash );
+      }
+
+      sim[leg] = profit_loss;
+      sim_dash[leg] = profit_loss_dash;
+
+      // if excuted UNCHAINED method
+      // always use the current spot rate
+      if ( MCType == UNCHAINED ) {
+        Spot = S;
+        Spot_dash = S;
+        // VALUE sk = DBL2NUM( Spot );
+        // rb_p(sk)
+      }
+    }
+    // legs loop end
+
+    // start from the Knock value
+    double ko_so_far = K, ko_so_far_dash = K;
+    if( KType == ABSOLUTE ) {
+      for( leg = 0; leg < NL; ++leg ) {
+        // simulation normal
+        if( ko_so_far > 0.0 ) {
+          if( sim[leg] >= 0.0 ) {
+            // knock out condition
+            double temp_payoff = sim[leg] * ( *( Ns_array + leg ) );
+
+            if( temp_payoff > ko_so_far ) {
+              sim_pos[leg] = ko_so_far;
+              ko_so_far = 0.0;
+            } else if( temp_payoff <= ko_so_far ) {
+              sim_pos[leg] = temp_payoff; // take the payoff in +ve's
+              ko_so_far -= temp_payoff; // update the knock out
+            }
+          } else {
+            sim_neg[leg] = sim[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+
+        // simulation reverse dash
+        if ( ko_so_far_dash > 0.0 ) {
+          if( sim_dash[leg] >= 0.0 ) {
+            // knock out condition
+            double temp_payoff_dash = sim_dash[leg] * ( *( Ns_array + leg ) );
+
+            if( temp_payoff_dash > ko_so_far_dash ) {
+              sim_dash_pos[leg] = ko_so_far_dash;
+              ko_so_far_dash = 0.0;
+            } else if( temp_payoff_dash <= ko_so_far_dash ) {
+              sim_dash_pos[leg] = temp_payoff_dash; // take the payoff in +ve's
+              ko_so_far_dash -= temp_payoff_dash; // update the knock out
+            }
+          } else {
+            sim_dash_neg[leg] = sim_dash[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+      }
+    } else if( KType == POINTS ) {
+      for( leg = 0; leg < NL; ++leg ) {
+        // simulation normal
+        if ( ko_so_far > 0.0 ) {
+          if( sim[leg] >= 0.0 ) {
+            // knock out condition
+            if( sim[leg] > ko_so_far ) {
+              sim_pos[leg] = ko_so_far * ( *( Ns_array + leg ) ); // discuss this
+              ko_so_far = 0.0;
+            } else if( sim[leg] <= ko_so_far ) {
+              sim_pos[leg] = sim[leg] * ( *( Ns_array + leg ) );
+              ko_so_far -= sim[leg];
+            }
+          } else {
+            sim_neg[leg] = sim[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+
+        // simulation reverse dash
+        if ( ko_so_far_dash > 0.0 ) {
+          if( sim_dash[leg] >= 0.0 ) {
+            // knock out condition
+            if( sim_dash[leg] > ko_so_far_dash ) {
+              sim_dash_pos[leg] = ko_so_far_dash * ( *( Ns_array + leg ) ); // discuss this
+              ko_so_far_dash = 0.0;
+            } else if( sim_dash[leg] <= ko_so_far_dash ) {
+              sim_dash_pos[leg] = sim_dash[leg] * ( *( Ns_array + leg ) );
+              ko_so_far_dash -= sim_dash[leg];
+            }
+          } else {
+            sim_dash_neg[leg] = sim_dash[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+      }
+    } else if( KType == LEGS ) {
+      for( leg = 0; leg < NL; ++leg ) {
+        // simulation normal
+        if ( ko_so_far > 0.0 ) {
+          if( sim[leg] >= 0.0 ) {
+            // knock out condition
+            sim_pos[leg] = sim[leg] * ( *( Ns_array + leg ) );
+            ko_so_far -= 1;
+          } else {
+            sim_neg[leg] = sim[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+
+        // simulation reverse dash
+        if ( ko_so_far_dash > 0.0 ) {
+          if( sim_dash[leg] >= 0.0 ) {
+            // knock out condition
+            sim_dash_pos[leg] = sim_dash[leg] * ( *( Ns_array + leg ) );
+            ko_so_far_dash -= 1;
+          } else {
+            sim_dash_neg[leg] = sim_dash[leg] * ( *( Ls_array + leg ) ) * ( *( Ns_array + leg ) );
+          }
+        }
+      }
+    }
+
+    // take sum of positive and negative payoffs and calculate pvs
+    double sim_pos_sum = 0.0, sim_neg_sum = 0.0, sim_dash_pos_sum = 0.0, sim_dash_neg_sum = 0.0;
+    for( leg = 0; leg < NL; ++leg ) {
+      sim_pos_sum += sim_pos[leg] * ( *( DFs_array + leg ) );
+      sim_neg_sum += sim_neg[leg] * ( *( DFs_array + leg ) );
+      sim_dash_pos_sum += sim_dash_pos[leg] * ( *( DFs_array + leg ) );
+      sim_dash_neg_sum += sim_dash_neg[leg] * ( *( DFs_array + leg ) );
+    }
+
+    // calculate +pv and -ve pv for individual leg
+    pvs_pos[sim_count]      = sim_pos_sum;
+    pvs_pos[sim_count + 1]  = sim_dash_pos_sum;
+    pvs_neg[sim_count]      = sim_neg_sum;
+    pvs_neg[sim_count + 1]  = sim_dash_neg_sum;
+  }
+
+  // sum all final +ve and -ve payoffs
+  for(sim_count = 0; sim_count < SCount; ++sim_count) {
+    pvs_pos_sum += *(pvs_pos + sim_count);
+    pvs_neg_sum += *(pvs_neg + sim_count);
+  }
+
+  // free dynamically alloted heap memory
+  free(pvs_pos);
+  free(pvs_neg);
+  free(Ls_array);
+  free(Ts_array);
+  free(Ns_array);
+  free(Xs_array);
+  free(vs_array);
+  free(bs_array);
+  free(DFs_array);
+
+  // return both payoffs
+  VALUE final_pvs = rb_hash_new();
+  rb_hash_aset(final_pvs, rb_str_new2("positive_pv"), DBL2NUM( pvs_pos_sum / SCount ));
+  rb_hash_aset(final_pvs, rb_str_new2("negative_pv"), DBL2NUM( pvs_neg_sum / SCount ));
+  rb_hash_aset(final_pvs, rb_str_new2("total_pv"), DBL2NUM( (pvs_neg_sum + pvs_pos_sum) / SCount ));
+  return final_pvs;
+}
+
+// The initialization method for this module
+void Init_tarf_monte_carlo() {
+  // rb_define_module - defines a module
+  mTarfMonteCarlo = rb_define_module("TarfMonteCarlo");
+
+  // rb_define_class_under - defines a class under passed module
+  cTarfMonteCarlo = rb_define_class_under(mTarfMonteCarlo, "MC", rb_cObject);
+
+  // TarfMonteCarlo::MC
+
+  // void rb_define_singleton_method(VALUE klass, const char *name, VALUE (*func)(), int argc)
+  rb_define_singleton_method(cTarfMonteCarlo, "box_muller", method_box_muller, 0);
+  rb_define_singleton_method(cTarfMonteCarlo, "run_monte_carlo", method_run_monte_carlo, -2);
+}
+

data/lib/tarf_monte_carlo.rb

@@ -0,0 +1,15 @@
+require "tarf_monte_carlo/version"
+
+# must reuired- for requiring tarf_monte_carlo.so file
+# my_malloc/my_malloc will be the shared object built when the gem is
+# installed then copied into lib/my_malloc/.
+
+begin
+  require "tarf_monte_carlo/#{RUBY_VERSION[/\d+.\d+/]}/tarf_monte_carlo"
+rescue LoadError
+  require "tarf_monte_carlo/tarf_monte_carlo"
+end
+
+module TarfMonteCarlo
+  # Your code goes here...
+end

data/lib/tarf_monte_carlo/version.rb

@@ -0,0 +1,7 @@
+# gem build tarf_monte_carlo.gemspec
+# gem push -v tarf_monte_carlo-2.1.gem
+# gem yank tarf_monte_carlo -v 2.1
+
+module TarfMonteCarlo
+  VERSION = "2.2"
+end

data/tarf_monte_carlo.gemspec

@@ -0,0 +1,46 @@
+# files = [
+#   "README.md",
+#   "Rakefile",
+#   "ext/tarf_monte_carlo/extconf.rb",
+#   "ext/tarf_monte_carlo/tarf_monte_carlo.c",
+#   "lib/tarf_monte_carlo.rb",
+#   "lib/tarf_monte_carlo/version.rb"
+# ]
+
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "tarf_monte_carlo/version"
+
+Gem::Specification.new do |spec|
+  spec.name          = "tarf_monte_carlo"
+  spec.version       = TarfMonteCarlo::VERSION
+  spec.authors       = ["Vivek Routh"]
+  spec.email         = ["vvkrth2@gmail.com"]
+
+  spec.summary       = %q{Monte Carlo Simulation.}
+  spec.description   = %q{Monte Carlo Simulation for TARF Contract.}
+  spec.homepage      = %q{https://github.com/vivekapex/tarf_monte_carlo}
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  # spec.files         = `git ls-files -z`.split("\x0") + files
+
+  spec.bindir        = "exe"
+
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  # spec.executables   = ["tarf_monte_carlo"]
+
+  spec.require_paths = ["lib"]
+  spec.extensions    = ["ext/tarf_monte_carlo/extconf.rb"]
+  spec.required_ruby_version = "~> 2.0"
+
+  spec.add_development_dependency "bundler", "~> 1.0"
+  spec.add_development_dependency "rake", "~> 10.4"
+  spec.add_development_dependency "rake-compiler", "~> 1.0"
+  spec.add_development_dependency "rake-compiler-dock", "~> 0.6.0"
+  spec.add_development_dependency "rspec", "~> 3.0", ">= 3.0.0"
+  spec.add_development_dependency "yard", "~> 0.9.11"
+
+  # spec.add_development_dependency "mini_portile2", "~> 2.3.0"
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification
+name: tarf_monte_carlo
+version: !ruby/object:Gem::Version
+  version: '2.2'
+platform: ruby
+authors:
+- Vivek Routh
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2020-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.4'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+- !ruby/object:Gem::Dependency
+  name: rake-compiler-dock
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.6.0
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 3.0.0
+    - - "~>"
+      - !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.0
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: yard
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.9.11
+description: Monte Carlo Simulation for TARF Contract.
+email:
+- vvkrth2@gmail.com
+executables: []
+extensions:
+- ext/tarf_monte_carlo/extconf.rb
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- ext/tarf_monte_carlo/extconf.rb
+- ext/tarf_monte_carlo/tarf_monte_carlo.c
+- lib/tarf_monte_carlo.rb
+- lib/tarf_monte_carlo/version.rb
+- tarf_monte_carlo.gemspec
+homepage: https://github.com/vivekapex/tarf_monte_carlo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - "~>"
+    - !ruby/object:Gem::Version
+      version: '2.0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.6
+signing_key: 
+specification_version: 4
+summary: Monte Carlo Simulation.
+test_files: []