Custom Python code for calculating the Probability of Profit (POP) for options trading strategies using Monte Carlo Simulations.

Related tags

Miscellaneouspoptions
Overview

poptions

Custom Python code for calculating the Probability of Profit (POP) for options trading strategies using Monte Carlo Simulations. The Monte Carlo Simulation runs thousands of individual stock price simulations and uses the data from these simulations to average out a POP number.

Unlike other calculators, poptions lets you specify a target profit, such as a percentage of maximum profit or a multiple of the debit paid, that will trigger your position to close when it's reached in the simulation. Additionally, you will specify the 'closing days', which refers to the number of calendar days that will pass until you close the position (assuming the target profit wasn't reached to trigger the closing).

In simpler words: the estimated POP from poptions refers to the probability of hitting a specified target profit within a specified number of calendar days.

Poptions lets you add MULTIPLE combinations of target profits and closing days!

Poptions also outputs an Average Days To Close (ADTC) number. This is the estimated average number of calendar days you will have to wait until you reach your target profit, assuming that the POP ended up in your favor.

Poptions can also be used to evaluate existing trades (see below).

Disclaimer: poptions has not been vetted by any certified professional or expert. The calculations do not constitute investment advice. They are for educational purposes only. Calculations may contain mistakes and are made using models with inherent limitations that are highlighted below. Use this tool at your own risk.

How does it work?

A great video explaining the underlying logic is shown here: https://www.tastytrade.com/shows/the-skinny-on-options-modeling/episodes/probability-of-50-profit-12-17-2015

In short, thousands of stock price simulations are executed in which the price change per day is modeled according to Geometric Brownian Motion. The Black-Scholes Model is then used to estimate the price of an options contract (or multiple contracts depending on the strategy used) per day in each simulation. The number of simulations in which the selected profit criteria is met (e.g. 50% of maximum profit within 20 calendar days) is divided by the total number of simulations, giving you an estimate of the POP. A similar averaging is done to acquire the ADTC.

poptions makes the following assumptions for its simulations:

  • The stock price volatility is equal to the implied volatility and remains constant.
  • Geometric Brownian Motion is used to model the stock price.
  • Risk-free interest rates remain constant.
  • The Black-Scholes Model is used to price options contracts.
  • Dividend yield is not considered.
  • Commissions are not considered.
  • Assignment risks are not considered.
  • Earnings date and stock splits are not considered.

Of course, not all of these assumptions are true in real life and so there are limitations to this approach. For example, it's highly unlikely that the stock price volatility remains constant for several days. Thus, one should take these results with a grain of salt.

How to use poptions

The requirements.txt file lists all the python packages (and their versions) that need to be installed for poptions to work.

A working example of a Call Credit Spread strategy is located in the poptions_examples.py file, as shown:

underlying = 137.31     # Current underlying price
short_strike = 145      # Short strike price
short_price = 1.13      # Short call price
long_strike = 150
long_price = 0.4
rate = 0        # Annualized risk-free rate as a percentage
sigma = 26.8        # Implied Volatility as a percentage
days_to_expiration = 45     # Calendar days left till expiration
percentage_array = [20, 30, 40]  # Percentage of maximum profit that will trigger the position to close
closing_days_array = [21, 22, 23]       # Max calendar days passed until position is closed
trials = 2000       # Number of independent trials

print("Call Credit Spread: ", poptions.callCreditSpread(underlying, sigma, rate, trials, days_to_expiration,
                                                        closing_days_array, percentage_array, short_strike,
                                                        short_price, long_strike, long_price))

The comments in the code should be self-explanatory, but the percentage_array, closing_days_array, and trials variables require some extra clarification:

  • The first elements in percentage_array and closing_days_array are 20 and 21, respectively.
    This means that our target profit is 20% of maximum profit (0.2 * (short_price - long_price) = $ 0.146). The Monte Carlo Simulation will consider each individual simulation (renamed to trial here) a success if this target profit is achieved. If this target profit is not reached within 21 calendar days, it will be considered a failure.

  • You can add multiple combinations of target profits and closing days by simply adding extra elements to percentage_array and closing_days_array! In the above example, we tell the Simulation to also evaluate 30% and 40% of maximum profits for 22 and 23 calendar days, respectively.

  • Increasing the number of trials will improve the accuracy of your estimations at the cost of a slower simulation.

