Uniform

The uniform distribution has a constant probability density over its supported range , and is zero everywhere else. In fact, this is just a formal way of describing the random, real-number generator on the interval [0,1] that you are familiar with, such as java.util.Random.nextDouble(). The default constructor sets a lower bound a = 0.0 and an upper bound of b = 1.0. The probability density of a uniform distribution is expressed graphically as a top hat or box shape, as shown in Figure 3-3.

Figure 3-3. Uniform PDF with parameters and

This has the following mathematical form:

The cumulative distribution function (CDF) looks like Figure 3-4.

Figure 3-4. Uniform CDF with parameters and

This has the form shown here:

In the uniform distribution, the mean and the variance are not directly specified, but are calculated from the lower and upper bounds with the following:

To invoke the uniform distribution with Java, use the class UniformDistribution(a, b), where the lower and upper bounds are specified in the constructor. Leaving the constructor arguments blank invokes the standard uniform distribution, where a = 0.0 and b = 1.0.

UniformRealDistribution dist = new UniformRealDistribution();
double lowerBound = dist.getSupportLowerBound(); // 0.0
double upperBound = dist.getSupportUpperBound(); // 1.0
double mean = dist.getNumericalMean();
double variance = dist.getNumericalVariance();
double standardDeviation = Math.sqrt(variance);
double probability = dist.density(0.5));
double cumulativeProbability = dist.cumulativeProbability(0.5);
double sample = dist.sample(); // e.g., 0.023
double[] samples = dist.sample(3); // e.g., {0.145, 0.878, 0.431}

Note that we could reparameterize the uniform distribution with and , where is the center point (the mean) and is the distance from the center to either the lower or upper bound. The variance then becomes with standard deviation . The PDF is then

and the CDF is

To express the uniform distribution in this centralized form, calculate and and enter them into the constructor:

/* initialize centralized uniform with mean = 10 and half-width = 2 */
double mean = 10.0
double hw = 2.0;
double a = mean - hw;
double b = mean + hw;
UniformRealDistribution dist = new UniformRealDistribution(a, b);

At this point, all of the methods will return the correct results without any further alterations. This reparameterization around the mean can be useful when trying to compare distributions. The centered, uniform distribution is naturally extended by the normal distribution (or other symmetric peaked distributions).

Normal

The most useful and widespread distribution, found in so many diverse use cases, is the normal distribution. Also known as the Gaussian distribution or the bell curve, this distribution is symmetric about a central peak whose width can vary. In many cases when we refer to something as having an average value with plus or minus a certain amount, we are referring to the normal distribution. For example, for exam grades in a classroom, the interpretation is that a few people do really well and a few people do really badly, but most people are average or right in the middle. In the normal distribution, the center of the distribution is the maximum peak and is also the mean of the distribution, μ. The width is parameterized by σ and is the standard deviation of the values. The distribution supports all values of and is shown in Figure 3-5.

Figure 3-5. Normal PDF with parameters and

The probability density is expressed mathematically as follows:

The cumulative distribution function is shaped like Figure 3-6.

Figure 3-6. Normal CDF with parameters and

This is expressed with the error function:

This is invoked via Java, where the default constructor creates the standard normal distribution with and . Otherwise, pass the parameters μ and σ to the constructor:

/* initialize with default mu=0 and sigma=1 */
NormalDistribution dist = new NormalDistribution();
double mu = dist.getMean(); // 0.0
double sigma = dist.getStandardDeviation(); // 1.0
double mean = dist.getNumericalMean(); // 0.0
double variance = dist.getNumericalVariance(); // 1.0
double lowerBound = dist.getSupportLowerBound(); // -Infinity
double upperBound = dist.getSupportUpperBound(); // Infinity
/* probability at a point x = 0.0 */
double probability = dist.density(0.0);
/* calc cum at x=0.0 */
double cumulativeProbability = dist.cumulativeProbability(0.0);
double sample = dist.sample(); // 1.0120001
double samples[] = dist.sample(3); // {.0102, -0.009, 0.011}

Multivariate normal

The normal distribution can be generalized to higher dimensions as the multivariate normal (a.k.a. multinormal) distribution. The variate x and the mean μ are vectors, while the covariance matrix Σ contains the variances on the diagonal and the covariances as i,j pairs. In general, the multivariate normal has a squashed ball shape and is symmetric about the mean. This distribution is perfectly round (or spherical) for unit normals when the covariances are 0 and variances are equivalent. An example of the distribution of random points is shown in Figure 3-7.

