RubyGems - option_lab - Versions diffs - 0.1.0 - Mend

option_lab 0.1.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (64) hide show

checksums.yaml +7 -0
data/.rspec +3 -0
data/.rubocop.yml +139 -0
data/.yard/hooks/before_generate.rb +7 -0
data/.yardopts +11 -0
data/Gemfile +26 -0
data/LICENSE.txt +21 -0
data/README.md +180 -0
data/Rakefile +44 -0
data/docs/OptionLab/BinomialTree.html +1271 -0
data/docs/OptionLab/BjerksundStensland.html +2022 -0
data/docs/OptionLab/BlackScholes.html +2388 -0
data/docs/OptionLab/Engine.html +1716 -0
data/docs/OptionLab/Models/AmericanModelInputs.html +937 -0
data/docs/OptionLab/Models/ArrayInputs.html +463 -0
data/docs/OptionLab/Models/BaseModel.html +223 -0
data/docs/OptionLab/Models/BinomialModelInputs.html +1161 -0
data/docs/OptionLab/Models/BlackScholesInfo.html +967 -0
data/docs/OptionLab/Models/BlackScholesModelInputs.html +851 -0
data/docs/OptionLab/Models/ClosedPosition.html +445 -0
data/docs/OptionLab/Models/EngineData.html +2523 -0
data/docs/OptionLab/Models/EngineDataResults.html +435 -0
data/docs/OptionLab/Models/Inputs.html +2241 -0
data/docs/OptionLab/Models/LaplaceInputs.html +777 -0
data/docs/OptionLab/Models/Option.html +736 -0
data/docs/OptionLab/Models/Outputs.html +1753 -0
data/docs/OptionLab/Models/PoPOutputs.html +645 -0
data/docs/OptionLab/Models/PricingResult.html +848 -0
data/docs/OptionLab/Models/Stock.html +583 -0
data/docs/OptionLab/Models/TreeVisualization.html +688 -0
data/docs/OptionLab/Models.html +251 -0
data/docs/OptionLab/Plotting.html +548 -0
data/docs/OptionLab/Support.html +2884 -0
data/docs/OptionLab/Utils.html +619 -0
data/docs/OptionLab.html +133 -0
data/docs/_index.html +376 -0
data/docs/class_list.html +54 -0
data/docs/css/common.css +1 -0
data/docs/css/full_list.css +58 -0
data/docs/css/style.css +503 -0
data/docs/file.LICENSE.html +70 -0
data/docs/file.README.html +263 -0
data/docs/file_list.html +64 -0
data/docs/frames.html +22 -0
data/docs/index.html +263 -0
data/docs/js/app.js +344 -0
data/docs/js/full_list.js +242 -0
data/docs/js/jquery.js +4 -0
data/docs/method_list.html +1974 -0
data/docs/top-level-namespace.html +110 -0
data/examples/american_options.rb +163 -0
data/examples/covered_call.rb +76 -0
data/lib/option_lab/binomial_tree.rb +238 -0
data/lib/option_lab/bjerksund_stensland.rb +276 -0
data/lib/option_lab/black_scholes.rb +323 -0
data/lib/option_lab/engine.rb +492 -0
data/lib/option_lab/models.rb +768 -0
data/lib/option_lab/plotting.rb +182 -0
data/lib/option_lab/support.rb +471 -0
data/lib/option_lab/utils.rb +107 -0
data/lib/option_lab/version.rb +5 -0
data/lib/option_lab.rb +134 -0
data/option_lab.gemspec +43 -0
metadata +207 -0

data/docs/top-level-namespace.html ADDED Viewed

