private LeastSquaresRegressionResult getResultWithStatistics( double[][] x, double[] y, double[] betas, double[] yModel, boolean useIntercept) { int n = x.length; double[] residuals = new double[n]; for (int i = 0; i < n; i++) { residuals[i] = y[i] - yModel[i]; } return new WeightedLeastSquaresRegressionResult(betas, residuals, 0.0, null, 0.0, 0.0, null, null, useIntercept); }
public LeastSquaresRegressionResult(LeastSquaresRegressionResult result) { ArgChecker.notNull(result, "regression result"); _betas = result.getBetas(); _residuals = result.getResiduals(); _meanSquareError = result.getMeanSquareError(); _standardErrorOfBeta = result.getStandardErrorOfBetas(); _rSquared = result.getRSquared(); _rSquaredAdjusted = result.getAdjustedRSquared(); _tStats = result.getTStatistics(); _pValues = result.getPValues(); _hasIntercept = result.hasIntercept(); }
private void assertRegression(final LeastSquaresRegressionResult result, final double[] a) { final double[] beta = result.getBetas(); final double[] tStat = result.getTStatistics(); final double[] pStat = result.getPValues(); final double[] stdErr = result.getStandardErrorOfBetas(); for (int i = 0; i < 5; i++) { assertEquals(beta[i], a[i], EPS); assertTrue(Math.abs(tStat[i]) > FACTOR); assertTrue(pStat[i] < EPS); assertTrue(stdErr[i] < EPS); } assertEquals(result.getRSquared(), 1, EPS); assertEquals(result.getAdjustedRSquared(), 1, EPS); } }
final GeneralizedLeastSquaresRegression regression = new GeneralizedLeastSquaresRegression(); final OrdinaryLeastSquaresRegression olsRegression = new OrdinaryLeastSquaresRegression(); LeastSquaresRegressionResult gls = regression.regress(x, w, yIntercept, true); LeastSquaresRegressionResult ols = olsRegression.regress(x, yIntercept, true); assertRegressions(n, 5, gls, ols); gls = regression.regress(x, w, yNoIntercept, false); ols = olsRegression.regress(x, yNoIntercept, false); assertRegressions(n, 4, gls, ols); gls = regression.regress(x, w, yIntercept, true); ols = olsRegression.regress(x, yIntercept, true); assertRegressions(n, 5, gls, ols); gls = regression.regress(x, w, yNoIntercept, false); ols = olsRegression.regress(x, yNoIntercept, false); assertRegressions(n, 4, gls, ols);
private void assertRegressions(final int n, final int k, final LeastSquaresRegressionResult regression1, final LeastSquaresRegressionResult regression2) { final double[] r1 = regression1.getResiduals(); final double[] r2 = regression2.getResiduals(); for (int i = 0; i < n; i++) { assertEquals(r1[i], r2[i], EPS); } final double[] b1 = regression1.getBetas(); final double[] b2 = regression2.getBetas(); for (int i = 0; i < k; i++) { assertEquals(b1[i], b2[i], EPS); } } }
public LeastSquaresRegressionResult regress(double[][] x, double[] y, boolean useIntercept) { checkData(x, y); double[][] indep = addInterceptVariable(x, useIntercept); double[] dep = new double[y.length]; for (int i = 0; i < y.length; i++) { dep[i] = y[i]; } DoubleMatrix matrix = DoubleMatrix.copyOf(indep); DoubleArray vector = DoubleArray.copyOf(dep); DoubleMatrix transpose = _algebra.getTranspose(matrix); DoubleMatrix betasVector = (DoubleMatrix) _algebra.multiply( _algebra.multiply(_algebra.getInverse(_algebra.multiply(transpose, matrix)), transpose), vector); double[] yModel = super.writeArrayAsVector(((DoubleMatrix) _algebra.multiply(matrix, betasVector)).toArray()); double[] betas = super.writeArrayAsVector(betasVector.toArray()); return getResultWithStatistics(x, y, betas, yModel, transpose, matrix, useIntercept); }
+ RANDOM.nextDouble() / FACTOR; final LeastSquaresRegressionResult result1 = REGRESSION.regress(x, null, y1, false); final LeastSquaresRegressionResult result2 = REGRESSION.regress(x, null, y2, true); assertRegression(result1, a1); assertRegression(result2, a2); final double[] residuals1 = result1.getResiduals(); for (int i = 0; i < n; i++) { assertEquals(y1[i], a1[0] * x[i][0] + a1[1] * x[i][1] + a1[2] * x[i][2] + a1[3] * x[i][3] + a1[4] * x[i][4] + residuals1[i], 10 * EPS); final double[] residuals2 = result2.getResiduals(); for (int i = 0; i < n; i++) { assertEquals(y2[i], a2[0] + a2[1] * x[i][0] + a2[2] * x[i][1] + a2[3] * x[i][2] + a2[4] * x[i][3] + a2[5]
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullNames() { new NamedVariableLeastSquaresRegressionResult(null, new LeastSquaresRegressionResult(null, null, 0, null, 0, 0, null, null, false)); }
@Override public LeastSquaresRegressionResult regress(double[][] x, double[][] weights, double[] y, boolean useIntercept) { if (weights == null) { throw new IllegalArgumentException("Cannot perform WLS regression without an array of weights"); } checkData(x, weights, y); log .info("Have a two-dimensional array for what should be a one-dimensional array of weights. " + "The weights used in this regression will be the diagonal elements only"); double[] w = new double[weights.length]; for (int i = 0; i < w.length; i++) { w[i] = weights[i][i]; } return regress(x, w, y, useIntercept); }
protected void checkData(double[][] x, double[] weights, double[] y) { checkData(x, y); if (weights != null) { if (weights.length == 0) { throw new IllegalArgumentException("No data in weights array"); } if (weights.length != x.length) { throw new IllegalArgumentException("Independent variable and weight arrays are not the same length"); } } }
@Override public LeastSquaresRegressionResult regress(double[][] x, double[][] weights, double[] y, boolean useIntercept) { if (weights != null) { log.info("Weights were provided for OLS regression: they will be ignored"); } return regress(x, y, useIntercept); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testInputs() { new LeastSquaresRegressionResult(null); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testLongArray() { NO_INTERCEPT.getPredictedValue(new double[] {2.4, 2.5, 3.4 }); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullRegression() { new NamedVariableLeastSquaresRegressionResult(new ArrayList<String>(), null); }
private void assertRegressions(final int n, final int k, final LeastSquaresRegressionResult regression1, final LeastSquaresRegressionResult regression2) { final double[] r1 = regression1.getResiduals(); final double[] r2 = regression2.getResiduals(); for (int i = 0; i < n; i++) { assertEquals(r1[i], r2[i], EPS); } final double[] b1 = regression1.getBetas(); final double[] t1 = regression1.getTStatistics(); final double[] p1 = regression1.getPValues(); final double[] s1 = regression1.getStandardErrorOfBetas(); final double[] b2 = regression2.getBetas(); final double[] t2 = regression2.getTStatistics(); final double[] p2 = regression2.getPValues(); final double[] s2 = regression2.getStandardErrorOfBetas(); for (int i = 0; i < k; i++) { assertEquals(b1[i], b2[i], EPS); assertEquals(t1[i], t2[i], EPS); assertEquals(p1[i], p2[i], EPS); assertEquals(s1[i], s2[i], EPS); } assertEquals(regression1.getRSquared(), regression2.getRSquared(), EPS); assertEquals(regression1.getAdjustedRSquared(), regression2.getAdjustedRSquared(), EPS); assertEquals(regression1.getMeanSquareError(), regression2.getMeanSquareError(), EPS); } }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNonMatchingInputs() { final List<String> names = Arrays.asList("A", "B"); final double[] array = new double[] {1. }; final LeastSquaresRegressionResult result = new LeastSquaresRegressionResult(array, array, 0., array, 0., 0., array, array, false); new NamedVariableLeastSquaresRegressionResult(names, result); }
protected void checkData(double[][] x, double[][] weights, double[] y) { checkData(x, y); if (weights != null) { if (weights.length == 0) { throw new IllegalArgumentException("No data in weights array"); } if (weights.length != x.length) { throw new IllegalArgumentException("Independent variable and weight arrays are not the same length"); } int n = weights[0].length; for (double[] w : weights) { if (w.length != n) { throw new IllegalArgumentException("Need a rectangular array of weight"); } } } }
@Test(expectedExceptions = IllegalArgumentException.class) public void testShortArray() { NO_INTERCEPT.getPredictedValue(new double[] {2.4 }); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testNullArray() { NO_INTERCEPT.getPredictedValue(null); }