/// <summary>
/// Maps from a list of asset pairs to a quoted asset set.
/// </summary>
/// <param name="assetPairs"></param>
/// <returns></returns>
internal static QuotedAssetSet MapFromAssetPairs(ICollection <Pair <Asset, BasicAssetValuation> > assetPairs)
{
var quotedAssetSet = new QuotedAssetSet();
var assets = new Asset[assetPairs.Count];
var basicAssetValuations = new BasicAssetValuation[assetPairs.Count];
var types = new List <ItemsChoiceType19>();
var index = 0;
foreach (var pair in assetPairs)
{
assets[index] = pair.First;
basicAssetValuations[index] = pair.Second;
var properties = new PriceableAssetProperties(assets[index].id);
var assetTypeFpML = AssetTypeConvertor.ParseEnumStringToFpML(properties.AssetType.ToString());
types.Add(assetTypeFpML);
index++;
}
quotedAssetSet.assetQuote = basicAssetValuations;
var instrumentSet = new InstrumentSet {
Items = assets.ToArray(), ItemsElementName = types.ToArray()
};
quotedAssetSet.instrumentSet = instrumentSet;
return(quotedAssetSet);
}
/// <summary>
///
/// </summary>
/// <param name="settings"></param>
/// <returns></returns>
private static BasicAssetValuation AssignSettings(object[][] settings)
{
var assets = new BasicAssetValuation();
var cols = settings[0].Length;
var i = 0;
assets.quote = new BasicQuotation[cols];
for (var c = 0; c < cols; c++)
{
assets.quote[i] = new BasicQuotation
{
measureType = new AssetMeasureType {
Value = Convert.ToString(settings[0][c])
}
};
if (settings[1][c] is string)
{
assets.quote[i].valueSpecified = false;
assets.quote[i].cashflowType = new CashflowType {
Value = Convert.ToString(settings[1][c])
};
}
else
{
assets.quote[i].valueSpecified = true;
assets.quote[i].value = Convert.ToDecimal(settings[1][c]);
}
i++;
}
return(assets);
}
public static BasicAssetValuation Add(BasicAssetValuation basicAssetValuation1, BasicAssetValuation basicAssetValuation2)
{
BasicAssetValuation result = BinarySerializerHelper.Clone(basicAssetValuation1);
var proccessedMeasureTypes = new List <string>();
foreach (BasicQuotation bq1 in result.quote)
{
proccessedMeasureTypes.Add(bq1.measureType.Value);
BasicQuotation bq2 = GetQuotationByMeasureType(basicAssetValuation2, bq1.measureType.Value);
if (null != bq2)
{
bq1.value += bq2.value;
}
}
var bqToAddToList = new List <BasicQuotation>();
foreach (BasicQuotation bq2 in basicAssetValuation2.quote)
{
if (-1 == proccessedMeasureTypes.IndexOf(bq2.measureType.Value))//if hasn't been processed in the first pass
{
bqToAddToList.Add(bq2);
}
}
bqToAddToList.AddRange(result.quote);
result.quote = bqToAddToList.ToArray();
return(result);
}
/// <summary>
/// Creates the asset controller data.
/// </summary>
/// <param name="metrics">The metrics.</param>
/// <param name="baseDate">The base date.</param>
/// <param name="market">The market.</param>
/// <returns></returns>
public IAssetControllerData CreateAssetControllerData(string[] metrics, DateTime baseDate, IMarketEnvironment market)
{
var bav = new BasicAssetValuation();
var quotes = new BasicQuotation[metrics.Length];
var index = 0;
foreach (var metric in metrics)
{
var quotation = new BasicQuotation
{
valueSpecified = true,
value = 0.0m,
measureType = new AssetMeasureType
{
Value =
metric
}
};
quotes[index] = quotation;
index++;
}
bav.quote = quotes;
return(new AssetControllerData(bav, baseDate, market));
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableCaplet"/> class.
/// This is a special case for use with the factry for bootstrapping, as it
/// uses no calendar logic. This is done by the factory.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="nodeStruct">A special class containing all salient data required.</param>
/// <param name="properties">The properties set This includes strike information.</param>
/// <param name="fixingCalendar">The fixing/expiry calendar></param>
/// <param name="paymentCalendar">The paymentCalendar calendar.</param>
/// <param name="notional">The notional. The default value is 1,000,000.00m.</param>
/// <param name="marketQuotes">The market quotes, including the volatility and possibly the fixed rate as a decimal contained in a basic quotation.</param>
public PriceableCaplet(DateTime baseDate, RateOptionNodeStruct nodeStruct, NamedValueSet properties, IBusinessCalendar fixingCalendar,
IBusinessCalendar paymentCalendar, Decimal notional, BasicAssetValuation marketQuotes)
: base(baseDate, nodeStruct.ResetDateAdjustment, nodeStruct.SimpleRateOption, notional, 1000000.0m, nodeStruct.BusinessDayAdjustments, marketQuotes)
{
Id = nodeStruct.SimpleRateOption.id;
IsCap = true;
IsDiscounted = false;
RateOption = nodeStruct.SimpleRateOption;
ResetDateOffset = nodeStruct.ResetDateAdjustment;
SpotDateOffset = nodeStruct.SpotDate;
UnderlyingRateIndex = nodeStruct.RateIndex;
AdjustedStartDate = GetSpotDate(baseDate, fixingCalendar, nodeStruct.SpotDate);
AdjustedEffectiveDate = GetEffectiveDate(AdjustedStartDate, paymentCalendar, nodeStruct.SimpleRateOption.startTerm, nodeStruct.BusinessDayAdjustments.businessDayConvention);
OptionsExpiryDate = GetFixingDate(AdjustedEffectiveDate, fixingCalendar, nodeStruct.ResetDateAdjustment);
MaturityDate = GetEffectiveDate(AdjustedStartDate, paymentCalendar, nodeStruct.SimpleRateOption.endTerm, nodeStruct.BusinessDayAdjustments.businessDayConvention);
PaymentDate = MaturityDate;
YearFraction = GetYearFraction(RateOption.dayCountFraction.Value, AdjustedEffectiveDate, MaturityDate);
TimeToExpiry = GetTimeToExpiry(baseDate, OptionsExpiryDate);
//Set the strike scalar. This must be after the number of expiry dates has been set.
var quotes = new List <BasicQuotation>(marketQuotes.quote);
//For the default cap the spot rate is used.
SetQuote("ForwardRate", quotes);
SetQuote("Strike", quotes);
//decimal? strike = properties.GetValue<decimal>("Strike", false);
//Strike = (decimal)strike;
}
/// <summary>
/// Parses the assetIdentifiers.
/// </summary>
/// <param name="assetIdentifiers"></param>
/// <param name="values"></param>
/// <param name="adjustments"></param>
/// <returns></returns>
public static FxRateSet ParseToFxRateSet(string[] assetIdentifiers, decimal[] values, decimal[] adjustments)
{
if (assetIdentifiers.Length != values.Length)
{
throw new ArgumentOutOfRangeException(nameof(values), "the rates do not match the number of assets");
}
if (adjustments != null && assetIdentifiers.Length != adjustments.Length)
{
throw new ArgumentOutOfRangeException(nameof(values), "the rates do not match the number of assets");
}
var quotedAssetSetFactory = new QuotedAssetSetFactory();
const string rateQuotationType = PriceableCommoditySpot.RateQuotationType;
int index = 0;
foreach (string assetIdentifier in assetIdentifiers)
{
var bav
= new BasicAssetValuation
{
objectReference = new AnyAssetReference {
href = assetIdentifier
}
};
var addOn = adjustments?[index] ?? 0.0m;
var bqs = new List <BasicQuotation>
{
BasicQuotationHelper.Create(values[index] + addOn, rateQuotationType, "DecimalRate")
};
bav.quote = bqs.ToArray();
quotedAssetSetFactory.AddAssetAndQuotes(Parse(assetIdentifier), bav);
index++;
}
return(quotedAssetSetFactory.CreateFxRateSet());
}
public DataTable GetDataTable()
{
if (null != _lastQuotedAssetSet)
{
foreach (DataRow dataRow in _dataTable.Rows)
{
var instrumentId = (string)dataRow["InstrumentId"];
List <BasicAssetValuation> basicAssetValuations =
QuotedAssetSet.GetAssetQuote(_lastQuotedAssetSet, instrumentId);
if (basicAssetValuations.Count > 0)
{
BasicAssetValuation bav0 = basicAssetValuations[0];
foreach (DataColumn dataColumn in _dataTable.Columns)
{
string columnName = dataColumn.ColumnName;
BasicQuotation basicQuotation = BasicAssetValuationHelper.GetQuotationByTiming(bav0, columnName);
if (null != basicQuotation)
{
dataRow[columnName] = basicQuotation.value;
}
}
}
}
}
_dataTable.AcceptChanges();
DataTable copy = _dataTable.Copy();
// remove "InstrumentId" column
//
copy.Columns.Remove("InstrumentId");
copy.AcceptChanges();
return(copy);
}
public DiscountCurveSolver(ILogger logger, ICoreCache cache, string nameSpace, DateTime baseDate, NamedValueSet properties, IEnumerable <Triplet <string, decimal, int> > assets,
decimal[] adjustments, string spreadAssetId, BasicAssetValuation spreadAssetValuation,
int spreadDays, double spread, int spreadStartIndex, int spreadEndIndex,
IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar)
{
_nameSpace = nameSpace;
_properties = properties;
_spreadAssetId = spreadAssetId;
_spreadAssetValuation = spreadAssetValuation;
_baseDate = baseDate;
_spread = spread;
_spreadStartIndex = spreadStartIndex;
_spreadEndIndex = spreadEndIndex;
_adjustments = adjustments;
var enumerable = assets as Triplet <string, decimal, int>[] ?? assets.ToArray();
_instruments = enumerable.Select(a => a.First).ToArray();
_rates = enumerable.Select(a => a.Second).ToArray();
_days = enumerable.Select(a => a.Third).ToArray();
_spreadDays = spreadDays;
_logger = logger;
_cache = cache;
_fixingCalendar = fixingCalendar;
_rollCalendar = rollCalendar;
// Calculate the function value for zero spread
decimal[] zeroAdjustments = adjustments.Select(a => 0m).ToArray();
_valueForZeroAdjustment
= RateCurve.CalculateImpliedQuote(_logger, _cache, _nameSpace, _baseDate, _properties, _instruments, _rates, zeroAdjustments, _spreadAssetId, _spreadAssetValuation,
_fixingCalendar, _rollCalendar);
}
private void Initialize(ILogger logger, ICoreCache cache, string nameSpace, NamedValueSet properties, IRateCurve baseCurve, IRateCurve quoteCurve,
string[] instruments, decimal[] values, FxCurve fxCurve, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar)
{
var curveId = (RateCurveIdentifier)PricingStructureIdentifier;
BaseCurve = baseCurve;
QuoteCurve = quoteCurve;
//Holder = new PricingStructureAlgorithmsHolder(logger, cache, curveId.PricingStructureType, curveId.Algorithm);
Initialize(properties, Holder);
var currency = properties.GetValue <string>(CurveProp.Currency1);
if (fxCurve != null && baseCurve == null)
{
var holder = new GenericRateCurveAlgorithmHolder(logger, cache, nameSpace);
// Create discount factors, without any input points
RateCurve basisAdjustedDiscountCurve = CreateBasisAdjustedDiscountCurve(fxCurve, quoteCurve, currency, curveId.BaseDate, holder);
TermCurve discountCurve = ((YieldCurveValuation)basisAdjustedDiscountCurve.PricingStructureValuation).discountFactorCurve;
CreateYieldCurve();
GetYieldCurveValuation().discountFactorCurve = discountCurve;
SetInterpolator(discountCurve, curveId.Algorithm, PricingStructureTypeEnum.RateSpreadCurve);
// Put FX curve into inputs
var assetQuotes = new List <BasicAssetValuation>();
BasicAssetValuation[] fxAssetQuotes = ((FxCurveValuation)fxCurve.GetFpMLData().Second).spotRate.assetQuote;
foreach (BasicAssetValuation assetQuote in fxAssetQuotes)
{
BasicAssetValuation clonedAssetQuote = XmlSerializerHelper.Clone(assetQuote);
clonedAssetQuote.definitionRef = FxCurveName;
assetQuotes.Add(clonedAssetQuote);
}
AddQuoteCurveInputs(assetQuotes);
((YieldCurveValuation)PricingStructureValuation).inputs = new QuotedAssetSet {
assetQuote = assetQuotes.ToArray()
};
}
else
{
List <IPriceableRateAssetController> swaps
= PriceableAssetFactory.CreatePriceableRateAssets(logger, cache, nameSpace, curveId.BaseDate, instruments, values, null, fixingCalendar, rollCalendar);
if (fxCurve == null)
{
// only use the input swaps
PriceableRateAssets = swaps;
}
else
{
var holder = new GenericRateCurveAlgorithmHolder(logger, cache, nameSpace);
// Add synthetic input points
RateCurve basisAdjustedDiscountCurve = CreateBasisAdjustedDiscountCurve(fxCurve, quoteCurve, currency, curveId.BaseDate, holder);
//TODO Add some extra short end point: 1D and 1W
string[] syntheticSwapPoints = { "1M", "2M", "3M", "6M", "9M" };
PriceableRateAssets = CreateSyntheticSwaps(logger, cache, nameSpace, BaseCurve, basisAdjustedDiscountCurve,
currency, curveId.BaseDate, syntheticSwapPoints, fixingCalendar, rollCalendar);
PriceableRateAssets.AddRange(swaps);
}
// bootstrap to create the discount factors
PriceableRateAssets = PriceableRateAssets.OrderBy(a => a.GetRiskMaturityDate()).ToList();
Bootstrap((YieldCurveValuation)GetFpMLData().Second);
}
}
public RatesObj(Asset asset, BasicAssetValuation bav)
{
Created = DateTime.Now;
Publisher = "Alex";
Instrument = asset.GetType().Name;
var identifier = new PriceableAssetProperties(asset.id);
if (asset is Deposit asset1)
{
var deposit = asset1;
InstrumentId = deposit.id;
Currency = identifier.Currency;
Term = deposit.term.ToString();
}
else
{
if (asset is SimpleIRSwap irSwap)
{
var swap = irSwap;
InstrumentId = swap.id;
Currency = identifier.Currency;
Term = swap.term.ToString();
}
else
{
if (asset is Future future1)
{
var future = future1;
InstrumentId = future.id;
Currency = identifier.Currency;
Term = identifier.Term;
}
}
}
if (bav.quote.Length > 0)
{
Rate1 = bav.quote[0].value;
if (bav.quote[0].quoteUnits != null)
{
Rate1Quotes = bav.quote[0].quoteUnits.Value;
}
if (bav.quote[0].measureType != null)
{
Rate1Measure = bav.quote[0].measureType.Value;
}
}
if (bav.quote.Length > 1)
{
Rate2 = bav.quote[1].value;
if (bav.quote[1].quoteUnits != null)
{
Rate2Quotes = bav.quote[1].quoteUnits.Value;
}
if (bav.quote[1].measureType != null)
{
Rate2Measure = bav.quote[1].measureType.Value;
}
}
}
public static BasicAssetValuation Create(params BasicQuotation[] basicQuotations)
{
var result = new BasicAssetValuation {
quote = basicQuotations
};
return(result);
}
/// <summary>
/// Create a grid from an array of names and complex array of data
/// The data will contain strings and decimals
/// </summary>
/// <param name="pSettings">The settings object used to generate these SABR parameters</param>
/// <param name="fields">The headers used to identify the SABR parameters</param>
/// <param name="data">An array of SABR parameters and expiry/tenor pairs</param>
/// <param name="valueDate">The valuation date</param>
/// <param name="surfaceId">The id for this matrix</param>
public SwaptionVolatilityMatrix(object[][] pSettings, string[] fields, object[][] data, DateTime valueDate, string surfaceId)
{
// Include a QuotedAssetSet to hold the Settings object used to generate this SABR parameters Matrix
Settings = AssignSettings(pSettings);
// Set the id for this matrix
id = surfaceId;
// Set the value date for this vol matrix
baseDate = new IdentifiedDate {
Value = valueDate
};
// Set the buildDate for this matrix
buildDateTime = DateTime.Now;
// Create the dataPoints structure. This will hold the matrix data
dataPoints = new MultiDimensionalPricingData();
var columns = fields.Length;
var rows = data.Length;
dataPoints.point = new PricingStructurePoint[rows * IdentifierFieldCount];
var point = 0;
// Loop through the arrays to populate the underlying VolatilityMatrix
for (var gRows = 0; gRows < rows; gRows++)
{
// Extract the expiry/tenor information for creating
var expiry = PeriodHelper.Parse(data[gRows][0].ToString());
var tenor = PeriodHelper.Parse(data[gRows][1].ToString());
for (var gCols = columns - IdentifierFieldCount; gCols < columns; gCols++)
{
dataPoints.point[point] = new PricingStructurePoint {
coordinate = new PricingDataPointCoordinate[1]
};
// Set up the co-ordinate (Expiry/Term) for each point
dataPoints.point[point].coordinate[0] = new PricingDataPointCoordinate
{
expiration = new TimeDimension[1]
};
// Set the Expiry for the co-ordinate point
dataPoints.point[point].coordinate[0].expiration[0] = new TimeDimension
{
Items = new object[] { expiry }
};
// Set the Term for the co-ordinate point
dataPoints.point[point].coordinate[0].term = new TimeDimension[1];
dataPoints.point[point].coordinate[0].term[0] = new TimeDimension {
Items = new object[] { tenor }
};
// Add the quotation characteristics for the point
// We will only record a value and the measure type
dataPoints.point[point].valueSpecified = true;
dataPoints.point[point].value = Convert.ToDecimal(data[gRows][gCols]);
dataPoints.point[point].measureType = new AssetMeasureType {
Value = fields[gCols]
};
point++;
}
}
}
/// <summary>
/// Creates the specified Basic asset valuation with a reference and set of quotations
/// </summary>
/// <param name="reference">The reference.</param>
/// <param name="basicQuotations">The basic quotations.</param>
/// <returns></returns>
public static BasicAssetValuation Create(string reference, params BasicQuotation[] basicQuotations)
{
BasicAssetValuation result = Create(basicQuotations);
result.objectReference = new AnyAssetReference {
href = reference
};
return(result);
}
/////<summary>
/////</summary>
/////<returns></returns>
//public decimal GetSpotRate()
//{
// var fxVal = (FxCurveValuation)GetFpMLData().Second;
// BasicAssetValuation spotRateAsset = (from spotRateAssets in fxVal.spotRate.assetQuote
// where spotRateAssets.objectReference.href.EndsWith("-Equity-SP", StringComparison.InvariantCultureIgnoreCase)//TODO FIX This!
// select spotRateAssets).Single();
// decimal spotRate = spotRateAsset.quote[0].value;
// return spotRate;
//}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace">THe client namespace</param>
/// <param name="equityId">THe curve asset.</param>
/// <param name="fixingCalendar"></param>
/// <param name="rollCalendar"></param>
/// <param name="baseDate"></param>
/// <returns></returns>
protected static DateTime GetSettlementDate(ILogger logger, ICoreCache cache, string nameSpace,
EquityCurveIdentifier equityId, IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar, DateTime baseDate)
{
BasicAssetValuation bav = BasicAssetValuationHelper.Create(BasicQuotationHelper.Create(0, "MarketQuote", PriceQuoteUnitsEnum.Price.ToString()));
var assetId = BuildSpotAssetId(equityId);
var priceableAsset = (IPriceableEquityAssetController)PriceableAssetFactory.Create(logger, cache, nameSpace, assetId, baseDate, bav, fixingCalendar, rollCalendar);
return(priceableAsset.GetRiskMaturityDate());
}
/// <summary>
/// Gets the metric results.
/// </summary>
/// <param name="valuation">The valuation.</param>
/// <param name="metric">The metric.</param>
/// <returns></returns>
public static decimal[] GetMetricResults(BasicAssetValuation valuation, string metric)
{
var results = new List <decimal>();
var quotes = new List <BasicQuotation>(valuation.quote);
var matchedQuotes = quotes.FindAll(item => String.Compare(item.measureType.Value, metric, StringComparison.OrdinalIgnoreCase) == 0);
if (matchedQuotes.Count > 0)
{
results.AddRange(matchedQuotes.Select(quotation => quotation.value));
}
return(results.ToArray());
}
/// <summary>
///
/// </summary>
/// <param name="logger"></param>
/// <param name="cache"></param>
/// <param name="nameSpace"></param>
/// <param name="fixingCalendar"></param>
/// <param name="rollCalendar"></param>
/// <param name="baseDate"></param>
/// <returns></returns>
public DateTime GetSpotDate(ILogger logger, ICoreCache cache, string nameSpace,
IBusinessCalendar fixingCalendar, IBusinessCalendar rollCalendar, DateTime baseDate)
{
BasicAssetValuation bav = BasicAssetValuationHelper.Create(BasicQuotationHelper.Create(0, "MarketQuote"));
string identifier = Currency1 + Currency2 + "-FxSpot-SP";//Currency2 would normally be USD.
var priceableAsset = (IPriceableFxAssetController)PriceableAssetFactory.Create(logger, cache, nameSpace, identifier, baseDate, bav, fixingCalendar, rollCalendar);
if (priceableAsset != null)
{
return(priceableAsset.GetRiskMaturityDate());
}
return(FxCurve1.GetSpotDate());//TODO Default to the first curve. Should merge the two!
}
private void AddBaseCurveInputs(List <BasicAssetValuation> assetQuotes)
{
QuotedAssetSet baseCurveInputs = ((YieldCurveValuation)BaseCurve?.GetFpMLData().Second)?.inputs;
if (baseCurveInputs?.assetQuote != null)
{
foreach (BasicAssetValuation assetQuote in baseCurveInputs.assetQuote)
{
BasicAssetValuation clonedAssetQuote = XmlSerializerHelper.Clone(assetQuote);
clonedAssetQuote.definitionRef = BaseCurveName;
assetQuotes.Add(clonedAssetQuote);
}
}
}
static public IAssetControllerData CreateModelData(string[] metrics, DateTime baseDate, IMarketEnvironment market)
{
var bav = new BasicAssetValuation();
var quotes = new BasicQuotation[metrics.Length];
var index = 0;
foreach (var metric in metrics)
{
quotes[index] = BasicQuotationHelper.Create(0.0m, metric);
index++;
}
bav.quote = quotes;
return(new AssetControllerData(bav, baseDate, market));
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableCapRateAsset"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="paymentBusinessDayAdjustments">The payment business day adjustments.</param>
/// <param name="resetBusinessDayAdjustments">The fixing business day adsjustments.</param>
/// <param name="calculation">The calculation class that determines if the swap is discounted or not.</param>
/// <param name="marketQuotes">The market Quote. This could be premium, normal volatility or lognormalvolatility as defined by the price quote units.</param>
protected PriceableCapRateAsset(DateTime baseDate, BusinessDayAdjustments paymentBusinessDayAdjustments,
RelativeDateOffset resetBusinessDayAdjustments, Calculation calculation,
BasicAssetValuation marketQuotes)
{
ModelIdentifier = "CapAsset";
BaseDate = baseDate;
Calculation = calculation;
PaymentBusinessDayAdjustments = paymentBusinessDayAdjustments;
FixingBusinessDayOffset = resetBusinessDayAdjustments;
if (marketQuotes != null)
{
var quotes = new List <BasicQuotation>(marketQuotes.quote);
SetQuote(VolatilityQuotationType, quotes);
}
}
/// <summary>
/// Creates the specified assets in a quoted asset set.
/// </summary>
/// <param name="assetIdentifiers">The asset identifiers.</param>
/// <param name="values">The adjusted rates.</param>
/// <param name="measureTypes">The measure types. Currently supports MarketQuote and Volatility.</param>
/// <param name="priceQuoteUnits">The price quote units. Currently supports Rates and LogNormalVolatility.</param>
/// <param name="includeMarketQuoteValues">An include flag. If false, then the market quotes are set as null.</param>
/// <returns></returns>
public static QuotedAssetSet Parse(string[] assetIdentifiers, Decimal[] values,
String[] measureTypes, String[] priceQuoteUnits, bool includeMarketQuoteValues)
{
if (assetIdentifiers.Length != values.Length && assetIdentifiers.Length != priceQuoteUnits.Length && (assetIdentifiers.Length != measureTypes.Length))
{
throw new ArgumentOutOfRangeException(nameof(values), "The rates do not match the number of assets");
}
var quotedAssetSetFactory = new QuotedAssetSetFactory();
foreach (string assetIdentifier in assetIdentifiers.Distinct())
{
int index = 0;
var bav
= new BasicAssetValuation
{
objectReference = new AnyAssetReference {
href = assetIdentifier
}
};
var bqs = new List <BasicQuotation>();
foreach (string ids in assetIdentifiers)
{
index++;
if (ids != assetIdentifier)
{
continue;
}
BasicQuotation bq;
if (measureTypes[index - 1] == AssetMeasureEnum.MarketQuote.ToString() && !includeMarketQuoteValues)
{
bq = BasicQuotationHelper.Create(measureTypes[index - 1],
priceQuoteUnits[index - 1]);
bqs.Add(bq);
}
else
{
bq = BasicQuotationHelper.Create(values[index - 1], measureTypes[index - 1],
priceQuoteUnits[index - 1]);
bqs.Add(bq);
}
}
bav.quote = bqs.ToArray();
quotedAssetSetFactory.AddAssetAndQuotes(Parse(assetIdentifier), bav);
}
return(quotedAssetSetFactory.Create());
}
/// <summary>
/// Maps from a list of asset pairs to a quoted asset set.
/// </summary>
/// <param name="assetPairs"></param>
/// <returns></returns>
internal static QuotedAssetSet MapFromAssetPairs(List <Pair <Asset, BasicAssetValuation> > assetPairs)
{
var quotedAssetSet = new QuotedAssetSet();
var assets = new Asset[assetPairs.Count];
var bavs = new BasicAssetValuation[assetPairs.Count];
var index = 0;
foreach (var pair in assetPairs)
{
assets[index] = pair.First;
bavs[index] = pair.Second;
index++;
}
quotedAssetSet.assetQuote = bavs;
quotedAssetSet.instrumentSet = assets;
return(quotedAssetSet);
}
// Assumption - QAS contains one BAV with one BQ
//
private static void MergeQuotedAssetSet(QuotedAssetSet quotedAssetSet)
{
BasicAssetValuation bavNew = quotedAssetSet.assetQuote[0];
BasicQuotation bqNew = bavNew.quote[0];
string newInstrumentId = bavNew.objectReference.href;
List <BasicAssetValuation> basicAssetValuationsOldWithTheSameIdAsNew = QuotedAssetSet.GetAssetQuote(_lastQuotedAssetSet, newInstrumentId);
if (basicAssetValuationsOldWithTheSameIdAsNew.Count == 0)
{
// Add
//
var temp = new List <BasicAssetValuation>(_lastQuotedAssetSet.assetQuote)
{
bavNew
};
_lastQuotedAssetSet.assetQuote = temp.ToArray();
}
else
{
//update
BasicAssetValuation bavOld = basicAssetValuationsOldWithTheSameIdAsNew[0];
bool bqUpdated = false;
foreach (BasicQuotation bqOld in bavOld.quote)
{
if (bqNew.timing.Value == bqOld.timing.Value)
{
bqOld.value = bqNew.value;
bqUpdated = true;
break;
}
}
if (!bqUpdated)
{
// Add
//
var tempBQ = new List <BasicQuotation>(bavOld.quote)
{
bqNew
};
bavOld.quote = tempBQ.ToArray();
}
}
}
/// <summary>
/// Add the settings used by this ATM vol object
/// </summary>
/// <param name="settings"></param>
/// <returns></returns>
private static BasicAssetValuation AssignSettings(object[][] settings)
{
var assets = new BasicAssetValuation();
int rows = settings.Length;
int startRow = settings[0][0].ToString().ToLower() == "settings" ? 1 : 0;
var quotes = new List <BasicQuotation>();
for (int row = startRow; row < rows; row++)
{
if (settings[row][0] != null)
{
var quote
= new BasicQuotation
{
measureType = new AssetMeasureType {
Value = settings[row][0].ToString()
}
};
object value = settings[row][1];
if (value is string)
{
// A string
quote.cashflowType = new CashflowType {
Value = value.ToString()
};
}
else if (value is DateTime)
{
// A DateTime
quote.valuationDateSpecified = true;
quote.valuationDate = Convert.ToDateTime(value);
}
else
{
// a decimal
quote.valueSpecified = true;
quote.value = Convert.ToDecimal(value);
}
quotes.Add(quote);
}
}
assets.quote = quotes.ToArray();
return(assets);
}
/// <summary>
///
/// </summary>
/// <param name="basicAssetValuationList"></param>
/// <returns></returns>
public static BasicAssetValuation Sum(List <BasicAssetValuation> basicAssetValuationList)
{
if (0 == basicAssetValuationList.Count)
{
throw new ArgumentException("basicAssetValuationList is empty");
}
if (1 == basicAssetValuationList.Count)
{
return(BinarySerializerHelper.Clone(basicAssetValuationList[0]));
}
// clone collection internally - just to keep invariant of the method.
//
List <BasicAssetValuation> clonedCollection = BinarySerializerHelper.Clone(basicAssetValuationList);
BasicAssetValuation firstElement = clonedCollection[0];
clonedCollection.RemoveAt(0);
BasicAssetValuation sumOfTheTail = Sum(clonedCollection);
return(Add(firstElement, sumOfTheTail));
}
static public void ProcessAssetControllerResults(IPriceableAssetController assetController, string[] metrics, DateTime baseDate)
{
Assert.IsNotNull(assetController);
Double[] times = { 0, 1, 5 };
Double[] dfs = { 1, 0.9, 0.3 };
ISimpleRateMarketEnvironment market = CreateSimpleRateMarketEnvironment(baseDate, times, dfs);
IAssetControllerData controllerData = CreateModelData(metrics, baseDate, market);
Assert.IsNotNull(controllerData);
Assert.AreEqual(controllerData.BasicAssetValuation.quote.Length, metrics.Length);
Assert.AreEqual(controllerData.BasicAssetValuation.quote[0].measureType.Value, metrics[0]);
BasicAssetValuation results = assetController.Calculate(controllerData);
Debug.Print("Id : {0}", assetController.Id);
foreach (var metric in results.quote)
{
Debug.Print("Id : {0} Metric Name : {1} Metric Value : {2}", assetController.Id, metric.measureType.Value, metric.value);
}
}
/// <summary>
/// Initializes a new instance of the <see cref="PriceableSimpleIRCap"/> class.
/// </summary>
/// <param name="baseDate">The base date.</param>
/// <param name="interestRateCap">An interest Rate Cap.</param>
/// <param name="properties">THe properies, including strike information.</param>
/// <param name="fixingCalendar">The fixing Calendar.</param>
/// <param name="paymentCalendar">The payment Calendar.</param>
/// <param name="marketQuotes">The market Quote: premium, normal flat volatility or lognormal flat volatility.</param>
public PriceableSimpleIRCap(DateTime baseDate, SimpleIRCapNodeStruct interestRateCap, NamedValueSet properties,
IBusinessCalendar fixingCalendar, IBusinessCalendar paymentCalendar, BasicAssetValuation marketQuotes)
: base(baseDate, interestRateCap.DateAdjustments, ReversePeriodMultiplier(interestRateCap.SpotDate), interestRateCap.Calculation, marketQuotes)
{
Id = interestRateCap.SimpleIRCap.id;
IsCap = true;
SimpleIRCap = interestRateCap.SimpleIRCap;
var spotDate = GetSpotDate(baseDate, fixingCalendar, interestRateCap.SpotDate);
if (SimpleIRCap != null)
{
var unadjustedDates =
Analytics.Schedulers.DateScheduler.GetUnadjustedDateSchedule(spotDate, SimpleIRCap.term,
SimpleIRCap.paymentFrequency);
AdjustedPeriodDates = AdjustedDateScheduler.GetAdjustedDateSchedule(unadjustedDates,
PaymentBusinessDayAdjustments.businessDayConvention, paymentCalendar);
//Adjust for the spot period backwards!
ExpiryDates = AdjustedDateScheduler.GetAdjustedDateSchedule(AdjustedPeriodDates,
FixingBusinessDayOffset, fixingCalendar);
//Remove the last date, which is not an expiry date.
ExpiryDates.RemoveAt(ExpiryDates.Count - 1);
TimesToExpiry = GetTimesToExpiry(ExpiryDates, baseDate);
//Set the strike scalar. This must be after the number of expiry dates has been set.
var quotes = new List <BasicQuotation>(marketQuotes.quote);
//For the default cap the spot rate is used.
SetQuote("SpotRate", quotes);
//If the strike is not provided it must be calculated!!
SetQuote("Strike", quotes);
//Set the spot date.
AdjustedStartDate = AdjustedPeriodDates[0];
RiskMaturityDate = ExpiryDates[ExpiryDates.Count - 1];
OptionsExpiryDate = ExpiryDates[ExpiryDates.Count - 1];
if (Strike != null && Strikes == null)
{
Strikes = CreateList((decimal)Strike, TimesToExpiry.Count);
}
if (Notionals == null)
{
Notionals = CreateList(InitialNotional, TimesToExpiry.Count);
}
}
if (ExpiryDates[0] <= BaseDate)
{
IncludeFirstPeriod = false;
}
if (DiscountingType != null)
{
ModelIdentifier = "DiscountCapAsset";
}
}
///// <summary>
///// Finds the enum from string.
///// </summary>
///// <param name="list">The list.</param>
///// <param name="findItem">The find item.</param>
///// <returns></returns>
//private static TEnumT FindEnumFromString<TEnumT>(List<TEnumT> list, string findItem)
//{
// var result = list.Find(metricItem => String.Compare(metricItem.ToString(), findItem, StringComparison.OrdinalIgnoreCase) == 0);
// return result;
//}
#endregion
#region Metric Helpers - moved from AssetHelper.
/// <summary>
/// Aggregates the coupon metric.
/// </summary>
/// <param name="valuations">The metrics calculation results.</param>
/// <param name="controllerMetrics">THe controller metrics</param>
/// <returns></returns>
public static Dictionary <string, decimal> AggregateMetrics(BasicAssetValuation valuations, List <string> controllerMetrics)
{
return(controllerMetrics.ToDictionary(metric => metric, metric => Aggregator.SumDecimals(GetMetricResults(valuations, metric))));
}
public void AddAssetAndQuotes(Asset underlyingAsset, BasicAssetValuation quotes)
{
_assetAndQuotes.Add(new Pair <Asset, BasicAssetValuation>(underlyingAsset, quotes));
}
/// <summary>
/// Merges a QuotedAssetSet with this. Note that the referential integrity between the assets
/// and valuations is checked and maintained.
/// </summary>
/// <param name="additional">The additional QuotedAssetSet.</param>
/// <param name="checkValuationAssetReferences">if set to <c>true</c> [check valuation asset references].</param>
/// <param name="includeEmptyCurrentQuotes">if set to <c>true</c> [include empty current quotes].</param>
/// <param name="includeEmptyAdditionalQuotes">if set to <c>true</c> [include empty additional quotes].</param>
/// <returns></returns>
public QuotedAssetSet Merge(QuotedAssetSet additional,
bool checkValuationAssetReferences,
bool includeEmptyCurrentQuotes,
bool includeEmptyAdditionalQuotes)
{
var result = new QuotedAssetSet();
// build unique instrumentSet and valuation quote lists
var instrumentMap = new Dictionary <string, Asset>();
var valuationMap = new Dictionary <string, BasicAssetValuation>();
if (instrumentSet != null && instrumentSet.Items != null)
{
foreach (Asset asset in instrumentSet.Items)//The asset type
{
string assetId = asset.id;
//Trace.WriteLine(String.Format("Merge: Existing asset: '{0}'", assetId);
instrumentMap[assetId.ToLower()] = asset;
}
}
if (assetQuote != null)
{
foreach (BasicAssetValuation currentValuation in assetQuote)
{
string assetId = currentValuation.objectReference.href;
if (checkValuationAssetReferences)
{
Asset asset;
if (!instrumentMap.TryGetValue(assetId.ToLower(), out asset))
{
throw new ApplicationException(String.Format(
"Cannot find asset '{0}' for assetQuote", assetId));
}
}
// merge the quotes
BasicAssetValuation existingValuation;
if (valuationMap.TryGetValue(assetId.ToLower(), out existingValuation))
{
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' updating existing valuation", assetId);
}
else
{
// not found - create a new valuation
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' creating existing valuation", assetId);
existingValuation = new BasicAssetValuation
{
objectReference = new AnyAssetReference {
href = assetId
},
quote = new List <BasicQuotation>().ToArray()
};
valuationMap[assetId.ToLower()] = existingValuation;
}
// append the assetquotes
var quotes = new List <BasicQuotation>(existingValuation.quote);
foreach (BasicQuotation quote in currentValuation.quote)
{
if (quote.valueSpecified || includeEmptyCurrentQuotes)
{
quotes.Add(quote);
//if (quote.valueSpecified)
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' adding existing quote value '{1}'", assetId, quote.value);
//else
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' adding existing empty quote", assetId);
}
else
{
//Trace.WriteLine(String.Format("Merge; Asset: '{0}' skipping existing empty quote", assetId);
}
}
existingValuation.quote = quotes.ToArray();
}
}
// add extra instruments
if (additional.instrumentSet != null && additional.instrumentSet.Items != null)
{
foreach (Asset asset in additional.instrumentSet.Items)
{
string assetId = asset.id;
if (!instrumentMap.ContainsKey(assetId.ToLower()))
{
instrumentMap[assetId.ToLower()] = asset;
//Trace.WriteLine(String.Format("Merge: Additional asset: '{0}'", assetId);
}
}
}
// append valuation quotes
if (additional.assetQuote != null)
{
foreach (BasicAssetValuation additionalValuation in additional.assetQuote)
{
string assetId = additionalValuation.objectReference.href;
if (checkValuationAssetReferences)
{
Asset asset;
if (!instrumentMap.TryGetValue(assetId.ToLower(), out asset))
{
throw new ApplicationException(String.Format(
"Cannot find asset '{0}' for assetQuote", assetId));
}
}
// merge the quotes
BasicAssetValuation existingValuation;
if (valuationMap.TryGetValue(assetId.ToLower(), out existingValuation))
{
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' updating additional valuation", assetId);
}
else
{
// not found - just add the valuation
existingValuation = new BasicAssetValuation
{
objectReference = new AnyAssetReference {
href = assetId
},
quote = new List <BasicQuotation>().ToArray()
};
valuationMap[assetId.ToLower()] = existingValuation;
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' creating additional valuation", assetId);
}
// append the assetquotes
var quotes = new List <BasicQuotation>(existingValuation.quote);
foreach (BasicQuotation quote in additionalValuation.quote)
{
if (quote.valueSpecified || includeEmptyAdditionalQuotes)
{
quotes.Add(quote);
//if (quote.valueSpecified)
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' adding additional quote value '{1}'", assetId, quote.value);
//else
//Trace.WriteLine(String.Format("Merge: Asset: '{0}' adding additional empty quote", assetId);
}
else
{
//Trace.WriteLine(String.Format("Merge; Asset: '{0}' skipping additional empty quote", assetId);
}
}
existingValuation.quote = quotes.ToArray();
}
}
var instSet = new InstrumentSet {
Items = instrumentMap.Values.ToArray()
};
result.instrumentSet = instSet;
result.assetQuote = valuationMap.Values.ToArray();
return(result);
}
protected override MDSResult <QuotedAssetSet> OnRequestMarketData(
IModuleInfo clientInfo,
Guid requestId,
MDSRequestType requestType,
NamedValueSet requestParams,
DateTimeOffset subsExpires,
QuotedAssetSet standardQuotedAssetSet)
{
// process request parameters
RequestProperties requestProperties = ProcessRequestParams(requestParams);
// process the asset/quote lists to produce 1 or more instrument/field matrices
RequestContext requestContext = ConvertStandardAssetQuotesToProviderInstrFieldCodes(requestType, standardQuotedAssetSet);
// process the instr/field code sets
var results = new List <BasicAssetValuation>();
foreach (ProviderInstrFieldCodeSet instrFieldCodeSet in requestContext.ProviderInstrFieldCodeSets)
{
var providerResults = new Dictionary <string, BasicQuotation>();
// simulated reply
var rng = new Random();
//List<BasicAssetValuation> results = new List<BasicAssetValuation>();
foreach (string t in instrFieldCodeSet.InstrumentIds)
{
var quote = new BasicAssetValuation
{
objectReference =
new AnyAssetReference {
href = t
},
quote = new BasicQuotation[instrFieldCodeSet.FieldNames.Count]
};
foreach (string t1 in instrFieldCodeSet.FieldNames)
{
var providerQuote = new BasicQuotation
{
measureType =
new AssetMeasureType
{
Value = AssetMeasureEnum.MarketQuote.ToString()
},
quoteUnits =
new PriceQuoteUnits
{
Value = PriceQuoteUnitsEnum.Rate.ToString()
},
value = Convert.ToDecimal(rng.NextDouble() * 10.0),
valueSpecified = true
};
// field value
// simulator returns a random decimal value
// field done
string providerQuoteKey = FormatProviderQuoteKey(t, t1);
providerResults[providerQuoteKey] = providerQuote;
}
}
// process provider results
//Dictionary<string, BasicQuotation> providerResults = BuildProviderResultsIndex(pages);
results.AddRange(ConvertProviderResultsToStandardValuations(providerResults, requestContext));
}
return(new MDSResult <QuotedAssetSet>
{
Result = new QuotedAssetSet {
assetQuote = results.ToArray()
}
});
}