@@ -0,0 +1,110 @@
+<!DOCTYPE html>
+<html>
+  <head>
+    <meta charset="utf-8">
+<meta name="viewport" content="width=device-width, initial-scale=1.0">
+<title>
+  Top Level Namespace
+    &mdash; OptionLab Documentation
+</title>
+  <link rel="stylesheet" href="css/style.css" type="text/css" />
+  <link rel="stylesheet" href="css/common.css" type="text/css" />
+<script type="text/javascript">
+  pathId = "";
+  relpath = '';
+</script>
+  <script type="text/javascript" charset="utf-8" src="js/jquery.js"></script>
+  <script type="text/javascript" charset="utf-8" src="js/app.js"></script>
+  </head>
+  <body>
+    <div class="nav_wrap">
+      <iframe id="nav" src="class_list.html?1"></iframe>
+      <div id="resizer"></div>
+    </div>
+    <div id="main" tabindex="-1">
+      <div id="header">
+        <div id="menu">
+    <a href="_index.html">Index</a> &raquo;
+    <span class="title">Top Level Namespace</span>
+</div>
+        <div id="search">
+    <a class="full_list_link" id="class_list_link"
+        href="class_list.html">
+        <svg width="24" height="24">
+          <rect x="0" y="4" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="12" width="24" height="4" rx="1" ry="1"></rect>
+          <rect x="0" y="20" width="24" height="4" rx="1" ry="1"></rect>
+        </svg>
+    </a>
+</div>
+        <div class="clear"></div>
+      </div>
+      <div id="content"><h1>Top Level Namespace
+</h1>
+<div class="box_info">
+</div>
+<h2>Defined Under Namespace</h2>
+<p class="children">
+      <strong class="modules">Modules:</strong> <span class='object_link'><a href="OptionLab.html" title="OptionLab (module)">OptionLab</a></span>
+</p>
+</div>
+      <div id="footer">
+  Generated on Sun Apr 27 16:09:33 2025 by
+  <a href="https://yardoc.org" title="Yay! A Ruby Documentation Tool" target="_parent">yard</a>
+  0.9.37 (ruby-3.3.3).
+</div>
+    </div>
+  </body>
+</html>

data/examples/american_options.rb ADDED Viewed

