The implementation of a new treasury and risk management system at a bank called for a formal validation of the both the system output, as well as the system configuration.

Validation / Configuration:
Defining swap curves, contributing rates and interpolation method. Validate discount curves and pricing models on linear products: deposits and loans bonds, interest rate swaps, forward, cross currency swaps
Validate VAR calculations and risk reports: replicate the VAR calculation of various deal types.

Development:
Develop liquidity management and risk management model for maturing and non-maturing accounts.
Various IT tasks: works on Bloomberg and Reuters interfaces, Excel tools, writing SQL Server queries and scrips.

European- and State regulations are open to dialogs with industries.

In this study, the financial impact on my client of a wide variety of possible future regulatory scenario’s are examined using quantitative modeling and scenario analysis. The results of the study and condensed into a strategic advice.

Bayes’s Rule

Mean – Variance and r-moment about the mean

Laplace transform of pdf

Information content

Conditional distribution

Characteristic function

Independent random variables

note:

Expected value

Jointly Normal Distribution density function

Orthogonal r.v.’s

Correlation coefficient

Normal random variables

Conditional densities

Chain rule for sequence of random variables

Sample mean

Note that the variance of sample mean is n-time smaller than the one of a single sample.

Sample variance

note:Sample variance

Random process X(t) and basis

note:Random process X(t)

Simulating the Schwartz type 1 stochastic process

The Schwartz type 1 model is a log price Ornstein-Uhlenbeck stochastic process. Monte Carlo simulation of the model can be done using the equation above. The above equation is an exact solution of the model, this means that the distribution of the simulation is exact, and that time steps can be any size.

Calibrating the Schwartz type 1 model

The Schwartz type 1 model is a log price Ornstein-Uhlenbeck stochastic process. The calibration can be done through a regression of the logprices as described in the above equation.

Complex process

note:

(r,s)-Fold Trimmed Mean Filters

Short the samples in the window and omit r first samples and s last samples

Note: You can now download an Excel worksheet containing the model
SitmoVasicekInterpolation.xls

The resulting model output can be used for various purposes:

• Monte Carlo scenario generation
• Yield curve interpolation
• Estimating optimal hedges, and the associated risk for non tradable products

In general this technique gives an analytical solution of the conditional scenario pdf.
Scenario generation can be accomplished by sampling from that distribution. A different
application is to calculate the average yield as a function of maturity (the average of
the scenario’s), which can be viewed as a interpolation method. Yet another applications is to use the relationships between yield to estimate hedges based on the relationship between interpolated yields and the available yields from quoted products.

The Vasicek SDE

We use the following notation for the Vasicek SDE rate model

(1)  

The spot rate distribution of the Vasicek model. The green line mu is the long term mean, blue line is the average forward rate, the three red lines are random scenario's, the blue area is the 95% confidence interval.

Properties of the rate

the rate has has the following properties

(2)  

Properties of the Yield

With a Gaussian spot, the yield can be shown to be Gaussian too. The yield is defined as
-the average compounded rate during the time interval up to -

(3)  

The yield of the Vasicek spot rate model. It looks similar to the spot rate except that it's less volatile due to the averaging.

The yield It has these properties

(4)  

the Cov is solved using this relation

(5)  

The Yield as a Gaussian

Let be the yield at a points in time.
To simplify notation, let and .
From the result we know that these yields will have a dimensional Gaussian distribution.

(6)  

Conditional Distribution of a Gaussian

The -dimensional Gaussian probability density functions is given by:

(7)  

with the distribution parameters the mean vector, the covariance matrix, and the determinant of .

Let and be partitioned into a set of free variable
, and a set of conditioning variables with known fixed values.

(8)  

The conditional density function of the multivariate Gaussian density is given as

which can also be written as

(9)  

Conditioning the Yield Distribution on a Set of Values

We will now apply the conditioning equation (9) to the Gaussian yield solution
of the vasicek model (4).
The conditioning values will be a set zero yields values obtained from zero coupon bonds, and the free variable(s) as parameterized functions that define the distribution of the yield curve in general -which we’ll use for interpolation, MC sampling etc.-.

A couple of interesting thing to note already based on equation (9) are:

• Looking at , the mean of the free variables depends linear on the conditioned values.
• The variance of the free variables does not depend on the values of conditioning varaibles ().

The mean yield and 95% probability intervals of the conditioned Vasicek model. The red dots are the market yield.

Adding Variance to Future Yields

The conditioned yield is not a very realistic model. It assumes an uncertain evolution of
a stochastic spot rate, yet at the same time assumes that we know the yields for a set of future periods exactly. We can however very easily make the yields stochastic using the law
of total probability (Bayes rules).

(10)  

Assuming that a set of yields are multivariate Gaussian, i.e.

(11)  

will result in a analytical, Gaussian solution

(12)  

Final Result

The final result, the Vasicek yield distribution, with adjusted (displaced) yield distributions slipped in to make it marked adjusted.

Binomial Tree, geometric Brownian motion: Cox, Ross, Rubinstein

The Binomial tree is a discretized description of geometric Brownian motion which is often used to describe asset behavior. The structure is a recombining tree where the asset S can move either up or down.

Trinomial Tree, geometric Brownian motion