Figure 3-7. Random points generated from 2D multinormal distribution

The probability distribution function of a dimensional multinormal distribution takes the form

Note that if the covariance matrix has a determinant equal to zero such that , then f(x) blows up to infinity. Also note that when , it is impossible to calculate the required inverse of the covariance . In this case, the matrix is termed singular. Apache Commons Math will throw the following exception if this is the case:

org.apache.commons.math3.linear.SingularMatrixException: matrix is singular

What causes a covariance matrix to become singular? This is a symptom of co-linearity, in which two (or more) variates of the underlying data are identical or linear combinations of each other. In other words, if we have three dimensions and the covariance matrix is singular, it may mean that the distribution of data could be better described in two or even one dimension.

There is no analytical expression for the CDF. It can be attained via numerical integration. However, Apache Commons Math supports only univariate numerical integration.

The multivariate normal takes means and covariance as arrays of doubles, although you can still use RealVector, RealMatrix, or Covariance instances with their getData() methods applied:

double[] means = {0.0, 0.0, 0.0};
double[][] covariances = {{1.0, 0.0, 0.0},{0.0, 1.0, 0.0}, {0.0, 0.0, 1.0}};
MultivariateNormalDistribution dist = 
  new MultivariateNormalDistribution(means, covariances);

/* probability at point x = {0.0, 0.0, 0.0} */
double probability = dist.density(x); // 0.1
double[] mn = dist.getMeans();
double[] sd = dist.getStandardDeviations();
/* returns a RealMatrix but can be converted to doubles */
double[][] covar = dist.getCovariances().getData();
double[] sample = dist.sample();
double[][] samples = dist.sample(3);

Note the special case in which the covariance is a diagonal matrix. This occurs when the variables are completely independent. The determinant of Σ is just the product of its diagonal elements . The inverse of a diagonal matrix is yet another diagonal matrix with each term expressed as . The PDF then reduces to the product of univariate normals:

As in the case of the unit normal, a unit multivariate normal has a mean vector of 0s and a covariance matrix equal to the identity matrix, a diagonal matrix of 1s.

Log normal

The log normal distribution is related to the normal distribution when the variate x is distributed logarithmically—that is, ln(x) is normally distributed. If we substitute ln(x) for x in the normal distribution, we get the log normal distribution. There are some subtle differences. Because the logarithm is defined only for positive x, this distribution has support on the interval , where x > 0. The distribution is asymmetric with a peak near the smaller values of x and a long tail stretching, infinitely, to higher values of x, as shown in Figure 3-8.

Figure 3-8. Log normal PDF with parameters and

The location (scale) parameter m and the shape parameter s rise to the PDF:

Here, m and s are the respective mean and standard deviation of the logarithmically distributed variate X. The CDF looks like Figure 3-9.

Figure 3-9. Log normal CDF with parameters and

This has the following form:

Unlike the normal distribution, the m is neither the mean (average value) nor the mode (most likely value or the peak) of the distribution. This is because of the larger number of values stretching off to positive infinity. The mean and variance of X are calculated from the following:

We can invoke a log normal distribution with this:

/* initialize with default m=0 and s=1 */
NormalDistribution dist = new NormalDistribution();
double lowerBound = dist.getSupportLowerBound(); // 0.0
double upperBound = dist.getSupportUpperBound(); // Infinity
double scale = dist.getScale(); // 0.0
double shape = dist.getShape(): // 1.0
double mean = dist.getNumericalMean(); // 1.649
double variance = dist.getNumericalVariance(); // 4.671
double density = dist.density(1.0); // 0.3989
double cumulativeProbability = dist.cumulativeProbability(1.0); // 0.5
double sample = dist.sample(); // 0.428
double[] samples = dist.sample(3); // {0.109, 5.284, 2.032}

Where do we see the log normal distribution? The distribution of ages in a human population, and (sometimes) in particle size distribution. Note that the log normal distribution arises from a multiplicative effect of many independent distributions.

Empirical

In some cases you have data, but do not know the distribution that the data came from. You can still approximate a distribution with your data and even calculate probability density, cumulative probability, and random numbers! The first step in working with an empirical distribution is to collect the data into bins of equal size spanning the range of the dataset. The class EmpiricalDistribution can input an array of doubles or can load a file locally or from a URL. In those cases, data must be one entry per line:

/* get 2500 random numbers from a standard normal distribution */
NormalDistribution nd = new NormalDistribution();
double[] data = nd.sample(2500);
        
// default constructor assigns bins = 1000
// better to try numPoints / 10
EmpiricalDistribution dist = new EmpiricalDistribution(25);
dist.load(data); // can also load from file or URL !!!
double lowerBound = dist.getSupportLowerBound(); // 0.5
double upperBound = dist.getSupportUpperBound(); // 10.1
double mean = dist.getNumericalMean(); // 5.48
double variance = dist.getNumericalVariance(); // 15.032
double density = dist.density(1.0); // 0.357
double cumulativeProbability = dist.cumulativeProbability(1.0); // 0.153
double sample = dist.sample(); // e.g., 1.396
double[] samples = dist.sample(3); // e.g., [10.098, 0.7934, 9.981]

We can plot the data from an empirical distribution as a type of bar chart called a histogram, shown in Figure 3-10.

Figure 3-10. Histogram of random normal with parameters and

The code for a histogram uses the BarChart plot from Chapter 1, except that we add the data directly from the EmpiricalDistribution instance that contains a List of all the SummaryStatistics of each bin:

/* for an existing EmpiricalDistribution with loaded data */
List<SummaryStatistics> ss = dist.getBinStats();
int binNum = 0;
for (SummaryStatistics s : ss) {
    /* adding bin counts to the XYChart.Series instance */
    series.getData().add(new Data(Integer.toString(binNum++), s.getN()));
}
// render histogram with JavaFX BarChart

Bernoulli

The Bernoulli distribution is the most basic and perhaps most familiar distribution because it is essentially a coin flip. In a “heads we win, tails we lose” situation, the coin has two possible states: tails (k = 0) and heads (k = 1), where k = 1 is designated to have a probability of success equal to p. If the coin is perfect, then p = 1/2; it is equally likely to get heads as it is tails. But what if the coin is “unfair,” indicating p ≠ 1/2? The probability mass function (PMF) can then be represented as follows:

The cumulative distribution function is shown here:

The mean and variance are calculated with the following:

Note that the Bernoulli distribution is related to the binomial distribution, where the number of trials equals n = 1. The Bernoulli distribution is implemented with the class BinomialDistribution(1, p) setting n = 1:

BinomialDistribution dist = new BinomialDistribution(1, 0.5);
int lowerBound = dist.getSupportLowerBound(); // 0
int upperBound = dist.getSupportUpperBound(); // 1
int numTrials = dist.getNumberOfTrials(); // 1
double probSuccess = dist.getProbabilityOfSuccess(); // 0.5
double mean = dist.getNumericalMean(); // 0.5
double variance = dist.getNumericalVariance(); // 0.25
// k = 1
double probability = dist.probability(1); // 0.5
double cumulativeProbability = dist.cumulativeProbability(1); // 1.0
int sample = dist.sample(); // e.g., 1
int[] samples = dist.sample(3); // e.g., [1, 0, 1]

Poisson

The Poisson distribution is often used to describe discrete, independent events that occur rarely. The number of events are the integers that occur over some interval with a constant rate gives rise to the PMF in Figure 3-13.

Figure 3-13. Poisson PMF with parameters

The form of the PMF is

Figure 3-14 shows the CDF.

Figure 3-14. Poisson CDF with parameters

The CDF is expressed via

The mean and variance are both equivalent to the rate parameter as

The Poisson is implemented with the parameter in the constructor and has an upper bound at Integer.MAX k = 2³² – 1 = 2147483647:

PoissonDistribution dist = new PoissonDistribution(3.0);
int lowerBound = dist.getSupportLowerBound(); // 0
int upperBound = dist.getSupportUpperBound(); // 2147483647
double mean = dist.getNumericalMean(); // 3.0
double variance = dist.getNumericalVariance(); // 3.0
// k = 1
double probability = dist.probability(1); // 0.1494
double cumulativeProbability = dist.cumulativeProbability(1); // 0.1991
int sample = dist.sample(); // e.g., 1
int[] samples = dist.sample(3); // e.g., [2, 4, 1]

Sample moments

In the case of real data, where the true statistical distribution function may not be known, we can estimate the central moments:

Here, the estimated mean is calculated as follows:

Updating moments

Without the factor 1/n for the estimate of the central moment, the form is as follows:

In this particular form, the unnormalized moments can be split into parts via straightforward calculations. This gives us a great advantage that the unnormalized moments can be calculated in parts, perhaps in different processes or even on different machines entirely, and we can glue back together the pieces later. Another advantage is that this formulation is less sensitive to extreme values. The combined unnormalized central moment for the two chunks is shown here:

is the difference between the means of the two data chunks. Of course, you will also need a method for merging the means, because this formula is applicable only for k > 1. Given any two data chunks with known means and counts, the total count is , and the mean is robustly calculated as follows:

If one of the data chunks has only one point x, then the formulation for combining the unnormalized central moments is simplified:

Here, is the difference between the added value x and the mean value of the existing data chunk.

In the next section, we will see how these formulas are used to robustly calculate important properties to statistics. They become essential in distributed computing applications when we wish to break statistical calculations into many parts. Another useful application is storeless calculations in which, instead of performing calculations on whole arrays of data, we keep track of moments as we go, and update them incrementally.

Count

The simplest statistic is the count of the number of points in the dataset:

long count = descriptiveStatistics.getN();

Sum

We can also access the sum of all values:

double sum = descriptiveStatistics.getSum();

Min

To retrieve the minimum value dataset, we use this:

double min = descriptiveStatistics.getMin();

Max

To retrieve the maximum value in the dataset, we use this:

double max = descriptiveStatistics.getMax();

Mean

The average value of the sample or mean is calculated directly:

However, this calculation is sensitive to extreme values, and given , the mean can be updated for each added value x:

Commons Math uses the update formula for mean calculation when the getMean() method is called:

double mean = descriptiveStatistics.getMean();

Median

The middle value of a sorted (ascending) dataset is the median. The advantage is that it minimizes the problem of extreme values. While there is no direct calculation of the median in Apache Commons Math, it is easy to calculate by taking the average of the two middle members if the array length is even; and otherwise, just return the middle member of the array:

// sort the stored values
double[] sorted = descriptiveStatistics.getSortedValues();
int n = sorted.length;
double median = (n % 2 == 0) ? (sorted[n/2-1]+sorted[n/2])/2.0 : sorted[n/2];

Mode

The mode is the most likely value. The concept of mode does not make sense if the values are doubles, because there is probably only one of each. Obviously, there will be exceptions (e.g., when many zeros occur) or if the dataset is large and the numerical precision is small (e.g., two decimal places). The mode has two use cases then: if the variate being considered is discrete (integer), then the mode can be useful, as in dataset four of Anscombe’s quartet. Otherwise, if you have created bins from empirical distribution, the mode is the max bin. However, you should consider the possibility that your data is noisy and the bin counts may erroneously identify an outlier as a mode.The StatUtils class contains several static methods useful for statistics. Here we utilize its mode method:

// if there is only one max, it's stored in mode[0]
// if there is more than one value that has equally high counts
// then values are stored in mode in ascending order
double[] mode = StatUtils.mode(x4);
//mode[0] = 8.0
double[] test = {1.0, 2.0, 2.0, 3.0, 3.0, 4.0}
//mode[0] = 2.0
//mode[1] = 3.0

Variance

The variance is a measure of how much the data is spread out and is always a positive, real number greater than or equal to zero. If all values of x are equal, the variance will be zero. Conversely, a larger spread of numbers will correspond to a larger variance. The variance of a known population of data points is equivalent to the second central moment about the mean and is expressed as follows:

However, most of the time we do not have all of the data—we are only sampling from a larger (possibly unknown) dataset and so a correction for this bias is needed:

This form is known as the sample variance and is most often the variance we will use. You may note that the sample variance can be expressed in terms of the second-order, unnormalized moment:

As with the mean calculation, the Commons Math variance is calculated using the update formula for the second unnormalized moment for a new data point , an existing mean and the newly updated mean :

Here, .

Most of the time when the variance is required, we are asking for the bias-corrected, sample variance because our data is usually a sample from some larger, possibly unknown, set of data:

double variance = descriptiveStatistics.getVariance()

However, it is also straightforward to retrieve the population variance if it is required:

double populationVariance = descriptiveStatistics.getPopulationVariance();

Standard deviation

The variance is difficult to visualize because it is on the order of x² and usually a large number compared to the mean. By taking the square root of the variance, we define this as the standard deviation s. This has the advantage of being in the same units of the variates and the mean. It is therefore helpful to use things like μ +– σ, which can indicate how much the data deviates from the mean. The standard deviation can be explicitly calculated with this:

However, in practice, we use the update formulas to calculate the sample variance, returning the standard deviation as the square root of the sample variance when required:

double standardDeviation = descriptiveStatistics.getStandardDeviation();

Should you require the population standard deviation, you can calculate this directly by taking the square root of the population variance.

Error on the mean

While it is often assumed that the standard deviation is the error on the mean, this is not true. The standard deviation describes how the data is spread around the average. To calculate the accuracy of the mean itself, s_x, we use the standard deviation:

And we use some simple Java:

double meanErr = descriptiveStatistics.getStandardDeviation() / 
                        Math.sqrt(descriptiveStatistics.getN());

Skewness

The skewness measures how asymmetrically distributed the data is and can be either a positive or negative real number. A positive skew signifies that most of the values leans toward the origin (x = 0), while a negative skew implies the values are distributed away (to right). A skewness of 0 indicates that the data is perfectly distributed on either side of the data distribution'’s peak value. The skewness can be calculated explicitly as follows:

However, a more robust calculation of the skewness is achieved by updating the third central moment:

Then you calculate the skewness when it is called for:

The Commons Math implementation iterates over the stored dataset, incrementally updating M3 and then performing the bias correction, and returns the skewness:

double skewness = descriptiveStatistics.getSkewness();

Kurtosis

The kurtosis is a measure of how “tailed” a distribution of data is. The sample kurtosis estimate is related to the fourth central moment about the mean and is calculated as shown here:

This can be simplified as follows:

A kurtosis at or near 0 signifies that the data distribution is extremely narrow. As the kurtosis increases, extreme values coincide with long tails. However, we often want to express the kurtosis as related to the normal distribution (which has a kurtosis = 3). We can then subtract this part and call the new quantity the excess kurtosis, although in practice most people just refer to the excess kurtosis as the kurtosis. In this definition, κ = 0 implies that the data has the same peak and tail shape as a normal distribution. A kurtosis higher than 3 is called leptokurtic and has wider tails than a normal distribution. When κ is less than 3, the distribution is said to be platykurtic and the distribution has few values in the tail (less than the normal distribution). The excess kurtosis calculation is as follows:

As in the case for the variance and skewness, the kurtosis is calculated by updating the fourth unnormalized central moment. For each point added to the calculation, M₄ can be updated with the following equation as long as the number of points n >= 4. At any point, the skew can be computed from the current value of M₄:

The default calculation returned by getKurtosis is the excess kurtosis definition. This can be checked by implementing the class org.apache.commons.math3​.stat.descriptive.moment.Kurtosis, which is called by getKurtosis():

double kurtosis = descriptiveStatistics.getKurtosis();

Covariance

The covariance is the two-dimensional equivalent of the variance. It measures how two variates, in combination, differ from their means. It is calculated as shown here:

Just as in the case of the one-dimensional, statistical sample moments, we note that the quantity

can be expressed as an incremental update to the co-moment of the pair of variables x_i and x_j, given a known means and counts for the existing dimensions:

Then the covariance can be calculated at any point:

The code to calculate the covariance is shown here:

Covariance cov = new Covariance();

/* examples using Anscombe's Quartet data */
double cov1 = cov.covariance(x1, y1); // 5.501
double cov2 = cov.covariance(x2, y2); // 5.499
double cov3 = cov.covariance(x3, y3); // 5.497
double cov4 = cov.covariance(x4, y5); // 5.499

If you already have the data in a 2D array of doubles or a RealMatrix instance, you can pass them directly to the constructor like this:

// double[][] myData or RealMatrix myData
Covariance covObj = new Covariance(myData);
// cov contains covariances and can be accessed
// from RealMatrix.get(i,j) retrieve elements
RealMatrix cov = covObj.getCovarianceMatrix();

Note that the diagonal of the covariance matrix is just the variance of column i and therefore the square root of the diagonal of the covariance matrix is the standard deviation of each dimension of data. Because the population mean is usually not known, we use the biased covariance with the sample mean. If we did know the population mean, the unbiased correction factor 1/n would be used to calculate the unbiased covariance:

Pearson’s correlation

The Pearson correlation coefficient is related to covariance via the following, and is a measure of how likely two variates are to vary together:

The correlation coefficient takes a value between –1 and 1, where 1 indicates that the two variates are nearly identical. –1 indicates that they are opposites. In Java, there are once again two options, but using the default constructor, we get this:

PearsonsCorrelation corr = new PearsonsCorrelation();

