public InterestRate CreateInterestRate(Instrument instrument, int maturity, InterestRateTenorType maturityType)
{
lock (objLock)
{
if (!(instrument.InstrumentType == InstrumentType.Deposit || instrument.InstrumentType == InstrumentType.InterestRateSwap))
{
throw new Exception("Instrument is not an Interest Rate");
}
string searchString = "ID = " + instrument.ID;
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(_interestRateTableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
DataRow r = table.NewRow();
r["ID"] = instrument.ID;
r["Maturity"] = maturity;
r["MaturityType"] = (int)maturityType;
rows.Add(r);
Database.DB["Quant"].UpdateDataTable(table);
return(InterestRate.FindInterestRate(instrument));
}
throw new Exception("InterestRate Already Exists");
}
}
public void AddCashFlow(double rate, InterestRateTenorType frequencyType, int frequency, InterestRateTenorType maturityType, int maturity, DayCountConvention dayCount)
{
// Console.WriteLine("Add Cashflow:" + rate + " " + frequencyType + " " + frequency + " " + maturityType + " " + maturity + " " + dayCount);
DateTime expiryDate = new DateTime();
switch (maturityType)
{
case InterestRateTenorType.Daily:
expiryDate = _startDate.AddActualDays(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Weekly:
expiryDate = _startDate.AddActualDays(maturity * 7, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Monthly:
expiryDate = _startDate.AddMonths(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
case InterestRateTenorType.Yearly:
expiryDate = _startDate.AddYears(maturity, TimeSeries.DateSearchType.Next).DateTime;
break;
default:
break;
}
CashFlowRate cf = new CashFlowRate(frequencyType, frequency, maturityType, maturity, dayCount, rate);
if (!_cashFlows.ContainsKey(expiryDate))
{
_cashFlows.Add(expiryDate, cf);
}
}
public CashFlowRate(InterestRateTenorType frequencyType, int frequency, InterestRateTenorType maturityType, int maturity, DayCountConvention dayCount, double rate)
{
this._frequencyType = frequencyType;
this._frequency = frequency;
this._maturityType = maturityType;
this._maturity = maturity;
this._dayCount = dayCount;
this._rate = rate;
}
public InterestRateSwap FindInterestRateSwap(InterestRate instrument)
{
lock (objLock)
{
if (_swaps.ContainsKey(instrument.ID))
{
return(_swaps[instrument.ID]);
}
if (instrument.InstrumentType != InstrumentType.InterestRateSwap)
{
throw new Exception("Instrument is not an Interest Rate Swap");
}
string tableName = _interestRateSwapTableName;
string searchString = "ID = " + instrument.ID;
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
return(null);
}
DataRow r = rows[0];
int floatFrequency = GetValue <int>(r, "FloatFrequency");
InterestRateTenorType floatFrequencyType = (InterestRateTenorType)GetValue <int>(r, "FloatFrequencyType");
DayCountConvention floatDayCountConvention = (DayCountConvention)GetValue <int>(r, "FloatDayCountConvention");
int fixedFrequency = GetValue <int>(r, "FixedFrequency");
InterestRateTenorType fixedFrequencyType = (InterestRateTenorType)GetValue <int>(r, "FixedFrequencyType");
DayCountConvention fixedDayCountConvention = (DayCountConvention)GetValue <int>(r, "FixedDayCountConvention");
int effective = GetValue <int>(r, "Effective");
InterestRateSwap swap = new InterestRateSwap(instrument, floatFrequency, floatFrequencyType, floatDayCountConvention, fixedFrequency, fixedFrequencyType, fixedDayCountConvention, effective);
_swaps.Add(swap.ID, swap);
if (_mainTables.ContainsKey(swap.ID))
{
_mainTables[swap.ID] = table;
}
else
{
_mainTables.Add(swap.ID, table);
}
return(swap);
}
}
public override void Initialize()
{
if (Initialized)
{
return;
}
_amount = this[DateTime.Now, -(int)MemoryType.Amount, TimeSeriesRollType.Last];
_startDate = DateTime.FromOADate((long)this[DateTime.Now, -(int)MemoryType.StartDate, TimeSeriesRollType.Last]);
_endDate = DateTime.FromOADate((long)this[DateTime.Now, -(int)MemoryType.EndDate, TimeSeriesRollType.Last]);
_frequency = (InterestRateTenorType)this[DateTime.Now, -(int)MemoryType.Frequency, TimeSeriesRollType.Last];
base.Initialize();
}
public InterestRateSwap(InterestRate rate,
int floatFrequency,
InterestRateTenorType floatFrequencyType,
DayCountConvention floatDayCountConvention,
int fixedFrequency,
InterestRateTenorType fixedFrequencyType,
DayCountConvention fixedDayCountConvention,
int effective)
: base(rate, rate.Maturity, rate.MaturityType)
{
this._floatFrequency = floatFrequency;
this._floatFrequencyType = floatFrequencyType;
this._floatDayCountConvention = floatDayCountConvention;
this._fixedFrequency = fixedFrequency;
this._fixedFrequencyType = fixedFrequencyType;
this._fixedDayCountConvention = fixedDayCountConvention;
this._effective = effective;
}
public InterestRate FindInterestRate(Instrument instrument)
{
lock (objLock)
{
if (_rates.ContainsKey(instrument.ID))
{
return(_rates[instrument.ID]);
}
if (instrument.InstrumentType == InstrumentType.Deposit || instrument.InstrumentType == InstrumentType.InterestRateSwap)
{
string tableName = _interestRateTableName;
string searchString = "ID = " + instrument.ID;
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(tableName, targetString, searchString);
DataRowCollection rows = table.Rows;
if (rows.Count == 0)
{
return(null);
}
DataRow r = rows[0];
int maturity = GetValue <int>(r, "Maturity");
InterestRateTenorType maturityType = (InterestRateTenorType)GetValue <int>(r, "MaturityType");
InterestRate rate = new InterestRate(instrument, maturity, maturityType);
_rates.Add(instrument.ID, rate);
if (_mainTables.ContainsKey(instrument.ID))
{
_mainTables[instrument.ID] = table;
}
else
{
_mainTables.Add(instrument.ID, table);
}
return(rate);
}
throw new Exception("Instrument is not an Interest Rate");
}
}
public static InterestRate CreateInterestRate(Instrument instrument, int maturity, InterestRateTenorType maturityType)
{
return(Factory.CreateInterestRate(instrument, maturity, maturityType));
}
public static InterestRateSwap CreateInterestRateSwap(InterestRate instrument, int floatFrequency, InterestRateTenorType floatFrequencyType, DayCountConvention floatDayCount, int fixedFrequency, InterestRateTenorType fixedFrequencyType, DayCountConvention fixedDayCount, int effective)
{
return(Factory.CreateInterestRateSwap(instrument, floatFrequency, floatFrequencyType, floatDayCount, fixedFrequency, fixedFrequencyType, fixedDayCount, effective));
}
public InterestRate(Instrument instrument, int maturity, InterestRateTenorType maturityType)
: base(instrument)
{
this._maturity = maturity;
this._maturityType = maturityType;
}
public InterestRateSwap CreateInterestRateSwap(InterestRate instrument, int floatFrequency, InterestRateTenorType floatFrequencyType, DayCountConvention floatDayCount, int fixedFrequency, InterestRateTenorType fixedFrequencyType, DayCountConvention fixedDayCount, int effective)
{
lock (objLock)
{
if (instrument.InstrumentType != InstrumentType.InterestRateSwap)
{
throw new Exception("Instrument is not an Interest Rate Swap");
}
string searchString = null;// "Name LIKE '" + name + "'";
string targetString = null;
DataTable table = Database.DB["Quant"].GetDataTable(_interestRateSwapTableName, targetString, searchString);
DataRowCollection rows = table.Rows;
var lrows = from lrow in new LINQList <DataRow>(rows)
where (int)lrow["ID"] == instrument.ID
select lrow;
if (lrows.Count() == 0)
{
DataRow r = table.NewRow();
r["ID"] = instrument.ID;
r["FloatFrequency"] = floatFrequency;
r["FloatFrequencyType"] = (int)floatFrequencyType;
r["FloatDayCountConvention"] = (int)floatDayCount;
r["FixedFrequency"] = fixedFrequency;
r["FixedFrequencyType"] = (int)fixedFrequencyType;
r["FixedDayCountConvention"] = (int)fixedDayCount;
r["Effective"] = effective;
rows.Add(r);
Database.DB["Quant"].UpdateDataTable(table);
return(FindInterestRateSwap(instrument));
}
throw new Exception("InterestRateSwap Already Exists");
}
}
private void _addCashFlow(CashFlowRate cashFlow)
{
// Console.WriteLine("Add Cashflow:" + cashFlow.Rate + " " + cashFlow.MaturityType + " " + cashFlow.Maturity + " " + cashFlow.FrequencyType + " " + cashFlow.Frequency + " " + cashFlow.DayCount);
double rate = cashFlow.Rate;
InterestRateTenorType frequencyType = cashFlow.FrequencyType;
int frequency = cashFlow.Frequency;
InterestRateTenorType maturityType = cashFlow.MaturityType;
int maturity = cashFlow.Maturity;
DayCountConvention dayCount = cashFlow.DayCount;
BusinessDay expiryDate = null;
switch (maturityType)
{
case InterestRateTenorType.Daily:
expiryDate = _startDate.AddActualDays(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddActualDays(maturity, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Weekly:
expiryDate = _startDate.AddActualDays(maturity * 7, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddActualDays(maturity * 7, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Monthly:
expiryDate = _startDate.AddMonths(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddMonths(maturity, BusinessDaySearchType.Next);
break;
case InterestRateTenorType.Yearly:
expiryDate = _startDate.AddYears(maturity, TimeSeries.DateSearchType.Next);
//expiryDate = _startDate.AddYears(maturity, BusinessDaySearchType.Next);
break;
default:
break;
}
BusinessDay runningDate = _startDate;
if (frequencyType == maturityType && frequency == maturity)
{
double t = expiryDate.YearsBetween(_startDate, dayCount);
double pv = 1 / (1 + rate * t);
t = expiryDate.YearsBetween(_startDate, DayCountConvention.Act365);
_zeroRates.TryAdd(t, -Math.Log(pv) / t);
}
else
{
int counter = 1;
double pvs = 0;
double PV = 0;
double t = 0;
bool flag = true;
BusinessDay previousDate = _startDate;
while (flag)
{
previousDate = runningDate;
if (frequencyType == InterestRateTenorType.Daily)
{
runningDate = runningDate.AddBusinessDays(frequency * counter);
}
else if (frequencyType == InterestRateTenorType.Weekly)
{
runningDate = _startDate.AddActualDays(7 * frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddActualDays(7 * frequency * counter, BusinessDaySearchType.Next);
else if (frequencyType == InterestRateTenorType.Monthly)
{
runningDate = _startDate.AddMonths(frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddMonths(frequency * counter, BusinessDaySearchType.Next);
else if (frequencyType == InterestRateTenorType.Yearly)
{
runningDate = _startDate.AddYears(frequency * counter, TimeSeries.DateSearchType.Next);
}
//runningDate = _startDate.AddYears(frequency * counter, BusinessDaySearchType.Next);
flag = (runningDate.DateTime < expiryDate.DateTime);
if (flag)
{
counter++;
t = runningDate.YearsBetween(previousDate, dayCount);
pvs += rate * t * PresentValue(runningDate.YearsBetween(_startDate, DayCountConvention.Act365));
t = expiryDate.YearsBetween(runningDate, dayCount);
PV = (1 - pvs) / (1 + rate * t);
}
}
t = expiryDate.YearsBetween(_startDate, DayCountConvention.Act365);
double zeroRate = -Math.Log(PV) / t;
_zeroRates.TryAdd(t, zeroRate);
}
}
public static CashFlowGroup CreateStrategy(Instrument instrument, BusinessDay initialDate, double amount, BusinessDay startDate, BusinessDay endDate, InterestRateTenorType ttype, Portfolio parent)
{
if (instrument.InstrumentType == InstrumentType.Strategy)
{
CashFlowGroup Strategy = new CashFlowGroup(instrument);
Strategy.TimeSeriesRoll = TimeSeriesRollType.Last;
Strategy.Amount = amount;
Strategy.StartDate = startDate.DateTime;
Strategy.EndDate = endDate.DateTime;
Strategy.Frequency = ttype;
Portfolio portfolio = null;
if (parent != null)
{
Instrument portfolio_instrument = Instrument.CreateInstrument(instrument.Name + "/Portfolio", InstrumentType.Portfolio, instrument.Name + "/Portfolio", instrument.Currency, FundingType.TotalReturn, instrument.SimulationObject);
portfolio = Portfolio.CreatePortfolio(portfolio_instrument, parent.LongReserve, parent.ShortReserve, parent);
portfolio.TimeSeriesRoll = TimeSeriesRollType.Last;
foreach (Instrument reserve in parent.Reserves)
{
portfolio.AddReserve(reserve.Currency, parent.Reserve(reserve.Currency, PositionType.Long), parent.Reserve(reserve.Currency, PositionType.Short));
}
if (parent.Strategy != null)
{
parent.Strategy.AddInstrument(Strategy, initialDate.DateTime);
}
}
else
{
Currency main_currency = instrument.Currency;
//ConstantStrategy main_cash_strategy = ConstantStrategy.CreateStrategy(instrument.Name + "/" + main_currency + "/Cash", main_currency, initialDate, 1.0, instrument.SimulationObject);
Instrument main_cash_strategy = Instrument.FindInstrument(main_currency.Name + " - Cash");
Instrument portfolio_instrument = Instrument.CreateInstrument(instrument.Name + "/Portfolio", InstrumentType.Portfolio, instrument.Name + "/Portfolio", main_currency, FundingType.TotalReturn, instrument.SimulationObject);
portfolio = Portfolio.CreatePortfolio(portfolio_instrument, main_cash_strategy, main_cash_strategy, parent);
portfolio.TimeSeriesRoll = TimeSeriesRollType.Last;
portfolio.AddReserve(main_currency, main_cash_strategy, main_cash_strategy);
}
portfolio.Strategy = Strategy;
Strategy.GenerateCashFlows(initialDate.DateTime);
double npv = Strategy.NPV(initialDate);
Strategy.Startup(initialDate, npv, portfolio);
Strategy.InitialDate = new DateTime(1990, 01, 06);
double npv2 = Strategy.NPV(initialDate);
// if (parent != null)
// parent.CreatePosition(Strategy, initialDate.DateTime, (Strategy[initialDate.DateTime] == 0.0 ? 0 : 1.0), npv2);
if (!instrument.SimulationObject)
{
Strategy.Portfolio.MasterPortfolio.Strategy.Tree.SaveNewPositions();
Strategy.Portfolio.MasterPortfolio.Strategy.Tree.Save();
}
return(Strategy);
}
else
{
throw new Exception("Instrument not a Strategy");
}
}
public static CashFlowGroup CreateCashFlowGroup(string name, Currency ccy, BusinessDay initialDate, double amount, BusinessDay startDate, BusinessDay endDate, InterestRateTenorType ttype, bool simulated, Portfolio parent)
{
Instrument instrument = Instrument.CreateInstrument(name, InstrumentType.Strategy, name, ccy, FundingType.TotalReturn, simulated);
return(CreateStrategy(instrument, initialDate, amount, startDate, endDate, ttype, parent));
}
