Attribute VB_Name = "FINAN_DERIV_BS_FINITE_LIBR"


Option Explicit     'Requires that all variables to be declared explicitly.
Option Base 1       'The "Option Base" statement allows to specify 0 or 1 as the
                    'default first index of arrays.


'--------------------------------------------------------------
' use globals as the integrator accepts no parameters
Private PUB_FORWARD_VAL As Double   ' Exp(RATE * time) * SPOT
Private PUB_MU_VAL As Double     ' Log(STRIKE / PUB_FORWARD_VAL)
Private PUB_SIGMA_VAL As Double  ' SIGMA * Sqr(time)
'--------------------------------------------------------------

'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : PDF_CALL_OPTION_FUNC
'DESCRIPTION   : BS pricing through integrating the pay off against the
'risk neutral density, both over spots and
'logarithmic moneyness (i.e. Breeden-Litzenberger).

'In finance, moneyness is a measure of the degree to which
'a derivative is likely to have positive monetary value at
'its expiration, in the risk-neutral measure. It can be
'measured in percentage probability, or in standard deviations.

'USEFUL REFERENCE: http://www.math.nyu.edu/research/carrp/

'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 001
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************


Function PDF_CALL_OPTION_FUNC(ByVal SPOT As Double, _
ByVal STRIKE As Double, _
ByVal EXPIRATION As Double, _
ByVal RATE As Double, _
ByVal SIGMA As Double)

Dim TEMP_VAL As Double
Dim FUNC_STR As String

Dim nLOOPS As Long
Dim EPSILON As Double

On Error GoTo ERROR_LABEL

nLOOPS = 400
EPSILON = 0.000000000000001

FUNC_STR = "PDF_CALL_OPTION_INTEGRAND_FUNC"

'MU --> RATE

PUB_FORWARD_VAL = Exp(RATE * EXPIRATION) * SPOT
PUB_MU_VAL = Log(STRIKE / PUB_FORWARD_VAL)
PUB_SIGMA_VAL = SIGMA * Sqr(EXPIRATION)

TEMP_VAL = PUB_SIGMA_VAL * PUB_SIGMA_VAL / 2 + 9 * PUB_SIGMA_VAL
' REMEMBER: TEMP_VAL (cut off) as infinite integral
' gives an overflow int(f, a, oo)

If PUB_MU_VAL < 0 Then ' if needed take care for a peak
  PDF_CALL_OPTION_FUNC = SPOT * (INTEGRATION_GAUSS_KRONROD_FUNC(FUNC_STR, PUB_MU_VAL, _
               -PUB_MU_VAL, nLOOPS, EPSILON) + _
                INTEGRATION_GAUSS_KRONROD_FUNC(FUNC_STR, -PUB_MU_VAL, _
               TEMP_VAL, nLOOPS, EPSILON))
ElseIf 0 <= PUB_MU_VAL Then
  PDF_CALL_OPTION_FUNC = SPOT * INTEGRATION_GAUSS_KRONROD_FUNC(FUNC_STR, PUB_MU_VAL, _
               TEMP_VAL, nLOOPS, EPSILON)
Else
  PDF_CALL_OPTION_FUNC = 0
End If ' or split at the peak

'Here i use adaptive Gauss-Kronrod point rules for finite or
'semi-infinite intervalls. That is 'known' to be a good working
'tool in Financial Mathematics.

Exit Function
ERROR_LABEL:
PDF_CALL_OPTION_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : PDF_CALL_OPTION_INTEGRAND_FUNC
'DESCRIPTION   : PDF Call Integral
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 002
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Private Function PDF_CALL_OPTION_INTEGRAND_FUNC(ByVal MU_VAL As Double)

Dim PI As Double

On Error GoTo ERROR_LABEL
PI = 3.14159265358979

PDF_CALL_OPTION_INTEGRAND_FUNC = (Exp(MU_VAL) - Exp(PUB_MU_VAL)) * _
    Exp(-0.5 * ((MU_VAL * (1 / PUB_SIGMA_VAL) + _
    0.5 * PUB_SIGMA_VAL)) ^ 2) * (1 / PUB_SIGMA_VAL) * _
    (1 / (2 * PI) ^ 0.5) _
    '--> ' the pdf for Black-Scholes: exp(-1/2*(mu/sigma+sigma/2)^2)/sigma/sqrt(2*Pi)