/* examples using Anscombe's Quartet data */
double corr1 = corr.correlation(x1, y1)); // 0.816
double corr2 = corr.correlation(x2, y2)); // 0.816
double corr3 = corr.correlation(x3, y3)); // 0.816
double corr4 = corr.correlation(x4, y4)); // 0.816

However, if we already have data, or a Covariance instance, we can use the following:

// existing Covariance cov
PearsonsCorrelation corrObj = new PearsonsCorrelation(cov);
// double[][] myData or RealMatrix myData
PearsonsCorrelation corrObj = new PearsonsCorrelation(myData);
// from RealMatrix.get(i,j) retrieve elements
RealMatrix corr = corrObj.getCorrelationMatrix();

Simple regression

If X has only one dimension, the problem is the familiar equation of a line , and the problem can be classified as simple regression. By calculating , the variance of and , and the covariance between and , we can estimate the slope:

Then, using the slope and the means of x and y, we can estimate the intercept:

The code in Java uses the SimpleRegression class:

SimpleRegression rg = new SimpleRegression();

/* x-y pairs of Anscombe's x1 and y1 */
double[][] xyData = {{10.0, 8.04}, {8.0, 6.95}, {13.0, 7.58},
        {9.0, 8.81}, {11.0, 8.33}, {14.0, 9.96}, {6.0, 7.24},
        {4.0, 4.26}, {12.0, 10.84}, {7.0, 4.82}, {5.0, 5.68}};

rg.addData(xyData);

/* get regression results */
double alpha = rg.getIntercept(); // 3.0
double alpha_err = rg.getInterceptStdErr(); // 1.12
double beta = rg.getSlope(); // 0.5
double beta_err = rg.getSlopeStdErr(); // 0.12 
double r2 = rg.getRSquare(); // 0.67

We can then interpret these results as , or more specifically as . How much can we trust this model? With , it’s a fairly decent fit, but the closer it is to the ideal of , the better. Note that if we perform the same regression on the other three datasets from Anscombe’s quartet, we get identical parameters, errors, and . This is a profound, albeit perplexing, result. Clearly, the four datasets look different, but their linear fits (the superposed blue lines) are identical. Although linear regression is a powerful yet simple method for understanding our data as in case 1, in case 2 linear regression in x is probably the wrong tool to use here. In case 3, linear regression is probably the right tool, but we could sensor (remove) the data point that appears to be an outlier. In case 4, a regression model is most likely not appropriate at all. This does demonstrate how easy it is to fool ourselves that a model is correct if we look at only a few parameters after blindly throwing data into an analysis method.

Multiple regression

There are many ways to solve this problem, but the most common and probably most useful is the ordinary least squares (OLS) method. The solution is expressed in terms of linear algebra:

The OLSMultipleLinearRegression class in Apache Commons Math is just a convenient wrapper around a QR decomposition. This implementation also provides additional functions beyond the QR decomposition that you will find useful. In particular, the variance-covariance matrix of is as follows, where the matrix R is from the QR decomposition:

In this case, R must be truncated to the dimension of beta. Given the fit residuals , we can calculate the variance of the errors where and are the respective number of rows and columns of . The square root of the diagonal values of times the constant gives us the estimate of errors on the fit parameters:

The Apache Commons Math implementation of ordinary least squares regression utilizes the QR decomposition covered in linear algebra. The methods in the example code are convenient wrappers around several standard matrix operations. Note that the default is to include an intercept term, and the corresponding value is the first position of the estimated parameters:

double[][] xNData = {{0, 0.5}, {1, 1.2}, {2, 2.5}, {3, 3.6}};
double[] yNData = {-1, 0.2, 0.9, 2.1};
// default is to include an intercept
OLSMultipleLinearRegression mr = new OLSMultipleLinearRegression();
/* NOTE that y and x are reversed compared to other classes / methods */
mr.newSampleData(yNData, xNData);
double[] beta = mr.estimateRegressionParameters();
// [-0.7499, 1.588, -0.5555]
double[] errs = mr.estimateRegressionParametersStandardErrors();
// [0.2635, 0.6626, 0.6211]
double r2 = mr.calculateRSquared();
// 0.9945

Linear regression is a vast topic with many adaptations—too many to be covered here. However, it is worth noting that these methods are relevant only if the relations between X and y are actually linear. Nature is full of nonlinear relationships, and in Chapter 5 we will address more ways of exploring these.