// This function is a kind of a dummy finction that uses other 2 function calculate standarddevation and calculate option price to calculate value of greek and option price.
public override void calulateOptionPriceAndGreeks(long numberOfSimulations, Double interstRate, int numberOfDays, bool antitheticReduction, bool controlVariateReduction, bool multithreading, Double del = 0, ChangeValue change = ChangeValue.NONE, MainWindow form = null, GraphPlotting plot = null)
{
Simulator.initializeYieldCurve();
Simulator.createRandomNumbers(this, numberOfSimulations, numberOfDays, antitheticReduction);
Double daysToExpiry = Convert.ToDouble((this.ExpiryDate - DateTime.Today).Days);
Double[] priceAtEnd = Simulator.getPath(this, numberOfSimulations, numberOfDays, del, change, controlVariateReduction, multithreading, plot: plot);
Double[] cv = new Double[priceAtEnd.Length];
Simulator.controlVariateList.CopyTo(cv);
this.price = calculateOptionPrice(numberOfSimulations, numberOfDays, daysToExpiry, controlVariateReduction: controlVariateReduction, multithreading: multithreading);
if (controlVariateReduction)
{
calculateStandardErrorwithcv(numberOfSimulations, priceAtEnd, daysToExpiry, antitheticReduction, cv);
}
else
{
calculateStandardError(numberOfSimulations, priceAtEnd, daysToExpiry, antitheticReduction);
}
greeks.calculateGreeks(numberOfSimulations, numberOfDays, daysToExpiry, this, controlVariateReduction: controlVariateReduction, multithreading: multithreading, form: form);
Simulator.randomNumbers.Clear();
}
virtual public void calulateOptionPriceAndGreeks(long numberOfSimulations, Double intersRate, int steps, bool antitheticReduction, bool controlVariateReduction, bool multithreading, Double del = 0, ChangeValue change = ChangeValue.NONE, MainWindow form = null, GraphPlotting plot = null)
{
}
//This function creates an path of the stock which we assume for brownian geometric motion.
#region Create Path for Underlying
public static Double[] getPath(Options option, long noOfSimulations, int numberOfDays, Double del, ChangeValue change, bool controlVariateReduction, bool multithreading = true, GraphPlotting plot = null)
{
changeValues(option, del, change);
Double[] priceAtEnd = new Double[noOfSimulations];
int numberofThreads = multithreading ? Environment.ProcessorCount : 1;
Double dt = Convert.ToDouble((option.ExpiryDate - DateTime.Today).Days) / (365 * numberOfDays);
if (controlVariateReduction)
{
controlVariateList.Clear();
}
int day = 0;
Parallel.ForEach(randomNumbers, new ParallelOptions {
MaxDegreeOfParallelism = numberofThreads
}, randomList =>
{
Double[] simulatedPathForOneSimulation = new Double[numberOfDays + 1];
simulatedPathForOneSimulation[0] = option.Underlying.Price;
double controlVariate = 0;
for (int time = 1; time <= numberOfDays; time++)
{
try
{
simulatedPathForOneSimulation[time] = simulatedPathForOneSimulation[time - 1] * Math.Exp(((yieldCurve[0].Rate - (Math.Pow(option.HistoricalVolatility, 2) / 2.0)) * (dt)) + option.HistoricalVolatility * Math.Sqrt(dt) * randomList[time - 1]);
if (controlVariateReduction)
{
Double delta = OptionDelta(simulatedPathForOneSimulation[time - 1], option.StrikePrice, yieldCurve[0].Rate, option.HistoricalVolatility, (numberOfDays - time) * dt);
if (option.Type == OptionType.PUT)
{
delta = delta - 1;
}
controlVariate += delta * (simulatedPathForOneSimulation[time] - (simulatedPathForOneSimulation[time - 1] * Math.Exp(yieldCurve[0].Rate * dt)));
}
}
catch (Exception e)
{
throw e;
}
}
lock (lck)
{
if (plot != null && day <= 0)
{
plot.addNewSeries(simulatedPathForOneSimulation);
}
switch (option.OptionKind)
{
case OptionKind.ASIAN:
priceAtEnd[day++] = simulatedPathForOneSimulation.Average();
break;
case OptionKind.BARRIER:
switch (((BarrierOption)option).BarrierOptionType)
{
case BarrierOptionType.UPOUT:
if (simulatedPathForOneSimulation.Max() > ((BarrierOption)option).Barrier)
{
priceAtEnd[day++] = -1;
}
else
{
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
}
break;
case BarrierOptionType.UPIN:
if (simulatedPathForOneSimulation.Max() <= ((BarrierOption)option).Barrier)
{
priceAtEnd[day++] = -1;
}
else
{
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
}
break;
case BarrierOptionType.DOWNOUT:
if (simulatedPathForOneSimulation.Min() < ((BarrierOption)option).Barrier)
{
priceAtEnd[day++] = -1;
}
else
{
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
}
break;
case BarrierOptionType.DOWNIN:
if (simulatedPathForOneSimulation.Min() >= ((BarrierOption)option).Barrier)
{
priceAtEnd[day++] = -1;
}
else
{
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
}
break;
default:
break;
}
break;
case OptionKind.DIGITAL:
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
break;
case OptionKind.EUROPEAN:
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
break;
case OptionKind.LOOKBACK:
switch (option.Type)
{
case OptionType.CALL:
priceAtEnd[day++] = simulatedPathForOneSimulation.Max();
break;
case OptionType.PUT:
priceAtEnd[day++] = simulatedPathForOneSimulation.Min();
break;
default:
break;
}
break;
case OptionKind.RANGE:
priceAtEnd[day++] = simulatedPathForOneSimulation.Max() - simulatedPathForOneSimulation.Min();
break;
default:
priceAtEnd[day++] = simulatedPathForOneSimulation[simulatedPathForOneSimulation.Length - 1];
break;
}
if (controlVariateReduction)
{
controlVariateList.Add(controlVariate);
}
}
});
if (change != ChangeValue.RATE && change != ChangeValue.TIME)
{
changeValues(option, -1 * del, change);
}
return(priceAtEnd);
}