Some Extra Notes:

  • Running poptions.callCreditSpread() will not output consistent results. There will always be some variance from its previous runs. This is because a new simulation is started from scratch for every run. The amount of variance depends on how high trials is set: More trials -> higher accuracy (less variance).

  • For the Long Call and Long Put strategies, percentage_array is replaced with multiple_array. This means that the target profit is now defined as a multiple of the debit that you paid to open the position. For example, if you bought a call option for $1.00, a value of [2] in multiple_array means that your target profit is 2 * $ 1.00 = $ 2.00.

  • You can evaluate existing trades with poptions! Type the net credit received into ONE of the short price variables, and leave the rest of the price variables at 0. Fill out all other variables with present data. Example: Net credit received was $0.73 for a Call Credit Spread, so short_price is 0.73 and long_price is 0. All other variables are filled with present data. For strategies where a net debit is paid like Debit Spreads, the debit paid should be in ONE of the long price variables, and leave the rest of the price variables at 0.

Entering existing trades is NOT supported for Covered Calls unless the current underlying price is the same as it was when you opened the position! This is because the underlying variable refers to the purchase price of the stock when you opened the position.

Running poptions_examples.py gives you the following output:

Call Credit Spread:  {'pop': [61.3, 57.65, 52.55], 'pop_error': [2.81, 2.85, 2.88], 'avg_dtc': [8.87, 10.3, 11.41], 'avg_dtc_error': [0.39, 0.43, 0.45]}
  • pop is the probability of reaching the target profit within the closing days. The first element in pop corresponds to the first elements in percentage_array and closing_days_array.

  • pop_error is the error range for pop. In the above example, for the first element, there is a 99% chance that the 'true' value for pop is between 58.49 (61.3 - 2.81) and 64.11 (61.3 + 2.81). Of course, this error range gets smaller as trials is increased.

  • avg_dtc refers to the Average Days To Close (ADTC).

  • avg_dtc_error is the error range for avg_dtc.

If avg_dtc falls on a weekend/holiday when the markets are closed, then you can assume that the closing date is on the following business/trading day.

SPEED BOOST with Numba!

If you're looking to potentially speed up simulations by 100x, the Numba python package can help you out! Numba translates Python functions to optimized machine code at runtime using the industry-standard LLVM compiler library. Numba-compiled numerical algorithms in Python can approach the speeds of C or FORTRAN.

Using Numba is shockingly easy. It requires making very little modifications to our code. Follow these steps to speed up poptions.callCreditSpread() in poptions_examples.py with Numba:

Open the CallCreditSpread.py file. Add the following decorator to this function:

@jit(nopython=True, cache=True)
def bsm_debit(sim_price, strikes, rate, time_fraction, sigma):
    ...

Open the MonteCarlo.py file. Add the decorator to this function:

@jit(nopython=True, cache=True)
def monteCarlo(underlying, rate, sigma, days_to_expiration, closing_days_array, trials, initial_credit,
                   min_profit, strikes, bsm_func):
    ...

Open the BlackScholes.py file. Add the decorator to the functions:

@jit(nopython=True, cache=True)
def blackScholesPut(s, k, rr, tt, sd):
    ...
    
@jit(nopython=True, cache=True)
def blackScholesCall(s, k, rr, tt, sd):
    ...

You're good to go, but you MUST account for the following: The first time you call poptions.callCreditSpread() will be slow (around a few seconds) since it triggers a compilation step for Numba. The second poptions.callCreditSpread() call is where you'll see the performance gains. Here's a comparison of the speeds between calls:

First poptions.callCreditSpread() call WITH Numba Compilation: 1.756 seconds
Second poptions.callCreditSpread() call WITHOUT Numba Compilation: 0.0064 seconds

Donations

If you like the project and feel like donating some crypto to the author(s), you can do so here:

BTC: 16xbCyVZB3x3PNFs1qQEXGsNgtTd4BKE6z

LTC: Lg1d1VEd5DMQzycZTSSeDEc59yomwDwX8j

Thank you!

License

MIT License

A description of this license can be found in the LICENSE.txt file.

A Unified Framework for Hydrology

Unified Framework for Hydrology The Python package unifhy (Unified Framework for Hydrology) is a hydrological modelling framework which combines inter

Unified Framefork for Hydrology - Community Organisation 6 Jan 01, 2023
Code for Crowd counting via unsupervised cross-domain feature adaptation.