@@ -0,0 +1,163 @@
+# frozen_string_literal: true
+require 'date'
+# Use the local code instead of the installed gem
+require_relative '../lib/option_lab'
+# Example of pricing American options using different models
+puts 'American Option Pricing Models Comparison'
+puts '----------------------------------------'
+# Input parameters
+spot_price = 100.0
+strike_price = 105.0
+risk_free_rate = 0.05
+volatility = 0.25
+dividend_yield = 0.03
+time_to_maturity = 1.0 # 1 year
+# Calculate option prices using both models
+puts "\nCall Option Comparison:"
+puts '----------------------'
+# Black-Scholes (European)
+bs_call_price = OptionLab::BlackScholes.get_bs_info(
+  spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, dividend_yield
+).call_price
+puts "European Call (Black-Scholes): $#{bs_call_price.round(4)}"
+# Cox-Ross-Rubinstein Binomial Tree (American)
+crr_call_price = OptionLab.price_binomial(
+  'call', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, 100, true, dividend_yield
+)
+puts "American Call (CRR Binomial): $#{crr_call_price.round(4)}"
+# Bjerksund-Stensland (American)
+bs_am_call_price = OptionLab.price_american(
+  'call', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, dividend_yield
+)
+puts "American Call (Bjerksund-Stensland): $#{bs_am_call_price.round(4)}"
+# Put option prices
+puts "\nPut Option Comparison:"
+puts '---------------------'
+# Black-Scholes (European)
+bs_put_price = OptionLab::BlackScholes.get_bs_info(
+  spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, dividend_yield
+).put_price
+puts "European Put (Black-Scholes): $#{bs_put_price.round(4)}"
+# Cox-Ross-Rubinstein Binomial Tree (American)
+crr_put_price = OptionLab.price_binomial(
+  'put', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, 100, true, dividend_yield
+)
+puts "American Put (CRR Binomial): $#{crr_put_price.round(4)}"
+# Bjerksund-Stensland (American)
+bs_am_put_price = OptionLab.price_american(
+  'put', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, dividend_yield
+)
+puts "American Put (Bjerksund-Stensland): $#{bs_am_put_price.round(4)}"
+# Calculate Greeks for the American put option (which typically has higher early exercise value)
+puts "\nAmerican Put Option Greeks Comparison:"
+puts '-----------------------------------'
+# CRR Binomial Greeks
+crr_greeks = OptionLab.get_binomial_greeks(
+  'put', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, 100, true, dividend_yield
+)
+puts 'CRR Binomial Greeks:'
+puts "Delta: #{crr_greeks[:delta].round(6)}"
+puts "Gamma: #{crr_greeks[:gamma].round(6)}"
+puts "Theta: #{crr_greeks[:theta].round(6)}"
+puts "Vega: #{crr_greeks[:vega].round(6)}"
+puts "Rho: #{crr_greeks[:rho].round(6)}"
+# Bjerksund-Stensland Greeks
+bs_am_greeks = OptionLab.get_american_greeks(
+  'put', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, dividend_yield
+)
+puts "\nBjerksund-Stensland Greeks:"
+puts "Delta: #{bs_am_greeks[:delta].round(6)}"
+puts "Gamma: #{bs_am_greeks[:gamma].round(6)}"
+puts "Theta: #{bs_am_greeks[:theta].round(6)}"
+puts "Vega: #{bs_am_greeks[:vega].round(6)}"
+puts "Rho: #{bs_am_greeks[:rho].round(6)}"
+# Generate binomial tree for visualization (using smaller number of steps)
+tree_data = OptionLab.get_binomial_tree(
+  'put', spot_price, strike_price, risk_free_rate, volatility, time_to_maturity, 5, true, dividend_yield
+)
+puts "\nBinomial Tree Visualization (5 steps):"
+puts '-------------------------------------'
+# Display tree parameters
+puts 'Parameters:'
+puts "Spot Price: $#{tree_data[:parameters][:spot_price]}"
+puts "Strike Price: $#{tree_data[:parameters][:strike_price]}"
+puts "Up Factor: #{tree_data[:parameters][:up_factor].round(4)}"
+puts "Down Factor: #{tree_data[:parameters][:down_factor].round(4)}"
+puts "Risk-Neutral Probability: #{tree_data[:parameters][:risk_neutral_probability].round(4)}"
+puts "\nPrice Tree:"
+tree_data[:stock_prices].each_with_index do |step_prices, step|
+  puts "Step #{step}: #{step_prices.take(step + 1).map { |p| p.round(2) }.join(', ')}"
+end
+puts "\nOption Value Tree:"
+tree_data[:option_values].each_with_index do |step_values, step|
+  puts "Step #{step}: #{step_values.take(step + 1).map { |v| v.round(2) }.join(', ')}"
+end
+puts "\nEarly Exercise Flags:"
+tree_data[:exercise_flags].each_with_index do |step_flags, step|
+  puts "Step #{step}: #{step_flags.take(step + 1).join(', ')}"
+end
+# Early exercise boundary analysis
+puts "\nEarly Exercise Boundary Analysis:"
+puts '--------------------------------'
+# Test a range of spot prices to find the early exercise boundary
+puts 'Finding early exercise boundary for American put option at various times to maturity:'
+puts "Time\tBoundary"
+[0.25, 0.5, 0.75, 1.0].each do |t|
+  # Binary search to find boundary
+  low = 50.0
+  high = strike_price
+  tolerance = 0.01
+  while (high - low) > tolerance
+    mid = (low + high) / 2
+    # Test if this spot price should be exercised early
+    tree = OptionLab.get_binomial_tree(
+      'put', mid, strike_price, risk_free_rate, volatility, t, 25, true, dividend_yield
+    )
+    if tree[:exercise_flags][0][0]
+      # Early exercise is optimal, look higher
+      low = mid
+    else
+      # Early exercise not optimal, look lower
+      high = mid
+    end
+  end
+  boundary = (low + high) / 2
+  puts "#{t}\t$#{boundary.round(2)}"
+end
+puts "\nExample completed successfully."

data/examples/covered_call.rb ADDED Viewed