Exit Function
ERROR_LABEL:
PDF_CALL_OPTION_INTEGRAND_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC
'DESCRIPTION   : Explicit finite difference method as applied to the
'Black-Scholes PDE for Call Options
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 003
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC(ByVal OUTPUT As Integer, _
ByVal SPOT As Double, _
ByVal STRIKE As Double, _
ByVal TENOR As Double, _
ByVal RATE As Double, _
ByVal SIGMA As Double, _
Optional ByVal DELTA_TENOR As Double = 0.04, _
Optional ByVal INIT_SPOT As Double = 0, _
Optional ByVal DELTA_SPOT As Double = 5, _
Optional ByVal NBINS_SPOT As Long = 10, _
Optional ByVal CND_TYPE As Integer = 0, _
Optional ByVal tolerance As Double = 0.000001, _
Optional ByVal EPSILON As Double = 0.000000000000001)

Dim i As Long
Dim j As Long

Dim SROW As Long
Dim NROWS As Long

Dim SCOLUMN As Long
Dim NCOLUMNS As Long

Dim TEMP_MATRIX() As Variant
Dim TEMP_VECTOR() As Variant

On Error GoTo ERROR_LABEL

NROWS = Int((TENOR - 0) / DELTA_TENOR) + 1
NCOLUMNS = Int(NBINS_SPOT)

ReDim TEMP_VECTOR(1 To 4, 1 To NCOLUMNS)

For j = 1 To NCOLUMNS
    TEMP_VECTOR(1, j) = 0.5 * DELTA_TENOR * (-RATE * (j - 1) + _
                        (SIGMA * (j - 1)) ^ 2) / (1 + RATE * DELTA_TENOR)
    TEMP_VECTOR(2, j) = (1 - (SIGMA * (j - 1)) ^ 2 * DELTA_TENOR) / _
                        (1 + RATE * DELTA_TENOR)
    TEMP_VECTOR(3, j) = 0.5 * DELTA_TENOR * (RATE * (j - 1) + _
                        (SIGMA * (j - 1)) ^ 2) / (1 + RATE * DELTA_TENOR)
    TEMP_VECTOR(4, j) = TEMP_VECTOR(1, j) + TEMP_VECTOR(2, j) + TEMP_VECTOR(3, j)
Next j

ReDim TEMP_MATRIX(0 To NROWS, 0 To NCOLUMNS)
TEMP_MATRIX(0, 0) = "TN / Sp"
        
If INIT_SPOT < tolerance Then
    SCOLUMN = (NCOLUMNS - 1) * (SPOT / DELTA_SPOT)
Else
    SCOLUMN = INIT_SPOT + NCOLUMNS * (SPOT / DELTA_SPOT)
End If
        
For j = NCOLUMNS To 1 Step -1
    TEMP_MATRIX(0, j) = SCOLUMN
    SCOLUMN = SCOLUMN - (SPOT / DELTA_SPOT)
    TEMP_MATRIX(NROWS, j) = MAXIMUM_FUNC(TEMP_MATRIX(0, j) - STRIKE, 0)
Next j
                
SROW = TENOR
For i = 1 To NROWS
    TEMP_MATRIX(i, 0) = SROW
    If i < NROWS Then
        TEMP_MATRIX(i, 1) = EPSILON
        TEMP_MATRIX(i, NCOLUMNS) = TEMP_MATRIX(0, NCOLUMNS) - _
                                    Exp(-RATE * (TEMP_MATRIX(i, 0))) * STRIKE
    End If
    SROW = SROW - DELTA_TENOR
Next i

Select Case OUTPUT
'-----------------------------------------------------------------------------------------
    Case 0
'-----------------------------------------------------------------------------------------
        EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC = TEMP_VECTOR
'-----------------------------------------------------------------------------------------
    Case 1 'Explicit Finite Difference
