Call Options

Introduction

Now, we are going to talk about call options.

As was mentioned in previous chapter, they are providing their owner with the right to buy underlying asset for a predetermined price in the future.

There are many strategies of how to use call options, in order to maximize profit/minimize risks, while using call options.

We will now discover two of them, using examples with stock shares as key asset.

Long Call

The first strategy we are going to discover - is so called Long Call.

In this strategy, trader simply buys call options, and expects corresponding stock prices to increase, so there will be an opportunity to save money by exercising option and buying stock shares for a lower price.

Here is a simplified graphic of dependencies between stock price and received profit:

Here price of one option(option premium) is 5, strike price is 50, and trader buys 10 call options - one for each stock.

As we can see, everything that goes below red dotted line, means negative profit or, practically - amount of money which trader loses.

We can see, that here trader loses money not only when stock price goes below the strike price, but also when it rises, but not enough. This is because trader still spent some money on buying options.

So, in order to make some profit from contracts, trader need to exercise option not just when stock price is above the strike price, but when it so much more than the strike price, that allows to compensate all the spendings on buying contracts plus gain some extra money.

Also we should notice, that the graphic has flat region, when price is below the strike one. This is because at this point owner don't use options, letting it expire, so the only loss - is money spent on buying contracts.

Additionally, here is a code example for the corresponding strategy:


              12345678910111213
            
# Defining all necessary variables
option_price = 5
number_call = 10
strike_price = 50
stock_price = 60
# Defining function `long_call` which will perform computations
def long_call(option_price, number_call, strike_price, stock_price):
  profit = (stock_price - strike_price - option_price) * number_call
  if stock_price < strike_price:
    profit = - option_price * number_call
  return profit
# Printing computed profit
print(long_call(option_price, number_call, strike_price, stock_price))

Covered Call

The second strategy is called Covered Call, and this one already way more complicated, than the previous one.

Here trader sells call contracts, but also buys specified number of stocks per each contract.

This strategy may be useful in case, when owner expects only small changes in price during the life of the specified call options.

Here trader, as long as he expects that stock price won't rise significantly during the life period of options, wants to get rid out of the majorly useless contracts and make money buy selling them, but, for another side, he wants to make 'insurance' by buying several stocks.

Graphically, it will look in the next way:

Here option premium is 5, owner sells 10 of them with a strike price of 30, and buys 10 stocks per each contract, where each stock is bought for a strike price.

We can see, that region where stock price is bigger than a strike price is flat. This happens because buying specific amount of stocks per each sold contract, and raise of stock prices leads to compensation of loss from selling contracts.

For another sight, we can see, that if stock price falls significantly lower than strike price - loss is huge, as long as trader loses way more money on stocks, which are cheaper now, than he gains from selling contracts.

This strategy may look not really attractive, as long as profit has strict upper bound, while loss can be huge, but again - important thing is context, and we need to remember, that this strategy for cases, when trader doesn't expect either high raise or fall of stock prices.


              12345678910111213141516
            
# Defining all necessary variables
option_price = 5
number_call = 10
strike_price = 30
stock_price = 29
n_shares = 10
# Defining function `covered_call` which will perform computations
def covered_call(option_price, number_call, strike_price, stock_price, n_shares):
  short_profit = option_price * number_call - n_shares * number_call * (stock_price - strike_price)
  if stock_price < strike_price:
    short_profit = option_price * number_call
  stock_profit = n_shares * number_call * (stock_price - strike_price)
  profit = stock_profit + short_profit
  return profit
# Printing computed profit
print(covered_call(option_price, number_call, strike_price, stock_price, n_shares))

Everything was clear?

Thanks for your feedback!

Section 2. Chapter 2