The Trinomial tree is a discretized description of geometric Brownian motion which is often used to describe asset behavior. The structure is a recombining tree where the asset S can move up, mid or down.

Binomial Tree, geometric Brownian motion: Jarrow, Rudd

This is the Jarrow and Rudd version of the Binomial tree. The Binomial tree is a discretized description of geometric Brownian motion which is often used to describe asset behavior. The structure is a recombining tree where the asset S can move either up or down.

Binomial Tree, geometric Brownian motion: Tian

This is the Tian version of the Binomial tree. The Binomial tree is a discretized description of geometric Brownian motion which is often used to describe asset behavior. The structure is a recombining tree where the asset S can move either up or down.

Binomial Tree, geometric Brownian motion: Trigeorgis

This is the Trigeorgis version of the Binomial tree. The Binomial tree is a discretized description of geometric Brownian motion which is often used to describe asset behavior. The structure is a recombining tree where the asset S can move either up or down.

First derivative: 2 point rules

Approximation formula for the first derivative. These equations are known as the forward and backward Eurler rules.

Second derivative: 3 point rule

Approximation of the second derivative using the 3 point rule.

First derivative: 3 point rules

Approximation formula for the first derivative. These 3 point equations have second order accuracy.

First derivative: 4 point rules

Approximation formula for the first derivative. These 4 point equations have third order accuracy.

Second derivative: 4 point rules

Approximation of the second derivative using the 4 point rule.

Second derivative: 5 point rules

Approximation of the second derivative using the 5 point rule.

First derivative: 3 point rules, asymmetrical

Asymmetrical approximation formula for the first derivative. These 3 point equations have second order accuracy.

First derivative: 5 point rules

Approximation formula for the first derivative. These 5 point equations have fourth order accuracy.

Ornstein-Uhlenbeck process

The Ornstein-Uhlenbeck process is the most common mean reverting stochastic process.

Geometric Brownian motion SDE

The Geometric Brownian describes the most widely used model in finance. It is used to simulate the stochastic behaviour of stocks, currencies, futures.

The value of this process is strick positive, St cannot get below zero.

Vasicek stochastic process

Cox-Ingersoll-Ross interest rate model

Schwartz type 1 stochastic process

The Schwartz type 1 model is a log price Ornstein-Uhlenbeck stochastic process.

Schwartz type 2 stochastic process

Swartz type 2 stochastic process is a two-factor process. The first factor is the spot price, the second factor a instantaneous convenience yield.

Heston stochastic volatility model

GARCH(1,1) stochastic volatility model

Generalized Auto-Regression Conditional Heteroskedacity (GARCH) stochastic volatility model.

Constant elasticity of volatility

General stochastic differential equation

General stochastic differential equation

Merton jump-diffusion

The Merton jump-diffusion process is an extension to geometric Brownian motion.

Clewlow and Strickland jump-diffusion mean-reversion

This is the Clewlow and Strickland jump-diffusion mean-reversion SDE. This process is used to describe processes in the energy markets.

Black-Karasinski short term interest rate

The Black Karasinski for the short term interest rate

Hull-White short term interest rate model

The Hull-While model is an extended version of the Vasicek model. The short term interest rate is normal distributed, and is mean reverting.

Normal distribution

Exponential distribution

Lognormal distribution

Gamma distribution

Double exponential (Laplacian) distribution

Uniform distribution

Beta distribution

Cauchy distribution

The Cauchy distribution has an undefined mean and variance.

Weibull distribution

Pareto distribution

Normal-inverse Gaussian distribution

Bivariate normal distribution

The bivariate normal probability density function for two correlated normal distributed variables x and y.

Bivariate normal distribution, alternative expression

The bivariate normal density function can also be expressed as the product of a normal distributed variable with a conditional probability distribution function.

Erlang distribution

Random value with Erlang distribution results as sum of k exponential distributed random values

Jointly Normal Distribution density function

Equations

with

	Price of the spread call option with payoff
	Price of a Black & Scholes vanilla option
	Gauss-Legendre quadrature weights
	Gauss-Legendre quadrature abscissas in the range -4 to +4
	Value of the long underlying
	Volatility of the long underlying
	Yield of the long underlying
	Value of the short underlying
	Volatility of the short underlying
	Yield of the short underlying
	Correlation between the underlyings
	Strike
	Time till expiration
	Normal density function

Equation

Suppose we have the following set of observations for the two variables .
The first two observations of and the last two observations of are missing (denoted by ‘?’).

Table 1

	?	?	15	12	14	13	14	10	15	16
	12	11	18	16	19	17	15	19	?	?

The first thing to do is to get initial estimates of the means and (co)variances. These first estimate are made using only complete data. This data is show in table 2 in bold. All the pairs of data with a value missing are thrown away.

Estimating the mean

Table 2

	?	?	15	12	14	13	14	10	15	16
	12	11	18	16	19	17	15	19	?	?

We estimate the means for the two variables

	= (15	+ 12	+ …	+ 10)/6	= 13
	= (18	+ 16	+ …	+ 19)/6	= 17.333

Esitmating (co)variances

Next we estimate the covariances using one of the formulas below. Is this case we use the second method.

	=(15^2	+ 12^2	+ …	+ 10^2	)/6	- 13^2	= 2.667
	=(15*18	+ 12*16	+ …	+ 10*19	)/6	- 13*17.333	= -0.5
	=(18^2	+ 16^2	+ …	+ 19^2	)/6	- 17.333^2	= 2.222