'-----------------------------------------------------------------------------------------
        
        For i = (NROWS - 1) To 1 Step -1
            For j = (NCOLUMNS - 1) To 2 Step -1
                TEMP_MATRIX(i, j) = TEMP_MATRIX(i + 1, j - 1) * TEMP_VECTOR(1, j) + _
                                         TEMP_MATRIX(i + 1, j) * TEMP_VECTOR(2, j) + _
                                         TEMP_MATRIX(i + 1, j + 1) * TEMP_VECTOR(3, j)
                                         
            Next j
        Next i
        
        EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC = TEMP_MATRIX
'-----------------------------------------------------------------------------------------
    Case Else 'Black-Scholes PDE
'-----------------------------------------------------------------------------------------
    
        For i = (NROWS) To 1 Step -1
            For j = (NCOLUMNS) To 1 Step -1
                If TEMP_MATRIX(0, j) < tolerance Then: TEMP_MATRIX(0, j) = EPSILON
                TEMP_MATRIX(i, j) = PDF_CALL_PRICE_BS_FUNC(STRIKE, _
                                TEMP_MATRIX(i, 0), RATE, _
                                FINITE_DIFFERENCE_ALPHA_FUNC(TEMP_MATRIX(0, j), _
                                RATE, SIGMA, TEMP_MATRIX(i, 0)), _
                                FINITE_DIFFERENCE_BETA_FUNC(SIGMA, TEMP_MATRIX(i, 0)), CND_TYPE)
                                         
            Next j
        Next i
        
        EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC = TEMP_MATRIX
'-----------------------------------------------------------------------------------------
End Select
'-----------------------------------------------------------------------------------------


Exit Function
ERROR_LABEL:
EXPLICIT_FINITE_DIFFERENCE_CALL_OPTION_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : PDF_CALL_PRICE_BS_FUNC
'DESCRIPTION   : BS Call Price PDF Function
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 004
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function PDF_CALL_PRICE_BS_FUNC(ByVal STRIKE As Double, _
ByVal EXPIRATION As Double, _
ByVal RATE As Double, _
ByVal ALPHA As Double, _
ByVal BETA As Double, _
Optional ByVal CND_TYPE As Integer = 0)

Dim D1_VAL As Double
Dim D2_VAL As Double
Dim TEMP_VAL As Double

On Error GoTo ERROR_LABEL

D1_VAL = (-1 * Log(STRIKE) / Log(Exp(1)) + ALPHA + BETA ^ 2) / BETA
D2_VAL = D1_VAL - BETA
TEMP_VAL = Exp(ALPHA + 0.5 * BETA ^ 2) * CND_FUNC(D1_VAL, CND_TYPE) - _
            STRIKE * CND_FUNC(D2_VAL, CND_TYPE)
PDF_CALL_PRICE_BS_FUNC = TEMP_VAL * Exp(-RATE * EXPIRATION)

Exit Function
ERROR_LABEL:
PDF_CALL_PRICE_BS_FUNC = Err.number
End Function

'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC

'DESCRIPTION   : This calculates price for European/ American Put
'Options using implicit finite difference method as described
'in Hull's book "Options, Futures and other Derivatives" in
'section 18.8

'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 005
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC(ByVal SPOT As Double, _
ByVal STRIKE As Double, _
ByVal RATE As Double, _
ByVal SIGMA As Double, _
ByVal TENOR As Double, _
Optional ByVal STEPS_PRICE As Long = 20, _
Optional ByVal TIME_STEPS As Long = 10, _
Optional ByVal EXER_TYPE As Integer = 0)
'--------------------------------------------------------------------------
'--------------------------------------------------------------------------
'SPOT: Spot Price
'STRIKE: Strike
'RATE: Risk free rate
'SIGMA: Volatility
'TENOR: Time to Maturity
'STEPS_PRICE: No. of steps in Stock Price
'TIME_STEPS: No. of Time steps
'EXER_TYPE: Exercise Type (0 for American,  else for European)
'--------------------------------------------------------------------------
'--------------------------------------------------------------------------

Dim i As Long '
Dim j As Long
Dim k As Long

Dim ii As Long
Dim jj As Long
Dim kk As Long

