public RegressionResult(ILevels independent_, DatedDataCollectionGen<double[]> regDataInput_, NMathStats.LinearRegression lin_, NMathStats.LinearRegressionAnova anova_)
{
m_independent = independent_;
m_lin = lin_;
m_regressionData = regDataInput_;
m_anova = anova_;
}
public void Evaluate(bool addIntercept_)
{
NMathCore.DoubleMatrix matrix = new CenterSpace.NMath.Core.DoubleMatrix(m_regressionMatrix);
NMathCore.DoubleVector obs = new CenterSpace.NMath.Core.DoubleVector(m_observations);
m_lin = new NMathStats.LinearRegression(matrix, obs, addIntercept_);
m_anova = new CenterSpace.NMath.Stats.LinearRegressionAnova(m_lin);
m_params = null;
NotifyAll();
}
public static void UpdateThisWithCentralOptions(SwapsSummaryRow summaryRow_)
{
try
{
var lin = DoRegression(summaryRow_,
GetRegressionCandidate(summaryRow_, Singleton<CentralSwitches>.Instance.RegressionArgs.Dependent),
Singleton<CentralSwitches>.Instance.RegressionArgs.NumberOfDays, true);
if (lin != null)
{
//summaryRow_.Beta = lin.ParameterEstimates[1].Value;
summaryRow_.SetRegressionREsiduals(new DatedDataCollectionGen<double>(summaryRow_.Instrument.A_Prices.Dates.SliceLast(Singleton<CentralSwitches>.Instance.RegressionArgs.NumberOfDays),
lin.Residuals.ToArray()));
var anova = new NMathStats.LinearRegressionAnova(lin);
summaryRow_.RSquared = anova.RSquared;
}
}
catch (Exception e)
{
Logger.Error(string.Format("Error updating regression stats for {0}", summaryRow_.ToString()),
typeof (RegressionHelper), e);
}
}
private void reCalculate()
{
ClearSeries();
if (!m_settings.IsValid || m_dependendSource==null)
return;
try
{
var topLeftData = new ScatterData();
var topRightData = new ScatterData();
foreach (var regressor in m_settings.RegressionCandidates)
{
var color = ColorAttribute.GetAttribute(regressor).Color;
var independent = RegressionHelper.GetRegressionCandidate(m_dependendSource, regressor);
foreach (var win in m_settings.Windows)
{
var lin = RegressionHelper.DoRegression(m_dependendSource, independent, (int)win);
string key = string.Format("[{0}] {1}_{2}", lin.ParameterEstimates[1].Value.ToString("##0.0#"), EnumDescriptionAttribute.GetDescription(regressor), EnumDescriptionAttribute.GetDescription(win));
AddBottomSeries(independent.A_Prices.Dates.SliceLast((int)win), lin.Residuals.ToArray(), key, color);
var anova = new NMathStats.LinearRegressionAnova(lin);
topLeftData.AddData(EnumDescriptionAttribute.GetDescription(regressor), Convert.ToDouble(win),
anova.RSquared,color);
topRightData.AddData(key, HelperMethods.GetPercentRank(lin.Residuals.ToArray(),lin.Residuals.Count()-1), anova.RSquared,color);
}
}
AddScatterSeries("areaTopLeft", topLeftData.XSeries.ToArray(), topLeftData.YSeries.ToArray(),
topLeftData.Labels.ToArray(), TOP_LEFT_SCATTER_LABEL, topLeftData.Colors.ToArray(), "###0.0#");
AddScatterSeries("areaTopRight", topRightData.XSeries.ToArray(), topRightData.YSeries.ToArray(),
topRightData.Labels.ToArray(), TOP_RIGHT_SCATTER_LABEL, topRightData.Colors.ToArray(), "###0.0#");
ultraChart1.CompositeChart.Legends[0].ChartLayers.AddRange(
ultraChart1.CompositeChart.ChartLayers.OfType<ChartLayerAppearance>()
.Where(x => x.ChartTypeAppearance is LineChartAppearance).ToArray());
}
catch (Exception ex_)
{
Logger.Error("Error recaculating regressions", typeof (MultiRegressionCompare), ex_);
}
}
internal static RegressionResult DoRegression(this ILevels levels_, RegressionArguments args_)
{
try
{
var myLevels = levels_.Levels;
var independentLevels = args_.Independent.Levels;
if (args_.RegressOn == RegressOn.Differences)
{
myLevels = myLevels.ToDifferences();
independentLevels = independentLevels.ToDifferences();
}
var m_regressionData =
myLevels.GetEndValues(args_.RegressionWindowLength).IntersectDates(independentLevels);
NMathCore.DoubleVector yV = new NMathCore.DoubleVector(m_regressionData.Data.Select(x => x[0]).ToArray());
NMathCore.DoubleMatrix matrix = new NMathCore.DoubleMatrix(m_regressionData.Data.Select(x => x[1]).ToArray().ToColumn());
var lin = new NMathStats.LinearRegression(obs: yV, A: matrix, addIntercept: true);
var anova = new NMathStats.LinearRegressionAnova(lin);
return new RegressionResult(args_.Independent, m_regressionData, lin, anova);
}
catch (Exception ex_)
{
Logger.Error(string.Format("Error recalculating regression for {0}", levels_.Name), typeof(RegressionExtensionMethods), ex_);
return null;
}
}
internal static DatedDataCollectionGen<double> GetRollingRegressionField(this ILevels levels_, RegressionArguments args_, RegressionField field_)
{
DatedDataCollectionGen<double> ret = null;
try
{
var myLevels = levels_.Levels;
var independentLevels = args_.Independent.Levels;
if (args_.RegressOn == RegressOn.Differences)
{
myLevels = myLevels.ToDifferences();
independentLevels = independentLevels.ToDifferences();
}
var m_regressionData =
myLevels.IntersectDates(independentLevels);
if (m_regressionData.Length < args_.RegressionWindowLength)
return null;
var myBucket = new List<double>();
var indepBucket = new List<double>();
var betas = new List<double>();
var dates = new List<DateTime>();
for (int i = 0; i < m_regressionData.Length; ++i)
{
myBucket.Add(m_regressionData.Data[i][0]);
indepBucket.Add(m_regressionData.Data[i][1]);
if (myBucket.Count < args_.RegressionWindowLength)
continue;
while (myBucket.Count > args_.RegressionWindowLength)
{
myBucket.RemoveAt(0);
indepBucket.RemoveAt(0);
}
var yV = new NMathCore.DoubleVector(myBucket.ToArray());
var matrix = new NMathCore.DoubleMatrix(indepBucket.ToArray().ToColumn());
try
{
var lin = new NMathStats.LinearRegression(obs: yV, A: matrix, addIntercept: true);
var anova = new NMathStats.LinearRegressionAnova(lin);
var result = new RegressionResult(args_.Independent, m_regressionData, lin, anova);
betas.Add(result[field_]);
dates.Add(m_regressionData.Dates[i]);
}
catch { }
}
ret = new DatedDataCollectionGen<double>(dates.ToArray(), betas.ToArray());
}
catch (Exception ex_)
{
Logger.Error("Error generated doing rolling beta", typeof(RegressionExtensionMethods), ex_);
return null;
}
return ret;
}