Estimating the correlation

Finally, we get the first estimate of the correlation:

= -0.2054

Using a linear model to fill in the missing data

The EM algorithms starts by finding values for the missing data, and the uncertainty of those estimates. The best guesses for the missing values are made using a least squares linear fits.

This first model will predict the missing values of based on using . This is illustrated in the plot below. The line is the linear fit, and values for are determined for and .

The second model is the other way around, and will be used to predict the missing values of .

Using the means and covariances, we get the following linear models

The estimate for the first missing value of that corresponds with the value 12 for will thus be

= 13 + -0.5 / 2.222 (12 – 17.333) = 14.2

Table 3 shows the completed table with all four missing values estimated

Table 3

	14.2	14.4	15	12	14	13	14	10	15	16
	12	11	18	16	19	17	15	19	17.0	16.8

Main loop

After estimating values for the missing data using least squares linear regression, we are ready to enter the iterative loop that converges to an optimal solution of the correlation estimate.

Updating the means

We estimate new values for means using the completed data

	= (14.2	+ 14.4	+ 15 …	+ 10	+ 15	+ 16	)/10	= 13.76
	= (12	+ 11	+ 18 …	+ 19	+ 17.0	+ 16.8	)/10	= 16.07

Updating the (co)variances

Next we update the covariances using one of the formulas below. These equations are the same as before, except that they have an additional term in the variance estimates that correct for the uncertainty in estimates of

	=(14.2^2	+ 14.4^2	+ …	+ 16^2	)/10	- 13.76^2	+ 2.667 (1 – 0.042) 2/10	= 3.18
	=(14.2*12	+ 14.4*11	+ …	+ 16*16.8	)/10	- 13.76*16.07		= -1.13
	=(12^2	+ 11^2	+ …	+ 16.8^2	)/10	- 16.07^2	+2.222(1 – 0.042) 2/10	= 7.07

Updating the correlation

Finally, we get an update of the correlation:

= -0.2374

Updating the estimates of the missing data

Using the updated means and covariances, we get the following linear models

The first missing value of will thus become

= 13.76 + -1.13 / 7.07 (12 – 16.07) = 14.41

Table 4 shows the completed table with all four missing values updated

Table 4

	14.4	14.6	15	12	14	13	14	10	15	16
	12	11	18	16	19	17	15	19	15.6	15.3

Repeating the process

These steps are repeated -starting with updating the means- a number of times untill the values converge.

step
0	13.00	17.33	2.67	-0.50	2.22	-0.21	14.20	14.42	16.96	16.77
1	13.76	16.07	3.18	-1.13	7.07	-0.24	14.41	14.57	15.63	15.28
2	13.80	15.79	3.31	-1.77	7.86	-0.35	14.65	14.88	15.15	14.61
3	13.85	15.68	3.38	-2.21	8.04	-0.42	14.86	15.14	14.93	14.27
4	13.90	15.62	3.45	-2.51	8.09	-0.47	15.02	15.33	14.82	14.09
5	13.94	15.59	3.51	-2.70	8.09	-0.51	15.13	15.47	14.77	14.00
6	13.96	15.58	3.56	-2.83	8.07	-0.53	15.21	15.56	14.75	13.96
7	13.98	15.57	3.61	-2.91	8.05	-0.54	15.27	15.63	14.75	13.94
8	13.99	15.57	3.64	-2.96	8.04	-0.55	15.31	15.67	14.75	13.93
9	14.00	15.57	3.66	-3.00	8.02	-0.55	15.33	15.71	14.75	13.93
10	14.00	15.57	3.68	-3.02	8.01	-0.56	15.35	15.73	14.75	13.93
11	14.01	15.57	3.69	-3.04	8.01	-0.56	15.36	15.74	14.75	13.92
12	14.01	15.57	3.70	-3.05	8.00	-0.56	15.37	15.75	14.75	13.92
13	14.01	15.57	3.70	-3.06	8.00	-0.56	15.38	15.76	14.75	13.92
14	14.01	15.57	3.71	-3.07	7.99	-0.56	15.38	15.77	14.75	13.92
15	14.01	15.57	3.71	-3.07	7.99	-0.56	15.38	15.77	14.75	13.92

Conclusions

This example shows that estimating correlation based on missing data can give substantial different values compared to methods that throw away all samples that have missing data. The initial guess of this algorithm gives a correlation of -0.21, which is a correlation estimate based on removing all missing data sampled. The final results is a correlation of -0.56. An explanation for this big difference is that two samples of are thrown away deviate strongly from the other values of . When including those samples, the estimate of the mean changes considerably (17.33 vs 16.07), which in turns has a strong impact in the estimate of the variance of (2.22 vs 7.07).

Bibliography

R. Rebonato, P. Jackel – The most general methodology to create a valid correlation matrix for risk management and option pricing purposesURL

Mortaza Jamshidian, Peter M. Bentler – ML Estimation of Mean and Covariance Structures with Missing Data Using Complete Data Routines URL

Roderick J A Little, Donald B Rubin – Statistical analysis with missing data
John Wiley \& Sons, Inc., New York, NY, USA, 1986

Three scenarios of a stock price, of which one has a high above 180.