Dim ATEMP_ARR As Variant
Dim BTEMP_ARR As Variant
Dim CTEMP_ARR As Variant

Dim DTEMP_ARR As Variant
Dim ETEMP_ARR As Variant
Dim FTEMP_ARR As Variant

Dim GTEMP_ARR As Variant
Dim HTEMP_ARR As Variant
Dim ITEMP_ARR As Variant
Dim JTEMP_ARR As Variant

Dim NTEMP_ARR As Variant
Dim OTEMP_ARR As Variant
Dim PTEMP_ARR As Variant

Dim QTEMP_ARR As Variant
Dim RTEMP_ARR As Variant
Dim STEMP_ARR As Variant

Dim TEMP_MATRIX As Variant

Dim TEMP_MULT As Double
Dim DELTA_TENOR As Double

On Error GoTo ERROR_LABEL

DELTA_TENOR = TENOR / TIME_STEPS 'time step size

TEMP_MULT = (SPOT * 2) / STEPS_PRICE 'stock price step size

ReDim NTEMP_ARR(1 To STEPS_PRICE + 1) 'vector to store option price grid
For i = 1 To UBound(NTEMP_ARR)
  NTEMP_ARR(i) = 0
Next i

ReDim STEMP_ARR(1 To STEPS_PRICE + 1)
For i = 0 To STEPS_PRICE
  NTEMP_ARR(i + 1) = MAXIMUM_FUNC(STRIKE - i * TEMP_MULT, 0)
  STEMP_ARR(i + 1) = i * TEMP_MULT
Next i

OTEMP_ARR = NTEMP_ARR

ReDim ATEMP_ARR(1 To STEPS_PRICE - 1)
ReDim BTEMP_ARR(1 To STEPS_PRICE - 1)
ReDim CTEMP_ARR(1 To STEPS_PRICE - 1)
ReDim PTEMP_ARR(1 To STEPS_PRICE - 1)

For j = 1 To STEPS_PRICE - 1
  ATEMP_ARR(j) = 0.5 * RATE * j * DELTA_TENOR - _
                0.5 * SIGMA * SIGMA * j * j * DELTA_TENOR
  BTEMP_ARR(j) = 1 + SIGMA * SIGMA * j * j * _
                DELTA_TENOR + RATE * DELTA_TENOR
  CTEMP_ARR(j) = -0.5 * RATE * j * DELTA_TENOR - _
                0.5 * SIGMA * SIGMA * j * j * DELTA_TENOR
  PTEMP_ARR(j) = STRIKE - j * TEMP_MULT
Next j

ReDim NTEMP_ARR(1 To STEPS_PRICE + 1)

'Apply boundary conditions for Put
NTEMP_ARR(1) = STRIKE
NTEMP_ARR(STEPS_PRICE + 1) = 0

'matrix of coffecients for set of equations in 18.29
ReDim TEMP_MATRIX(1 To STEPS_PRICE - 1, 1 To STEPS_PRICE - 1)
TEMP_MATRIX(1, 1) = BTEMP_ARR(1)
TEMP_MATRIX(1, 2) = CTEMP_ARR(1)

TEMP_MATRIX(STEPS_PRICE - 1, STEPS_PRICE - 2) = ATEMP_ARR(STEPS_PRICE - 1)
TEMP_MATRIX(STEPS_PRICE - 1, STEPS_PRICE - 1) = BTEMP_ARR(STEPS_PRICE - 1)

For j = 2 To STEPS_PRICE - 2
  TEMP_MATRIX(j, j - 1) = ATEMP_ARR(j)
  TEMP_MATRIX(j, j) = BTEMP_ARR(j)
  TEMP_MATRIX(j, j + 1) = CTEMP_ARR(j)
Next j

For i = 1 To TIME_STEPS 'Start rollback of time steps
  ReDim QTEMP_ARR(1 To STEPS_PRICE - 1)
  QTEMP_ARR(1) = OTEMP_ARR(2) - ATEMP_ARR(1) * NTEMP_ARR(1)
  QTEMP_ARR(STEPS_PRICE - 1) = OTEMP_ARR(STEPS_PRICE) - _
                        CTEMP_ARR(STEPS_PRICE - 1) * _
                        NTEMP_ARR(STEPS_PRICE + 1)
  For j = 2 To STEPS_PRICE - 2
    QTEMP_ARR(j) = OTEMP_ARR(j + 1)
  Next j