@@ -0,0 +1,76 @@
+# frozen_string_literal: true
+require 'date'
+# Use the local code instead of the installed gem
+require_relative '../lib/option_lab'
+# Example of a covered call strategy
+# A covered call involves owning the underlying stock and selling call options against it
+# Step 1: Define input parameters
+input_data = {
+  stock_price: 168.99,               # Current stock price
+  volatility: 0.483,                 # Annualized volatility (48.3%)
+  interest_rate: 0.045,              # Annualized risk-free interest rate (4.5%)
+  start_date: Date.new(2023, 1, 16), # Strategy start date
+  target_date: Date.new(2023, 2, 17), # Strategy target date
+  min_stock: 68.99,                  # Minimum stock price for analysis
+  max_stock: 268.99,                 # Maximum stock price for analysis
+  # The covered call strategy is defined with two legs:
+  # 1. Long 100 shares of stock
+  # 2. Short 1 call option with strike price 185.0 and premium 4.1
+  strategy: [
+    { type: 'stock', n: 100, action: 'buy' },
+    {
+      type: 'call',
+      strike: 185.0,
+      premium: 4.1,
+      n: 100,
+      action: 'sell',
+      expiration: Date.new(2023, 2, 17),
+    },
+  ],
+}
+# Step 2: Run the strategy calculation
+puts 'Calculating strategy outcomes...'
+outputs = OptionLab.run_strategy(input_data)
+# Step 3: Print the results
+puts "\nCovered Call Strategy Results:"
+puts '------------------------------'
+puts outputs
+# Step 4: Extract and display key metrics
+puts "\nKey Metrics:"
+puts "Probability of Profit: #{(outputs.probability_of_profit * 100).round(2)}%"
+puts "Expected Profit (when profitable): $#{outputs.expected_profit}" if outputs.expected_profit
+puts "Expected Loss (when unprofitable): $#{outputs.expected_loss}" if outputs.expected_loss
+puts "Strategy Cost: $#{outputs.strategy_cost}"
+puts "Maximum Return: $#{outputs.maximum_return_in_the_domain}"
+puts "Minimum Return: $#{outputs.minimum_return_in_the_domain}"
+# Step 5: Print Greeks for each leg
+puts "\nGreeks by Strategy Leg:"
+puts 'Leg 1 (Stock):'
+puts "  Delta: #{outputs.delta[0]}"
+puts 'Leg 2 (Call Option):'
+puts "  Delta: #{outputs.delta[1]}"
+puts "  Gamma: #{outputs.gamma[1]}"
+puts "  Theta: #{outputs.theta[1]}"
+puts "  Vega: #{outputs.vega[1]}"
+puts "  Rho: #{outputs.rho[1]}"
+puts "  Implied Volatility: #{(outputs.implied_volatility[1] * 100).round(2)}%"
+puts "  ITM Probability: #{(outputs.in_the_money_probability[1] * 100).round(2)}%"
+# Step 6: Export P/L data to CSV
+csv_filename = 'covered_call_pl.csv'
+OptionLab.pl_to_csv(outputs, csv_filename)
+puts "\nProfit/Loss data exported to #{csv_filename}"
+# Step 7: Plot the profit/loss diagram
+puts "\nGenerating profit/loss diagram..."
+OptionLab.plot_pl(outputs)
+puts 'Plot displayed. Close the plot window to exit.'

data/lib/option_lab/binomial_tree.rb ADDED Viewed