Equation

	The highest value of in the time period 0
H	The level of the high for which the probability is calculated
	The current value of the geometric Brownian motion
	The value of the geometric Brownian motion at time t
	The drift of the geometric Brownian motion
	The volatility of the geometric Brownian motion
Erfc	The complementary error function
ln	Natural logarithm

Example equation usage

Parameter values

T	3
H	180
	100
	0.05
	0.30

Substitution of values …

and

thus

The probability that the high of stock gets above 180 is thus 26.7%, and that is stays below 73.3%

E.g. we can store this matrix

in a vector like this

The only thing we need to do is to convert two dimensional indices (r,c) into a one dimensional index. Using template we can do this very efficiently compile time, minimizing the run-time overhead.

This template version support up to 4 dimensional tensors.

template <int d1,int d2=1,int d3=1,int d4=1>
class TensorIndex {
  public:
	enum {SIZE = d1*d2*d3*d4 };
	enum {LEN1 = d1 };
	enum {LEN2 = d2 };
	enum {LEN3 = d3 };
	enum {LEN4 = d4 };
 
    static int indexOf(const int i) { 
      return i;
    }
    static int indexOf(const int i,const int j) {
      return j*d1 + i;
    }
    static int indexOf(const int i,const int j, const int k) {
      return (k*d2 + j)*d1 + i;
    }
    static int indexOf(const int i,const int j, const int k,const int l) {
      return ((l*d3 + k)*d2 + j)*d1 + i;
    }
};

Example Usage

The examples below demonstrate:

• to work with a matrix, using a std::vector as storage
• work with a four dimensional tensor using a simple array as storage

#include <vector>
 
int main(int argc, char* argv[])
{
    // First example
    //=================================
 
    // A matrix of 3 rows and 4 columns.
    typedef TensorIndex<3,4> M;
 
    // Store the matrix in a std::vector
    std::vector<double> M_Storage(M::SIZE);
 
    // Fill it with ones
    for (int row=0; row<M::LEN1; ++row)
        for (int col=0; col<M::LEN2; ++col)
            M_Storage[M::indexOf(row,col)] = 1.0;
 
 
    // Second example
    //=================================
    // A 4 x 5 x 6 x 7 cube
    typedef TensorIndex<4,5,6,7> T;
 
    // Use an array for storage
    double T_Storage[T::SIZE];
 
    // Fill it with ones
    for (int i=0; i<T::LEN1; ++i)
        for (int j=0; j<T::LEN2; ++j)
            for (int k=0; k<T::LEN3; ++k)
                for (int l=0; l<T::LEN4; ++l)
                    T_Storage[T::indexOf(i,j,k,l)] = 1.0;
 
	return 0;
}

Efficiency and speed

The translation of the indices is done compile time. The code snippet from the above example

typedef TensorIndex<3,4> M;
 
std::vector<double> M_Storage(M::SIZE);
 
for (int row=0; row<M::LEN1; ++row)
    for (int col=0; col<M::LEN2; ++col)
        M_Storage[M::indexOf(row,col)] = 1.0;

gets translated to

std::vector<double> M_Storage(12);
 
for (int row=0; row<3; ++row)
    for (int col=0; col<4; ++col)
        M_Storage[4*row+col] = 1.0;

Alternative Template: 1-based indices

Many numerical algorithms and mathematical articles use a notation where indices start counting from 1 (instead of 0 as in C++). The following template can be used to make the transition from that notation to the zero based C++ standard easy.

template <int d1,int d2=1,int d3=1,int d4=1>
class TensorIndex_base1 {
  public:
	enum {SIZE = d1*d2*d3*d4 };
	enum {LEN1 = d1 };
	enum {LEN2 = d2 };
	enum {LEN3 = d3 };
	enum {LEN4 = d4 };
 
    static int indexOf(const int i) { 
      return i -1;
    }
    static int indexOf(const int i,const int j) {
      return j*d1 + i -1 -d1;
    }
    static int indexOf(const int i,const int j, const int k) {
      return (k*d2 + j)*d1 + i -1 -d1 -d1*d2;
    }
    static int indexOf(const int i,const int j, const int k,const int l) {
      return ((l*d3 + k)*d2 + j)*d1 + i -1 -d1 -d1*d2 - d1*d2*d3;
    }
};
 
...
 
// Example Usage
    typedef TensorIndex_base1<3,4> M;
 
    double M_Storage[M::SIZE];
 
    for (int i=1; i<=M::LEN1; ++i)
        for (int j=1; j<=M::LEN2; ++j)
            M_Storage[M::indexOf(i,j)] = 1.0;

A particular nice feature of this single-pass weighted covariance algorithms is that it also allows for parallel execution and merging of subset statistics.

The algorithm is based on the paper :
Chan, Tony F.; Golub, Gene H.; LeVeque, Randall J. (1979), “Updating Formulae and a Pairwise Algorithm for Computing Sample Variances.”, Technical Report STAN-CS-79-773, Department of Computer Science, Stanford University.

The algorithm: sp_mean_covariance.hpp

#ifndef SP_MEAN_COVARIANCE_HPP
#define SP_MEAN_COVARIANCE_HPP
 
#include <vector>
 
