public void Process(PathBlock block)
{
var nFactors = block.Factors;
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var randsForSteps = new Vector <double> [nFactors][];
for (var r = 0; r < randsForSteps.Length; r++)
{
randsForSteps[r] = block.GetStepsForFactor(path, r).ToArray();
}
for (var step = 1; step < block.NumberOfSteps; step++)
{
var randsForThisStep = new Vector <double> [nFactors];
for (var r = 0; r < randsForThisStep.Length; r++)
{
randsForThisStep[r] = randsForSteps[r][step];
}
var correlatedRands = Correlate(randsForThisStep);
for (var r = 0; r < randsForSteps.Length; r++)
{
var x = block.GetStepsForFactor(path, r);
x[step] = correlatedRands[r];
}
}
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var p1 = block.GetStepsForFactor(path, _assetIndex1);
var p2 = block.GetStepsForFactor(path, _assetIndex2);
var p1Arr = new double[Vector <double> .Count][];
var p2Arr = new double[Vector <double> .Count][];
for (var i = 0; i < Vector <double> .Count; i++)
{
p1Arr[i] = new double[p1.Length];
p2Arr[i] = new double[p2.Length];
}
for (var step = 0; step < p1.Length; step++)
{
for (var i = 0; i < Vector <double> .Count; i++)
{
p1Arr[i][step] = p1[step][i];
p2Arr[i][step] = p2[step][i];
}
}
var correls = new double[Vector <double> .Count];
for (var i = 0; i < correls.Length; i++)
{
var returns1 = p1Arr[i].Returns(true);
var returns2 = p2Arr[i].Returns(true);
correls[i] = returns1.Correlation(returns2).Correlation;
}
_results.Add(new Vector <double>(correls));
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var previousStep = new Vector <double>(_forwardCurve(0));
var steps = block.GetStepsForFactor(path, _factorIndex);
steps[0] = previousStep;
for (var step = 1; step < block.NumberOfSteps; step++)
{
var W = steps[step];
var dt = new Vector <double>(_timesteps.TimeSteps[step]);
var drifts = new Vector <double>(_drifts[step]);
var vols = new double[Vector <double> .Count];
for (var s = 0; s < vols.Length; s++)
{
vols[s] = System.Math.Sqrt(
System.Math.Max(0,
_lvInterps[step - 1].Interpolate(previousStep[s])));
}
var volVec = new Vector <double>(vols);
var bm = (drifts - volVec * volVec / _two) * dt + (volVec * _timesteps.TimeStepsSqrt[step] * W);
previousStep *= bm.Exp();
steps[step] = previousStep;
}
}
}
public void Process(PathBlock block)
{
var temp = new double[Vector <double> .Count];
for (var s = 0; s < block.NumberOfSteps; s++)
{
for (var f = 0; f < block.Factors; f++)
{
var dim = f * block.NumberOfSteps + s;
for (var p = 0; p < block.NumberOfPaths; p += Vector <double> .Count)
{
var path = p + block.GlobalPathIndex + 1;
var x = GetValueViaGreyCode(path, dim);
temp[0] = ConvertRandToDouble(x, dim);
for (var i = 1; i < Vector <double> .Count; i++)
{
path = i + p + block.GlobalPathIndex + 1;
x ^= _v[dim + _seed][BitShifting.FindFirstSet(~(uint)path) - 1];
temp[i] = ConvertRandToDouble(x, dim);
}
var pathSpan = block.GetStepsForFactor(p, f);
pathSpan[s] = new Vector <double>(temp);
}
}
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var steps = block.GetStepsForFactor(path, _assetIndex);
var finalValues = steps[_expiryIndex] - (new Vector <double>(_strike));
finalValues = Vector.Max(new Vector <double>(0), finalValues);
_results.Add(finalValues);
}
}
public static IPathBlock GetBlock(int nSteps)
{
var b = new PathBlock(_nPaths, 2, nSteps, 0);
for (var i = 0; i < _nPaths; i += Vector <double> .Count)
{
var p = b.GetStepsForFactor(i, 0);
for (var j = 0; j < nSteps; j++)
{
p[j] = new Vector <double>(100.0);
}
var pfx = b.GetStepsForFactor(i, 1);
for (var j = 0; j < nSteps; j++)
{
pfx[j] = new Vector <double>(1.0);
}
}
return(b);
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var steps = block.GetStepsForFactor(path, _assetIndex);
var finalValues = new Vector <double>(0.0);
for (var i = 0; i < _dateIndexes.Length; i++)
{
finalValues += steps[_dateIndexes[i]];
}
finalValues = (new Vector <double>(_strike)) - (finalValues / new Vector <double>(_dateIndexes.Length));
finalValues = Vector.Max(new Vector <double>(0), finalValues);
_results.Add(finalValues);
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var previousStep = new Vector <double>(_forwardCurve(0));
var steps = block.GetStepsForFactor(path, _factorIndex);
steps[0] = previousStep;
for (var step = 1; step < block.NumberOfSteps; step++)
{
var W = steps[step];
var dt = new Vector <double>(_timesteps.TimeSteps[step]);
var bm = (_drifts[step] - _vols[step] * _vols[step] / 2.0) * dt + (_vols[step] * _timesteps.TimeStepsSqrt[step] * W);
previousStep *= bm.Exp();
steps[step] = previousStep;
}
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
//This should be set to the spot price here
var previousStep = new Vector <double>(_spot);
var steps = block.GetStepsForFactor(path, _factorIndex);
steps[0] = previousStep;
for (var step = 1; step < block.NumberOfSteps; step++)
{
var drift = _drift * _timesteps.TimeSteps[step] * previousStep;
var delta = _scaledVol * steps[step] * previousStep;
previousStep = (previousStep + drift + delta);
steps[step] = previousStep;
}
}
}
public void Process(PathBlock block)
{
for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count)
{
var steps = block.GetStepsForFactor(path, _assetIndex);
var previousIndex = new double[Vector <double> .Count];
steps[0].CopyTo(previousIndex);
steps[0] = new Vector <double>(0);
for (var step = 1; step < block.NumberOfSteps; step++)
{
var currentIndex = new double[Vector <double> .Count];
steps[step].CopyTo(currentIndex);
if (_logReturns)
{
}
else
{
steps[step] = new Vector <double>(currentIndex) / new Vector <double>(previousIndex) - new Vector <double>(1.0);
}
previousIndex = currentIndex;
}
}
}