@@ -0,0 +1,238 @@
+# frozen_string_literal: true
+require 'numo/narray'
+module OptionLab
+  # Implementation of the Cox-Ross-Rubinstein (CRR) binomial tree model
+  # for American and European options pricing
+  module BinomialTree
+    class << self
+      # Price an option using the Cox-Ross-Rubinstein binomial tree model
+      # @param option_type [String] 'call' or 'put'
+      # @param s0 [Float] Spot price
+      # @param x [Float] Strike price
+      # @param r [Float] Risk-free interest rate
+      # @param volatility [Float] Volatility
+      # @param years_to_maturity [Float] Time to maturity in years
+      # @param n_steps [Integer] Number of time steps
+      # @param is_american [Boolean] True for American options, false for European
+      # @param dividend_yield [Float] Continuous dividend yield
+      # @return [Float] Option price
+      def price_option(option_type, s0, x, r, volatility, years_to_maturity, n_steps = 100, is_american = true, dividend_yield = 0.0)
+        # Calculate time step
+        dt = years_to_maturity / n_steps.to_f
+        # Calculate up and down factors
+        u = Math.exp(volatility * Math.sqrt(dt))
+        d = 1.0 / u
+        # Calculate risk-neutral probability
+        effective_r = r - dividend_yield
+        p = (Math.exp(effective_r * dt) - d) / (u - d)
+        # Calculate discount factor
+        discount = Math.exp(-r * dt)
+        # Initialize price tree
+        stock_prices = Array.new(n_steps + 1) { Array.new(n_steps + 1, 0.0) }
+        option_values = Array.new(n_steps + 1) { Array.new(n_steps + 1, 0.0) }
+        # Fill stock price tree
+        (0..n_steps).each do |i|
+          (0..i).each do |j|
+            stock_prices[i][j] = s0 * (u**(i - j)) * (d**j)
+          end
+        end
+        # Calculate option values at expiration (i = n_steps)
+        (0..n_steps).each do |j|
+          option_values[n_steps][j] = option_payoff(option_type, stock_prices[n_steps][j], x)
+        end
+        # Work backwards through the tree
+        (n_steps - 1).downto(0) do |i|
+          (0..i).each do |j|
+            # Expected value (European option value)
+            expected_value = discount * (p * option_values[i + 1][j] + (1 - p) * option_values[i + 1][j + 1])
+            if is_american
+              # For American options, compare with immediate exercise value
+              exercise_value = option_payoff(option_type, stock_prices[i][j], x)
+              option_values[i][j] = [expected_value, exercise_value].max
+            else
+              # For European options, use expected value
+              option_values[i][j] = expected_value
+            end
+          end
+        end
+        # Root node contains the option price
+        option_values[0][0]
+      end
+      # Calculate option payoff at expiration
+      # @param option_type [String] 'call' or 'put'
+      # @param stock_price [Float] Stock price
+      # @param strike [Float] Strike price
+      # @return [Float] Option payoff
+      def option_payoff(option_type, stock_price, strike)
+        if option_type == 'call'
+          [stock_price - strike, 0.0].max
+        elsif option_type == 'put'
+          [strike - stock_price, 0.0].max
+        else
+          raise ArgumentError, "Option type must be either 'call' or 'put'!"
+        end
+      end
+      # Get a full binomial tree as a structured output
+      # @param option_type [String] 'call' or 'put'
+      # @param s0 [Float] Spot price
+      # @param x [Float] Strike price
+      # @param r [Float] Risk-free interest rate
+      # @param volatility [Float] Volatility
+      # @param years_to_maturity [Float] Time to maturity in years
+      # @param n_steps [Integer] Number of time steps
+      # @param is_american [Boolean] True for American options, false for European
+      # @param dividend_yield [Float] Continuous dividend yield
+      # @return [Hash] Tree structure with stock prices and option values
+      def get_tree(option_type, s0, x, r, volatility, years_to_maturity, n_steps = 15, is_american = true, dividend_yield = 0.0)
+        # Calculate time step
+        dt = years_to_maturity / n_steps.to_f
+        # Calculate up and down factors
+        u = Math.exp(volatility * Math.sqrt(dt))
+        d = 1.0 / u
+        # Calculate risk-neutral probability
+        effective_r = r - dividend_yield
+        p = (Math.exp(effective_r * dt) - d) / (u - d)
+        # Calculate discount factor
+        discount = Math.exp(-r * dt)
+        # Initialize price tree
+        stock_prices = Array.new(n_steps + 1) { Array.new(n_steps + 1, 0.0) }
+        option_values = Array.new(n_steps + 1) { Array.new(n_steps + 1, 0.0) }
+        exercise_flags = Array.new(n_steps + 1) { Array.new(n_steps + 1, false) }
+        # Fill stock price tree
+        (0..n_steps).each do |i|
+          (0..i).each do |j|
+            stock_prices[i][j] = s0 * (u**(i - j)) * (d**j)
+          end
+        end
+        # Calculate option values at expiration (i = n_steps)
+        (0..n_steps).each do |j|
+          option_values[n_steps][j] = option_payoff(option_type, stock_prices[n_steps][j], x)
+        end
+        # Work backwards through the tree
+        (n_steps - 1).downto(0) do |i|
+          (0..i).each do |j|
+            # Expected value (European option value)
+            expected_value = discount * (p * option_values[i + 1][j] + (1 - p) * option_values[i + 1][j + 1])
+            if is_american
+              # For American options, compare with immediate exercise value
+              exercise_value = option_payoff(option_type, stock_prices[i][j], x)
+              if exercise_value > expected_value
+                option_values[i][j] = exercise_value
+                exercise_flags[i][j] = true
+              else
+                option_values[i][j] = expected_value
+              end
+            else
+              # For European options, use expected value
+              option_values[i][j] = expected_value
+            end
+          end
+        end
+        # Return tree structure
+        {
+          stock_prices: stock_prices,
+          option_values: option_values,
+          exercise_flags: exercise_flags,
+          parameters: {
+            option_type: option_type,
+            spot_price: s0,
+            strike_price: x,
+            risk_free_rate: r,
+            volatility: volatility,
+            time_to_maturity: years_to_maturity,
+            steps: n_steps,
+            is_american: is_american,
+            dividend_yield: dividend_yield,
+            up_factor: u,
+            down_factor: d,
+            risk_neutral_probability: p,
+          },
+        }
+      end
+      # Calculate option Greeks using the CRR model and finite difference methods
+      # @param option_type [String] 'call' or 'put'
+      # @param s0 [Float] Spot price
+      # @param x [Float] Strike price
+      # @param r [Float] Risk-free interest rate
+      # @param volatility [Float] Volatility
+      # @param years_to_maturity [Float] Time to maturity in years
+      # @param n_steps [Integer] Number of time steps
+      # @param is_american [Boolean] True for American options, false for European
+      # @param dividend_yield [Float] Continuous dividend yield
+      # @return [Hash] Option Greeks (delta, gamma, theta, vega, rho)
+      def get_greeks(option_type, s0, x, r, volatility, years_to_maturity, n_steps = 100, is_american = true, dividend_yield = 0.0)
+        # Small increment for finite difference calculation
+        h_s = s0 * 0.001    # For Delta and Gamma
+        h_t = 1.0 / 365     # For Theta (1 day)
+        h_v = 0.001         # For Vega
+        h_r = 0.0001        # For Rho
+        # Base price
+        price = price_option(option_type, s0, x, r, volatility, years_to_maturity, n_steps, is_american, dividend_yield)
+        # Delta: ∂V/∂S
+        price_up = price_option(option_type, s0 + h_s, x, r, volatility, years_to_maturity, n_steps, is_american, dividend_yield)
+        price_down = price_option(option_type, s0 - h_s, x, r, volatility, years_to_maturity, n_steps, is_american, dividend_yield)
+        delta = (price_up - price_down) / (2 * h_s)
+        # Gamma: ∂²V/∂S²
+        gamma = (price_up - 2 * price + price_down) / (h_s * h_s)
+        # Theta: -∂V/∂t
+        price_t_down = if years_to_maturity - h_t > 0
+          price_option(option_type, s0, x, r, volatility, years_to_maturity - h_t, n_steps, is_american, dividend_yield)
+        else
+          option_payoff(option_type, s0, x)
+        end
+        theta = -(price_t_down - price) / h_t
+        # Vega: ∂V/∂σ
+        price_v_up = price_option(option_type, s0, x, r, volatility + h_v, years_to_maturity, n_steps, is_american, dividend_yield)
+        vega = (price_v_up - price) / h_v
+        # Rho: ∂V/∂r
+        price_r_up = price_option(option_type, s0, x, r + h_r, volatility, years_to_maturity, n_steps, is_american, dividend_yield)
+        rho = (price_r_up - price) / h_r
+        # Return Greeks
+        {
+          delta: delta,
+          gamma: gamma,
+          theta: theta,
+          vega: vega,
+          rho: rho,
+        }
+      end
+    end
+  end
+end