struct sp_mean_covariance {
    int     D;
    int     D2;
    double  W;
    std::vector<double> T;
    std::vector<double> S;
    std::vector<double> dX;
 
    sp_mean_covariance() 
    {
        D = 0;
        D2 = 0;
        T.clear();
        dX.clear();
        S.clear();
    }
 
    sp_mean_covariance(int D_) 
    {
        resize( D_ );
    }
 
    void resize(int D_) 
    {
        D = D_;
        D2 = (D_*(D_+1)/2);
 
        T.resize(D_);
        dX.resize(D_);
        S.resize( D_*(D_+1)/2 );
 
        clear();
    }
 
    void clear()
    {
        for (int d=0; d<D; ++d) {
            T[d] = 0.;
            dX[d] = 0.;
        }
        for (int d=0; d<D2; ++d) {
            S[d] = 0.;
        }
        W = 0.;
 
    }
 
 
    void add(double* x)
    {
        if (W == 0.) {
            W = 1.;
            for (int i=0; i<D ; ++i) T[i] = x[i];
            for (int i=0; i<D2; ++i) S[i] = 0.;
            return;
        }
        W += 1.;
        for (int i=0; i<D; ++i)     
            T[i] += x[i];
 
        double* Si = &S[0];
        double  f  = 1. / W / (W-1.);
        for (int i=0; i<D; ++i) dX[i] = W*x[i]-T[i];
 
        for (int r=0; r<D; ++r) {
            for (int c=0; c<=r; ++c) {
                *Si += f * dX[r] * dX[c];
                Si++;
            }
        }
    }
 
 
    inline void add(sp_mean_covariance& M)
    {
        add(M.W, &M.T[0], &M.S[0]);
    }
 
    void add(double W_, double* T_, double* S_)
    {
 
        if (W == 0.) {
            W = W_;
            for (int i=0; i<D ; ++i) T[i] = T_[i];
            for (int i=0; i<D2; ++i) S[i] = S_[i];
            return;
        }
        for (int i=0; i<D ; ++i) 
            dX[i] = T_[i]/W_ - T[i]/W;
 
        double* Si = &S[0];
        double* Si_ = &S_[0];
        double  f  = W * W_ / (W + W_);
        for (int r=0; r<D; ++r) {
            for (int c=0; c<=r; ++c) {
                *Si += *Si_ + f * dX[r] * dX[c];
                Si++;
                Si_++;
            }
        }
 
        for (int i=0; i<D ; ++i)
            T[i] += T_[i];
        W += W_;
    }
 
 
    inline void addw(double w, double* x)
    {
        //--------------------------------
        // add( w, w*x, 0. );
        //--------------------------------
        if (W == 0.) {
            W = w;
            for (int i=0; i<D ; ++i) T[i] = w*x[i];
            for (int i=0; i<D2; ++i) S[i] = 0.;
            return;
        }
 
        for (int i=0; i<D ; ++i) 
            dX[i] = x[i] - T[i]/W;
 
        double* Si = &S[0];
        double  f  = W * w / (W + w);
        for (int r=0; r<D; ++r) {
            for (int c=0; c<=r; ++c) {
                *Si += f * dX[r] * dX[c];
                Si++;
            }
        }
 
        for (int i=0; i<D ; ++i) T[i] += w*x[i];
        W += w;
    }
 
    double mean(int i) const { return T[i]/W; }
    double cov(int i) const { return S[i]/W; } 
    double covp(int i) const { return S[i]/(W-1.); }
};
 
#endif

1D scalar test

    {
        int N = 10;
        double x[] = { 4., 1., 9., 4., 9., 6., 8., 9., 5., 5. };
        double ans_mu = 6;
        double ans_var = 6.6;
 
        sp_mean_variance M;
 
        for (int i=0; i<N; ++i)
            M.add( x[i] );
 
        assert( std::abs( ans_mu  - M.mean() ) < 0.0001 );
        assert( std::abs( ans_var - M.var()  ) < 0.0001 );
    }

3D weighted test

    {
        int N = 10;
        int D = 3;
 
        double x[] = {
            5., 7., 1.,
            7., 8., 3.,
            8., 4., 2.,
            7., 2., 8.,
            1., 7., 3.,
            3., 8., 6.,
            2., 7., 5.,
            6., 5., 7.,
            9., 1., 8.,
            6., 7., 1.
        };
 
        double ans_mu[] = { 5.4, 5.6, 4.4 };
 
        double ans_cov[] = { 
             6.24, 
            -3.94, 5.64,
             1.14,-3.74, 6.84 
        };
 
        sp_mean_covariance M(3);
        for (int i=0; i<N; ++i) {
            M.addw(1., &x[i*D] );
        }
        std::cout << "W=" << M.W << std::endl;
        for (int i=0; i<M.D; ++i) std::cout << "mean=" << M.mean(i) << " ";
        std::cout << std::endl;
        for (int i=0; i<M.D2; ++i) std::cout << "cov=" << M.cov(i) << " ";
        std::cout << std::endl;
    }