'-------------------------------------------------------------------------------
  'Solve Tridiagonal System
'-------------------------------------------------------------------------------
  jj = UBound(TEMP_MATRIX, 1)
  ii = LBound(TEMP_MATRIX, 1)
  kk = jj - ii + 1
  
  'Extract the vectors DTEMP_ARR,ETEMP_ARR,FTEMP_ARR of the tridiagonal matrix
  
  ReDim DTEMP_ARR(1 To kk)
  ReDim ETEMP_ARR(1 To kk)
  ReDim FTEMP_ARR(1 To kk)
  ReDim JTEMP_ARR(1 To kk)
  
  DTEMP_ARR(1) = 0
  FTEMP_ARR(kk) = 0
  For j = 2 To kk
    DTEMP_ARR(j) = TEMP_MATRIX(ii + j - 1, ii + j - 2)
  Next j
  For j = 1 To kk
    ETEMP_ARR(j) = TEMP_MATRIX(ii + j - 1, ii + j - 1)
  Next j
  For j = 1 To kk - 1
    FTEMP_ARR(j) = TEMP_MATRIX(ii + j - 1, ii + j)
  Next j
  
  JTEMP_ARR = QTEMP_ARR
  
  ReDim GTEMP_ARR(1 To kk)
  ReDim HTEMP_ARR(1 To kk)
  
  GTEMP_ARR(1) = ETEMP_ARR(1)
  HTEMP_ARR(1) = JTEMP_ARR(1)
  
  
  For k = 2 To kk
    TEMP_MULT = DTEMP_ARR(k) / GTEMP_ARR(k - 1)
    GTEMP_ARR(k) = ETEMP_ARR(k) - TEMP_MULT * FTEMP_ARR(k - 1)
    HTEMP_ARR(k) = JTEMP_ARR(k) - TEMP_MULT * HTEMP_ARR(k - 1)
  Next k
  
  ReDim ITEMP_ARR(1 To kk)
  
  ITEMP_ARR(kk) = HTEMP_ARR(kk) / GTEMP_ARR(kk)
  
  For k = kk - 1 To 1 Step -1
    ITEMP_ARR(k) = (HTEMP_ARR(k) - FTEMP_ARR(k) * _
                    ITEMP_ARR(k + 1)) / GTEMP_ARR(k)
  Next k
  
  RTEMP_ARR = ITEMP_ARR
  
  For j = 2 To STEPS_PRICE
        Select Case EXER_TYPE
        Case 0 ', "a", "amer"
              OTEMP_ARR(j) = MAXIMUM_FUNC(RTEMP_ARR(j - 1), PTEMP_ARR(j - 1))
        Case Else 'European
              OTEMP_ARR(j) = RTEMP_ARR(j - 1)
        End Select
  Next j
  
  OTEMP_ARR(1) = NTEMP_ARR(1)
  OTEMP_ARR(STEPS_PRICE + 1) = NTEMP_ARR(STEPS_PRICE + 1)
  
Next i

'-----------------------------------------------------------------------------
'-----------------------------------------------------------------------------
'Returns an interpolated value of ITEMP_ARR doing DTEMP_ARR lookup of xarr->yarr
'-----------------------------------------------------------------------------
'-----------------------------------------------------------------------------

If ((SPOT < STEMP_ARR(LBound(STEMP_ARR))) Or (SPOT > _
    STEMP_ARR(UBound(STEMP_ARR)))) Then
  IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC = "Interp: SPOT is out of bound"
  Exit Function
End If

If STEMP_ARR(LBound(STEMP_ARR)) = SPOT Then
  IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC = OTEMP_ARR(LBound(OTEMP_ARR))
  Exit Function
