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; } }