public static double GetRatingFromRanking(int ranking, RegressionType regressionType)
{
double rating = 0;
if (regressionType == RegressionType.Logarithmic)
{
rating = (94.6740233 + -14.68314639 * Math.Log(ranking + Math.E)) / 100;
}
else if (regressionType == RegressionType.Exponential)
{
rating = 65.54 * Math.Pow(Math.E, -0.0093221 * ranking) / 100;
}
else if (regressionType == RegressionType.ArcTan)
{
rating = (-25 * Math.Atan(0.1 * ranking - 1.5) + 55) / 100;
}
else if (regressionType == RegressionType.Inverse)
{
rating = (-1833.15 / (-1.05558 * ranking - 23.703) + 12.144) / 100;
}
else if (regressionType == RegressionType.Linear)
{
rating = (-0.3134148880054439 * ranking + 64.4390619317387) / 100;
}
else if (regressionType == RegressionType.None)
{
return(0.5);
}
if (rating < 0.01)
{
rating = 0.01;
}
return(rating);
}
public DoubleMatrix GetCompanyGenerated(RegressionType type, int lag)
{
//Create DataMatrix
DoubleMatrix dblMtrx = new DoubleMatrix(m_observations.Count - lag, 5);
switch (type)
{
case RegressionType.Full:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = m_observations[i].KloutScore;
dblMtrx[i, 1] = m_observations[i].NumberFavorites != 0 ? m_observations[i].NumberFavorites : AlmostZero;
dblMtrx[i, 2] = m_observations[i].NumberFriends != 0 ? m_observations[i].NumberFriends : AlmostZero;
dblMtrx[i, 3] = m_observations[i].NumberStatuses != 0 ? m_observations[i].NumberStatuses : AlmostZero;
dblMtrx[i, 4] = m_observations[i].StockPrice;
}
break;
case RegressionType.Delta:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = m_observations[i].KloutScore - m_observations[i + lag].KloutScore;
int favDelta = m_observations[i].NumberFavorites - m_observations[i + lag].NumberFavorites;
dblMtrx[i, 1] = favDelta != 0 ? favDelta : AlmostZero;
int friDelta = m_observations[i].NumberFriends - m_observations[i + lag].NumberFriends;
dblMtrx[i, 2] = friDelta != 0 ? friDelta : AlmostZero;
int statDelta = m_observations[i].NumberStatuses - m_observations[i + lag].NumberStatuses;
dblMtrx[i, 3] = statDelta != 0 ? statDelta : AlmostZero;
double stockDelta = m_observations[i].StockPrice - m_observations[i + lag].StockPrice;
dblMtrx[i, 4] = stockDelta != 0 ? stockDelta : AlmostZero;
}
break;
case RegressionType.PercentChanged:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = (m_observations[i].KloutScore - m_observations[i + lag].KloutScore) / m_observations[i].KloutScore;
int favDelta = m_observations[i].NumberFavorites == 0 ? 0 : (m_observations[i].NumberFavorites - m_observations[i + lag].NumberFavorites) / m_observations[i].NumberFavorites;
dblMtrx[i, 1] = favDelta != 0 ? favDelta : AlmostZero;
int friDelta = m_observations[i].NumberFriends == 0 ? 0 : (m_observations[i].NumberFriends - m_observations[i + lag].NumberFriends) / m_observations[i].NumberFriends;
dblMtrx[i, 2] = friDelta != 0 ? friDelta : AlmostZero;
int statDelta = m_observations[i].NumberStatuses == 0 ? 0 : (m_observations[i].NumberStatuses - m_observations[i + lag].NumberStatuses) / m_observations[i].NumberStatuses;
dblMtrx[i, 3] = statDelta != 0 ? statDelta : AlmostZero;
double stockDelta = m_observations[i].StockPrice == 0 ? 0 : (m_observations[i].StockPrice - m_observations[i + lag].StockPrice) / m_observations[i].StockPrice;
dblMtrx[i, 4] = stockDelta != 0 ? stockDelta : AlmostZero;
}
break;
}
return(dblMtrx);
}
/// <summary>
/// The method which does the actual calculations for the X and Y estimators, a and b parameters and r-squared.
/// </summary>
private static double[] OrdinaryLeastSquares(DataTable dt, string xField, string yField, RegressionType regressionType)
{
List<string> auxiliaryFields = new List<string>();
//Calculate a and b parameters
if (regressionType == RegressionType.Logarithmic)
{
dt.Columns.Add("__LnX", typeof(double));
dt.Rows.Cast<DataRow>().ToList().ForEach(r => r.SetField("__LnX", Math.Log((double)r[xField])));
xField = "__LnX";
//auxiliaryFields.Add("__LnX");
}
dt.Columns.Add("__XY", typeof(double), string.Format("{0} * {1}", xField, yField));
dt.Columns.Add("__X2", typeof(double), string.Format("{0} * {0}", xField));
dt.Columns.Add("__Y2", typeof(double), string.Format("{0} * {0}", yField));
auxiliaryFields.AddRange(new string[] { "__XY", "__X2", "__Y2" });
double xSum = (double)dt.Compute(string.Format("SUM([{0}])", xField), "");
double ySum = (double)dt.Compute(string.Format("SUM([{0}])", yField), "");
double xAvg = (double)dt.Compute(string.Format("AVG([{0}])", xField), "");
double yAvg = (double)dt.Compute(string.Format("AVG([{0}])", yField), "");
double xySum = (double)dt.Compute("SUM([__XY])", "");
double x2Sum = (double)dt.Compute("SUM([__X2])", "");
double y2Sum = (double)dt.Compute("SUM([__Y2])", "");
int n = dt.Rows.Count;
double slope = (n * xySum - xSum * ySum) / (n * x2Sum - xSum * xSum);
double intercept = yAvg - slope * xAvg;
//Calculate r-squared
dt.Columns.Add("__SSTField", typeof(double), string.Format("({0} - {1}) * ({0} - {1})", yField, yAvg));
dt.Columns.Add("__Yest_Orig", typeof(double), string.Format("{0} * {1} + {2}", slope, xField, intercept));
dt.Columns.Add("__SSEField", typeof(double), string.Format("({0} - __Yest_Orig) * ({0} - __Yest_Orig)", yField));
double SST = (double)dt.Compute("SUM([__SSTField])", "");
double SSE = (double)dt.Compute("SUM([__SSEField])", "");
auxiliaryFields.AddRange(new string[] { "__SSTField", "__SSEField" });
double rSquarred = 1 - SSE / SST;
RemoveAuxiliaryFields(dt, auxiliaryFields);
return new double[] { slope, intercept, rSquarred };
}
public DoubleVector GetPrices(RegressionType type, int size, int lag = 0)
{
//Create DataMatrix
DoubleVector dbleVctr = new DoubleVector(size);
switch (type)
{
case RegressionType.Full:
if (lag == 0)
{
int counter = 0;
for (int i = Length - size; i < Length; i++)
{
dbleVctr[counter] = m_observations[i].StockPrice;
counter++;
}
}
else
{
for (int i = 0; i < size; i++)
{
dbleVctr[i] = m_observations[i].StockPrice;
}
}
break;
case RegressionType.Delta:
for (int i = 0; i < size; i++)
{
double priceDelta = m_observations[i].StockPrice - m_observations[i + lag].StockPrice;
dbleVctr[i] = priceDelta == 0 ? AlmostZero : priceDelta;
}
break;
case RegressionType.PercentChanged:
for (int i = 0; i < size; i++)
{
double priceDelta = (m_observations[i].StockPrice - m_observations[i + lag].StockPrice) / m_observations[i].StockPrice;
dbleVctr[i] = priceDelta == 0 ? AlmostZero : priceDelta;
}
break;
}
return(dbleVctr);
}
/// <summary>
/// Creates a regression model out of an existing data source within the RadHtmlChart control.
/// </summary>
/// <param name="HtmlChart">The RadHtmlChart instance.</param>
/// <param name="DataSource">The DataTable data source.</param>
/// <param name="DataFieldX">The name of the column in the data source that stores the x-values. </param>
/// <param name="DataFieldY">The name of the column in the data source that stores the y-values.</param>
/// <param name="RegressionModelType">The type of the regression model.</param>
public static void Plot(RadHtmlChart HtmlChart, DataTable DataSource, string DataFieldX, string DataFieldY, RegressionType RegressionModelType)
{
//Calculate a and b coefficients
double[] estimators = OrdinaryLeastSquares(DataSource, DataFieldX, DataFieldY, RegressionModelType);
double slope = estimators[0];
double intercept = estimators[1];
double rSquared = estimators[2];
//Add x and y estimates
string estYFieldName = "__Yest";
string estXFieldName = "__Xest";
AddRegressionFields(DataSource, DataFieldX, DataFieldY, estXFieldName, estYFieldName, slope, intercept, RegressionModelType);
//Form the equation, used for the series name
string equationSeriesName = FormatStringEquation(RegressionModelType, slope, intercept, rSquared);
//Add a new series with the regression line
AddRegressionSeries(HtmlChart, estXFieldName, estYFieldName, equationSeriesName);
//Data bind the chart to the new data source
HtmlChart.DataSource = DataSource;
HtmlChart.DataBind();
}
public DoubleMatrix GetCustomerGenerated(RegressionType type, int lag)
{
//Create DataMatrix
DoubleMatrix dblMtrx = new DoubleMatrix(m_observations.Count - lag, 3);
switch (type)
{
case RegressionType.Full:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = m_observations[i].KloutScore;
dblMtrx[i, 1] = m_observations[i].NumberFollowers != 0 ? m_observations[i].NumberFollowers : AlmostZero;
dblMtrx[i, 2] = m_observations[i].StockPrice;
}
break;
case RegressionType.Delta:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = m_observations[i].KloutScore - m_observations[i + lag].KloutScore;
int folDelta = m_observations[i].NumberFollowers - m_observations[i + lag].NumberFollowers;
dblMtrx[i, 1] = folDelta != 0 ? folDelta : AlmostZero;
double stockDelta = m_observations[i].StockPrice - m_observations[i + lag].StockPrice;
dblMtrx[i, 2] = stockDelta != 0 ? stockDelta : AlmostZero;
}
break;
case RegressionType.PercentChanged:
for (int i = 0; i < m_observations.Count - lag; i++)
{
dblMtrx[i, 0] = (m_observations[i].KloutScore - m_observations[i + lag].KloutScore) / m_observations[i].KloutScore;
int folDelta = m_observations[i].NumberFollowers == 0 ? 0 : (m_observations[i].NumberFollowers - m_observations[i + lag].NumberFollowers) / m_observations[i].NumberFollowers;
dblMtrx[i, 1] = folDelta != 0 ? folDelta : AlmostZero;
double stockDelta = (m_observations[i].StockPrice - m_observations[i + lag].StockPrice) / m_observations[i].StockPrice;
dblMtrx[i, 2] = stockDelta != 0 ? stockDelta : AlmostZero;
}
break;
}
return(dblMtrx);
}
public void InitSingle()
{
regressionType = RegressionType.Channel;
upLine = false;
downLine = false;
}
private void Forecasting(double[][] inputValues, out double[][] outputValues, string[] parameterList, string[] extraParameterList)
{
RegressionType regressionType = RegressionType.Polynomial;
int num;
try
{
if (parameterList[0] == "Exponential")
{
regressionType = RegressionType.Exponential;
num = 2;
}
else if (parameterList[0] == "Linear")
{
regressionType = RegressionType.Polynomial;
num = 2;
}
else if (parameterList[0] == "Logarithmic")
{
regressionType = RegressionType.Logarithmic;
num = 2;
}
else if (parameterList[0] == "Power")
{
regressionType = RegressionType.Power;
num = 2;
}
else
{
num = int.Parse(parameterList[0], CultureInfo.InvariantCulture);
}
}
catch (Exception)
{
num = 2;
}
if (num <= 5 && num >= 1)
{
if (num > inputValues[0].Length)
{
throw new InvalidOperationException(SR.ExceptionForecastingNotEnoughDataPoints(num.ToString(CultureInfo.InvariantCulture)));
}
int forecastingPeriod;
try
{
forecastingPeriod = int.Parse(parameterList[1], CultureInfo.InvariantCulture);
}
catch (Exception)
{
forecastingPeriod = inputValues[0].Length / 2;
}
bool flag;
try
{
flag = bool.Parse(parameterList[2]);
}
catch (Exception)
{
flag = true;
}
bool flag2;
try
{
flag2 = bool.Parse(parameterList[3]);
}
catch (Exception)
{
flag2 = true;
}
double[][] array = default(double[][]);
this.Regression(regressionType, inputValues, out array, num, forecastingPeriod);
if (!flag2 && !flag)
{
outputValues = array;
}
else
{
double[][] array2 = new double[2][]
{
new double[inputValues[0].Length / 2],
new double[inputValues[0].Length / 2]
};
for (int i = 0; i < inputValues[0].Length / 2; i++)
{
array2[0][i] = inputValues[0][i];
array2[1][i] = inputValues[1][i];
}
double[][] array3 = default(double[][]);
this.Regression(regressionType, array2, out array3, num, inputValues[0].Length / 2);
double num2 = 0.0;
for (int j = inputValues[0].Length / 2; j < array3[1].Length; j++)
{
num2 += (array3[1][j] - inputValues[1][j]) * (array3[1][j] - inputValues[1][j]);
}
num2 /= (double)(inputValues[0].Length - inputValues[0].Length / 2);
num2 = Math.Sqrt(num2);
num2 /= (double)(inputValues[0].Length / 4);
double num3 = 0.0;
for (int k = 0; k < inputValues[0].Length; k++)
{
num3 += (array[1][k] - inputValues[1][k]) * (array[1][k] - inputValues[1][k]);
}
num3 /= (double)inputValues[0].Length;
num3 = Math.Sqrt(num3);
outputValues = new double[4][];
outputValues[0] = array[0];
outputValues[1] = array[1];
outputValues[2] = new double[array[0].Length];
outputValues[3] = new double[array[0].Length];
if (!flag)
{
num3 = 0.0;
}
if (!flag2)
{
num2 = 0.0;
}
for (int l = 0; l < inputValues[0].Length; l++)
{
outputValues[2][l] = array[1][l] + 2.0 * num3;
outputValues[3][l] = array[1][l] - 2.0 * num3;
}
double num4 = 0.0;
for (int m = inputValues[0].Length; m < array[0].Length; m++)
{
num4 += num2;
outputValues[2][m] = array[1][m] + num4 + 2.0 * num3;
outputValues[3][m] = array[1][m] - num4 - 2.0 * num3;
}
}
return;
}
throw new InvalidOperationException(SR.ExceptionForecastingDegreeInvalid);
}
private void PolynomialRegression(RegressionType regressionType, double[][] inputValues, out double[][] outputValues, int polynomialDegree, int forecastingPeriod, double logInterval)
{
double[] array = new double[polynomialDegree];
int num = inputValues[0].Length;
double num2 = 1.7976931348623157E+308;
double num3 = 1.0;
num3 = Math.Abs(inputValues[0][0] - inputValues[0][inputValues[0].Length - 1]) / (double)(inputValues[0].Length - 1);
if (num3 <= 0.0)
{
num3 = 1.0;
}
if (regressionType != RegressionType.Logarithmic)
{
for (int i = 0; i < inputValues[0].Length; i++)
{
if (num2 > inputValues[0][i])
{
num2 = inputValues[0][i];
}
}
for (int j = 0; j < inputValues[0].Length; j++)
{
inputValues[0][j] -= num2 - 1.0;
}
}
if (regressionType == RegressionType.Power)
{
for (int k = 0; k < inputValues[0].Length; k++)
{
inputValues[0][k] = Math.Log(inputValues[0][k]);
inputValues[1][k] = Math.Log(inputValues[1][k]);
}
}
double[][] array2 = new double[polynomialDegree][];
for (int l = 0; l < polynomialDegree; l++)
{
array2[l] = new double[polynomialDegree];
}
for (int m = 0; m < polynomialDegree; m++)
{
for (int n = 0; n < polynomialDegree; n++)
{
array2[n][m] = 0.0;
for (int num4 = 0; num4 < inputValues[0].Length; num4++)
{
array2[n][m] += Math.Pow(inputValues[0][num4], (double)(n + m));
}
}
}
double num5 = this.Determinant(array2);
for (int num6 = 0; num6 < polynomialDegree; num6++)
{
double[][] array3 = this.CopyDeterminant(array2);
for (int num7 = 0; num7 < polynomialDegree; num7++)
{
array3[num6][num7] = 0.0;
for (int num8 = 0; num8 < inputValues[0].Length; num8++)
{
array3[num6][num7] += inputValues[1][num8] * Math.Pow(inputValues[0][num8], (double)num7);
}
}
array[num6] = this.Determinant(array3) / num5;
}
outputValues = new double[2][];
outputValues[0] = new double[num + forecastingPeriod];
outputValues[1] = new double[num + forecastingPeriod];
switch (regressionType)
{
case RegressionType.Polynomial:
for (int num12 = 0; num12 < num + forecastingPeriod; num12++)
{
outputValues[0][num12] = inputValues[0][0] + (double)num12 * num3;
outputValues[1][num12] = 0.0;
for (int num13 = 0; num13 < polynomialDegree; num13++)
{
outputValues[1][num12] += array[num13] * Math.Pow(outputValues[0][num12], (double)num13);
}
}
break;
case RegressionType.Exponential:
for (int num10 = 0; num10 < num + forecastingPeriod; num10++)
{
outputValues[0][num10] = inputValues[0][0] + (double)num10 * num3;
outputValues[1][num10] = Math.Exp(array[0]) * Math.Exp(array[1] * outputValues[0][num10]);
}
break;
case RegressionType.Logarithmic:
for (int num11 = 0; num11 < num + forecastingPeriod; num11++)
{
outputValues[0][num11] = Math.Exp(inputValues[0][0]) + (double)num11 * logInterval;
outputValues[1][num11] = array[1] * Math.Log(outputValues[0][num11]) + array[0];
}
break;
case RegressionType.Power:
for (int num9 = 0; num9 < num + forecastingPeriod; num9++)
{
outputValues[0][num9] = Math.Exp(inputValues[0][0]) + (double)num9 * logInterval;
outputValues[1][num9] = Math.Exp(array[0]) * Math.Pow(outputValues[0][num9], array[1]);
}
break;
}
if (regressionType != RegressionType.Logarithmic)
{
for (int num14 = 0; num14 < num + forecastingPeriod; num14++)
{
outputValues[0][num14] += num2 - 1.0;
}
}
}
/// <summary>
/// The method which creates the equation with the a and b coefficients and r-squared. It is used in the legend.
/// </summary>
private static string FormatStringEquation(RegressionType regressionType, double slope, double intercept, double rSquared)
{
string XName = "X";
if (regressionType == RegressionType.Logarithmic)
{
XName = "Ln(X)";
}
return string.Format("Y = {0} * {3} + {1}\\nR-Squared: {2}", Math.Round(slope, 4), Math.Round(intercept, 4), Math.Round(rSquared, 4), XName);
}
/// <summary>
/// This method add creates the data source fields for the x and y values to plot the regression model.
/// </summary>
private static void AddRegressionFields(DataTable dt, string xField, string yField, string XestField, string YestField, double slope, double intercept, RegressionType RegressionModelType)
{
int n = dt.Rows.Count;
double xMin = (double)dt.Compute(string.Format("Min([{0}])", xField), "");
double xMax = (double)dt.Compute(string.Format("Max([{0}])", xField), "");
double step = (xMax - xMin) / (n - 1);
double cumulative = xMin;
dt.Columns.Add(XestField, typeof(double));
dt.Columns.Add(YestField, typeof(double));
for (int i = 0; i < n; i++)
{
if (RegressionModelType == RegressionType.Logarithmic)
{
dt.Rows[i][YestField] = Math.Log(cumulative) * slope + intercept;
}
else
{
dt.Rows[i][YestField] = cumulative * slope + intercept;
}
dt.Rows[i][XestField] = cumulative;
cumulative += step;
}
}
