public void Bind(ReturnsEval.DataSeriesEvaluator eval_, ReturnsEval.Period period_)
{
m_eval = eval_;
m_period = period_;
ClearSeries();
DatedDataCollectionGen<double> daily = eval_.Daily;
AddSeries(eval_.Daily.Dates, eval_.Daily.CumulativeReturnSeries, "Cumulative Pnl", 40, "##0.0#%");
{
DatedDataCollectionGen<double>[] years = new DatedDataCollectionGen<double>[]
{
daily.ToYearsCumulativeYTD(),
daily.ToYearsCumulativeYTD()
};
int index = 1;
for (int i = 0; i < years[0].Length; ++i)
{
if (i>0 && years[0].Dates[i].Year != years[0].Dates[i - 1].Year)
index = (index == 1) ? 0 : 1;
years[index].Data[i] = 0d;
}
if (ShowYearly)
{
AddSeries(years[0].Dates, years[0].Data, "YTD Cumulative(A)", 40, "##0.0#%");
AddSeries(years[1].Dates, years[1].Data, "YTD Cumulative(B)", 40, "##0.0#%");
}
}
//AddSeries(daily.Dates, daily.ToYearsCumulativeYTD().Data, "YTD Cumulative", 40, "##0.0#%");
//AddSeries(daily.Dates, daily.ToMonthsCumulativeMTD().Data, "MTD Cumulative", 40, "##0.0#%");
}
public ConditionalCorrelationAnalyzer(ReturnsEval.DataSeriesEvaluator eval1_, ReturnsEval.DataSeriesEvaluator eval2_)
{
m_eval = eval1_;
m_eval2 = eval2_;
// find common dates
List<DateTime> commonDates = new List<DateTime>();
List<DateTime> stratDates = new List<DateTime>(m_eval.Daily.Dates);
foreach (DateTime date in m_eval2.Daily.Dates)
if (stratDates.Contains(date))
commonDates.Add(date);
QuickSort.Sort<DateTime>(commonDates);
List<double> first = new List<double>();
List<double> second = new List<double>();
// get the values for each of the common dates
foreach (DateTime date in commonDates)
{
first.Add(m_eval.Daily.DataValueOnDate(date));
second.Add(m_eval2.Daily.DataValueOnDate(date));
}
m_eval = new DataSeriesEvaluator(commonDates.ToArray(), first.ToArray(), eval1_.Name, DataSeriesType.Returns);
m_eval2 = new DataSeriesEvaluator(commonDates.ToArray(), second.ToArray(), eval2_.Name, DataSeriesType.Returns);
recalc();
}
public async Task SetDependent(DataSeriesEvaluator dependent_, RegressionField field_, bool runRegression_=true)
{
m_dependent = dependent_;
m_regField = field_;
if (runRegression_)
await DoRegression();
}
public static void Go()
{
var spreadDefs = new[]
{
new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["C "],0,MonthCode.U),new MonthYearOffset(Singleton<ComIDs>.Instance["C "],0,MonthCode.Z),false),
new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["W "],0,MonthCode.U),new MonthYearOffset(Singleton<ComIDs>.Instance["W "],0,MonthCode.Z),false),
//new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["S "],0,MonthCode.Q),new MonthYearOffset(Singleton<ComIDs>.Instance["S "],1,MonthCode.F),false),
new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["SB"],0,MonthCode.V),new MonthYearOffset(Singleton<ComIDs>.Instance["SB"],1,MonthCode.K),false),
new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["NG"],0,MonthCode.X),new MonthYearOffset(Singleton<ComIDs>.Instance["NG"],0,MonthCode.H),false),
new SpreadDefinition(new MonthYearOffset(Singleton<ComIDs>.Instance["XB"],0,MonthCode.J),new MonthYearOffset(Singleton<ComIDs>.Instance["XB"],0,MonthCode.U),false),
};
foreach (var spreadDef in spreadDefs)
{
//StratParamSurface.StratParamData resultSet = new StratParamSurface.StratParamData("minWindowSize_, zScoreThreshold"
var listOfpoints = new List<StratParamSurface.StratParamDataPoint>();
for(int days=30; days<120; days+=10)
{
for(double threshold=0.5;threshold<2.0;threshold+=0.1)
{
var args = new WeightGeneratorArgs()
{
Lookback=5,
MinWindowLength=days,
WeightGenerationType=WeightGeneratorType.LongestZScoreOverThreshold,
ZScoreThreshold=threshold
};
var gen = new SpreadWeightGenerator(args, spreadDef);
var pnl = gen.GetSimplePnl();
if (pnl.Length == 0) continue; // weren't met
var eval = new ReturnsEval.DataSeriesEvaluator(pnl.Dates, pnl.Data, "blah", ReturnsEval.DataSeriesType.Returns);
listOfpoints.Add(new StratParamSurface.StratParamDataPoint()
{
X = Convert.ToDouble(days),
Y = threshold,
Eval = eval
});
}
}
var data = new StratParamSurface.StratParamData(
XLabel_: "minWindowSize_",
YLabel_: "zScoreThreshold",
data_: listOfpoints,
pointFunc_: (p) => p.Eval.Daily.AnnualSharpeRatio
);
var control = new StratParamSurface();
control.Create(data);
control.DisplayInShowForm(spreadDef.ToString());
}
}
public void Create(ReturnsEval.DataSeriesEvaluator eval_, ReturnsEval.Period startingPeriod_)
{
m_args = new ARgsClass();
m_args.Period = startingPeriod_;
boundComboBox1.Items.Add(ReturnsEval.Period.Daily);
boundComboBox1.Items.Add(ReturnsEval.Period.Monthly);
boundComboBox1.Bind(m_args, "Period", new Validators.EnumDescValidator(ReturnsEval.Period.Daily));
m_eval = eval_;
m_args.PropertyChanged += handleArgsChanged;
rebind();
}
private void btnCombinePnl_Click(object sender, EventArgs e)
{
var all = spreadWeightGeneratorCollectionGrid1.ListOfGenerators;
if (all.Count() == 0) return;
ConstructGen<double> con = new ConstructGen<double>(all.Count());
con.ColumnHeadings = new string[con.ArrayLength];
for (int i = 0; i < con.ArrayLength; ++i)
{
var item = all.ElementAt(i);
con.ColumnHeadings[i] = item.ToString();
con.SetColumnValues(i, item.GetSimplePnl());
}
if (con.NeedsToSortKeys())
con.SortKeys();
var eval = new ReturnsEval.DataSeriesEvaluator("Combined", ReturnsEval.DataSeriesType.Returns);
eval.AddInnerSeries(con.Dates.ToArray(), con.ToArray(), con.ColumnHeadings);
eval.Display("Combined");
}
public static Task<ReturnsEval.DataSeriesEvaluator> GetHistoricalPnlEvaluatorTask(this Signal sig_)
{
var t = new Task<ReturnsEval.DataSeriesEvaluator>(() =>
{
ReturnsEval.DataSeriesEvaluator eval = null;
try
{
var result = sig_.PnlResult;
eval = new ReturnsEval.DataSeriesEvaluator(sig_.DisplayName, ReturnsEval.DataSeriesType.Returns);
eval.AddInnerSeries(result.CombinedPnl.Dates.ToArray(), result.CombinedPnl.ToArray(), result.CombinedPnl.ColumnHeadings);
//if(result.CombinedPnl.Dates.Count>260)
// eval.Evaluate(result.CombinedPnl.Dates[result.CombinedPnl.Dates.Count-253],result.CombinedPnl.LastDate);
//else
eval.Evaluate();
}
catch (Exception ex_)
{
Logger.Error("Error generating pnl for signal", typeof(ExtensionMethods), ex_);
}
return eval;
});
return t;
}
/// <summary>
/// Make sure dimensions are the same! It's up to you to get it right.
/// </summary>
/// <param name="eval_"></param>
public void AddInnerEvaluator(DataSeriesEvaluator eval_)
{
m_innerEvaluators.Add(eval_);
}
protected override void handleclick(EventArgs e_)
{
try
{
DatedDataCollectionGen<double> hist = null;
hist = m_signal.GetSignalGridProvider().GetHistoryForCcyPair(m_ccy1, m_ccy2);
if (hist == null) hist = m_signal.GetSignalGridProvider().GetHistoryForCcyPair(m_ccy2, m_ccy1, -1d);
ConstructGen<double> con = new ConstructGen<double>(Singleton<FXIDs>.Instance.ColumnHeadings);
for (int i = 0; i < hist.Dates.Length; ++i)
{
con.SetValue(hist.Dates[i], m_ccy1.ArrayIndex, hist.Data[i]);
con.SetValue(hist.Dates[i], m_ccy2.ArrayIndex, -hist.Data[i]);
}
var rets = ReturnsFromFXWeights.DoIt_DailyWeights(dailyWts_: con);
var eval = new ReturnsEval.DataSeriesEvaluator(m_signal.Name, ReturnsEval.DataSeriesType.Returns);
eval.AddInnerSeries(rets.CombinedPnl.Dates.ToArray(), rets.CombinedPnl.ToArray(), rets.CombinedPnl.ColumnHeadings);
eval.Evaluate();
eval.Display(string.Format("{0}: {1}/{2} signal performance",m_signal.Name,m_ccy1,m_ccy2)).Icon = Util.BmpToIcon(Properties.Resources.money);
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error generating and showing pnl for signal grid ccy pair ({0}/{1})", m_ccy1.Code, m_ccy2.Code), typeof(SignalPnlOverTime), ex_);
}
}
public async Task DoRegression()
{
if (m_dependent == null) return;
lineChartDataDisplay1.ClearSeries();
var bench = getBenchmark();
if (bench == null) return;
var spSeries = bench.GetReturns();
if (spSeries == null)
{
lbl_IR.Text = string.Empty;
angledLabel1.Text = "Benchmark not set";
return;
}
angledLabel1.Text = string.Format("Rolling {0}", bench.Name);
lbl_IR.BringToFront();
var leftField = m_regField;
//var rightField = RegressionField.IR;
var eval = new DataSeriesEvaluator(spSeries.Dates, spSeries.Data, "blah", DataSeriesType.Returns);
await Task.Run(() =>
{
eval.Evaluate();
eval.Daily.RollingSharpeSeries.ToString(); // kick off creation of rolling shared
});
#region Daily
if (m_dependent.FinestGranularity == Period.Daily)
{
var dailySpan = m_dependent.Daily.RollingSharpeSeries.Span;
var dailyIntersect = m_dependent.Daily.InterectDatesKeepSeparate(eval.Daily);
var rollingDaily =
await
Task.Run<DatedDataCollectionGen<LinearRegression>>(
() => HelperMethods.GetRollingStat(dailyIntersect.Item1, dailyIntersect.Item2, dailySpan, getRegression));
//var rollingDaily = HelperMethods.GetRollingStat(dailyIntersect.Item1, dailyIntersect.Item2, dailySpan , getRegression);
lbl_IR.Text =
getRegression(dailyIntersect.Item1.Data, dailyIntersect.Item2.Data)
.GetStat(RegressionField.IR, Period.Daily)
.ToString("##0.0");
if (rollingDaily != null && rollingDaily.Length > 0)
{
var cht = lineChartDataDisplay1.AddSeries(
dates_: rollingDaily.Dates,
values_: rollingDaily.Data.Select(x => x.GetStat(leftField, Period.Daily)).ToArray(),
desc_: string.Format("{0}: Daily({1}), Left", EnumDescriptionAttribute.GetDescription(leftField), dailySpan),
yLabelFormat_: leftField.getDisplayFormat(),
yAxisExtent_: 40,
color_: Color.White);
cht.AxisY.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
cht.AxisX.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
}
}
#endregion
#region Weekly
if (m_dependent.FinestGranularity == Period.Daily || m_dependent.FinestGranularity == Period.Weekly)
{
var weeklySpan = (m_dependent.FinestGranularity == Period.Daily)
? Convert.ToInt32(Math.Round(m_dependent.Daily.RollingSharpeSeries.Span/5d, 0))
: m_dependent.Weekly.RollingSharpeSeries.Span;
var weeklyIntersect = m_dependent.Weekly.InterectDatesKeepSeparate(eval.Weekly);
var rollingWeekly =
await
Task.Run<DatedDataCollectionGen<LinearRegression>>(
() =>
HelperMethods.GetRollingStat(weeklyIntersect.Item1, weeklyIntersect.Item2, weeklySpan, getRegression));
if (m_dependent.FinestGranularity == Period.Weekly)
{
lbl_IR.Text =
getRegression(weeklyIntersect.Item1.Data, weeklyIntersect.Item2.Data)
.GetStat(RegressionField.IR, Period.Weekly)
.ToString("##0.0");
}
if (rollingWeekly != null && rollingWeekly.Length > 0)
{
var cht = lineChartDataDisplay1.AddSeries(
dates_: rollingWeekly.Dates,
values_: rollingWeekly.Data.Select(x => x.GetStat(leftField, Period.Weekly)).ToArray(),
desc_: string.Format("{0}: Weekly({1}), Left", leftField, weeklySpan),
yLabelFormat_: leftField.getDisplayFormat(),
yAxisExtent_: 40,
color_: Color.Orange);
cht.AxisY.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
cht.AxisX.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
}
}
#endregion
#region Monthly
if (m_dependent.FinestGranularity == Period.Weekly || m_dependent.FinestGranularity == Period.Monthly)
{
var monthlySpan = m_dependent.FinestGranularity == Period.Weekly
? Convert.ToInt32(Math.Round(m_dependent.Weekly.RollingSharpeSeries.Span/4.1d, 0))
: m_dependent.Monthly.RollingSharpeSeries.Span;
var monthlyIntersect = m_dependent.Monthly.InterectDatesKeepSeparate(eval.Monthly);
var rollingMonthly =
await
Task.Run<DatedDataCollectionGen<LinearRegression>>(
() =>
HelperMethods.GetRollingStat(monthlyIntersect.Item1, monthlyIntersect.Item2, monthlySpan, getRegression));
if (m_dependent.FinestGranularity == Period.Monthly)
{
lbl_IR.Text =
getRegression(monthlyIntersect.Item1.Data, monthlyIntersect.Item2.Data)
.GetStat(RegressionField.IR, Period.Monthly)
.ToString("##0.0");
}
if (rollingMonthly != null && rollingMonthly.Length > 0)
{
var cht = lineChartDataDisplay1.AddSeries(
dates_: rollingMonthly.Dates,
values_: rollingMonthly.Data.Select(x => x.GetStat(leftField, Period.Monthly)).ToArray(),
desc_: string.Format("{0}: Monthly({1}), Left", leftField, monthlySpan),
yLabelFormat_: leftField.getDisplayFormat(),
yAxisExtent_: 40,
color_: Color.LightPink);
cht.AxisY.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
cht.AxisX.TickmarkStyle = Infragistics.UltraChart.Shared.Styles.AxisTickStyle.Smart;
}
}
#endregion
}
internal static void Go()
{
DatedDataCollectionGen<double> stratReturns = null;
{
var pathToReturns = @"e:\stratReturnsSeries.csv";
var dates = new List<DateTime>();
var data = new List<double>();
foreach (var v in CsvFile.Read<LineItem>(pathToReturns))
{
dates.Add(v.Date);
data.Add(v.Return);
}
stratReturns = new DatedDataCollectionGen<double>(dates.ToArray(), data.ToArray());
}
var stratEval = new ReturnsEval.DataSeriesEvaluator(stratReturns.Dates, stratReturns.Data, "strat", ReturnsEval.DataSeriesType.Returns);
var spx = BbgTalk.HistoryRequester.GetHistory(stratReturns.Dates[0], "SPX INDEX", "PX_CLOSE_1D", false);
{
for (int i = 1; i < spx.Length; ++i)
{
spx.Data[i - 1] = spx.Data[i];
}
}
var spxR = spx.ToReturns();
var spxEval = new ReturnsEval.DataSeriesEvaluator(spxR.Dates, spxR.Data, "SPX", ReturnsEval.DataSeriesType.Returns);
spxEval.Evaluate();
spxEval.Display("spx");
double[] perfDuringDrawdown = new double[stratReturns.Length];
var listOfRecords = new List<DrawdownItem>();
foreach (var dd in spxEval.Daily.DrawDowns)
{
if (Math.Abs(dd.ValueDown) > 0.03)
{
double perf = 0d;
for (int i = 0; i < stratReturns.Length; ++i)
{
if (stratReturns.Dates[i] >= dd.StartDate && stratReturns.Dates[i] <= dd.LowDate)
{
perfDuringDrawdown[i] = stratReturns.Data[i];
perf += stratReturns.Data[i];
}
}
if (perf != 0d)
{
stratEval.Evaluate(dd.StartDate, dd.LowDate);
listOfRecords.Add(new DrawdownItem()
{
DateStart = dd.StartDate,
DateBottomOut = dd.LowDate,
ChangeInSPX = -dd.ValueDown,
StrategyPerformance = perf,
TopStratDrawdown = stratEval.Daily.DrawDowns.Count()==0 ? 0d : -stratEval.Daily.DrawDowns.OrderByDescending(x=>x.ValueDown).First().ValueDown
});
}
}
}
{
var origStratCumulative = stratReturns.ToCumulative();
var perDuringDrawdownCumulative = new DatedDataCollectionGen<double>(stratReturns.Dates, perfDuringDrawdown).ToCumulative();
var spxCumulative = spxEval.Daily.ToCumulative();
var linechart = new SI.Controls.LineChartDataDisplay();
linechart.AddSeries(origStratCumulative.Dates, origStratCumulative.Data, "Original strategy");
linechart.AddSeries(perDuringDrawdownCumulative.Dates, perDuringDrawdownCumulative.Data, "Strat during SPX drawdown");
linechart.AddSeries(spxCumulative.Dates, spxCumulative.Data, "SPX cumulative return", 80, "####0.0");
{
var legend = linechart.AddCompositeLegendForAllLayers();
legend.Bounds = new System.Drawing.Rectangle(30, 0, 20, 30);
legend.BoundsMeasureType = Infragistics.UltraChart.Shared.Styles.MeasureType.Percentage;
legend.PE.ElementType = PaintElementType.Gradient;
legend.PE.FillGradientStyle = GradientStyle.ForwardDiagonal;
legend.PE.Fill = Color.DarkGray;
legend.PE.FillStopColor = Color.DarkGray;
legend.Border.CornerRadius = 10;
legend.Border.Color = Color.White;
legend.Border.Thickness = 1;
}
linechart.DisplayInShowForm("Strat analysis during >3% SPX drawdowns");
}
var g = listOfRecords.DisplayInGrid("Records");
g.SetHeaderClickSort();
}
public EvaluatorComparisonItem(DataSeriesEvaluator eval_, string key_, object o_)
:this(eval_)
{
AddObject(key_, o_);
}
public EvaluatorComparisonItem(DataSeriesEvaluator eval_)
{
m_eval = eval_;
m_eval.Evaluated += handleEvaluated;
}
public static List<ReturnsEval.DataSeriesEvaluator> GetEvalListFromArgs(string[] argsList_)
{
List<ReturnsEval.DataSeriesEvaluator> list = new List<ReturnsEval.DataSeriesEvaluator>();
foreach (string s in argsList_)
{
if (System.IO.Directory.Exists(s))
{
foreach (string path in System.IO.Directory.GetFiles(s))
{
ReturnsEval.DataSeriesEvaluator ev = ReturnsEval.DataSeriesEvaluator.ReadFromDisk(path);
if (ev != null) list.Add(ev);
KeyValuePair<ConstructGen<double>, ReturnsEval.DataSeriesEvaluator> kvp = ExtensionMethods.ReadFromDisk<KeyValuePair<ConstructGen<double>, ReturnsEval.DataSeriesEvaluator>>(path);
if (kvp.Value != null) list.Add(kvp.Value);
}
}
else if (System.IO.File.Exists(s))
{
if (s.EndsWith(".xml"))
{
System.Xml.XmlDocument doc = new System.Xml.XmlDocument();
System.Xml.XmlTextReader reader = new System.Xml.XmlTextReader(string.Format(@"file://{0}", s.Replace(@"\", "/")));
reader.MoveToContent();
doc.Load(reader);
reader.Close();
foreach (System.Xml.XmlNode node in doc.DocumentElement.SelectNodes("BloombergTicker"))
{
DatedDataCollectionGen<double> hist = BbgTalk.HistoryRequester.GetHistory(new DateTime(2000, 1, 1), node.InnerText, "PX_LAST", true);
DatedDataCollectionGen<double> genHist = new DatedDataCollectionGen<double>(hist.Dates, hist.Data).ToReturns();
BbgTalk.RDResult nameData = BbgTalk.HistoryRequester.GetReferenceData(node.InnerText, "SHORT_NAME", null);
ReturnsEval.DataSeriesEvaluator eval = new ReturnsEval.DataSeriesEvaluator(genHist.Dates, genHist.Data, nameData["SHORT_NAME"].GetValue<string>(), ReturnsEval.DataSeriesType.Returns);
list.Add(eval);
}
}
else
{
ReturnsEval.DataSeriesEvaluator ev = ReturnsEval.DataSeriesEvaluator.ReadFromDisk(s);
if (ev != null) list.Add(ev);
KeyValuePair<ConstructGen<double>, ReturnsEval.DataSeriesEvaluator> kvp = SI.ExtensionMethods.ReadFromDisk<KeyValuePair<ConstructGen<double>, ReturnsEval.DataSeriesEvaluator>>(s);
if (kvp.Value != null) list.Add(kvp.Value);
}
}
}
return list;
}
public virtual void Create(IList<ReturnsEval.DataSeriesEvaluator> evals_,SI.ReturnsEval.EvalComparer.TDType initialFocus_=ReturnsEval.EvalComparer.TDType.Inception)
{
hideInnerAttributionPanel(do_: true);
m_focus = initialFocus_;
m_comp = new ReturnsEval.EvalComparer();
m_comp.Create(evals_);
m_workingEval = new ReturnsEval.DataSeriesEvaluator("working", ReturnsEval.DataSeriesType.Returns);
for (int i = 0; i < evals_.Count; ++i)
m_workingEval.AddInnerSeries(m_comp.PnlConstruct.Dates.ToArray(), m_comp.PnlConstruct.GetColumnValues(i), evals_[i].Name);
m_workingEval.Evaluate();
dateTimePickerAsOfDate.Value = m_comp.AsOfDate;
dateTimePickerAsOfDate.ValueChanged += dateTimePickerAsOfDate_ValueChanged;
dateTimePickerCustomStartDate.Value = m_comp.CustomStartDate;
dateTimePickerCustomStartDate.ValueChanged += dateTimePickerCustomStartDate_ValueChanged;
//dateTimePickerAsOfDate.DataBindings.Add("Value", m_comp, "AsOfDate", false, DataSourceUpdateMode.OnPropertyChanged);
m_comp.PropertyChanged += handleCompChanged;
reloadPerf();
//reloadCorrels();
gridPerf.ColourNegativesRed();
gridPerf.Bind(m_perfRows, typeof(PerfRow));
gridPerf.AutoSizeGridColumns();
reloadCumulatives();
setHeaderClickAction(doSort_: false);
gridPerf.AddClickHandler("Perf1Day", new SI.Controls.RowClickedEventHandler(handle1DClicked));
gridPerf.AddClickHandler("PerfWTD", new SI.Controls.RowClickedEventHandler(handleWTDClicked));
gridPerf.AddClickHandler("PerfMTD", new SI.Controls.RowClickedEventHandler(handleMTDClicked));
gridPerf.AddClickHandler("PerfYTD", new SI.Controls.RowClickedEventHandler(handleYTDClicked));
gridPerf.AddClickHandler("PerfQTD", new SI.Controls.RowClickedEventHandler(handleQTDClicked));
gridPerf.AddClickHandler("PerfInception", new SI.Controls.RowClickedEventHandler(handleInceptionClicked));
gridPerf.AddClickHandler("PerfCTD", new SI.Controls.RowClickedEventHandler(handleCTDClicked));
gridPerf.AddClickHandler("RVS_21", new SI.Controls.RowClickedEventHandler(handleRVSSharpeClicked));
gridPerf.AddClickHandler("StrategyName", new SI.Controls.RowClickedEventHandler(handleStratNameClicked));
gridPerf.AddClickHandler("PerfOneYear", new SI.Controls.RowClickedEventHandler(handle1YClicked));
gridPerf.AddClickHandler("PerfTwoYear", new SI.Controls.RowClickedEventHandler(handle2YClicked));
gridPerf.AddClickHandler("Selected", new SI.Controls.RowClickedEventHandler(handleSelectedClicked));
gridPerf.AddClickHandler("DD", new SI.Controls.RowClickedEventHandler(handleDDClicked));
innerTotalReturnAttributionDisplayChart1.Chart.EmptyChartText = "Click Strategy period to show attribution";
tbWinLength.Bind(m_extraArgs, "RetVolSharpeWindowLength", new Validators.IntValidator());
tbRollVolWin.Bind(m_extraArgs, "RollingWindowLength", new Validators.IntValidator());
tbCorrWin.Bind(m_comp, "CorrelWindow", new Validators.IntValidator());
cmbRollType.AddItems(typeof(ReturnsEval.RollingSeriesType));
cmbRollType.Bind(m_extraArgs, "RollingSeriesType", new Validators.EnumDescValidator(ReturnsEval.RollingSeriesType.Vol));
m_extraArgs.PropertyChanged += handleExtraArgsChanged;
gridCorrs.ColourNegativesRed();
gridPerf.Grid.DisplayLayout.Override.RowSelectors = Infragistics.Win.DefaultableBoolean.False;
innerTotalReturnAttributionDisplayChart1.DataClicked += handleDataClicked;
periodReturnsColumnChart1.ColumnClicked += handlePeriodReturnsChartClicked;
periodReturnsColumnChart2.ColumnClicked += handlePeriodReturnsChartClicked;
gridPerf.RowRightClicked += (a, b) =>
{
var pr = b.ListObject as PerfRow;
if (pr == null) return;
getContextMenu().Items.Clear();
getContextMenu().Items.Add(new StrategyPnlDetailMenuItem(pr.StrategyName.Name, m_comp.FindEval(pr.StrategyName.Name),m_comp.GetDate(m_focus)));
getContextMenu().Show(Cursor.Position);
};
}