CDFA-pytorch Code for Unsupervised crowd counting via cross-domain feature adaptation. Pre-trained models Google Drive Baidu Cloud : t4qc Environment

Guanchen Ding 6 Dec 11, 2022
Originally used during Marketplace.tf's open period, this program was used to get the profit of items bought with keys and sold for dollars.

Originally used during Marketplace.tf's open period, this program was used to get the profit of items bought with keys and sold for dollars. Practically useless for me now, but can be used as an exam

BoggoTV 1 Dec 11, 2021
Width-customizer-for-streamlit-apps - Width customizer for Streamlit Apps

🎈 Width customizer for Streamlit Apps As of now, you can only change your Strea

Charly Wargnier 5 Aug 09, 2022
Stocks Trading News Alert Using Python

Stocks-Trading-News-Alert-Using-Python Ever Thought of Buying Shares of your Dream Company, When their stock price got down? But It is not possible to

Ayush Verma 3 Jul 29, 2022
A blazing fast mass certificate generator script for the community ⚡

A simple mass certificate generator script for the community ⚡ Source Code · Docs · Raw Script Docs All you need Certificate Design a simple template

Tushar Nankani 24 Jan 03, 2023
Coronavirus Tracker API

Coronavirus Tracker API Provides up-to-date data about Coronavirus outbreak. Includes numbers about confirmed cases, deaths and recovered. Support mul

Francisco Laguna 1 Oct 31, 2020
A Linux program to create a Windows USB stick installer from a real Windows DVD or image.

WoeUSB-ng A Linux program to create a Windows USB stick installer from a real Windows DVD or image. This package contains two programs: woeusb: A comm

Longinus 1 Nov 19, 2021
【AI创造营】参赛作品

-AI-emmmm 【AI创造营】参赛作品 鬼畜小视频 AiStuido地址:https://aistudio.baidu.com/aistudio/projectdetail/1647685 BiliBili视频地址:https://www.bilibili.com/video/BV1Zv411b

107 Nov 09, 2022
IST-Website - IST Tutoring Portal for python

IST Tutoring Portal This portal is a web based interface to handle student help

Jean 3 Jan 03, 2022
Open source stenotype engine

Plover Bringing stenography to everyone. Homepage Releases Wiki Blog Google Group Discord Chat About Installation Getting help Contributing Donations

Open Steno Project 2k Jan 09, 2023
A code ecosystem that helps to find the equate any formula.

A code ecosystem that helps to find the equate any formula. The good part here is that the code finds the formula needed and/or operates on a formula (performs algebra) on it to give you an answer.

SubtleCoder 1 Nov 23, 2021
An easy way to access to your EPITECH subjects based on the Roslyn's database.

An easy way to access to your EPITECH subjects based on the Roslyn's database.

Mathias 1 Feb 09, 2022
Small tool to use hero .json files created with Optolith for The Dark Eye/ Das Schwarze Auge 5 to perform talent probes.

DSA5-ProbeMaker A little tool for The Dark Eye 5th Edition (Das Schwarze Auge 5) to load .json from Optolith character generation and easily perform t

2 Jan 06, 2022
AdventOfCode 2021 solutions from the Devcord server

adventofcode-21 Ein Sammel-Repository für Advent of Code 2021-Lösungen der deutschen DevCord-Community. A repository collecting Advent of Code 2021 so

Devcord 12 Aug 26, 2022
This repository contains various tools useful for offensive operations (reversing, etc) regarding the PE (Portable Executable) format

PE-Tools This repository contains various tools useful for offensive operations (reversing, etc) regarding the PE (Portable Executable) format Install

stark0de 4 Oct 13, 2022
hey, this repo is the backend of the sociio project

sociio backend Hey, this repository is a part of sociio project , In this repo we are working to create an independent server for everything you can i

2 Jun 09, 2022
A small script I made that takes any standard Decklist of magic the gathering cards and pulls all card images from scryfall at once!

A small script I made that takes any standard Decklist of magic the gathering cards and pulls all card images from scryfall at once!

15 Aug 26, 2022
Python MapReduce library written in Cython.

Python MapReduce library written in Cython. Visit us in #hadoopy on freenode. See the link below for documentation and tutorials.

Brandyn White 243 Sep 16, 2022
Tutorials for on-ramping to StarkNet

Full-Stack StarkNet Repo containing the code for a short tutorial series I wrote while diving into StarkNet and learning Cairo. Aims to onramp existin

Sam Barnes 71 Dec 07, 2022