public override IPricingResult Calculate(SwapLeg premiumLeg, IMarketCondition market, PricingRequest request)
{
var valuationDate = market.ValuationDate;
var result = new PricingResult(valuationDate, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = CalcRPv(premiumLeg, market);
}
var accDates = premiumLeg.Accruals.ToArray();
if (result.IsRequested(PricingRequest.Ai))
{
if (!accDates.Any() || valuationDate >= accDates.Last() || valuationDate <= premiumLeg.StartDate)
{
result.Ai = 0.0;
}
else
{
var idx = Array.FindIndex(accDates, x => x > valuationDate) - 1;
var dcf = premiumLeg.DayCount.CalcDayCountFraction(accDates[idx], valuationDate);
CfCalculationDetail[] temp;
var coupon = premiumLeg.Coupon.GetCoupon(accDates[idx], accDates[idx + 1], market.FixingCurve.Value, market.HistoricalIndexRates, out temp);
result.Ai = premiumLeg.Notional * coupon * dcf;
}
}
return(result);
}
protected virtual void SetPricingVol(PricingResult result, IOption option, IMarketCondition market)
{
var vol = AnalyticalOptionPricerUtil.pricingVol(volSurf: market.VolSurfaces.Value.Values.First(),
exerciseDate: option.ExerciseDates.Last(), option: option, spot: market.SpotPrices.Value.Values.First());
result.PricingVol = vol;
}
public static PricingResult BuildPricingResult(Notification notification)
{
PricingResult pricingResult = new PricingResult();
if (notification == null)
{
return(pricingResult);
}
// offer data
pricingResult.ASIN = notification.NotificationPayload.AnyOfferChangedNotification.OfferChangeTrigger.ASIN;
DateTime timeOfOfferChange = DateTime.UtcNow;
if (DateTime.TryParse(notification.NotificationPayload.AnyOfferChangedNotification.OfferChangeTrigger.TimeOfOfferChange, out timeOfOfferChange))
{
pricingResult.TimeOfOfferChange = timeOfOfferChange;
}
pricingResult.LandedPrice = GetLandedPrice(notification);
pricingResult.ListingPrice = GetListingPrice(notification);
if (pricingResult.LandedPrice == 0.0m)
{
pricingResult.LandedPrice = GetLowestOfferPrice(notification);
}
return(pricingResult);
}
private void EvaluateEnterpriseMultiple(PricingResult pricingResults, Models.Domain.MarketData stockMarketData)
{
var financialStatement = _statementOrganizer.GetLastFinancialStatement();
if (financialStatement == null)
{
return;
}
var marketCap = stockMarketData.MarketCapitalization ?? 0;
var debt = financialStatement.BalanceSheet.TotalLongTermDebt +
financialStatement.BalanceSheet.TotalShortTermDebt;
var minorityInterest = financialStatement.BalanceSheet.MinorityInterest;
var cash = financialStatement.BalanceSheet.CashCashEquivalentAndShortTermInvestments;
var preferredStock = financialStatement.BalanceSheet.PreferredStock;
var enterpriseValue = marketCap + debt + minorityInterest + preferredStock - cash;
pricingResults.EnterpriseValue = enterpriseValue;
var ebitda = financialStatement.IncomeStatement.Ebit +
financialStatement.CashFlowStatement.CfDepreciationAmortization;
if (ebitda != 0)
{
pricingResults.EnterpriseMultiple = enterpriseValue / ebitda;
}
}
public override IPricingResult Calculate(EquityLinkedNote <TOption> trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
var optionResult = OptionEngine.Calculate(trade.Option, market, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = optionResult.Pv + trade.Notional * market.DiscountCurve.Value.GetDf(market.ValuationDate, trade.UnderlyingMaturityDate);
}
if (result.IsRequested(PricingRequest.Delta))
{
result.Delta = optionResult.Delta;
}
if (result.IsRequested(PricingRequest.Gamma))
{
result.Gamma = optionResult.Gamma;
}
if (result.IsRequested(PricingRequest.Rho))
{
result.Rho = optionResult.Rho;
}
if (result.IsRequested(PricingRequest.Vega))
{
result.Vega = optionResult.Vega;
}
if (result.IsRequested(PricingRequest.Theta))
{
result.Theta = optionResult.Theta;
}
return(result);
}
private void EvaluateMultiples(PricingResult pricingResults, Models.Domain.MarketData stockMarketData)
{
var lastStatement = _statementOrganizer.GetLastFinancialStatement();
if (lastStatement == null)
{
return;
}
var revenue = lastStatement.IncomeStatement.TotalRevenue;
var earnings = lastStatement.IncomeStatement.NetIncomeApplicableToCommon;
if (stockMarketData.MarketCapitalization.HasValue && earnings > 0)
{
pricingResults.PriceEarningRatio = (decimal)(stockMarketData.MarketCapitalization)
/ earnings;
}
if (stockMarketData.MarketCapitalization.HasValue && revenue != 0)
{
pricingResults.PriceToSalesRatio = (decimal)stockMarketData.MarketCapitalization / revenue;
}
if (stockMarketData.MarketCapitalization.HasValue && lastStatement.BalanceSheet.RealTotalEquity != 0)
{
pricingResults.PriceToBookRatio = (decimal)stockMarketData.MarketCapitalization /
lastStatement.BalanceSheet.RealTotalEquity;
}
}
private void PerformReturnsStatistics(PricingResult pricingResults)
{
if (pricingResults.AnnualResults.Any())
{
pricingResults.AverageRoa = pricingResults.AnnualResults.Average(x => x.ReturnOnAssets);
pricingResults.AverageRoe = pricingResults.AnnualResults.Average(x => x.ReturnOnEquity);
pricingResults.AverageRoic = pricingResults.AnnualResults.Average(x => x.ReturnOnInvestedCapital);
pricingResults.AverageAssetTurnover = pricingResults.AnnualResults.Average(x => x.AssetTurnover);
pricingResults.AverageCurrentRatio = pricingResults.AnnualResults.Average(x => x.CurrentRatio);
pricingResults.AverageFreeCashFlow = pricingResults.AnnualResults.Average(x => x.FreeCashFlow);
pricingResults.AverageGrossMargin = pricingResults.AnnualResults.Average(x => x.GrossMargin);
pricingResults.AverageLeverage = pricingResults.AnnualResults.Average(x => x.Leverage);
pricingResults.AverageNetMargin = pricingResults.AnnualResults.Average(x => x.NetMargin);
pricingResults.AverageQuickRatio = pricingResults.AnnualResults.Average(x => x.QuickRatio);
var lastResult = pricingResults.AnnualResults.OrderByDescending(x => x.Year).First();
pricingResults.CurrentRoa = lastResult.ReturnOnAssets;
pricingResults.CurrentRoe = lastResult.ReturnOnEquity;
pricingResults.CurrentRoic = lastResult.ReturnOnInvestedCapital;
pricingResults.CurrentAssetTurnover = lastResult.AssetTurnover;
pricingResults.CurrentCurrentRatio = lastResult.CurrentRatio;
pricingResults.CurrentFreeCashFlow = lastResult.FreeCashFlow;
pricingResults.CurrentGrossMargin = lastResult.GrossMargin;
pricingResults.CurrentLeverage = lastResult.Leverage;
pricingResults.CurrentNetMargin = lastResult.NetMargin;
pricingResults.CurrentQuickRatio = lastResult.QuickRatio;
}
}
public PricingContext ProcessMessage(Notification notification)
{
string asin = notification.NotificationPayload.AnyOfferChangedNotification.OfferChangeTrigger.ASIN;
Product product = dataRepository.GetFirstAsync <Product>(x => x.ASIN == asin).Result;
if (product == null)
{
return(null);
}
nLogger.Log(LogLevel.Info, string.Format("Product found for ASIN: {0}", product.ASIN));
PricingResult pricingResult = ProductLogic.SetPrice(notification, product);
nLogger.Log(LogLevel.Info, string.Format("SetPrice logic executed"));
pricingResult.DateEntry = DateTime.UtcNow;
if (pricingResult.IsPriceChanged)
{
nLogger.Log(LogLevel.Info, string.Format("New price selected: {0}", pricingResult.NewPrice));
product.CurrentPrice = pricingResult.NewPrice;
product.DateUpdated = DateTime.UtcNow;
}
return(new PricingContext {
Product = product, PricingResult = pricingResult
});
}
public static PricingResult SetPrice(Notification notification, Product product)
{
PricingResult pricingResult = BuildPricingResult(notification);
decimal buyBoxPrice = pricingResult.LandedPrice; // Using LandedPrice
// populate Product values
pricingResult.MaxPrice = product.MaxAmazonSellPrice;
pricingResult.MinPrice = product.MinAmazonSellPrice;
pricingResult.OriginalPrice = product.CurrentPrice;
pricingResult.PriceCategorySelected = FindPriceCategory(buyBoxPrice, product);
decimal setPrice = pricingResult.MaxPrice;
if (pricingResult.PriceCategorySelected.Equals(PriceCategory.BuyBox))
{
setPrice = buyBoxPrice;
}
if (pricingResult.PriceCategorySelected.Equals(PriceCategory.Min))
{
setPrice = pricingResult.MinPrice;
}
pricingResult.NewPrice = setPrice;
return(pricingResult);
}
public override IPricingResult Calculate(CommodityProduct.CommoditySwap trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
var valuationDate = market.ValuationDate;
var maturityDate = trade.MaturityDate;
var recTicker = trade.RecTicker;
var payTicker = trade.PayTicker;
var fxTicker = trade.FxTicker;
var recLegSpot = market.SpotPrices.Value[recTicker];
var paylegSpot = market.SpotPrices.Value[payTicker];
//to do: retrieve fx from market
var fx = market.FxSpot.Value[fxTicker];
var recFx = (trade.RecCcy != CurrencyCode.CNY) ? fx : 1.0;
var payFx = (trade.PayCcy != CurrencyCode.CNY) ? fx : 1.0;
if (valuationDate > maturityDate)
{
result.Pv = 0.0;
result.asset1Delta = result.asset2Delta = result.asset3Delta = 0.0;
}
else
{
//To do: fx leg
result.Pv = trade.RecNotional * recLegSpot * recFx - trade.PayNotional * paylegSpot * payFx + trade.FxNotional * fx;
result.asset1Delta = trade.RecNotional * recFx;
result.asset2Delta = -1.0 * trade.PayNotional * payFx;
}
return(result);
}
public Dictionary <string, Hint> GiveHints(PricingResult pricingResult)
{
var hints = new Dictionary <string, Hint>();
if (pricingResult == null)
{
return(hints);
}
if (pricingResult.DiscountOnNcav >= 30)
{
hints.Add("NCAV", new Hint {
Level = AlertLevel.Success, Message = "The Discount to Net Current Asset Value is equal to " + pricingResult.DiscountOnNcav + "%. A discount superior to 30% is often an indicator that the stock is undervalued."
});
}
if (pricingResult.PriceEarningRatio > 0 && pricingResult.PriceEarningRatio <= 10)
{
hints.Add("PER", new Hint {
Level = AlertLevel.Success, Message = "The Price To Earnings Ratio is equal to " + pricingResult.PriceEarningRatio + ". A P/E ratio inferior to 10 is often an indicator that the stock is undervalued."
});
}
if (pricingResult.PriceEarningRatio > 23)
{
hints.Add("PER", new Hint {
Level = AlertLevel.Warning, Message = "The Price To Earnings Ratio is equal to " + pricingResult.PriceEarningRatio + ". A P/E ratio superior to 23 is often an indicator that the stock may be overvalued."
});
}
if (pricingResult.PriceToSalesRatio > 8)
{
hints.Add("PS", new Hint {
Level = AlertLevel.Danger, Message = "The Price To Sales Ratio is equal to " + pricingResult.PriceToSalesRatio + ". A P/S ratio superior to 8 is often an indicator that the stock is strongly overvalued."
});
}
return(hints);
}
public override IPricingResult Calculate(IFxCashflowInstrument fxTrade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
result.ComponentPvs = GetComponentPvs(fxTrade, market);
return(result);
}
public CsPricingResult(Guid clientId,
Guid requestId,
PricingResult result,
TradeInfoBase tradeInfo)
{
ClientId = clientId;
RequestId = requestId;
TradeInfo = tradeInfo;
Result = result;
}
public override IPricingResult Calculate(DynamicLeveragedNote dln, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
double finalLeverage;
result.Pv = CalcPv(dln, market, out finalLeverage);
result.Delta = finalLeverage * result.Pv;
return(result);
}
public override IPricingResult Calculate(CallableBond callableBond, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = CalcPv(callableBond, market);
}
return(result);
}
public override IPricingResult Calculate(Loan trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
if (result.IsRequested(PricingRequest.Cashflow))
{
result.Cashflows = trade.GetCashflows(market);
result.CashflowDict = result.Cashflows.ToDictionary(x => x.ToCfKey(), x => x.PaymentAmount);
}
return(result);
}
private void PerformPiotroskiStatistics(PricingResult pricingResults)
{
if (pricingResults.PiotroskiResults.Any())
{
var lastResult = pricingResults.PiotroskiResults.OrderByDescending(x => x.Year)
.First();
pricingResults.CurrentPiotroskiScore = lastResult.GlobalFScore;
pricingResults.AveragePiotroskiScore = (decimal)pricingResults.PiotroskiResults.Average(x => x.GlobalFScore);
pricingResults.AverageSalesGrowth = pricingResults.PiotroskiResults.Average(x => x.SalesGrowth);
pricingResults.CurrentSalesGrowth = lastResult.SalesGrowth;
}
}
public async Task <ActionResult <PricingResult> > GetListAsync(string solutionId)
{
var prices = (await _mediator.Send(new GetPriceBySolutionIdQuery(solutionId))).ToList();
var result = new PricingResult
{
Id = solutionId,
Name = prices.First()?.CatalogueItemName,
Prices = prices.Select(GetPriceResult)
};
return(result);
}
public static bool isHighOrderPricing(PricingResult result)
{
if (result.IsRequested(PricingRequest.DDeltaDt) ||
result.IsRequested(PricingRequest.DVegaDt) ||
result.IsRequested(PricingRequest.DDeltaDvol) ||
result.IsRequested(PricingRequest.DVegaDvol))
{
return(true);
}
else
{
return(false);
}
}
public override IPricingResult Calculate(ConstantLeveragedNote cln, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
double finalNoteValue;
result.Pv = CalcPv(cln, market, out finalNoteValue);
var startFxRate = cln.FxRates[cln.StartDate];
var endFxRate = cln.FxRates[market.ValuationDate];
result.Delta = finalNoteValue * cln.TargetLeverage * endFxRate / startFxRate;
return(result);
}
public static bool isBasicPricing(PricingResult result)
{
if (result.IsRequested(PricingRequest.Delta) ||
result.IsRequested(PricingRequest.Gamma) ||
result.IsRequested(PricingRequest.Vega) ||
result.IsRequested(PricingRequest.Theta) ||
result.IsRequested(PricingRequest.Rho))
{
return(true);
}
else
{
return(false);
}
}
private void EvaluateNcaV(PricingResult pricingResults, Models.Domain.MarketData marketData)
{
var statement = _statementOrganizer.GetLastFinancialStatement();
if (statement == null)
{
return;
}
pricingResults.NetCurrentAssetValue =
statement.BalanceSheet.TotalCurrentAssets - statement.BalanceSheet.TotalLiabilities;
if (marketData.MarketCapitalization.HasValue && pricingResults.NetCurrentAssetValue > 0)
{
pricingResults.DiscountOnNcav =
(1 - (decimal)marketData.MarketCapitalization / pricingResults.NetCurrentAssetValue) * 100;
}
}
public void BuyALotGetADiscount_Theory_When_Exceed_The_Limit(int minItemsInCart, double percentDiscount)
{
// ARRANGE
var promo = new BuyALotGetADiscountPromotion(minItemsInCart, percentDiscount);
var result = new PricingResult(TestData.Cart1)
{
TotalPrice = 100, TotalPriceToPay = 0, TotalDiscount = 0
};
// ACT
promo.Apply(result);
// ASSERT
Assert.Equal(100, result.TotalPrice);
Assert.Equal(100 - (decimal)percentDiscount, result.TotalPriceToPay, 3);
Assert.Equal((decimal)percentDiscount, result.TotalDiscount);
}
public override IPricingResult Calculate(InterestRateSwap trade, IMarketCondition market, PricingRequest request)
{
var cfEngine = new CashflowProductEngine <SwapLeg>();
var leg1Result = cfEngine.Calculate(trade.FixedLeg, market, PricingRequest.All);
var mkt4Leg2 = market.UpdateCondition(new UpdateMktConditionPack <IYieldCurve>(x => x.DiscountCurve, market.FgnDiscountCurve.Value),
new UpdateMktConditionPack <IYieldCurve>(x => x.FixingCurve, market.FgnFixingCurve.Value));
var leg2Result = cfEngine.Calculate(trade.FloatingLeg, mkt4Leg2, PricingRequest.All);
var result = new PricingResult(market.ValuationDate, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = leg1Result.Pv + leg2Result.Pv;
}
if (result.IsRequested(PricingRequest.Dv01))
{
result.Dv01 = leg1Result.Dv01 + leg2Result.Dv01;
}
if (result.IsRequested(PricingRequest.Pv01))
{
var bumpedIrs = trade.Bump(1);
var bumpedPv = new CashflowProductEngine <InterestRateSwap>().Calculate(bumpedIrs, market, PricingRequest.Pv).Pv;
result.Pv01 = bumpedPv - result.Pv;
}
if (result.IsRequested(PricingRequest.Ai))
{
result.Ai = leg1Result.Ai + leg2Result.Ai;
}
if (result.IsRequested(PricingRequest.Cashflow))
{
result.Cashflows = leg1Result.Cashflows.Union(leg2Result.Cashflows).ToArray();
}
if (result.IsRequested(PricingRequest.KeyRateDv01))
{
result.KeyRateDv01 = PricingResultExtension.Aggregate(leg1Result.KeyRateDv01, leg2Result.KeyRateDv01);
}
return(result);
}
public override IPricingResult Calculate(AbsWithRepurchase trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
if (result.IsRequested(PricingRequest.Cashflow))
{
var underlyingLoanCfs = trade.GetCashflows(market, false).ToArray();
var surplus = 0.0;
var repurchasedLoanCfs = new List <Cashflow[]> {
underlyingLoanCfs
};
var underlyingLoanPayDates = repurchasedLoanCfs.SelectMany(x => x.Select(cf => cf.PaymentDate)).Distinct().ToArray();
var payOutCashflows = trade.Tranches.SelectMany(x => x.GetCashflows(market, false)).ToArray();
//assumption: repurchased loans have same features as the original loan excepth the startDate and mautirytDate
for (var i = 0; i < underlyingLoanPayDates.Length - 1; ++i)
{
//repurchase prior to the final cash flow
var tCfs = repurchasedLoanCfs.SelectMany(x => x).Where(x => x.PaymentDate == underlyingLoanPayDates[i] && (x.CashflowType == CashflowType.Principal || x.CashflowType == CashflowType.Coupon || x.CashflowType == CashflowType.Tax)).ToArray();
surplus += tCfs.Sum(x => x.PaymentAmount);
var payOutAmount = payOutCashflows.Where(x => x.PaymentDate >= underlyingLoanPayDates[i] && x.PaymentDate < underlyingLoanPayDates[i + 1]).Sum(x => x.PaymentAmount);
surplus -= payOutAmount;
var endDate = trade.PayOutDates.Where(x => x > underlyingLoanPayDates[i]);
if (endDate.Any())
{
repurchasedLoanCfs.Add(RepurchasedLoanCashflow(underlyingLoanPayDates[i + 1], surplus * trade.RepurchaseRatio, trade.Loan, market, underlyingLoanPayDates[i], endDate.First()));
}
surplus *= (1.0 - trade.RepurchaseRatio);
}
var payOutCf =
payOutCashflows.Select(
x =>
new Cashflow(x.AccrualEndDate, x.AccrualEndDate, x.PaymentDate, -x.PaymentAmount, x.PaymentCurrency,
x.CashflowType, x.IsFixed, market.GetDf(x.PaymentDate), x.CalculationDetails, x.RefStartDate, x.RefEndDate, x.StartPrincipal, x.CouponRate));
result.Cashflows = repurchasedLoanCfs.SelectMany(x => x).Union(payOutCf).ToArray();
}
return(result);
}
public override IPricingResult Calculate(CreditDefaultSwap creditDefaultSwap, IMarketCondition market, PricingRequest request)
{
var valuationDate = market.ValuationDate;
var result = new PricingResult(valuationDate, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = _premiumLegEngine.Calculate(creditDefaultSwap.PremiumLeg, market, PricingRequest.Pv).Pv
+ _protectionLegEngine.Calculate(creditDefaultSwap.ProtectionLeg, market, PricingRequest.Pv).Pv;
}
if (result.IsRequested(PricingRequest.Ai))
{
result.Ai = _premiumLegEngine.Calculate(creditDefaultSwap.PremiumLeg, market, PricingRequest.Ai).Ai;
}
return(result);
}
public override IPricingResult Calculate(CommodityProduct.CommodityForwardCNY trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
var valuationDate = market.ValuationDate;
var maturityDate = trade.MaturityDate;
if (valuationDate > maturityDate)
{
result.Pv = 0.0;
result.Delta = 0.0;
}
else
{
result.Pv = (market.SpotPrices.Value.Values.First() + trade.Basis) * trade.Notional;
result.Delta = trade.Notional;
}
return(result);
}
public override IPricingResult Calculate(ResetStrikeOption trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
var exerciseDate = trade.ExerciseDates.Last();
var strikefixingDate = trade.StrikeFixingDate;
var spot = market.SpotPrices.Value.Values.First();
var sigma = AnalyticalOptionPricerUtil.pricingVol(volSurf: market.VolSurfaces.Value.Values.First(),
exerciseDate: exerciseDate, option: trade, spot: spot);
var T = AnalyticalOptionPricerUtil.timeToMaturityFraction(market.ValuationDate, exerciseDate, trade);
var t = AnalyticalOptionPricerUtil.timeToMaturityFraction(market.ValuationDate, strikefixingDate, trade);
var riskFreeRate = market.DiscountCurve.Value.ZeroRate(market.ValuationDate, exerciseDate);
var dividendRateInput = market.DividendCurves.Value.Values.First().ZeroRate(market.ValuationDate, exerciseDate);
var dividendRate = AnalyticalOptionPricerUtil.dividenRate(trade.UnderlyingProductType, dividendRateInput, riskFreeRate);
var calculator = new ResetStrikeOptionCalculator(trade.OptionType, trade.ResetStrikeType, trade.UnderlyingProductType,
trade.Strike,
market.SpotPrices.Value.Values.First(),
T,
t,
sigma,
riskFreeRate,
dividendRate,
trade.Notional);
result.Pv = calculator.Pv;
result.Delta = calculator.Delta;
result.DeltaCash = result.Delta * market.SpotPrices.Value.Values.First();
result.Gamma = calculator.Gamma;
result.GammaCash = result.Gamma * market.SpotPrices.Value.Values.First() * market.SpotPrices.Value.Values.First() / 100;
result.Vega = calculator.Vega;
result.Rho = calculator.Rho;
result.Theta = calculator.Theta;
result.DDeltaDt = calculator.DDeltaDt;
result.DDeltaDvol = calculator.DDeltaDvol;
result.DVegaDvol = calculator.DDeltaDvol;
result.DVegaDt = calculator.DVegaDt;
return(result);
}
private void EvaluatePriceToFcf(PricingResult pricingResults, Models.Domain.MarketData marketData)
{
if (!pricingResults.AnnualResults.Any())
{
return;
}
var lastResult = pricingResults.AnnualResults.OrderByDescending(x => x.Year).First();
var fcf = lastResult.FreeCashFlow;
if (fcf != 0)
{
pricingResults.CurrentPriceToFcfRatio = (marketData.MarketCapitalization ?? 0) / fcf;
}
if (pricingResults.AverageFreeCashFlow == 0)
{
return;
}
pricingResults.AveragePriceToFcfRatio =
(marketData.MarketCapitalization ?? 0) / pricingResults.AverageFreeCashFlow;
}
public override IPricingResult Calculate(Forward <TUnderlying> trade, IMarketCondition market, PricingRequest request)
{
var result = new PricingResult(market.ValuationDate, request);
if (result.IsRequested(PricingRequest.Pv))
{
result.Pv = CalcPv(trade, market);
}
if (result.IsRequested(PricingRequest.Dv01))
{
result.Dv01 = GetRisks(trade, market, PricingRequest.Dv01).Dv01;
}
if (result.IsRequested(PricingRequest.Dv01Underlying))
{
result.Dv01 = GetRisks(trade, market, PricingRequest.Dv01Underlying).Dv01Underlying;
}
return(result);
}