End If
For i = LBound(STEMP_ARR) To UBound(STEMP_ARR)
  If STEMP_ARR(i) >= SPOT Then
    IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC = OTEMP_ARR(i - 1) + (SPOT - _
                    STEMP_ARR(i - 1)) / (STEMP_ARR(i) - _
                    STEMP_ARR(i - 1)) * (OTEMP_ARR(i) - _
                    OTEMP_ARR(i - 1))
    Exit Function
  End If
Next i

Exit Function
ERROR_LABEL:
IMPLICIT_FINITE_DIFFERENCE_PUT_OPTION_FUNC = Err.number
End Function

'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : FINITE_DIFFERENCE_ALPHA_FUNC
'DESCRIPTION   : FD Alpha Function
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 006
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function FINITE_DIFFERENCE_ALPHA_FUNC(ByVal SPOT As Double, _
ByVal RATE As Double, _
ByVal SIGMA As Double, _
ByVal EXPIRATION As Double)
On Error GoTo ERROR_LABEL
FINITE_DIFFERENCE_ALPHA_FUNC = Log(SPOT) / Log(Exp(1)) + (RATE - 0.5 * SIGMA ^ 2) * EXPIRATION
Exit Function
ERROR_LABEL:
FINITE_DIFFERENCE_ALPHA_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : FINITE_DIFFERENCE_BETA_FUNC
'DESCRIPTION   : FD Beta Function
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 007
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function FINITE_DIFFERENCE_BETA_FUNC(ByVal SIGMA As Double, _
ByVal EXPIRATION As Double)
On Error GoTo ERROR_LABEL
FINITE_DIFFERENCE_BETA_FUNC = SIGMA * EXPIRATION ^ 0.5
Exit Function
ERROR_LABEL:
FINITE_DIFFERENCE_BETA_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : FINITE_DIFFERENCE_LOG_RETURNS_DENSITY_FUNC
'DESCRIPTION   : Log Returns Density Function
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 008
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function FINITE_DIFFERENCE_LOG_RETURNS_DENSITY_FUNC(ByVal LOG_RETURN As Double, _
ByVal ALPHA As Double, _
ByVal BETA As Double, _
ByVal SPOT As Double)

Dim PI As Double
Dim TEMP_VAL As Double
On Error GoTo ERROR_LABEL
PI = 3.14159265358979
TEMP_VAL = (LOG_RETURN - ALPHA + (Log(SPOT) / Log(Exp(1)))) ^ 2 / (2 * BETA ^ 2)
FINITE_DIFFERENCE_LOG_RETURNS_DENSITY_FUNC = 1 / (BETA * (2 * PI) ^ 0.5) * Exp(-TEMP_VAL)
Exit Function
ERROR_LABEL:
FINITE_DIFFERENCE_LOG_RETURNS_DENSITY_FUNC = Err.number
End Function


'************************************************************************************
'************************************************************************************
'© Copyright NicoSystem 2009. All rights reserved by Rafael Nicolas Fermin Cota,
'San Francisco, CA. USA  www.rnfc.org
'nfermincota.hba2005@ivey.ca
'************************************************************************************
'************************************************************************************
'FUNCTION      : FINITE_DIFFERENCE_LOG_NORMAL_DENSITY_FUNC
'DESCRIPTION   : Log Normal Density Function
'LIBRARY       : DERIVATIVES
'GROUP         : BS_FINITE
'ID            : 009
'AUTHOR        : RAFAEL NICOLAS FERMIN COTA

'************************************************************************************
'************************************************************************************

Function FINITE_DIFFERENCE_LOG_NORMAL_DENSITY_FUNC(ByVal ALPHA As Double, _
ByVal BETA As Double, _
ByVal SPOT As Double)
Dim PI As Double
Dim TEMP_VAL As Double
On Error GoTo ERROR_LABEL
PI = 3.14159265358979
TEMP_VAL = (-(Log(SPOT) / Log(Exp(1)) - ALPHA) ^ 2) / (2 * BETA ^ 2)
FINITE_DIFFERENCE_LOG_NORMAL_DENSITY_FUNC = 1 / (SPOT * BETA * (2 * PI) ^ 0.5) * Exp(TEMP_VAL)
Exit Function
ERROR_LABEL:
FINITE_DIFFERENCE_LOG_NORMAL_DENSITY_FUNC = Err.number
End Function