-- This Lua program calculates the IV (Implied Volatility) of the Black-Scholes model.
-- The Black-Scholes model is used to calculate the theoretical price of options.
-- The IV represents the volatility implied by the market price of the option.

-- Global constants for the Black-Scholes formula
local d1 = 0.0
local d2 = 0.0
local epsilon = 0.000001
local maxIterations = 100

--- Calculate the IV (Implied Volatility) of the Black-Scholes model
-- This function calculates and returns the IV of the Black-Scholes model based on the given parameters.
-- @param S The current price of the underlying asset
-- @param K The strike price of the option
-- @param r The risk-free interest rate
-- @param T The time to expiration of the option
-- @param C The market price of the option
-- @param type The type of the option (either "call" or "put")
-- @return The IV of the Black-Scholes model or nil if there's an error, along with an error message.
local function calculateIV(S, K, r, T, C, optionType)
    -- Validate the input
    if S <= 0 or K <= 0 or r <= 0 or T <= 0 or C <= 0 then
        return nil, "Invalid input. All parameters should be positive numbers."
    end
    
    if optionType ~= "call" and optionType ~= "put" then
        return nil, "Invalid input. Option type should be either 'call' or 'put'."
    end
    
    -- Define the function to calculate the option price using the Black-Scholes formula
    local function calculateOptionPrice(sigma)
        -- Calculate d1 and d2
        d1 = (math.log(S / K) + (r + 0.5 * sigma^2) * T) / (sigma * math.sqrt(T))
        d2 = d1 - sigma * math.sqrt(T)
        
        -- Calculate the option price
        local optionPrice = 0.0
        if optionType == "call" then
            optionPrice = S * norm.cdf(d1) - K * math.exp(-r * T) * norm.cdf(d2)
        else
            optionPrice = K * math.exp(-r * T) * norm.cdf(-d2) - S * norm.cdf(-d1)
        end
        
        return optionPrice
    end
    
    -- Define the function to calculate the derivative of the option price with respect to sigma
    local function calculateOptionPriceDerivative(sigma)
        -- Calculate the derivative of the option price
        local dOptionPrice = 0.0
        if optionType == "call" then
            dOptionPrice = S * math.sqrt(T) * norm.pdf(d1)
        else
            dOptionPrice = -S * math.sqrt(T) * norm.pdf(-d1)
        end
        
        return dOptionPrice
    end
    
    -- Implement the Newton-Raphson method to find the IV
    local sigma = math.sqrt(2 * math.abs((math.log(S / K) + r * T) / T))
    local optionPrice = calculateOptionPrice(sigma)
    local optionPriceDerivative = calculateOptionPriceDerivative(sigma)
    local iteration = 0
    
    while math.abs(optionPrice - C) > epsilon and iteration < maxIterations do
        sigma = sigma - (optionPrice - C) / optionPriceDerivative
        optionPrice = calculateOptionPrice(sigma)
        optionPriceDerivative = calculateOptionPriceDerivative(sigma)
        iteration = iteration + 1
    end
    
    -- Check if the IV calculation converged
    if iteration >= maxIterations then
        return nil, "Failed to converge. Maximum number of iterations reached."
    end
    
    return sigma
end

-- Main execution
print("[INFO] Starting program.")

local S = 100  -- Example input: current price of the underlying asset
local K = 100  -- Example input: strike price of the option
local r = 0.05  -- Example input: risk-free interest rate
local T = 1  -- Example input: time to expiration of the option
local C = 10  -- Example input: market price of the option
local optionType = "call"  -- Example input: type of the option

local IV, err = calculateIV(S, K, r, T, C, optionType)

if IV then
    plot(string.format("The IV of the Black-Scholes model is: %.4f", IV))
else
    plot("[ERROR]", err)
end

plot("[INFO] Program finished.")