3D weighted and parallel merge test

    {
        int N = 10;
        int D = 3;
 
        double x[] = {
            5., 7., 1.,
            7., 8., 3.,
            8., 4., 2.,
            7., 2., 8.,
            1., 7., 3.,
            3., 8., 6.,
            2., 7., 5.,
            6., 5., 7.,
            9., 1., 8.,
            6., 7., 1.
        };
 
        double ans_mu[] = { 5.4, 5.6, 4.4 };
 
        double ans_cov[] = { 
             6.24, 
            -3.94, 5.64,
             1.14,-3.74, 6.84 
        };
 
        sp_mean_covariance M(3);
        sp_mean_covariance M2(3);
        for (int i=0; i<6; ++i) {
            M.addw(1., &x[i*D] );
        }
        for (int i=6; i<N; ++i) {
            M2.addw(1., &x[i*D] );
        }
        M.add(M2);
        std::cout << "W=" << M.W << std::endl;
        for (int i=0; i<M.D; ++i) std::cout << "mean=" << M.mean(i) << " ";
        std::cout << std::endl;
        for (int i=0; i<M.D2; ++i) std::cout << "cov=" << M.cov(i) << " ";
        std::cout << std::endl;
    }

Payoff of the digital spread option

Digital spread options have a payoff that depends on the difference -spread- between two underlying S1,S2. The payoff is 1 unit (Dollar, Euro) if the spread S1-S2 is greater that a strike K, and zero otherwise.

An example contract would be: you get 1 dollar is the price of Apple stocks is more than 50 dollars higher than that of IBM exactly one year from now.

Pricing Formula

There is no analytical simple formula for the price of digital spread options. High accurate (arbitrary precision) approximations can however be calculating using the formula’s below. The pricing formulas for the digital spread call and put option are given by:

with the following functions and symbols

Symbol	Description
	Present value of the underlying
	Volatility of the underlying
	Yield of the underlying
	Correlation between the underlying
	Strike
	The interest rate (continuously compounded)
	Time till expiration in years
	The density of the normal (Gaussian) distribution function.
	The cumulative probability of the normal (Gaussian) distribution function.
	e to the power of x

The values are the abscesses and weights of Gauss Legendre quadrature scaled to a region in which the standard normal density function is significantly positive.

The table below gives the numbers for the 16 point Gauss Legendre quadrature scales to the range [-4 to 4]

-3.9576037399666	0.108609837647007
-3.77830009229293	0.249014095754591
-3.46252480955133	0.380634046729972
-3.02161763342001	0.498515885022136
-2.47150497761058	0.598383955266293
-1.83206711062891	0.67662607758001
-1.12641420311704	0.730413660179694
-0.38005003935055	0.757802441820274
0.38005003935055	0.757802441820274
1.12641420311704	0.730413660179694
1.83206711062891	0.67662607758001
2.47150497761058	0.598383955266293
3.02161763342001	0.498515885022136
3.46252480955133	0.380634046729972
3.77830009229293	0.249014095754591
3.9576037399666	0.108609837647007

Example

What is the value of the following digital spread call?

The contract pays 1 dollar is the price of Apple stock is at least
40 dollar higher than that of IBM in one year time. The current market
prices for Apple stock is 146, and for IBM 116. The risk free interest
rate is 5%. The stocks have a correlation of 0.55, and both Apple and
IBM stock have a volatility of 0.25

= 148.7633252
= 118.1955187
For i=1 we get:
= -3.957604
= 0.108610
= -8.175308
= 3.4207E-13
= 1.5842E-04
= 5.88577E-18

Repeating this for i=2 to 16, summing the results and multiplying with we finally get a value of 0.3588

VBA (Visual Basic for Applications) code

Function DigitalSpreadOption( _
    S1 As Double, _
    S2 As Double, _
    v1 As Double, _
    v2 As Double, _
    Y1 As Double, _
    Y2 As Double, _
    c As Double, _
    r As Double, _
    t As Double, _
    K As Double, _
    IsCall As Boolean) As Double
 
'The Digital Spread call has a payoff of 1 if S1-S2>K and else zero.
'The Digital Spread put has a payoff of 1 if S1-S2<K and else zero.

' PARAMETERS:
' - S1,S2 are the present values of the underlyings.
' - v1,v2 the volatilities of the underlyings
' - Y1,Y2 the yields: Use zero yield for futures, 
'         set the yield to the interest rate for stocks
' - c the correlation between S1,S2
' - r the interest rate (continuously compounded)
' - t time till expiration in years
' - K Strike

