public Data getPrice(DateTime t1, DateTime t2, TimeSpan step)
{
if (t1 > t2)
{
throw new ArgumentOutOfRangeException("Start date must be before end date");
}
if (step.TotalDays <= 0)
{
throw new ArgumentOutOfRangeException("Step must be strictly positive");
}
DateTime t = t1;
List<DateTime> dates = new List<DateTime>();
while (t < t2)
{
dates.Add(t);
t += step;
}
Dictionary<DateTime, double> prices = AccessDB.Get_Asset_Price(this.name, dates);
Data data = new Data(this.name);
foreach(DateTime d in dates)
{
if (prices.ContainsKey(d))
{
data.add(new DataPoint(d, prices[d]));
}
else
{
data.add(new DataPoint(d, AccessDB.Get_Asset_Price(this.name, d)));
}
}
return data;
}
/**
* simulate an everglades product and it's underlying portfolio
* evolution with the adviced hedging portfolio, and return a list
* of Data :
* * Data of product price evolution
* * Data of hedging portfolio price evolution
* * Data of tracking error evolution
* * Data of cash spent for hedging portfolio evolution
*
*/
public List<Data> simulateHedgeEvolution(bool with_currency)
{
RandomNormal rand = new RandomNormal();
LinkedList<DateTime> list_dates = everg.getObservationDates();
LinkedList<DateTime> list_anticipated_dates = everg.getAnticipatedDates();
DateTime first = list_dates.First();
List<IAsset> simulated_list = new List<IAsset>();
List<ICurrency> underlying_list_cur = new List<ICurrency>();
double r = 0.03;
foreach (IAsset ass in Assets)
{
simulated_list.Add(new AssetSimulated(ass, list_dates, rand));
if (with_currency)
{
Currencies curEnum = ass.getCurrency().getEnum();
if (!underlying_list_cur.Any(x => x.getEnum() == curEnum) && curEnum != Currencies.EUR)
{
underlying_list_cur.Add(new CurrencySimulated(curEnum, rand, r));
}
}
}
Everglades everg_simul = new Everglades(simulated_list, underlying_list_cur);
Portfolio hedge_simul = new Portfolio(simulated_list);
Data tracking_error = new Data("simulation-graph-trackingerror");
Data everglades_price = new Data("simulation-graph-prices-everg");
Data hedge_price = new Data("simulation-graph-prices-hedge");
Data portsolo_price = new Data("simulation-graph-soloport");
Data cash_price = new Data("simulation-graph-cash");
Dictionary<String, Data> list_asset_price = new Dictionary<string, Data>();
foreach (IAsset asset in simulated_list)
{
String nameTemp = asset.getName();
list_asset_price[nameTemp] = new Data(nameTemp);
}
foreach (IAsset cur in underlying_list_cur)
{
String nameTemp = cur.getName();
list_asset_price[nameTemp] = new Data(nameTemp);
}
double cash_t = 0;
double portvalue;
double portsolovalue;
double evergvalue;
DateTime date_prev = list_dates.First();
// used for anticipated end of everglades
bool breakk = false;
foreach (DateTime date in list_dates)
{
// get prices of assets at these dates in Data
foreach (IAsset asset in simulated_list)
{
String nameTemp = asset.getName();
list_asset_price[nameTemp].add(new DataPoint(date, asset.getPrice(date)));
}
foreach (IAsset cur in underlying_list_cur)
{
String nameTemp = cur.getName();
list_asset_price[nameTemp].add(new DataPoint(date, cur.getPrice(date)));
}
if (date == list_dates.First())
{
Tuple<double, double[], bool> compute = everg_simul.computePrice(date, with_currency);
evergvalue = compute.Item1;
hedge_simul = everg_simul.getDeltaPortfolio(date, compute.Item2, with_currency);
portsolovalue = hedge_simul.getPrice(date);
cash_t = evergvalue - portsolovalue;
portvalue = portsolovalue + cash_t;
}
else
{
// here we (virtually) sell old hedging portfolio
double t = (date - date_prev).TotalDays / 360;
portvalue = hedge_simul.getPrice(date) + hedge_simul.getDividend(date_prev, date) + cash_t * Math.Exp(r * t);
cash_t = portvalue;
Tuple<double, double[], bool> compute = everg_simul.computePrice(date, with_currency);
// test if date is a constatation date
if (list_anticipated_dates.Contains(date))
{
// if the date is an anticipated constatation date, we check if
// we must break now, and if we do we set the price of everglades
// with payoff and set breakk to true.
if (compute.Item3)
{
evergvalue = compute.Item1;
portsolovalue = hedge_simul.getPrice(date);
cash_t -= evergvalue;
breakk = true;
}
else
{
// if not the last date, we simply price the product and ajust our edge
evergvalue = compute.Item1;
hedge_simul = everg_simul.getDeltaPortfolio(date, compute.Item2, with_currency);
portsolovalue = hedge_simul.getPrice(date);
cash_t -= portsolovalue;
}
}
else if (date == everg_simul.getLastDate())
{
evergvalue = compute.Item1;
cash_t -= evergvalue;
portsolovalue = hedge_simul.getPrice(date);
}
else
{
// if not the last date, we simply price the product and ajust our edge
evergvalue = compute.Item1;
hedge_simul = everg_simul.getDeltaPortfolio(date, compute.Item2, with_currency);
portsolovalue = hedge_simul.getPrice(date);
cash_t -= hedge_simul.getPrice(date);
}
}
double err = (evergvalue - portvalue) / evergvalue;
if (!double.IsInfinity(evergvalue) && !double.IsNaN(evergvalue))
{
everglades_price.add(new DataPoint(date, evergvalue));
}
if (!double.IsInfinity(portvalue) && !double.IsNaN(portvalue))
{
hedge_price.add(new DataPoint(date, portvalue));
}
if (!double.IsInfinity(portsolovalue) && !double.IsNaN(portsolovalue))
{
portsolo_price.add(new DataPoint(date, portsolovalue));
}
if (!double.IsInfinity(err) && !double.IsNaN(err))
{
tracking_error.add(new DataPoint(date, err));
}
if (!double.IsInfinity(cash_t) && !double.IsNaN(cash_t))
{
cash_price.add(new DataPoint(date, cash_t));
}
if (breakk)
{
break;
}
date_prev = date;
}
List<Data> list = new List<Data>();
list.Add(everglades_price);
list.Add(hedge_price);
list.Add(tracking_error);
list.Add(cash_price);
list.Add(portsolo_price);
foreach (Data dat in list_asset_price.Values)
{
list.Add(dat);
}
return list;
}
public Data getPrice(DateTime t1, DateTime t2, TimeSpan step)
{
if (!(dataCache.t1 == t1 && dataCache.t2 == t2 && dataCache.step == step))
{
Data data = new Data("everglades");
DateTime t = t1;
while (t < t2)
{
data.add(new DataPoint(t, getPrice(t)));
t += step;
}
data.add(new DataPoint(t2, getPrice(t2)));
dataCache = new DataCache { t1 = t1, t2 = t2, step = step, dat = data };
}
return dataCache.dat;
}
public Data getHedgeForOne(DateTime t1, DateTime t2, TimeSpan step)
{
Data data = new Data("hedge");
DateTime t = t1;
while (t < t2)
{
//data.add(new DataPoint(t, ( Hedging_Portfolio.getPrice(t) + cash) / (double)shares_everg));
try
{
data.add(new DataPoint(t, (AccessDB.getPortfolioValue(t) / (double)shares_everg)));
}
catch (Exception)
{
}
t += step;
}
try
{
data.add(new DataPoint(t2, AccessDB.getPortfolioValue(t2) / (double)shares_everg));
}
catch (Exception)
{
}
return data;
}
public Data getPrice(DateTime t1, DateTime t2, TimeSpan step, double divisor)
{
Data data = new Data("portfolio");
DateTime t = t1;
while (t < t2)
{
data.add(new DataPoint(t, getPriceEuro(t) / divisor));
t += step;
}
data.add(new DataPoint(t2, getPriceEuro(t2) / divisor));
return data;
}
