public void Process(IPathBlock block) { var index = 0; for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { for (var factor = 0; factor < block.Factors; factor++) { for (var step = 0; step < block.NumberOfSteps; step++) { var dim = step * block.Factors + factor; for (var i = 0; i < Vector <double> .Count; i++) { var pathid = path + i + block.GlobalPathIndex; var point = CreatePoint(pathid, dim) / Pow(2.0, 32.0); //point = ShiftNumber(point,dim); if (_useNormalInv) { point = Math.Statistics.NormInv(point); } block.RawData[index] = point; index++; } } } } Debug.Assert(block.RawData.Length == index); }
public void Process(IPathBlock block) { if (CompactMode) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _factorIndex); SetupAverages(steps); if (CompactMode) { if (!PathSumsByBlock.ContainsKey(block.GlobalPathIndex)) { PathSumsByBlock.Add(block.GlobalPathIndex, new double[steps.Length]); PathCountsByBlock.Add(block.GlobalPathIndex, steps.Length); } for (var i = 0; i < steps.Length; i++) { for (var j = 0; j < Vector <double> .Count; j++) { PathSumsByBlock[block.GlobalPathIndex][i] += steps[i][j]; } } } else { for (var i = 0; i < steps.Length; i++) { for (var j = 0; j < Vector <double> .Count; j++) { lock (_threadLock) { PathSum[i] += steps[i][j]; } } } } } } else { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _factorIndex); SetupAverages(steps); for (var i = 0; i < steps.Length; i++) { for (var j = 0; j < Vector <double> .Count; j++) { lock (_threadLock) { PathSum[i] += steps[i][j]; } } } } } }
public void Process(IPathBlock block) { ParallelUtils.Instance.For(0, block.NumberOfPaths, Vector <double> .Count, path => //for (var path = 0; path < block.NumberOfPaths; path += Vector<double>.Count) { var stepsMain = block.GetStepsForFactor(path, _mainFactorIndex); for (var f = 0; f < _factorIndices.Length; f++) //ParallelUtils.Instance.For(0,_factorIndices.Length,1,f=> { var previousStep = new Vector <double>(_forwardCurve(_futuresExpiries[f])); var steps = block.GetStepsForFactor(path, _factorIndices[f]); var c = 0; foreach (var kv in _pastFixings.Where(x => x.Key < _startDate)) { steps[c] = new Vector <double>(kv.Value); c++; } steps[c] = previousStep; for (var step = c + 1; step < block.NumberOfSteps; step++) { var W = steps[step]; var dt = new Vector <double>(_timesteps.TimeSteps[step]); var bm = (_vols[step][f] * _vols[step][f] / 2.0) * dt + (_vols[step][f] * _timesteps.TimeStepsSqrt[step] * W); previousStep *= bm.Exp(); steps[step] = previousStep; } }//).Wait(); for (var step = 0; step < block.NumberOfSteps; step++) { var frontMonth = block.GetStepsForFactor(path, _frontMonthFactors[step]); stepsMain[step] = frontMonth[step]; } }).Wait(); }
public void Process(IPathBlock block) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { for (var d = 0; d < _nDims; d++) { var steps = block.GetStepsForFactor(path, _assetIxs[d]); for (var fd = 0; fd < _dateIxsFwd.Length; fd++) { for (var v = 0; v < Vector <double> .Count; v++) { if (d == 0) { _pathwiseValuesFwd[block.GlobalPathIndex + path + v][fd] = steps[_dateIxsFwd[fd]][v]; _pathwiseValuesReg[block.GlobalPathIndex + path + v] = steps[_dateIxRegression][v]; } else { _pathwiseValuesFwd[block.GlobalPathIndex + path + v][fd] *= steps[_dateIxsFwd[fd]][v]; _pathwiseValuesReg[block.GlobalPathIndex + path + v] *= steps[_dateIxRegression][v]; } } } } } }
public unsafe void Process(IPathBlock block) { if (!UseNormalInverse) { for (var i = 0; i < block.TotalBlockSize; i += (UseAnthithetic ? 2 : 1)) { block[i] = GenerateDouble(); if (UseAnthithetic) { block[i + 1] = 1.0 - block[i]; } } } else { for (var i = 0; i < block.TotalBlockSize; i += (UseAnthithetic ? 2 : 1)) { block[i] = Math.Statistics.NormInv(GenerateDouble()); if (UseAnthithetic) { block[i + 1] = -block[i]; } } } }
public void Process(IPathBlock 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); var c = 0; foreach (var kv in _pastFixings.Where(x => x.Key < _startDate)) { steps[c] = new Vector <double>(kv.Value); c++; } steps[c] = previousStep; for (var step = c + 1; step < block.NumberOfSteps; step++) { var W = steps[step]; var dt = new Vector <double>(_timesteps.TimeSteps[step]); var vols = new double[Vector <double> .Count]; for (var s = 0; s < vols.Length; s++) { vols[s] = Sqrt(Max(0, _lvInterps[step - 1].Interpolate(previousStep[s]))); } var volVec = new Vector <double>(vols); var bm = (_drifts[step] - volVec * volVec / _two) * dt + (volVec * _timesteps.TimeStepsSqrt[step] * W); previousStep *= bm.Exp(); steps[step] = previousStep; } } }
public void Process(IPathBlock 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(IPathBlock 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(IPathBlock 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 = 0; 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(IPathBlock block) { SetupFactors(); if (PathCalc.CompactMode) { var averagesForThisBlock = PathCalc.PathSumsByBlock[block.GlobalPathIndex].Select(a => a / PathCalc.PathCountsByBlock[block.GlobalPathIndex]).ToArray(); var factorsForThisBlock = _fwds.Select((f, ix) => new Vector <double>(f / averagesForThisBlock[ix])).ToArray(); for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _factorIndex); for (var step = 0; step < block.NumberOfSteps; step++) { steps[step] *= factorsForThisBlock[step]; } } } else { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _factorIndex); for (var step = 0; step < block.NumberOfSteps; step++) { steps[step] *= _correctionFactors[step]; } } } }
public void Process(IPathBlock block) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { for (var d = 0; d < _nDims; d++) { var steps = block.GetStepsForFactor(path, d); var targetIx = 0; var nextTarget = _dateIndexes[targetIx]; for (var s = 0; s < steps.Length; s++) { if (s == nextTarget) { for (var v = 0; v < Vector <double> .Count; v++) { _pathwiseValues[targetIx][block.GlobalPathIndex + path + v][d] = steps[s][v]; } targetIx++; if (targetIx == _dateIndexes.Length) { break; } nextTarget = _dateIndexes[targetIx]; } } } } }
public void Process(IPathBlock 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 override void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; if (_callPut == OptionType.C) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); Span <Vector <double> > stepsFx = null; if (_fxName != null) { stepsFx = block.GetStepsForFactor(path, _fxIndex); } var minValue = new Vector <double>(double.MaxValue); for (var i = 0; i < _dateIndexes.Length; i++) { minValue = Vector.Min(steps[_dateIndexes[i]] * (_fxName != null ? stepsFx[_dateIndexes[i]] : _one), minValue); } var lastValue = steps[_dateIndexes.Last()] * (_fxName != null ? stepsFx[_dateIndexes.Last()] : _one); var payoff = (lastValue - minValue) * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } else { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); Span <Vector <double> > stepsFx = null; if (_fxName != null) { stepsFx = block.GetStepsForFactor(path, _fxIndex); } var maxValue = new Vector <double>(double.MinValue); for (var i = 0; i < _dateIndexes.Length; i++) { maxValue = Vector.Max(steps[_dateIndexes[i]] * (_fxName != null ? stepsFx[_dateIndexes[i]] : _one), maxValue); } var lastValue = steps[_dateIndexes.Last()] * (_fxName != null ? stepsFx[_dateIndexes.Last()] : _one); var payoff = (maxValue - lastValue) * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } }
public void Process(IPathBlock block) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _fxPairIx); var stepsInv = block.GetStepsForFactor(path, _invertedFxPairIx); for (var s = 0; s < steps.Length; s++) { stepsInv[s] = _one / steps[s]; } } }
public unsafe void Process(IPathBlock block) { for (var f = 0; f < block.Factors; f++) { for (var p = 0; p < block.NumberOfPaths; p += Vector <double> .Count) { var s = block.GetStepsForFactor(p, f); for (var i = 0; i < block.NumberOfSteps; i++) { s[i] = _returnVec; } } } }
public void Process(IPathBlock 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); } }
internal void ConvertToSimCcyIfNeeded(IPathBlock block, int pathId, Vector <double> values, int payDateIndex) { if (_requiresConversionToSimCcy) { var stepsFxConv = block.GetStepsForFactor(pathId, _conversionToSimCcyIx); if (_requiresConversionToSimCcyInverted) { values *= stepsFxConv[payDateIndex]; } else { values /= stepsFxConv[payDateIndex]; } } }
public void Process(IPathBlock 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 unsafe void Process(IPathBlock block) { var currentIndex = 0 * block.NumberOfPaths * block.NumberOfSteps; for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { //This should be set to the spot price here var previousStep = Vector <double> .One; for (var step = 0; step < block.NumberOfSteps; step++) { //ref Vector<double> currentValue = ref block.ReadVectorByRef(currentIndex); //currentValue = Vector.Multiply(previousStep, currentValue); //previousStep = currentValue; //currentIndex += Vector<double>.Count; } } }
public void Process(IPathBlock block) { for (var ix = 0; ix < _regressionIndices.Length; ix++) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _regressionIndices[ix]); var targetIx = 0; var nextTarget = _dateIndexes[targetIx]; for (var s = 0; s < steps.Length; s++) { if (s == nextTarget) { if (ix == 0) { for (var v = 0; v < Vector <double> .Count; v++) { _pathwiseValues[targetIx][block.GlobalPathIndex + path + v] = steps[s][v]; } } else { for (var v = 0; v < Vector <double> .Count; v++) { _pathwiseValues[targetIx][block.GlobalPathIndex + path + v] *= steps[s][v]; } } targetIx++; if (targetIx == _dateIndexes.Length) { break; } nextTarget = _dateIndexes[targetIx]; } } } } }
public override void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; var barrierDownHit = new Vector <double>(0); var barrierUpHit = new Vector <double>(0); var expiryValue = new Vector <double>(0); for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); var minValue = new Vector <double>(double.MaxValue); var maxValue = new Vector <double>(double.MinValue); for (var i = 0; i < _dateIndexes.Length; i++) { minValue = Vector.Min(steps[_dateIndexes[i]], minValue); maxValue = Vector.Max(steps[_dateIndexes[i]], maxValue); } barrierDownHit = Vector.Abs(Vector.ConvertToDouble(Vector.LessThan(minValue, _barrierDownVec))); barrierUpHit = Vector.ConvertToDouble(Vector.GreaterThan(maxValue, _barrierUpVec)); if (_barrierType == BarrierType.KI) { var barrierHit = Vector.BitwiseAnd(barrierDownHit, barrierUpHit); var payoff = barrierHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } else //KO { var barrierHit = Vector.BitwiseAnd(Vector <double> .One - barrierDownHit, Vector <double> .One - barrierUpHit); var payoff = barrierHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } }
public void Process(IPathBlock 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); var c = 0; foreach (var kv in _pastFixings.Where(x => x.Key < _startDate)) { steps[c] = new Vector <double>(kv.Value); c++; } steps[c] = previousStep; for (var step = c + 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; } //transform for (var step = c + 1; step < block.NumberOfSteps; step++) { var ws = new double[Vector <double> .Count]; for (var v = 0; v < ws.Length; v++) { var t1 = Log(steps[step][v] / _spot0); var t2 = (_spotDrifts[step] - _spotVols[step] * _spotVols[step] / 2.0) * _timesteps.Times[step]; t1 -= t2; t1 /= _spotVols[step] * _spotTimesSqrt[step]; t1 = Statistics.NormSDist(t1); ws[v] = _invCdfs[step].Interpolate(t1); } steps[step] = new Vector <double>(ws); } } }
public void Process(IPathBlock 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); var c = 0; foreach (var kv in _pastFixings.Where(x => x.Key < _startDate)) { steps[c] = new Vector <double>(kv.Value); c++; } steps[c] = previousStep; if (_siegelInvert) { for (var step = c + 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; } } else { for (var step = c + 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(IPathBlock 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; } } }
public void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; var barrierHit = new Vector <double>(0); var expiryValue = new Vector <double>(0); if (_barrierSide == BarrierSide.Down) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); var minValue = new Vector <double>(double.MaxValue); for (var i = 0; i < _dateIndexes.Length; i++) { minValue = Vector.Min(steps[_dateIndexes[i]], minValue); } barrierHit = Vector.ConvertToDouble(Vector.LessThan(minValue, _barrierVec)); if (_barrierType == BarrierType.KI) { var payoff = -barrierHit * _notional; var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } else //KO { var didntHit = (new Vector <double>(1.0)) + barrierHit; var payoff = didntHit * _notional; var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } } else { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); var maxValue = new Vector <double>(double.MinValue); for (var i = 0; i < _dateIndexes.Length; i++) { maxValue = Vector.Max(steps[_dateIndexes[i]], maxValue); } barrierHit = Vector.ConvertToDouble(Vector.GreaterThan(maxValue, _barrierVec)); if (_barrierType == BarrierType.KI) { var payoff = barrierHit * _notional; var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } else //KO { var didntHit = (new Vector <double>(1.0)) + barrierHit; var payoff = didntHit * _notional; var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } } }
public abstract void Process(IPathBlock block);
public void Process(IPathBlock block) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var stepsByFactor = new Dictionary <int, Vector <double>[]>(); foreach (var ix in _assetIndices) { stepsByFactor.Add(ix, block.GetStepsForFactor(path, ix).ToArray()); } var indexCounter = 0; var nextIndex = _calculationDateIndices[indexCounter]; var steps = stepsByFactor.First().Value; var fixingDictionaries = _assetFxModel.FixingDictionaryNames.ToDictionary(x => x, x => (IFixingDictionary) new FixingDictionary(_assetFxModel.GetFixingDictionary(x))); for (var i = 0; i < steps.Length; i++) { var d = _timeFeature.Dates[i]; for (var j = 0; j < Vector <double> .Count; j++) { for (var a = 0; a < _assetIndices.Length; a++) { if (!fixingDictionaries.TryGetValue(_assetIds[a], out var fd)) { throw new Exception($"Fixing dictionary not found for asset {_assetIds[a]} "); } fd[d] = stepsByFactor[a][i][j]; } } if (i == nextIndex) { var currentDate = _calculationDates[indexCounter]; var newModel = _assetFxModel.Clone(); newModel.OverrideBuildDate(currentDate); newModel.AddFixingDictionaries(fixingDictionaries); var spotsByAsset = stepsByFactor.ToDictionary(x => x.Key, x => x.Value[i]); for (var j = 0; j < Vector <double> .Count; j++) { //build on-path price curves in model foreach (var spot in spotsByAsset) { var assetId = _assetIds[spot.Key]; var baseCurve = _assetFxModel.GetPriceCurve(assetId); var spotOnCurve = baseCurve.GetPriceForFixingDate(currentDate); var ratio = spot.Value[j] / spotOnCurve; var newCurve = new FactorPriceCurve(baseCurve, ratio); newModel.AddPriceCurve(assetId, newCurve); } var ead = _portfolio.SaCcrEAD(newModel, _reportingCurrency, _assetIdToGroupMap); var capital = _counterpartyRiskWeight * ead; if (!_expectedCapital.ContainsKey(currentDate)) { lock (_threadLock) { if (!_expectedCapital.ContainsKey(currentDate)) { _expectedCapital.Add(currentDate, 0.0); } } } if (double.IsNaN(capital) || double.IsInfinity(capital)) { throw new Exception("Invalid capital generated"); } _expectedCapital[currentDate] += capital; } indexCounter++; nextIndex = indexCounter < _calculationDateIndices.Length ? _calculationDateIndices[indexCounter] : int.MaxValue; } } } }
public void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; var nTotalVec = new Vector <double> [_nTotal.Length]; for (var i = 0; i < nTotalVec.Length; i++) { nTotalVec[i] = new Vector <double>(_nTotal[i]); } for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); Span <Vector <double> > stepsFx = null; if (_fxName != null) { stepsFx = block.GetStepsForFactor(path, _fxIndex); } var avgs = new Vector <double> [_dateIndexes.Count]; var avgVec = new Vector <double>((_callPut == OptionType.C) ? double.MaxValue : double.MinValue); var setReg = new double[Vector <double> .Count]; for (var a = 0; a < _dateIndexes.Count; a++) { var pastSum = new Vector <double>(0.0); for (var p = 0; p < _dateIndexesPast[a].Length; p++) { pastSum += steps[_dateIndexesPast[a][p]] * (_fxName != null ? stepsFx[_dateIndexesPast[a][p]] : _one); } var spotAtExpiry = steps[_decisionDateIx] * (_fxName != null ? stepsFx[_decisionDateIx] : _one); if (VanillaModel != null && AverageRegressors[a] == null) { avgs[a] = pastSum / nTotalVec[a]; for (var i = 0; i < Vector <double> .Count; i++) { setReg[i] = spotAtExpiry[i] * _expiryToSettleCarry; } } else { var futSum = new double[Vector <double> .Count]; for (var i = 0; i < Vector <double> .Count; i++) { futSum[i] = AverageRegressors[a] == null ? 0.0 : AverageRegressors[a].Predict(spotAtExpiry[i]) * _nFuture[a]; setReg[i] = SettlementRegressor.Predict(spotAtExpiry[i]); } var futVec = new Vector <double>(futSum); avgs[a] = (futVec + pastSum) / nTotalVec[a]; } avgVec = (_callPut == OptionType.C) ? Vector.Min(avgs[a], avgVec) : Vector.Max(avgs[a], avgVec); } var setVec = new Vector <double>(setReg); var payoff = (_callPut == OptionType.C) ? Vector.Max(new Vector <double>(0), setVec - avgVec) : Vector.Max(new Vector <double>(0), avgVec - setVec); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff * _notional; } }
public override void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; var barrierHit = new Vector <double>(0); var expiryValue = new Vector <double>(0); if (_barrierSide == BarrierSide.Down) { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); var minValue = new Vector <double>(double.MaxValue); for (var i = 0; i < _dateIndexes.Length; i++) { minValue = Vector.Min(steps[_dateIndexes[i]], minValue); } barrierHit = Vector.ConvertToDouble(Vector.LessThan(minValue, _barrierVec)); expiryValue = steps[_expiryIx]; var vanillaValue = _callPut == OptionType.C ? Vector.Max(expiryValue - _strikeVec, _zero) : Vector.Max(_strikeVec - expiryValue, _zero); if (_barrierType == BarrierType.KI) { var payoff = vanillaValue * barrierHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } else //KO { var didntHit = (new Vector <double>(1.0)) - barrierHit; var payoff = vanillaValue * didntHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } } else { for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); var maxValue = new Vector <double>(double.MinValue); for (var i = 0; i < _dateIndexes.Length; i++) { maxValue = Vector.Max(steps[_dateIndexes[i]], maxValue); } barrierHit = Vector.ConvertToDouble(Vector.GreaterThan(maxValue, _barrierVec)); expiryValue = steps[_expiryIx]; var vanillaValue = _callPut == OptionType.C ? Vector.Max(expiryValue - _strikeVec, _zero) : Vector.Max(_strikeVec - expiryValue, _zero); if (_barrierType == BarrierType.KI) { var payoff = vanillaValue * barrierHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } else //KO { var didntHit = (new Vector <double>(1.0)) + barrierHit; var payoff = vanillaValue * didntHit * _notional; ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff; } } } }
public override void Process(IPathBlock block) { var blockBaseIx = block.GlobalPathIndex; var nTotalVec = new Vector <double>(_nTotal); for (var path = 0; path < block.NumberOfPaths; path += Vector <double> .Count) { var steps = block.GetStepsForFactor(path, _assetIndex); Span <Vector <double> > stepsFx = null; if (_fxName != null) { stepsFx = block.GetStepsForFactor(path, _fxIndex); } var pastSum = new Vector <double>(0.0); for (var p = 0; p < _dateIndexesPast.Length; p++) { pastSum += steps[_dateIndexesPast[p]] * (_fxName != null ? stepsFx[_dateIndexesPast[p]] : _one); } var spotAtExpiry = steps[_decisionDateIx] * (_fxName != null ? stepsFx[_decisionDateIx] : _one); if (VanillaModel != null && AverageRegressor == null) { var setReg = new double[Vector <double> .Count]; for (var i = 0; i < Vector <double> .Count; i++) { setReg[i] = spotAtExpiry[i] + _expiryToSettleCarry; } var avgVec = pastSum / nTotalVec; var setVec = new Vector <double>(setReg); var payoff = (_callPut == OptionType.C) ? Vector.Max(new Vector <double>(0), setVec - avgVec) : Vector.Max(new Vector <double>(0), avgVec - setVec); ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff * _notional; } else { var futSum = new double[Vector <double> .Count]; var setReg = new double[Vector <double> .Count]; for (var i = 0; i < Vector <double> .Count; i++) { futSum[i] = AverageRegressor == null ? 0.0 : AverageRegressor.Predict(spotAtExpiry[i]) * _nFuture; setReg[i] = SettlementRegressor.Predict(spotAtExpiry[i]); } var futVec = new Vector <double>(futSum); var avgVec = (futVec + pastSum) / nTotalVec; var setVec = new Vector <double>(setReg); var payoff = (_callPut == OptionType.C) ? Vector.Max(new Vector <double>(0), setVec - avgVec) : Vector.Max(new Vector <double>(0), avgVec - setVec); ConvertToSimCcyIfNeeded(block, path, payoff, _dateIndexes.Last()); var resultIx = (blockBaseIx + path) / Vector <double> .Count; _results[resultIx] = payoff * _notional; } } }