' NOTES:
' This function uses two non standard functions:
'- NormDens, the density function of the standard normal distribution
'- NormProb, the cumulative standard normal function

    'Gauss Legendre Quadrature on the interval -5 to 5
    Dim x_i As Variant
    Dim w_i As Variant
    x_i = Array( _
    -4.98631930924741, -4.92805755772634, -4.82381127793753, -4.6745303796887, _
    -4.48160577883026, -4.24683806866285, -3.97241897983971, -3.66091059370145, _
    -3.31522133465108, -2.93857878620381, -2.53449954466115, -2.10675638065318, _
    -1.65934301141064, -1.19643681126069, -0.722359807913982, -0.241538328438692, _
     0.241538328438692, 0.722359807913982, 1.19643681126069, 1.65934301141064, _
     2.10675638065318, 2.53449954466115, 2.93857878620381, 3.31522133465108, _
     3.66091059370145, 3.97241897983971, 4.24683806866285, 4.48160577883026, _
     4.6745303796887, 4.82381127793753, 4.92805755772634, 4.98631930924741)
 
    w_i = Array( _
    0.035093050047348, 8.13719736545292E-02, 0.126960326546311, 0.171369314565107, _
    0.214179490111091, 0.254990296311873, 0.293420467392676, 0.329111113881808, _
    0.361728970544243, 0.390969478935351, 0.416559621134734, 0.438260465022019, _
    0.455869393478819, 0.469221995404022, 0.478193600396374, 0.482700442573639, _
    0.482700442573639, 0.478193600396374, 0.469221995404022, 0.455869393478819, _
    0.438260465022019, 0.416559621134734, 0.390969478935351, 0.361728970544243, _
    0.329111113881808, 0.293420467392676, 0.254990296311873, 0.214179490111091, _
    0.171369314565107, 0.126960326546311, 8.13719736545292E-02, 0.035093050047348)
 
    Dim E1 As Double
    Dim E2 As Double
    Dim m_i As Double
 
    Dim Prob As Double
    E1 = S1 * Exp((Y1 - 0.5 * v1 * v1) * t)
    E2 = S2 * Exp((Y2 - 0.5 * v2 * v2) * t)
    Prob = 0
 
    For i = LBound(x_i) To UBound(x_i)
        m_i = Log((E1 * Exp(x_i(i) * v1 * Sqr(t)) - K) / E2) _ 
               / (v2 * Sqr(t))
        Prob = Prob + w_i(i) * NormDens(x_i(i)) _
              * NormProb((m_i - c * x_i(i)) / Sqr(1 - c * c))
    Next
 
    If IsCall Then
        DigitalSpreadOption = Prob * Exp(-r * t)
    Else
        DigitalSpreadOption = (1# - Prob) * Exp(-r * t)
    End If
End Function

Public Function NormProb(ByVal x As Double) As Double
 
  Dim t As Double
  Const b1 = 0.31938153
  Const b2 = -0.356563782
  Const b3 = 1.781477937
  Const b4 = -1.821255978
  Const b5 = 1.330274429
  Const p = 0.2316419
  Const c = 0.39894228
 
  If x >= 0 Then
      t = 1# / (1# + p * x)
      NormProb = (1# - c * Exp(-x * x / 2#) * t * _
      (t * (t * (t * (t * b5 + b4) + b3) + b2) + b1))
  Else
      t = 1# / (1# - p * x)
      NormProb = (c * Exp(-x * x / 2#) * t * _
      (t * (t * (t * (t * b5 + b4) + b3) + b2) + b1))
  End If
End Function

Public Function NormDens(ByVal x As Double) As Double
    NormDens = Exp(-0.5 * x * x) / 2.506628274631
End Function

Hourly electricity prices for various months of the year.

We found three main elements in the business chain that allow for optimization:

Water Transport

Raw material for the water purification process is raw water. Raw water is transported from a distant location to the purification plan, and that transport consumes a lot of energy. There are two main elements that define the optimal transport schedule. First is the size of buffers. Buffers generate flexibility in delivery schedules, it allows you e.g. to postpone transport. The second element is the efficiency of transport. Speeding up transport will increase the amount of energy that is needed for transporting the same volume. This is caused by increased pipe friction as a function of the flow speed.

Pump efficiency curves: Increased flowspeed (horizontal axis) will increase energy consumption (gray line y-axis)

The optimization model we developed optimized the two factors. On one hand we want to postpone transport to moment when electricity prices are low, but the consequence is that we will need to transport water at higher speeds to make up for the delayed water volume delivery, and that higher speed comes as a cost of increased friction and energy consumption.

Other elements

The two other elements for which we have investigated cost reduction strategies is the water purification plant, and using the emergency supply auxiliary power generators for opportunistic electricity supply during extreme high electricity prices.

• The least squares regression method
• maximum likelihood method

Introduction

The stochastic differential equation (SDE) for the Ornstein-Uhlenbeck process is given by

with the mean reversion rate, the mean, and the volatility.

An example simulation

The table and figure below show a simulated scenario for the Ornstein-Uhlenbeck process with time step =0.25, mean reversion rate =3.0, long term mean =1.0 and a noise term of =0.50. We will use this data to explain the model calibration steps.

A scenarios of a the Ornstein-Uhlenbeck process. The scenarios start at S(0)=3 and reverting to a long term mean of 1.

i	t
0	0.00	3.0000
1	0.25	1.7600	-1.0268
2	0.50	1.2693	-0.4985
3	0.75	1.1960	0.3825
4	1.00	0.9468	-0.8102
5	1.25	0.9532	-0.1206
6	1.50	0.6252	-1.9604
7	1.75	0.8604	0.2079
8	2.00	1.0984	0.9134
9	2.25	1.4310	2.1375
10	2.50	1.3019	0.5461
11	2.75	1.4005	1.4335
12	3.00	1.2686	0.4414
13	3.25	0.7147	-2.2912
14	3.50	0.9237	0.3249
15	3.75	0.7297	-1.3019
16	4.00	0.7105	-0.8995
17	4.25	0.8683	0.0281
18	4.50	0.7406	-1.0959
19	4.75	0.7314	-0.8118
20	5.00	0.6232	-1.3890

The following simulation equation is used for generating paths (sampled with fixed time steps of =0.25). The equation is an exact solution of the SDE.

The random numbers used in this example are shown in the last column of the table 1.

Calibration using least squares regression

The relationship between consecutive observations is linear with a iid normal random term

Least square fitting of a line to the data.

The relationship between the linear fit and the model parameters is given by

rewriting these equations gives

Calculating the least squares regression

Most software tools (Excel, Matlab, R, Octave, Maple, …) have built in functionality for least square regression. If its not available, a least square regression can easily be done by calculating the the quantities below:

from which we get the following parameters of the least square fit

Example

Applying the regression to the data in table 1 we get

Param	Value
	22.5301
	20.1534
	30.8338
	25.1973
	22.2222
	0.4574
	0.4924
	0.2073

These results allow us to recover the model parameters:

Param	Value
	0.9075
	3.1288
	0.5831

Calibration using Maximum Likelihood estimates

Conditional probability density function

The conditional probability density function is easily derived by combining the simulation equation above with the probability density function of the normal distribution function:

Conditional probability density function -red- of S at t=1.

The equation of the conditional probability density of an observation given a previous observation (with a time step between them) is given by

with

Log-likelihood function

The log-likelihood function of a set of observation can be derived from the conditional density function

Maximum likelihood conditions

The maximum of this log-likelihood surface can be found at the location where all the partial derivatives are zero. This leads to the following set of constraints.

Log likelihood function as function of mu.

Log likelihood function as function of lambda.

Solution of the conditions

The problem with these conditions is that the solutions depend on each other. However, both and are independent of , and knowing either or will directly give the value the other.
The solution of can be found once both and are determined. To solve these equations it is thus sufficient to find either or .
Finding can be done by substituting the condition into the .

First we change notation of the and condition using the same notation as before, i.e

which gives us:

substituting into gives

removing denominators

collecting terms

moving all to the left

Final results: The maximum likelihood equations

mean:

mean reversion rate:

variance:

with

Example

Calculating the sums based on table 1 we get

Param	Value
	22.5301
	20.1534
	30.8338
	25.1973
	22.2222

These results allow us to recover the model parameters:

Param	Value
	0.9075
	3.1288
	0.5532

Matlab Code

Least Squares Calibration

function [mu,sigma,lambda] = OU_Calibrate_LS(S,delta)
  n = length(S)-1;
 
  Sx  = sum( S(1:end-1) );
  Sy  = sum( S(2:end) );
  Sxx = sum( S(1:end-1).^2 );
  Sxy = sum( S(1:end-1).*S(2:end) );
  Syy = sum( S(2:end).^2 );
 
  a  = ( n*Sxy - Sx*Sy ) / ( n*Sxx -Sx^2 );
  b  = ( Sy - a*Sx ) / n;
  sd = sqrt( (n*Syy - Sy^2 - a*(n*Sxy - Sx*Sy) )/n/(n-2) );
 
  lambda = -log(a)/delta;
  mu     = b/(1-a);
  sigma  =  sd * sqrt( -2*log(a)/delta/(1-a^2) );
end

Maximum Likelyhood Calibration

function [mu,sigma,lambda] = OU_Calibrate_ML(S,delta)
  n = length(S)-1;
 
  Sx  = sum( S(1:end-1) );
  Sy  = sum( S(2:end) );
  Sxx = sum( S(1:end-1).^2 );
  Sxy = sum( S(1:end-1).*S(2:end) );
  Syy = sum( S(2:end).^2 );
 
  mu  = (Sy*Sxx - Sx*Sxy) / ( n*(Sxx - Sxy) - (Sx^2 - Sx*Sy) );
  lambda = -log( (Sxy - mu*Sx - mu*Sy + n*mu^2) / (Sxx -2*mu*Sx + n*mu^2) ) / delta;
  a = exp(-lambda*delta);
  sigmah2 = (Syy - 2*a*Sxy + a^2*Sxx - 2*mu*(1-a)*(Sy - a*Sx) + n*mu^2*(1-a)^2)/n;
  sigma = sqrt(sigmah2*2*lambda/(1-a^2));
end

Example Usage

S = [ 3.0000 1.7600 1.2693 1.1960 0.9468 0.9532 0.6252 ...
      0.8604 1.0984 1.4310 1.3019 1.4005 1.2686 0.7147 ...
      0.9237 0.7297 0.7105 0.8683 0.7406 0.7314 0.6232 ];
 
delta = 0.25;
 
[mu1, sigma1, lambda1] = OU_Calibrate_LS(S,delta)
[mu2, sigma2, lambda2] = OU_Calibrate_ML(S,delta)

gives

mu1     = 0.90748788828331
sigma1  = 0.58307607458526
lambda1 = 3.12873217812387
 
mu2     = 0.90748788828331
sigma2  = 0.55315453345189
lambda2 = 3.12873217812386

There are various reasons for doing so:

• Centralized storage, allowing for structured backup and replication
• Multiuser environment, allowing for roles, and authentication

The project involves designed database the structure, make it portable for a MySQL, MSSQL or Oracle backend, and convert VBA code inside Excel to code that connects to databases.

The goal of the project was to model the financial and strategic effects of 5 different (national and European) renewable energy regulatory scenariose on its portfolio.

This model looked into the entire value chain (upstream, trading and sales), analysing the risks for the grey portfolio, existing green installations and new asset development with a specific focus on possible movements within the national merit order.